1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 /* This file handles generation of all the assembler code
25 *except* the instructions of a function.
26 This includes declarations of variables and their initial values.
28 We also output the assembler code for constants stored in memory
29 and are responsible for combining constants with the same value. */
33 #include "coretypes.h"
40 #include "hard-reg-set.h"
48 #include "langhooks.h"
52 #include "tree-mudflap.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h" /* Needed for external data
59 declarations for e.g. AIX 4.x. */
62 /* The (assembler) name of the first globally-visible object output. */
63 extern GTY(()) const char *first_global_object_name;
64 extern GTY(()) const char *weak_global_object_name;
66 const char *first_global_object_name;
67 const char *weak_global_object_name;
70 struct constant_descriptor_rtx;
71 struct rtx_constant_pool;
73 struct varasm_status GTY(())
75 /* If we're using a per-function constant pool, this is it. */
76 struct rtx_constant_pool *pool;
78 /* Number of tree-constants deferred during the expansion of this
80 unsigned int deferred_constants;
83 #define n_deferred_constants (cfun->varasm->deferred_constants)
85 /* Number for making the label on the next
86 constant that is stored in memory. */
88 static GTY(()) int const_labelno;
90 /* Carry information from ASM_DECLARE_OBJECT_NAME
91 to ASM_FINISH_DECLARE_OBJECT. */
93 int size_directive_output;
95 /* The last decl for which assemble_variable was called,
96 if it did ASM_DECLARE_OBJECT_NAME.
97 If the last call to assemble_variable didn't do that,
100 tree last_assemble_variable_decl;
102 /* The following global variable indicates if the first basic block
103 in a function belongs to the cold partition or not. */
105 bool first_function_block_is_cold;
107 /* We give all constants their own alias set. Perhaps redundant with
108 MEM_READONLY_P, but pre-dates it. */
110 static HOST_WIDE_INT const_alias_set;
112 static const char *strip_reg_name (const char *);
113 static int contains_pointers_p (tree);
114 #ifdef ASM_OUTPUT_EXTERNAL
115 static bool incorporeal_function_p (tree);
117 static void decode_addr_const (tree, struct addr_const *);
118 static hashval_t const_desc_hash (const void *);
119 static int const_desc_eq (const void *, const void *);
120 static hashval_t const_hash_1 (const tree);
121 static int compare_constant (const tree, const tree);
122 static tree copy_constant (tree);
123 static void output_constant_def_contents (rtx);
124 static void output_addressed_constants (tree);
125 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
126 static unsigned min_align (unsigned, unsigned);
127 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
128 static void globalize_decl (tree);
129 static void maybe_assemble_visibility (tree);
130 #ifdef BSS_SECTION_ASM_OP
131 #ifdef ASM_OUTPUT_BSS
132 static void asm_output_bss (FILE *, tree, const char *,
133 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
135 #ifdef ASM_OUTPUT_ALIGNED_BSS
136 static void asm_output_aligned_bss (FILE *, tree, const char *,
137 unsigned HOST_WIDE_INT, int)
140 #endif /* BSS_SECTION_ASM_OP */
141 static void mark_weak (tree);
142 static void output_constant_pool (const char *, tree);
144 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
145 section *text_section;
146 section *data_section;
147 section *readonly_data_section;
148 section *sdata_section;
149 section *ctors_section;
150 section *dtors_section;
151 section *bss_section;
152 section *sbss_section;
154 /* Various forms of common section. All are guaranteed to be nonnull. */
155 section *tls_comm_section;
156 section *comm_section;
157 section *lcomm_section;
159 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
161 section *bss_noswitch_section;
163 /* The section that holds the main exception table, when known. The section
164 is set either by the target's init_sections hook or by the first call to
165 switch_to_exception_section. */
166 section *exception_section;
168 /* The section that holds the DWARF2 frame unwind information, when known.
169 The section is set either by the target's init_sections hook or by the
170 first call to switch_to_eh_frame_section. */
171 section *eh_frame_section;
173 /* asm_out_file's current section. This is NULL if no section has yet
174 been selected or if we lose track of what the current section is. */
177 /* True if code for the current function is currently being directed
178 at the cold section. */
179 bool in_cold_section_p;
181 /* A linked list of all the unnamed sections. */
182 static GTY(()) section *unnamed_sections;
184 /* Return a nonzero value if DECL has a section attribute. */
185 #ifndef IN_NAMED_SECTION
186 #define IN_NAMED_SECTION(DECL) \
187 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
188 && DECL_SECTION_NAME (DECL) != NULL_TREE)
191 /* Hash table of named sections. */
192 static GTY((param_is (section))) htab_t section_htab;
194 /* A table of object_blocks, indexed by section. */
195 static GTY((param_is (struct object_block))) htab_t object_block_htab;
197 /* The next number to use for internal anchor labels. */
198 static GTY(()) int anchor_labelno;
200 /* A pool of constants that can be shared between functions. */
201 static GTY(()) struct rtx_constant_pool *shared_constant_pool;
203 /* Helper routines for maintaining section_htab. */
206 section_entry_eq (const void *p1, const void *p2)
208 const section *old = p1;
209 const char *new = p2;
211 return strcmp (old->named.name, new) == 0;
215 section_entry_hash (const void *p)
217 const section *old = p;
218 return htab_hash_string (old->named.name);
221 /* Return a hash value for section SECT. */
224 hash_section (section *sect)
226 if (sect->common.flags & SECTION_NAMED)
227 return htab_hash_string (sect->named.name);
228 return sect->common.flags;
231 /* Helper routines for maintaining object_block_htab. */
234 object_block_entry_eq (const void *p1, const void *p2)
236 const struct object_block *old = p1;
237 const section *new = p2;
239 return old->sect == new;
243 object_block_entry_hash (const void *p)
245 const struct object_block *old = p;
246 return hash_section (old->sect);
249 /* Return a new unnamed section with the given fields. */
252 get_unnamed_section (unsigned int flags, void (*callback) (const void *),
257 sect = ggc_alloc (sizeof (struct unnamed_section));
258 sect->unnamed.common.flags = flags | SECTION_UNNAMED;
259 sect->unnamed.callback = callback;
260 sect->unnamed.data = data;
261 sect->unnamed.next = unnamed_sections;
263 unnamed_sections = sect;
267 /* Return a SECTION_NOSWITCH section with the given fields. */
270 get_noswitch_section (unsigned int flags, noswitch_section_callback callback)
274 sect = ggc_alloc (sizeof (struct unnamed_section));
275 sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
276 sect->noswitch.callback = callback;
281 /* Return the named section structure associated with NAME. Create
282 a new section with the given fields if no such structure exists. */
285 get_section (const char *name, unsigned int flags, tree decl)
287 section *sect, **slot;
290 htab_find_slot_with_hash (section_htab, name,
291 htab_hash_string (name), INSERT);
292 flags |= SECTION_NAMED;
295 sect = ggc_alloc (sizeof (struct named_section));
296 sect->named.common.flags = flags;
297 sect->named.name = ggc_strdup (name);
298 sect->named.decl = decl;
304 if ((sect->common.flags & ~SECTION_DECLARED) != flags
305 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
307 /* Sanity check user variables for flag changes. */
309 decl = sect->named.decl;
311 error ("%+D causes a section type conflict", decl);
317 /* Return true if the current compilation mode benefits from having
318 objects grouped into blocks. */
321 use_object_blocks_p (void)
323 return flag_section_anchors;
326 /* Return the object_block structure for section SECT. Create a new
327 structure if we haven't created one already. Return null if SECT
330 static struct object_block *
331 get_block_for_section (section *sect)
333 struct object_block *block;
339 slot = htab_find_slot_with_hash (object_block_htab, sect,
340 hash_section (sect), INSERT);
341 block = (struct object_block *) *slot;
344 block = (struct object_block *)
345 ggc_alloc_cleared (sizeof (struct object_block));
352 /* Create a symbol with label LABEL and place it at byte offset
353 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
354 is not yet known. LABEL must be a garbage-collected string. */
357 create_block_symbol (const char *label, struct object_block *block,
358 HOST_WIDE_INT offset)
363 /* Create the extended SYMBOL_REF. */
364 size = RTX_HDR_SIZE + sizeof (struct block_symbol);
365 symbol = ggc_alloc_zone (size, &rtl_zone);
367 /* Initialize the normal SYMBOL_REF fields. */
368 memset (symbol, 0, size);
369 PUT_CODE (symbol, SYMBOL_REF);
370 PUT_MODE (symbol, Pmode);
371 XSTR (symbol, 0) = label;
372 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
374 /* Initialize the block_symbol stuff. */
375 SYMBOL_REF_BLOCK (symbol) = block;
376 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
382 initialize_cold_section_name (void)
384 const char *stripped_name;
388 gcc_assert (cfun && current_function_decl);
389 if (cfun->unlikely_text_section_name)
392 dsn = DECL_SECTION_NAME (current_function_decl);
393 if (flag_function_sections && dsn)
395 name = alloca (TREE_STRING_LENGTH (dsn) + 1);
396 memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
398 stripped_name = targetm.strip_name_encoding (name);
400 buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
401 cfun->unlikely_text_section_name = ggc_strdup (buffer);
404 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
407 /* Tell assembler to switch to unlikely-to-be-executed text section. */
410 unlikely_text_section (void)
414 if (!cfun->unlikely_text_section_name)
415 initialize_cold_section_name ();
417 return get_named_section (NULL, cfun->unlikely_text_section_name, 0);
420 return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
423 /* When called within a function context, return true if the function
424 has been assigned a cold text section and if SECT is that section.
425 When called outside a function context, return true if SECT is the
426 default cold section. */
429 unlikely_text_section_p (section *sect)
434 name = cfun->unlikely_text_section_name;
436 name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
440 && SECTION_STYLE (sect) == SECTION_NAMED
441 && strcmp (name, sect->named.name) == 0);
444 /* Return a section with a particular name and with whatever SECTION_*
445 flags section_type_flags deems appropriate. The name of the section
446 is taken from NAME if nonnull, otherwise it is taken from DECL's
447 DECL_SECTION_NAME. DECL is the decl associated with the section
448 (see the section comment for details) and RELOC is as for
449 section_type_flags. */
452 get_named_section (tree decl, const char *name, int reloc)
456 gcc_assert (!decl || DECL_P (decl));
458 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
460 flags = targetm.section_type_flags (decl, name, reloc);
462 return get_section (name, flags, decl);
465 /* If required, set DECL_SECTION_NAME to a unique name. */
468 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
469 int flag_function_or_data_sections)
471 if (DECL_SECTION_NAME (decl) == NULL_TREE
472 && targetm.have_named_sections
473 && (flag_function_or_data_sections
474 || DECL_ONE_ONLY (decl)))
475 targetm.asm_out.unique_section (decl, reloc);
478 #ifdef BSS_SECTION_ASM_OP
480 #ifdef ASM_OUTPUT_BSS
482 /* Utility function for ASM_OUTPUT_BSS for targets to use if
483 they don't support alignments in .bss.
484 ??? It is believed that this function will work in most cases so such
485 support is localized here. */
488 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
490 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
491 unsigned HOST_WIDE_INT rounded)
493 targetm.asm_out.globalize_label (file, name);
494 switch_to_section (bss_section);
495 #ifdef ASM_DECLARE_OBJECT_NAME
496 last_assemble_variable_decl = decl;
497 ASM_DECLARE_OBJECT_NAME (file, name, decl);
499 /* Standard thing is just output label for the object. */
500 ASM_OUTPUT_LABEL (file, name);
501 #endif /* ASM_DECLARE_OBJECT_NAME */
502 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
507 #ifdef ASM_OUTPUT_ALIGNED_BSS
509 /* Utility function for targets to use in implementing
510 ASM_OUTPUT_ALIGNED_BSS.
511 ??? It is believed that this function will work in most cases so such
512 support is localized here. */
515 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
516 const char *name, unsigned HOST_WIDE_INT size,
519 switch_to_section (bss_section);
520 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
521 #ifdef ASM_DECLARE_OBJECT_NAME
522 last_assemble_variable_decl = decl;
523 ASM_DECLARE_OBJECT_NAME (file, name, decl);
525 /* Standard thing is just output label for the object. */
526 ASM_OUTPUT_LABEL (file, name);
527 #endif /* ASM_DECLARE_OBJECT_NAME */
528 ASM_OUTPUT_SKIP (file, size ? size : 1);
533 #endif /* BSS_SECTION_ASM_OP */
535 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
536 /* Return the hot section for function DECL. Return text_section for
540 hot_function_section (tree decl)
542 if (decl != NULL_TREE
543 && DECL_SECTION_NAME (decl) != NULL_TREE
544 && targetm.have_named_sections)
545 return get_named_section (decl, NULL, 0);
551 /* Return the section for function DECL.
553 If DECL is NULL_TREE, return the text section. We can be passed
554 NULL_TREE under some circumstances by dbxout.c at least. */
557 function_section (tree decl)
561 if (first_function_block_is_cold)
564 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
565 if (decl != NULL_TREE
566 && DECL_SECTION_NAME (decl) != NULL_TREE)
567 return reloc ? unlikely_text_section ()
568 : get_named_section (decl, NULL, 0);
570 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
572 return reloc ? unlikely_text_section () : hot_function_section (decl);
577 current_function_section (void)
579 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
580 if (current_function_decl != NULL_TREE
581 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
582 return in_cold_section_p ? unlikely_text_section ()
583 : get_named_section (current_function_decl,
586 return targetm.asm_out.select_section (current_function_decl,
588 DECL_ALIGN (current_function_decl));
590 return (in_cold_section_p
591 ? unlikely_text_section ()
592 : hot_function_section (current_function_decl));
596 /* Return the read-only data section associated with function DECL. */
599 default_function_rodata_section (tree decl)
601 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
603 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
605 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
607 size_t len = strlen (name) + 3;
608 char* rname = alloca (len);
610 strcpy (rname, ".rodata");
611 strcat (rname, name + 5);
612 return get_section (rname, SECTION_LINKONCE, decl);
614 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
615 else if (DECL_ONE_ONLY (decl)
616 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
618 size_t len = strlen (name) + 1;
619 char *rname = alloca (len);
621 memcpy (rname, name, len);
623 return get_section (rname, SECTION_LINKONCE, decl);
625 /* For .text.foo we want to use .rodata.foo. */
626 else if (flag_function_sections && flag_data_sections
627 && strncmp (name, ".text.", 6) == 0)
629 size_t len = strlen (name) + 1;
630 char *rname = alloca (len + 2);
632 memcpy (rname, ".rodata", 7);
633 memcpy (rname + 7, name + 5, len - 5);
634 return get_section (rname, 0, decl);
638 return readonly_data_section;
641 /* Return the read-only data section associated with function DECL
642 for targets where that section should be always the single
643 readonly data section. */
646 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
648 return readonly_data_section;
651 /* Return the section to use for string merging. */
654 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
655 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
656 unsigned int flags ATTRIBUTE_UNUSED)
660 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
661 && TREE_CODE (decl) == STRING_CST
662 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
664 && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0
665 && TREE_STRING_LENGTH (decl) >= len)
667 enum machine_mode mode;
668 unsigned int modesize;
674 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
675 modesize = GET_MODE_BITSIZE (mode);
676 if (modesize >= 8 && modesize <= 256
677 && (modesize & (modesize - 1)) == 0)
679 if (align < modesize)
682 str = TREE_STRING_POINTER (decl);
683 unit = GET_MODE_SIZE (mode);
685 /* Check for embedded NUL characters. */
686 for (i = 0; i < len; i += unit)
688 for (j = 0; j < unit; j++)
689 if (str[i + j] != '\0')
696 sprintf (name, ".rodata.str%d.%d", modesize / 8,
698 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
699 return get_section (name, flags, NULL);
704 return readonly_data_section;
707 /* Return the section to use for constant merging. */
710 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
711 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
712 unsigned int flags ATTRIBUTE_UNUSED)
714 unsigned int modesize = GET_MODE_BITSIZE (mode);
716 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
722 && (align & (align - 1)) == 0)
726 sprintf (name, ".rodata.cst%d", (int) (align / 8));
727 flags |= (align / 8) | SECTION_MERGE;
728 return get_section (name, flags, NULL);
730 return readonly_data_section;
733 /* Given NAME, a putative register name, discard any customary prefixes. */
736 strip_reg_name (const char *name)
738 #ifdef REGISTER_PREFIX
739 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
740 name += strlen (REGISTER_PREFIX);
742 if (name[0] == '%' || name[0] == '#')
747 /* The user has asked for a DECL to have a particular name. Set (or
748 change) it in such a way that we don't prefix an underscore to
751 set_user_assembler_name (tree decl, const char *name)
753 char *starred = alloca (strlen (name) + 2);
755 strcpy (starred + 1, name);
756 change_decl_assembler_name (decl, get_identifier (starred));
757 SET_DECL_RTL (decl, NULL_RTX);
760 /* Decode an `asm' spec for a declaration as a register name.
761 Return the register number, or -1 if nothing specified,
762 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
763 or -3 if ASMSPEC is `cc' and is not recognized,
764 or -4 if ASMSPEC is `memory' and is not recognized.
765 Accept an exact spelling or a decimal number.
766 Prefixes such as % are optional. */
769 decode_reg_name (const char *asmspec)
775 /* Get rid of confusing prefixes. */
776 asmspec = strip_reg_name (asmspec);
778 /* Allow a decimal number as a "register name". */
779 for (i = strlen (asmspec) - 1; i >= 0; i--)
780 if (! ISDIGIT (asmspec[i]))
782 if (asmspec[0] != 0 && i < 0)
785 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
791 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
793 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
796 #ifdef ADDITIONAL_REGISTER_NAMES
798 static const struct { const char *const name; const int number; } table[]
799 = ADDITIONAL_REGISTER_NAMES;
801 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
803 && ! strcmp (asmspec, table[i].name))
804 return table[i].number;
806 #endif /* ADDITIONAL_REGISTER_NAMES */
808 if (!strcmp (asmspec, "memory"))
811 if (!strcmp (asmspec, "cc"))
820 /* Return true if DECL's initializer is suitable for a BSS section. */
823 bss_initializer_p (tree decl)
825 return (DECL_INITIAL (decl) == NULL
826 || DECL_INITIAL (decl) == error_mark_node
827 || (flag_zero_initialized_in_bss
828 /* Leave constant zeroes in .rodata so they
830 && !TREE_READONLY (decl)
831 && initializer_zerop (DECL_INITIAL (decl))));
834 /* Compute the alignment of variable specified by DECL.
835 DONT_OUTPUT_DATA is from assemble_variable. */
838 align_variable (tree decl, bool dont_output_data)
840 unsigned int align = DECL_ALIGN (decl);
842 /* In the case for initialing an array whose length isn't specified,
843 where we have not yet been able to do the layout,
844 figure out the proper alignment now. */
845 if (dont_output_data && DECL_SIZE (decl) == 0
846 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
847 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
849 /* Some object file formats have a maximum alignment which they support.
850 In particular, a.out format supports a maximum alignment of 4. */
851 if (align > MAX_OFILE_ALIGNMENT)
853 warning (0, "alignment of %q+D is greater than maximum object "
854 "file alignment. Using %d", decl,
855 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
856 align = MAX_OFILE_ALIGNMENT;
859 /* On some machines, it is good to increase alignment sometimes. */
860 if (! DECL_USER_ALIGN (decl))
862 #ifdef DATA_ALIGNMENT
863 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
865 #ifdef CONSTANT_ALIGNMENT
866 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
867 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
871 /* Reset the alignment in case we have made it tighter, so we can benefit
872 from it in get_pointer_alignment. */
873 DECL_ALIGN (decl) = align;
876 /* Return the section into which the given VAR_DECL or CONST_DECL
877 should be placed. PREFER_NOSWITCH_P is true if a noswitch
878 section should be used wherever possible. */
881 get_variable_section (tree decl, bool prefer_noswitch_p)
885 /* If the decl has been given an explicit section name, then it
886 isn't common, and shouldn't be handled as such. */
887 if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
889 if (DECL_THREAD_LOCAL_P (decl))
890 return tls_comm_section;
891 if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
895 if (DECL_INITIAL (decl) == error_mark_node)
896 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
897 else if (DECL_INITIAL (decl))
898 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
902 resolve_unique_section (decl, reloc, flag_data_sections);
903 if (IN_NAMED_SECTION (decl))
904 return get_named_section (decl, NULL, reloc);
906 if (!DECL_THREAD_LOCAL_P (decl)
907 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
908 && bss_initializer_p (decl))
910 if (!TREE_PUBLIC (decl))
911 return lcomm_section;
912 if (bss_noswitch_section)
913 return bss_noswitch_section;
916 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
919 /* Return the block into which object_block DECL should be placed. */
921 static struct object_block *
922 get_block_for_decl (tree decl)
926 if (TREE_CODE (decl) == VAR_DECL)
928 /* The object must be defined in this translation unit. */
929 if (DECL_EXTERNAL (decl))
932 /* There's no point using object blocks for something that is
933 isolated by definition. */
934 if (DECL_ONE_ONLY (decl))
938 /* We can only calculate block offsets if the decl has a known
940 if (DECL_SIZE_UNIT (decl) == NULL)
942 if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
945 /* Find out which section should contain DECL. We cannot put it into
946 an object block if it requires a standalone definition. */
947 if (TREE_CODE (decl) == VAR_DECL)
948 align_variable (decl, 0);
949 sect = get_variable_section (decl, true);
950 if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
953 return get_block_for_section (sect);
956 /* Make sure block symbol SYMBOL is in block BLOCK. */
959 change_symbol_block (rtx symbol, struct object_block *block)
961 if (block != SYMBOL_REF_BLOCK (symbol))
963 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
964 SYMBOL_REF_BLOCK (symbol) = block;
968 /* Return true if it is possible to put DECL in an object_block. */
971 use_blocks_for_decl_p (tree decl)
973 /* Only data DECLs can be placed into object blocks. */
974 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
977 /* Detect decls created by dw2_force_const_mem. Such decls are
978 special because DECL_INITIAL doesn't specify the decl's true value.
979 dw2_output_indirect_constants will instead call assemble_variable
980 with dont_output_data set to 1 and then print the contents itself. */
981 if (DECL_INITIAL (decl) == decl)
987 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
988 have static storage duration. In other words, it should not be an
989 automatic variable, including PARM_DECLs.
991 There is, however, one exception: this function handles variables
992 explicitly placed in a particular register by the user.
994 This is never called for PARM_DECL nodes. */
997 make_decl_rtl (tree decl)
999 const char *name = 0;
1003 /* Check that we are not being given an automatic variable. */
1004 gcc_assert (TREE_CODE (decl) != PARM_DECL
1005 && TREE_CODE (decl) != RESULT_DECL);
1007 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1008 gcc_assert (TREE_CODE (decl) != VAR_DECL
1009 || TREE_STATIC (decl)
1010 || TREE_PUBLIC (decl)
1011 || DECL_EXTERNAL (decl)
1012 || DECL_REGISTER (decl));
1014 /* And that we were not given a type or a label. */
1015 gcc_assert (TREE_CODE (decl) != TYPE_DECL
1016 && TREE_CODE (decl) != LABEL_DECL);
1018 /* For a duplicate declaration, we can be called twice on the
1019 same DECL node. Don't discard the RTL already made. */
1020 if (DECL_RTL_SET_P (decl))
1022 /* If the old RTL had the wrong mode, fix the mode. */
1023 x = DECL_RTL (decl);
1024 if (GET_MODE (x) != DECL_MODE (decl))
1025 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
1027 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1030 /* ??? Another way to do this would be to maintain a hashed
1031 table of such critters. Instead of adding stuff to a DECL
1032 to give certain attributes to it, we could use an external
1033 hash map from DECL to set of attributes. */
1035 /* Let the target reassign the RTL if it wants.
1036 This is necessary, for example, when one machine specific
1037 decl attribute overrides another. */
1038 targetm.encode_section_info (decl, DECL_RTL (decl), false);
1040 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1041 on the new decl information. */
1043 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1044 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
1045 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
1047 /* Make this function static known to the mudflap runtime. */
1048 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1049 mudflap_enqueue_decl (decl);
1054 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1056 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1057 && DECL_REGISTER (decl))
1059 error ("register name not specified for %q+D", decl);
1061 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1063 const char *asmspec = name+1;
1064 reg_number = decode_reg_name (asmspec);
1065 /* First detect errors in declaring global registers. */
1066 if (reg_number == -1)
1067 error ("register name not specified for %q+D", decl);
1068 else if (reg_number < 0)
1069 error ("invalid register name for %q+D", decl);
1070 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1071 error ("data type of %q+D isn%'t suitable for a register",
1073 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1074 error ("register specified for %q+D isn%'t suitable for data type",
1076 /* Now handle properly declared static register variables. */
1081 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1083 DECL_INITIAL (decl) = 0;
1084 error ("global register variable has initial value");
1086 if (TREE_THIS_VOLATILE (decl))
1087 warning (OPT_Wvolatile_register_var,
1088 "optimization may eliminate reads and/or "
1089 "writes to register variables");
1091 /* If the user specified one of the eliminables registers here,
1092 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1093 confused with that register and be eliminated. This usage is
1094 somewhat suspect... */
1096 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1097 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1098 REG_USERVAR_P (DECL_RTL (decl)) = 1;
1100 if (TREE_STATIC (decl))
1102 /* Make this register global, so not usable for anything
1104 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1105 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1106 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1108 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1110 globalize_reg (reg_number + --nregs);
1113 /* As a register variable, it has no section. */
1117 /* Now handle ordinary static variables and functions (in memory).
1118 Also handle vars declared register invalidly. */
1119 else if (name[0] == '*')
1121 #ifdef REGISTER_PREFIX
1122 if (strlen (REGISTER_PREFIX) != 0)
1124 reg_number = decode_reg_name (name);
1125 if (reg_number >= 0 || reg_number == -3)
1126 error ("register name given for non-register variable %q+D", decl);
1131 /* Specifying a section attribute on a variable forces it into a
1132 non-.bss section, and thus it cannot be common. */
1133 if (TREE_CODE (decl) == VAR_DECL
1134 && DECL_SECTION_NAME (decl) != NULL_TREE
1135 && DECL_INITIAL (decl) == NULL_TREE
1136 && DECL_COMMON (decl))
1137 DECL_COMMON (decl) = 0;
1139 /* Variables can't be both common and weak. */
1140 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1141 DECL_COMMON (decl) = 0;
1143 if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1144 x = create_block_symbol (name, get_block_for_decl (decl), -1);
1146 x = gen_rtx_SYMBOL_REF (Pmode, name);
1147 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1148 SET_SYMBOL_REF_DECL (x, decl);
1150 x = gen_rtx_MEM (DECL_MODE (decl), x);
1151 if (TREE_CODE (decl) != FUNCTION_DECL)
1152 set_mem_attributes (x, decl, 1);
1153 SET_DECL_RTL (decl, x);
1155 /* Optionally set flags or add text to the name to record information
1156 such as that it is a function name.
1157 If the name is changed, the macro ASM_OUTPUT_LABELREF
1158 will have to know how to strip this information. */
1159 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1161 /* Make this function static known to the mudflap runtime. */
1162 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1163 mudflap_enqueue_decl (decl);
1166 /* Make the rtl for variable VAR be volatile.
1167 Use this only for static variables. */
1170 make_var_volatile (tree var)
1172 gcc_assert (MEM_P (DECL_RTL (var)));
1174 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1177 /* Output a string of literal assembler code
1178 for an `asm' keyword used between functions. */
1181 assemble_asm (tree string)
1185 if (TREE_CODE (string) == ADDR_EXPR)
1186 string = TREE_OPERAND (string, 0);
1188 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1191 /* Record an element in the table of global destructors. SYMBOL is
1192 a SYMBOL_REF of the function to be called; PRIORITY is a number
1193 between 0 and MAX_INIT_PRIORITY. */
1196 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1197 int priority ATTRIBUTE_UNUSED)
1199 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1200 /* Tell GNU LD that this is part of the static destructor set.
1201 This will work for any system that uses stabs, most usefully
1203 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1204 dbxout_stab_value_label (XSTR (symbol, 0));
1206 sorry ("global destructors not supported on this target");
1211 default_named_section_asm_out_destructor (rtx symbol, int priority)
1213 const char *section = ".dtors";
1216 /* ??? This only works reliably with the GNU linker. */
1217 if (priority != DEFAULT_INIT_PRIORITY)
1219 sprintf (buf, ".dtors.%.5u",
1220 /* Invert the numbering so the linker puts us in the proper
1221 order; constructors are run from right to left, and the
1222 linker sorts in increasing order. */
1223 MAX_INIT_PRIORITY - priority);
1227 switch_to_section (get_section (section, SECTION_WRITE, NULL));
1228 assemble_align (POINTER_SIZE);
1229 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1232 #ifdef DTORS_SECTION_ASM_OP
1234 default_dtor_section_asm_out_destructor (rtx symbol,
1235 int priority ATTRIBUTE_UNUSED)
1237 switch_to_section (dtors_section);
1238 assemble_align (POINTER_SIZE);
1239 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1243 /* Likewise for global constructors. */
1246 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1247 int priority ATTRIBUTE_UNUSED)
1249 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1250 /* Tell GNU LD that this is part of the static destructor set.
1251 This will work for any system that uses stabs, most usefully
1253 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1254 dbxout_stab_value_label (XSTR (symbol, 0));
1256 sorry ("global constructors not supported on this target");
1261 default_named_section_asm_out_constructor (rtx symbol, int priority)
1263 const char *section = ".ctors";
1266 /* ??? This only works reliably with the GNU linker. */
1267 if (priority != DEFAULT_INIT_PRIORITY)
1269 sprintf (buf, ".ctors.%.5u",
1270 /* Invert the numbering so the linker puts us in the proper
1271 order; constructors are run from right to left, and the
1272 linker sorts in increasing order. */
1273 MAX_INIT_PRIORITY - priority);
1277 switch_to_section (get_section (section, SECTION_WRITE, NULL));
1278 assemble_align (POINTER_SIZE);
1279 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1282 #ifdef CTORS_SECTION_ASM_OP
1284 default_ctor_section_asm_out_constructor (rtx symbol,
1285 int priority ATTRIBUTE_UNUSED)
1287 switch_to_section (ctors_section);
1288 assemble_align (POINTER_SIZE);
1289 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1293 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1294 a nonzero value if the constant pool should be output before the
1295 start of the function, or a zero value if the pool should output
1296 after the end of the function. The default is to put it before the
1299 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1300 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1303 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1304 to be output to assembler.
1305 Set first_global_object_name and weak_global_object_name as appropriate. */
1308 notice_global_symbol (tree decl)
1310 const char **type = &first_global_object_name;
1312 if (first_global_object_name
1313 || !TREE_PUBLIC (decl)
1314 || DECL_EXTERNAL (decl)
1315 || !DECL_NAME (decl)
1316 || (TREE_CODE (decl) != FUNCTION_DECL
1317 && (TREE_CODE (decl) != VAR_DECL
1318 || (DECL_COMMON (decl)
1319 && (DECL_INITIAL (decl) == 0
1320 || DECL_INITIAL (decl) == error_mark_node))))
1321 || !MEM_P (DECL_RTL (decl)))
1324 /* We win when global object is found, but it is useful to know about weak
1325 symbol as well so we can produce nicer unique names. */
1326 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1327 type = &weak_global_object_name;
1333 rtx decl_rtl = DECL_RTL (decl);
1335 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1336 name = ggc_strdup (p);
1342 /* Output assembler code for the constant pool of a function and associated
1343 with defining the name of the function. DECL describes the function.
1344 NAME is the function's name. For the constant pool, we use the current
1345 constant pool data. */
1348 assemble_start_function (tree decl, const char *fnname)
1351 char tmp_label[100];
1352 bool hot_label_written = false;
1354 cfun->unlikely_text_section_name = NULL;
1356 first_function_block_is_cold = false;
1357 if (flag_reorder_blocks_and_partition)
1359 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1360 cfun->hot_section_label = ggc_strdup (tmp_label);
1361 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1362 cfun->cold_section_label = ggc_strdup (tmp_label);
1363 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1364 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1365 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1366 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1371 cfun->hot_section_label = NULL;
1372 cfun->cold_section_label = NULL;
1373 cfun->hot_section_end_label = NULL;
1374 cfun->cold_section_end_label = NULL;
1377 /* The following code does not need preprocessing in the assembler. */
1381 if (CONSTANT_POOL_BEFORE_FUNCTION)
1382 output_constant_pool (fnname, decl);
1384 resolve_unique_section (decl, 0, flag_function_sections);
1386 /* Make sure the not and cold text (code) sections are properly
1387 aligned. This is necessary here in the case where the function
1388 has both hot and cold sections, because we don't want to re-set
1389 the alignment when the section switch happens mid-function. */
1391 if (flag_reorder_blocks_and_partition)
1393 switch_to_section (unlikely_text_section ());
1394 assemble_align (FUNCTION_BOUNDARY);
1395 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1397 /* When the function starts with a cold section, we need to explicitly
1398 align the hot section and write out the hot section label.
1399 But if the current function is a thunk, we do not have a CFG. */
1400 if (!current_function_is_thunk
1401 && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1403 switch_to_section (text_section);
1404 assemble_align (FUNCTION_BOUNDARY);
1405 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1406 hot_label_written = true;
1407 first_function_block_is_cold = true;
1410 else if (DECL_SECTION_NAME (decl))
1412 /* Calls to function_section rely on first_function_block_is_cold
1413 being accurate. The first block may be cold even if we aren't
1414 doing partitioning, if the entire function was decided by
1415 choose_function_section (predict.c) to be cold. */
1417 initialize_cold_section_name ();
1419 if (cfun->unlikely_text_section_name
1420 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1421 cfun->unlikely_text_section_name) == 0)
1422 first_function_block_is_cold = true;
1425 in_cold_section_p = first_function_block_is_cold;
1427 /* Switch to the correct text section for the start of the function. */
1429 switch_to_section (function_section (decl));
1430 if (flag_reorder_blocks_and_partition
1431 && !hot_label_written)
1432 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1434 /* Tell assembler to move to target machine's alignment for functions. */
1435 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1436 if (align < force_align_functions_log)
1437 align = force_align_functions_log;
1440 ASM_OUTPUT_ALIGN (asm_out_file, align);
1443 /* Handle a user-specified function alignment.
1444 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1445 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1446 if (align_functions_log > align
1447 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1449 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1450 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1451 align_functions_log, align_functions - 1);
1453 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1457 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1458 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1461 (*debug_hooks->begin_function) (decl);
1463 /* Make function name accessible from other files, if appropriate. */
1465 if (TREE_PUBLIC (decl))
1467 notice_global_symbol (decl);
1469 globalize_decl (decl);
1471 maybe_assemble_visibility (decl);
1474 if (DECL_PRESERVE_P (decl))
1475 targetm.asm_out.mark_decl_preserved (fnname);
1477 /* Do any machine/system dependent processing of the function name. */
1478 #ifdef ASM_DECLARE_FUNCTION_NAME
1479 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1481 /* Standard thing is just output label for the function. */
1482 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1483 #endif /* ASM_DECLARE_FUNCTION_NAME */
1486 /* Output assembler code associated with defining the size of the
1487 function. DECL describes the function. NAME is the function's name. */
1490 assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1492 #ifdef ASM_DECLARE_FUNCTION_SIZE
1493 /* We could have switched section in the middle of the function. */
1494 if (flag_reorder_blocks_and_partition)
1495 switch_to_section (function_section (decl));
1496 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1498 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1500 output_constant_pool (fnname, decl);
1501 switch_to_section (function_section (decl)); /* need to switch back */
1503 /* Output labels for end of hot/cold text sections (to be used by
1505 if (flag_reorder_blocks_and_partition)
1507 section *save_text_section;
1509 save_text_section = in_section;
1510 switch_to_section (unlikely_text_section ());
1511 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1512 if (first_function_block_is_cold)
1513 switch_to_section (text_section);
1515 switch_to_section (function_section (decl));
1516 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1517 switch_to_section (save_text_section);
1521 /* Assemble code to leave SIZE bytes of zeros. */
1524 assemble_zeros (unsigned HOST_WIDE_INT size)
1526 /* Do no output if -fsyntax-only. */
1527 if (flag_syntax_only)
1530 #ifdef ASM_NO_SKIP_IN_TEXT
1531 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1532 so we must output 0s explicitly in the text section. */
1533 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1535 unsigned HOST_WIDE_INT i;
1536 for (i = 0; i < size; i++)
1537 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1542 ASM_OUTPUT_SKIP (asm_out_file, size);
1545 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1548 assemble_align (int align)
1550 if (align > BITS_PER_UNIT)
1552 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1556 /* Assemble a string constant with the specified C string as contents. */
1559 assemble_string (const char *p, int size)
1564 /* If the string is very long, split it up. */
1568 int thissize = size - pos;
1569 if (thissize > maximum)
1572 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1580 /* A noswitch_section_callback for lcomm_section. */
1583 emit_local (tree decl ATTRIBUTE_UNUSED,
1584 const char *name ATTRIBUTE_UNUSED,
1585 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1586 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1588 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1589 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1590 size, DECL_ALIGN (decl));
1592 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1593 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1596 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1601 /* A noswitch_section_callback for bss_noswitch_section. */
1603 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1605 emit_bss (tree decl ATTRIBUTE_UNUSED,
1606 const char *name ATTRIBUTE_UNUSED,
1607 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1608 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1610 #if defined ASM_OUTPUT_ALIGNED_BSS
1611 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1614 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1620 /* A noswitch_section_callback for comm_section. */
1623 emit_common (tree decl ATTRIBUTE_UNUSED,
1624 const char *name ATTRIBUTE_UNUSED,
1625 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1626 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1628 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1629 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1630 size, DECL_ALIGN (decl));
1632 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1633 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1636 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1641 /* A noswitch_section_callback for tls_comm_section. */
1644 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1645 const char *name ATTRIBUTE_UNUSED,
1646 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1647 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1649 #ifdef ASM_OUTPUT_TLS_COMMON
1650 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1653 sorry ("thread-local COMMON data not implemented");
1658 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1659 NAME is the name of DECL's SYMBOL_REF. */
1662 assemble_noswitch_variable (tree decl, const char *name, section *sect)
1664 unsigned HOST_WIDE_INT size, rounded;
1666 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1669 /* Don't allocate zero bytes of common,
1670 since that means "undefined external" in the linker. */
1674 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1675 so that each uninitialized object starts on such a boundary. */
1676 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1677 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1678 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1680 if (!sect->noswitch.callback (decl, name, size, rounded)
1681 && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1682 warning (0, "requested alignment for %q+D is greater than "
1683 "implemented alignment of %wu", decl, rounded);
1686 /* A subroutine of assemble_variable. Output the label and contents of
1687 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
1688 is as for assemble_variable. */
1691 assemble_variable_contents (tree decl, const char *name,
1692 bool dont_output_data)
1694 /* Do any machine/system dependent processing of the object. */
1695 #ifdef ASM_DECLARE_OBJECT_NAME
1696 last_assemble_variable_decl = decl;
1697 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1699 /* Standard thing is just output label for the object. */
1700 ASM_OUTPUT_LABEL (asm_out_file, name);
1701 #endif /* ASM_DECLARE_OBJECT_NAME */
1703 if (!dont_output_data)
1705 if (DECL_INITIAL (decl)
1706 && DECL_INITIAL (decl) != error_mark_node
1707 && !initializer_zerop (DECL_INITIAL (decl)))
1708 /* Output the actual data. */
1709 output_constant (DECL_INITIAL (decl),
1710 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1713 /* Leave space for it. */
1714 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1718 /* Assemble everything that is needed for a variable or function declaration.
1719 Not used for automatic variables, and not used for function definitions.
1720 Should not be called for variables of incomplete structure type.
1722 TOP_LEVEL is nonzero if this variable has file scope.
1723 AT_END is nonzero if this is the special handling, at end of compilation,
1724 to define things that have had only tentative definitions.
1725 DONT_OUTPUT_DATA if nonzero means don't actually output the
1726 initial value (that will be done by the caller). */
1729 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1730 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1733 rtx decl_rtl, symbol;
1736 if (lang_hooks.decls.prepare_assemble_variable)
1737 lang_hooks.decls.prepare_assemble_variable (decl);
1739 last_assemble_variable_decl = 0;
1741 /* Normally no need to say anything here for external references,
1742 since assemble_external is called by the language-specific code
1743 when a declaration is first seen. */
1745 if (DECL_EXTERNAL (decl))
1748 /* Output no assembler code for a function declaration.
1749 Only definitions of functions output anything. */
1751 if (TREE_CODE (decl) == FUNCTION_DECL)
1754 /* Do nothing for global register variables. */
1755 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1757 TREE_ASM_WRITTEN (decl) = 1;
1761 /* If type was incomplete when the variable was declared,
1762 see if it is complete now. */
1764 if (DECL_SIZE (decl) == 0)
1765 layout_decl (decl, 0);
1767 /* Still incomplete => don't allocate it; treat the tentative defn
1768 (which is what it must have been) as an `extern' reference. */
1770 if (!dont_output_data && DECL_SIZE (decl) == 0)
1772 error ("storage size of %q+D isn%'t known", decl);
1773 TREE_ASM_WRITTEN (decl) = 1;
1777 /* The first declaration of a variable that comes through this function
1778 decides whether it is global (in C, has external linkage)
1779 or local (in C, has internal linkage). So do nothing more
1780 if this function has already run. */
1782 if (TREE_ASM_WRITTEN (decl))
1785 /* Make sure targetm.encode_section_info is invoked before we set
1787 decl_rtl = DECL_RTL (decl);
1789 TREE_ASM_WRITTEN (decl) = 1;
1791 /* Do no output if -fsyntax-only. */
1792 if (flag_syntax_only)
1797 if (! dont_output_data
1798 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1800 error ("size of variable %q+D is too large", decl);
1804 gcc_assert (MEM_P (decl_rtl));
1805 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
1806 symbol = XEXP (decl_rtl, 0);
1807 name = XSTR (symbol, 0);
1808 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1809 notice_global_symbol (decl);
1811 /* Compute the alignment of this data. */
1813 align_variable (decl, dont_output_data);
1814 set_mem_align (decl_rtl, DECL_ALIGN (decl));
1816 if (TREE_PUBLIC (decl))
1817 maybe_assemble_visibility (decl);
1819 if (DECL_PRESERVE_P (decl))
1820 targetm.asm_out.mark_decl_preserved (name);
1822 /* First make the assembler name(s) global if appropriate. */
1823 sect = get_variable_section (decl, false);
1824 if (TREE_PUBLIC (decl)
1826 && (sect->common.flags & SECTION_COMMON) == 0)
1827 globalize_decl (decl);
1829 /* Output any data that we will need to use the address of. */
1830 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1831 output_addressed_constants (DECL_INITIAL (decl));
1833 /* dbxout.c needs to know this. */
1834 if (sect && (sect->common.flags & SECTION_CODE) != 0)
1835 DECL_IN_TEXT_SECTION (decl) = 1;
1837 /* If the decl is part of an object_block, make sure that the decl
1838 has been positioned within its block, but do not write out its
1839 definition yet. output_object_blocks will do that later. */
1840 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
1842 gcc_assert (!dont_output_data);
1843 place_block_symbol (symbol);
1845 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1846 assemble_noswitch_variable (decl, name, sect);
1849 switch_to_section (sect);
1850 if (DECL_ALIGN (decl) > BITS_PER_UNIT)
1851 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1852 assemble_variable_contents (decl, name, dont_output_data);
1856 /* Return 1 if type TYPE contains any pointers. */
1859 contains_pointers_p (tree type)
1861 switch (TREE_CODE (type))
1864 case REFERENCE_TYPE:
1865 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1866 so I'll play safe and return 1. */
1872 case QUAL_UNION_TYPE:
1875 /* For a type that has fields, see if the fields have pointers. */
1876 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1877 if (TREE_CODE (fields) == FIELD_DECL
1878 && contains_pointers_p (TREE_TYPE (fields)))
1884 /* An array type contains pointers if its element type does. */
1885 return contains_pointers_p (TREE_TYPE (type));
1892 /* In unit-at-a-time mode, we delay assemble_external processing until
1893 the compilation unit is finalized. This is the best we can do for
1894 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1895 it all the way to final. See PR 17982 for further discussion. */
1896 static GTY(()) tree pending_assemble_externals;
1898 #ifdef ASM_OUTPUT_EXTERNAL
1899 /* True if DECL is a function decl for which no out-of-line copy exists.
1900 It is assumed that DECL's assembler name has been set. */
1903 incorporeal_function_p (tree decl)
1905 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1909 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1910 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1913 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1914 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1920 /* Actually do the tests to determine if this is necessary, and invoke
1921 ASM_OUTPUT_EXTERNAL. */
1923 assemble_external_real (tree decl)
1925 rtx rtl = DECL_RTL (decl);
1927 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1928 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1929 && !incorporeal_function_p (decl))
1931 /* Some systems do require some output. */
1932 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1933 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1939 process_pending_assemble_externals (void)
1941 #ifdef ASM_OUTPUT_EXTERNAL
1943 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1944 assemble_external_real (TREE_VALUE (list));
1946 pending_assemble_externals = 0;
1950 /* Output something to declare an external symbol to the assembler.
1951 (Most assemblers don't need this, so we normally output nothing.)
1952 Do nothing if DECL is not external. */
1955 assemble_external (tree decl ATTRIBUTE_UNUSED)
1957 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1958 main body of this code is only rarely exercised. To provide some
1959 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1960 open. If it's not, we should not be calling this function. */
1961 gcc_assert (asm_out_file);
1963 #ifdef ASM_OUTPUT_EXTERNAL
1964 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1967 if (flag_unit_at_a_time)
1968 pending_assemble_externals = tree_cons (0, decl,
1969 pending_assemble_externals);
1971 assemble_external_real (decl);
1975 /* Similar, for calling a library function FUN. */
1978 assemble_external_libcall (rtx fun)
1980 /* Declare library function name external when first used, if nec. */
1981 if (! SYMBOL_REF_USED (fun))
1983 SYMBOL_REF_USED (fun) = 1;
1984 targetm.asm_out.external_libcall (fun);
1988 /* Assemble a label named NAME. */
1991 assemble_label (const char *name)
1993 ASM_OUTPUT_LABEL (asm_out_file, name);
1996 /* Set the symbol_referenced flag for ID. */
1998 mark_referenced (tree id)
2000 TREE_SYMBOL_REFERENCED (id) = 1;
2003 /* Set the symbol_referenced flag for DECL and notify callgraph. */
2005 mark_decl_referenced (tree decl)
2007 if (TREE_CODE (decl) == FUNCTION_DECL)
2009 /* Extern inline functions don't become needed when referenced.
2010 If we know a method will be emitted in other TU and no new
2011 functions can be marked reachable, just use the external
2013 struct cgraph_node *node = cgraph_node (decl);
2014 if (!DECL_EXTERNAL (decl)
2015 && (!node->local.vtable_method || !cgraph_global_info_ready
2016 || !node->local.finalized))
2017 cgraph_mark_needed_node (node);
2019 else if (TREE_CODE (decl) == VAR_DECL)
2021 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
2022 cgraph_varpool_mark_needed_node (node);
2023 /* C++ frontend use mark_decl_references to force COMDAT variables
2024 to be output that might appear dead otherwise. */
2025 node->force_output = true;
2027 /* else do nothing - we can get various sorts of CST nodes here,
2028 which do not need to be marked. */
2032 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2033 until we find an identifier that is not itself a transparent alias.
2034 Modify the alias passed to it by reference (and all aliases on the
2035 way to the ultimate target), such that they do not have to be
2036 followed again, and return the ultimate target of the alias
2040 ultimate_transparent_alias_target (tree *alias)
2042 tree target = *alias;
2044 if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2046 gcc_assert (TREE_CHAIN (target));
2047 target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2048 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2049 && ! TREE_CHAIN (target));
2056 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2057 starts with a *, the rest of NAME is output verbatim. Otherwise
2058 NAME is transformed in a target-specific way (usually by the
2059 addition of an underscore). */
2062 assemble_name_raw (FILE *file, const char *name)
2065 fputs (&name[1], file);
2067 ASM_OUTPUT_LABELREF (file, name);
2070 /* Like assemble_name_raw, but should be used when NAME might refer to
2071 an entity that is also represented as a tree (like a function or
2072 variable). If NAME does refer to such an entity, that entity will
2073 be marked as referenced. */
2076 assemble_name (FILE *file, const char *name)
2078 const char *real_name;
2081 real_name = targetm.strip_name_encoding (name);
2083 id = maybe_get_identifier (real_name);
2088 mark_referenced (id);
2089 ultimate_transparent_alias_target (&id);
2091 name = IDENTIFIER_POINTER (id);
2092 gcc_assert (! TREE_CHAIN (id));
2095 assemble_name_raw (file, name);
2098 /* Allocate SIZE bytes writable static space with a gensym name
2099 and return an RTX to refer to its address. */
2102 assemble_static_space (unsigned HOST_WIDE_INT size)
2105 const char *namestring;
2108 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2110 namestring = ggc_strdup (name);
2112 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2113 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2115 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2116 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2119 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2120 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2123 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2124 so that each uninitialized object starts on such a boundary. */
2125 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2126 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2127 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2128 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2129 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2130 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2137 /* Assemble the static constant template for function entry trampolines.
2138 This is done at most once per compilation.
2139 Returns an RTX for the address of the template. */
2141 static GTY(()) rtx initial_trampoline;
2143 #ifdef TRAMPOLINE_TEMPLATE
2145 assemble_trampoline_template (void)
2152 if (initial_trampoline)
2153 return initial_trampoline;
2155 /* By default, put trampoline templates in read-only data section. */
2157 #ifdef TRAMPOLINE_SECTION
2158 switch_to_section (TRAMPOLINE_SECTION);
2160 switch_to_section (readonly_data_section);
2163 /* Write the assembler code to define one. */
2164 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2167 ASM_OUTPUT_ALIGN (asm_out_file, align);
2170 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2171 TRAMPOLINE_TEMPLATE (asm_out_file);
2173 /* Record the rtl to refer to it. */
2174 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2175 name = ggc_strdup (label);
2176 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2177 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2179 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2180 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2182 return initial_trampoline;
2186 /* A and B are either alignments or offsets. Return the minimum alignment
2187 that may be assumed after adding the two together. */
2189 static inline unsigned
2190 min_align (unsigned int a, unsigned int b)
2192 return (a | b) & -(a | b);
2195 /* Return the assembler directive for creating a given kind of integer
2196 object. SIZE is the number of bytes in the object and ALIGNED_P
2197 indicates whether it is known to be aligned. Return NULL if the
2198 assembly dialect has no such directive.
2200 The returned string should be printed at the start of a new line and
2201 be followed immediately by the object's initial value. */
2204 integer_asm_op (int size, int aligned_p)
2206 struct asm_int_op *ops;
2209 ops = &targetm.asm_out.aligned_op;
2211 ops = &targetm.asm_out.unaligned_op;
2216 return targetm.asm_out.byte_op;
2230 /* Use directive OP to assemble an integer object X. Print OP at the
2231 start of the line, followed immediately by the value of X. */
2234 assemble_integer_with_op (const char *op, rtx x)
2236 fputs (op, asm_out_file);
2237 output_addr_const (asm_out_file, x);
2238 fputc ('\n', asm_out_file);
2241 /* The default implementation of the asm_out.integer target hook. */
2244 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2245 unsigned int size ATTRIBUTE_UNUSED,
2246 int aligned_p ATTRIBUTE_UNUSED)
2248 const char *op = integer_asm_op (size, aligned_p);
2249 /* Avoid GAS bugs for large values. Specifically negative values whose
2250 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2251 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2253 return op && (assemble_integer_with_op (op, x), true);
2256 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2257 the alignment of the integer in bits. Return 1 if we were able to output
2258 the constant, otherwise 0. We must be able to output the constant,
2259 if FORCE is nonzero. */
2262 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2266 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2268 /* See if the target hook can handle this kind of object. */
2269 if (targetm.asm_out.integer (x, size, aligned_p))
2272 /* If the object is a multi-byte one, try splitting it up. Split
2273 it into words it if is multi-word, otherwise split it into bytes. */
2276 enum machine_mode omode, imode;
2277 unsigned int subalign;
2278 unsigned int subsize, i;
2280 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2281 subalign = MIN (align, subsize * BITS_PER_UNIT);
2282 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2283 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2285 for (i = 0; i < size; i += subsize)
2287 rtx partial = simplify_subreg (omode, x, imode, i);
2288 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2294 /* If we've printed some of it, but not all of it, there's no going
2299 gcc_assert (!force);
2305 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2307 long data[4] = {0, 0, 0, 0};
2309 int bitsize, nelts, nunits, units_per;
2311 /* This is hairy. We have a quantity of known size. real_to_target
2312 will put it into an array of *host* longs, 32 bits per element
2313 (even if long is more than 32 bits). We need to determine the
2314 number of array elements that are occupied (nelts) and the number
2315 of *target* min-addressable units that will be occupied in the
2316 object file (nunits). We cannot assume that 32 divides the
2317 mode's bitsize (size * BITS_PER_UNIT) evenly.
2319 size * BITS_PER_UNIT is used here to make sure that padding bits
2320 (which might appear at either end of the value; real_to_target
2321 will include the padding bits in its output array) are included. */
2323 nunits = GET_MODE_SIZE (mode);
2324 bitsize = nunits * BITS_PER_UNIT;
2325 nelts = CEIL (bitsize, 32);
2326 units_per = 32 / BITS_PER_UNIT;
2328 real_to_target (data, &d, mode);
2330 /* Put out the first word with the specified alignment. */
2331 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2332 nunits -= units_per;
2334 /* Subsequent words need only 32-bit alignment. */
2335 align = min_align (align, 32);
2337 for (i = 1; i < nelts; i++)
2339 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2340 nunits -= units_per;
2344 /* Given an expression EXP with a constant value,
2345 reduce it to the sum of an assembler symbol and an integer.
2346 Store them both in the structure *VALUE.
2347 EXP must be reducible. */
2349 struct addr_const GTY(())
2352 HOST_WIDE_INT offset;
2356 decode_addr_const (tree exp, struct addr_const *value)
2358 tree target = TREE_OPERAND (exp, 0);
2364 if (TREE_CODE (target) == COMPONENT_REF
2365 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2368 offset += int_byte_position (TREE_OPERAND (target, 1));
2369 target = TREE_OPERAND (target, 0);
2371 else if (TREE_CODE (target) == ARRAY_REF
2372 || TREE_CODE (target) == ARRAY_RANGE_REF)
2374 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2375 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2376 target = TREE_OPERAND (target, 0);
2382 switch (TREE_CODE (target))
2386 x = DECL_RTL (target);
2390 x = gen_rtx_MEM (FUNCTION_MODE,
2391 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2399 x = output_constant_def (target, 1);
2406 gcc_assert (MEM_P (x));
2410 value->offset = offset;
2413 /* Uniquize all constants that appear in memory.
2414 Each constant in memory thus far output is recorded
2415 in `const_desc_table'. */
2417 struct constant_descriptor_tree GTY(())
2419 /* A MEM for the constant. */
2422 /* The value of the constant. */
2425 /* Hash of value. Computing the hash from value each time
2426 hashfn is called can't work properly, as that means recursive
2427 use of the hash table during hash table expansion. */
2431 static GTY((param_is (struct constant_descriptor_tree)))
2432 htab_t const_desc_htab;
2434 static struct constant_descriptor_tree * build_constant_desc (tree);
2435 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2437 /* Compute a hash code for a constant expression. */
2440 const_desc_hash (const void *ptr)
2442 return ((struct constant_descriptor_tree *)ptr)->hash;
2446 const_hash_1 (const tree exp)
2451 enum tree_code code = TREE_CODE (exp);
2453 /* Either set P and LEN to the address and len of something to hash and
2454 exit the switch or return a value. */
2459 p = (char *) &TREE_INT_CST (exp);
2460 len = sizeof TREE_INT_CST (exp);
2464 return real_hash (TREE_REAL_CST_PTR (exp));
2467 p = TREE_STRING_POINTER (exp);
2468 len = TREE_STRING_LENGTH (exp);
2472 return (const_hash_1 (TREE_REALPART (exp)) * 5
2473 + const_hash_1 (TREE_IMAGPART (exp)));
2477 unsigned HOST_WIDE_INT idx;
2480 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2482 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2484 hi = hi * 603 + const_hash_1 (value);
2492 struct addr_const value;
2494 decode_addr_const (exp, &value);
2495 switch (GET_CODE (value.base))
2498 /* Don't hash the address of the SYMBOL_REF;
2499 only use the offset and the symbol name. */
2501 p = XSTR (value.base, 0);
2502 for (i = 0; p[i] != 0; i++)
2503 hi = ((hi * 613) + (unsigned) (p[i]));
2507 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2518 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2519 + const_hash_1 (TREE_OPERAND (exp, 1)));
2523 case NON_LVALUE_EXPR:
2524 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2527 /* A language specific constant. Just hash the code. */
2531 /* Compute hashing function. */
2533 for (i = 0; i < len; i++)
2534 hi = ((hi * 613) + (unsigned) (p[i]));
2539 /* Wrapper of compare_constant, for the htab interface. */
2541 const_desc_eq (const void *p1, const void *p2)
2543 const struct constant_descriptor_tree *c1 = p1;
2544 const struct constant_descriptor_tree *c2 = p2;
2545 if (c1->hash != c2->hash)
2547 return compare_constant (c1->value, c2->value);
2550 /* Compare t1 and t2, and return 1 only if they are known to result in
2551 the same bit pattern on output. */
2554 compare_constant (const tree t1, const tree t2)
2556 enum tree_code typecode;
2558 if (t1 == NULL_TREE)
2559 return t2 == NULL_TREE;
2560 if (t2 == NULL_TREE)
2563 if (TREE_CODE (t1) != TREE_CODE (t2))
2566 switch (TREE_CODE (t1))
2569 /* Integer constants are the same only if the same width of type. */
2570 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2572 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2574 return tree_int_cst_equal (t1, t2);
2577 /* Real constants are the same only if the same width of type. */
2578 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2581 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2584 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2587 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2588 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2589 TREE_STRING_LENGTH (t1)));
2592 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2593 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2597 VEC(constructor_elt, gc) *v1, *v2;
2598 unsigned HOST_WIDE_INT idx;
2600 typecode = TREE_CODE (TREE_TYPE (t1));
2601 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2604 if (typecode == ARRAY_TYPE)
2606 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2607 /* For arrays, check that the sizes all match. */
2608 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2610 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2615 /* For record and union constructors, require exact type
2617 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2621 v1 = CONSTRUCTOR_ELTS (t1);
2622 v2 = CONSTRUCTOR_ELTS (t2);
2623 if (VEC_length (constructor_elt, v1)
2624 != VEC_length (constructor_elt, v2))
2627 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2629 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2630 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2632 /* Check that each value is the same... */
2633 if (!compare_constant (c1->value, c2->value))
2635 /* ... and that they apply to the same fields! */
2636 if (typecode == ARRAY_TYPE)
2638 if (!compare_constant (c1->index, c2->index))
2643 if (c1->index != c2->index)
2654 struct addr_const value1, value2;
2656 decode_addr_const (t1, &value1);
2657 decode_addr_const (t2, &value2);
2658 return (value1.offset == value2.offset
2659 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2665 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2666 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2670 case NON_LVALUE_EXPR:
2671 case VIEW_CONVERT_EXPR:
2672 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2677 nt1 = lang_hooks.expand_constant (t1);
2678 nt2 = lang_hooks.expand_constant (t2);
2679 if (nt1 != t1 || nt2 != t2)
2680 return compare_constant (nt1, nt2);
2689 /* Make a copy of the whole tree structure for a constant. This
2690 handles the same types of nodes that compare_constant handles. */
2693 copy_constant (tree exp)
2695 switch (TREE_CODE (exp))
2698 /* For ADDR_EXPR, we do not want to copy the decl whose address
2699 is requested. We do want to copy constants though. */
2700 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2701 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2702 copy_constant (TREE_OPERAND (exp, 0)));
2704 return copy_node (exp);
2709 return copy_node (exp);
2712 return build_complex (TREE_TYPE (exp),
2713 copy_constant (TREE_REALPART (exp)),
2714 copy_constant (TREE_IMAGPART (exp)));
2718 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2719 copy_constant (TREE_OPERAND (exp, 0)),
2720 copy_constant (TREE_OPERAND (exp, 1)));
2724 case NON_LVALUE_EXPR:
2725 case VIEW_CONVERT_EXPR:
2726 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2727 copy_constant (TREE_OPERAND (exp, 0)));
2731 tree copy = copy_node (exp);
2732 VEC(constructor_elt, gc) *v;
2733 unsigned HOST_WIDE_INT idx;
2734 tree purpose, value;
2736 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
2737 CONSTRUCTOR_ELTS (exp)));
2738 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
2740 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
2741 ce->index = purpose;
2742 ce->value = copy_constant (value);
2744 CONSTRUCTOR_ELTS (copy) = v;
2750 tree t = lang_hooks.expand_constant (exp);
2752 gcc_assert (t == exp);
2753 return copy_constant (t);
2758 /* Return the alignment of constant EXP in bits. */
2761 get_constant_alignment (tree exp)
2765 align = TYPE_ALIGN (TREE_TYPE (exp));
2766 #ifdef CONSTANT_ALIGNMENT
2767 align = CONSTANT_ALIGNMENT (exp, align);
2772 /* Return the section into which constant EXP should be placed. */
2775 get_constant_section (tree exp)
2777 if (IN_NAMED_SECTION (exp))
2778 return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
2780 return targetm.asm_out.select_section (exp,
2781 compute_reloc_for_constant (exp),
2782 get_constant_alignment (exp));
2785 /* Return the size of constant EXP in bytes. */
2787 static HOST_WIDE_INT
2788 get_constant_size (tree exp)
2792 size = int_size_in_bytes (TREE_TYPE (exp));
2793 if (TREE_CODE (exp) == STRING_CST)
2794 size = MAX (TREE_STRING_LENGTH (exp), size);
2798 /* Subroutine of output_constant_def:
2799 No constant equal to EXP is known to have been output.
2800 Make a constant descriptor to enter EXP in the hash table.
2801 Assign the label number and construct RTL to refer to the
2802 constant's location in memory.
2803 Caller is responsible for updating the hash table. */
2805 static struct constant_descriptor_tree *
2806 build_constant_desc (tree exp)
2812 struct constant_descriptor_tree *desc;
2814 desc = ggc_alloc (sizeof (*desc));
2815 desc->value = copy_constant (exp);
2817 /* Propagate marked-ness to copied constant. */
2818 if (flag_mudflap && mf_marked_p (exp))
2819 mf_mark (desc->value);
2821 /* Create a string containing the label name, in LABEL. */
2822 labelno = const_labelno++;
2823 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2825 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2826 if (use_object_blocks_p ())
2828 section *sect = get_constant_section (exp);
2829 symbol = create_block_symbol (ggc_strdup (label),
2830 get_block_for_section (sect), -1);
2833 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2834 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
2835 SET_SYMBOL_REF_DECL (symbol, desc->value);
2836 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2838 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2839 set_mem_attributes (rtl, exp, 1);
2840 set_mem_alias_set (rtl, 0);
2841 set_mem_alias_set (rtl, const_alias_set);
2843 /* Set flags or add text to the name to record information, such as
2844 that it is a local symbol. If the name is changed, the macro
2845 ASM_OUTPUT_LABELREF will have to know how to strip this
2846 information. This call might invalidate our local variable
2847 SYMBOL; we can't use it afterward. */
2849 targetm.encode_section_info (exp, rtl, true);
2856 /* Return an rtx representing a reference to constant data in memory
2857 for the constant expression EXP.
2859 If assembler code for such a constant has already been output,
2860 return an rtx to refer to it.
2861 Otherwise, output such a constant in memory
2862 and generate an rtx for it.
2864 If DEFER is nonzero, this constant can be deferred and output only
2865 if referenced in the function after all optimizations.
2867 `const_desc_table' records which constants already have label strings. */
2870 output_constant_def (tree exp, int defer)
2872 struct constant_descriptor_tree *desc;
2873 struct constant_descriptor_tree key;
2876 /* Look up EXP in the table of constant descriptors. If we didn't find
2877 it, create a new one. */
2879 key.hash = const_hash_1 (exp);
2880 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
2885 desc = build_constant_desc (exp);
2886 desc->hash = key.hash;
2890 maybe_output_constant_def_contents (desc, defer);
2894 /* Subroutine of output_constant_def: Decide whether or not we need to
2895 output the constant DESC now, and if so, do it. */
2897 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2900 rtx symbol = XEXP (desc->rtl, 0);
2901 tree exp = desc->value;
2903 if (flag_syntax_only)
2906 if (TREE_ASM_WRITTEN (exp))
2907 /* Already output; don't do it again. */
2910 /* We can always defer constants as long as the context allows
2914 /* Increment n_deferred_constants if it exists. It needs to be at
2915 least as large as the number of constants actually referred to
2916 by the function. If it's too small we'll stop looking too early
2917 and fail to emit constants; if it's too large we'll only look
2918 through the entire function when we could have stopped earlier. */
2920 n_deferred_constants++;
2924 output_constant_def_contents (symbol);
2927 /* Subroutine of output_constant_def_contents. Output the definition
2928 of constant EXP, which is pointed to by label LABEL. ALIGN is the
2929 constant's alignment in bits. */
2932 assemble_constant_contents (tree exp, const char *label, unsigned int align)
2936 size = get_constant_size (exp);
2938 /* Do any machine/system dependent processing of the constant. */
2939 #ifdef ASM_DECLARE_CONSTANT_NAME
2940 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2942 /* Standard thing is just output label for the constant. */
2943 ASM_OUTPUT_LABEL (asm_out_file, label);
2944 #endif /* ASM_DECLARE_CONSTANT_NAME */
2946 /* Output the value of EXP. */
2947 output_constant (exp, size, align);
2950 /* We must output the constant data referred to by SYMBOL; do so. */
2953 output_constant_def_contents (rtx symbol)
2955 tree exp = SYMBOL_REF_DECL (symbol);
2958 /* Make sure any other constants whose addresses appear in EXP
2959 are assigned label numbers. */
2960 output_addressed_constants (exp);
2962 /* We are no longer deferring this constant. */
2963 TREE_ASM_WRITTEN (exp) = 1;
2965 /* If the constant is part of an object block, make sure that the
2966 decl has been positioned within its block, but do not write out
2967 its definition yet. output_object_blocks will do that later. */
2968 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2969 place_block_symbol (symbol);
2972 switch_to_section (get_constant_section (exp));
2973 align = get_constant_alignment (exp);
2974 if (align > BITS_PER_UNIT)
2975 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2976 assemble_constant_contents (exp, XSTR (symbol, 0), align);
2979 mudflap_enqueue_constant (exp);
2982 /* Look up EXP in the table of constant descriptors. Return the rtl
2983 if it has been emitted, else null. */
2986 lookup_constant_def (tree exp)
2988 struct constant_descriptor_tree *desc;
2989 struct constant_descriptor_tree key;
2992 key.hash = const_hash_1 (exp);
2993 desc = htab_find_with_hash (const_desc_htab, &key, key.hash);
2995 return (desc ? desc->rtl : NULL_RTX);
2998 /* Used in the hash tables to avoid outputting the same constant
2999 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3000 are output once per function, not once per file. */
3001 /* ??? Only a few targets need per-function constant pools. Most
3002 can use one per-file pool. Should add a targetm bit to tell the
3005 struct rtx_constant_pool GTY(())
3007 /* Pointers to first and last constant in pool, as ordered by offset. */
3008 struct constant_descriptor_rtx *first;
3009 struct constant_descriptor_rtx *last;
3011 /* Hash facility for making memory-constants from constant rtl-expressions.
3012 It is used on RISC machines where immediate integer arguments and
3013 constant addresses are restricted so that such constants must be stored
3015 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3017 /* Current offset in constant pool (does not include any
3018 machine-specific header). */
3019 HOST_WIDE_INT offset;
3022 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
3024 struct constant_descriptor_rtx *next;
3028 HOST_WIDE_INT offset;
3030 enum machine_mode mode;
3036 /* Hash and compare functions for const_rtx_htab. */
3039 const_desc_rtx_hash (const void *ptr)
3041 const struct constant_descriptor_rtx *desc = ptr;
3046 const_desc_rtx_eq (const void *a, const void *b)
3048 const struct constant_descriptor_rtx *x = a;
3049 const struct constant_descriptor_rtx *y = b;
3051 if (x->mode != y->mode)
3053 return rtx_equal_p (x->constant, y->constant);
3056 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
3059 const_rtx_hash_1 (rtx *xp, void *data)
3061 unsigned HOST_WIDE_INT hwi;
3062 enum machine_mode mode;
3068 code = GET_CODE (x);
3069 mode = GET_MODE (x);
3070 h = (hashval_t) code * 1048573 + mode;
3078 const int shift = sizeof (hashval_t) * CHAR_BIT;
3079 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3082 h ^= (hashval_t) hwi;
3083 for (i = 1; i < n; ++i)
3086 h ^= (hashval_t) hwi;
3092 if (mode == VOIDmode)
3094 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3098 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3104 for (i = XVECLEN (x, 0); i-- > 0; )
3105 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3110 h ^= htab_hash_string (XSTR (x, 0));
3114 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3118 case UNSPEC_VOLATILE:
3119 h = h * 251 + XINT (x, 1);
3127 *hp = *hp * 509 + h;
3131 /* Compute a hash value for X, which should be a constant. */
3134 const_rtx_hash (rtx x)
3137 for_each_rtx (&x, const_rtx_hash_1, &h);
3142 /* Create and return a new rtx constant pool. */
3144 static struct rtx_constant_pool *
3145 create_constant_pool (void)
3147 struct rtx_constant_pool *pool;
3149 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3150 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3151 const_desc_rtx_eq, NULL);
3158 /* Initialize constant pool hashing for a new function. */
3161 init_varasm_status (struct function *f)
3163 struct varasm_status *p;
3165 p = ggc_alloc (sizeof (struct varasm_status));
3168 p->pool = create_constant_pool ();
3169 p->deferred_constants = 0;
3172 /* Given a MINUS expression, simplify it if both sides
3173 include the same symbol. */
3176 simplify_subtraction (rtx x)
3178 rtx r = simplify_rtx (x);
3182 /* Given a constant rtx X, make (or find) a memory constant for its value
3183 and return a MEM rtx to refer to it in memory. */
3186 force_const_mem (enum machine_mode mode, rtx x)
3188 struct constant_descriptor_rtx *desc, tmp;
3189 struct rtx_constant_pool *pool;
3196 /* If we're not allowed to drop X into the constant pool, don't. */
3197 if (targetm.cannot_force_const_mem (x))
3200 /* Record that this function has used a constant pool entry. */
3201 current_function_uses_const_pool = 1;
3203 /* Decide which pool to use. */
3204 pool = (targetm.use_blocks_for_constant_p (mode, x)
3205 ? shared_constant_pool
3206 : cfun->varasm->pool);
3208 /* Lookup the value in the hashtable. */
3211 hash = const_rtx_hash (x);
3212 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3215 /* If the constant was already present, return its memory. */
3217 return copy_rtx (desc->mem);
3219 /* Otherwise, create a new descriptor. */
3220 desc = ggc_alloc (sizeof (*desc));
3223 /* Align the location counter as required by EXP's data type. */
3224 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3225 #ifdef CONSTANT_ALIGNMENT
3227 tree type = lang_hooks.types.type_for_mode (mode, 0);
3228 if (type != NULL_TREE)
3229 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3233 pool->offset += (align / BITS_PER_UNIT) - 1;
3234 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3237 desc->constant = tmp.constant;
3238 desc->offset = pool->offset;
3241 desc->align = align;
3242 desc->labelno = const_labelno;
3245 pool->offset += GET_MODE_SIZE (mode);
3247 pool->last->next = desc;
3249 pool->first = pool->last = desc;
3252 /* Create a string containing the label name, in LABEL. */
3253 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3256 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3257 the constants pool. */
3258 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3260 section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3261 symbol = create_block_symbol (ggc_strdup (label),
3262 get_block_for_section (sect), -1);
3265 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3267 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3268 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3269 SET_SYMBOL_REF_CONSTANT (symbol, desc);
3271 /* Construct the MEM. */
3272 desc->mem = def = gen_const_mem (mode, symbol);
3273 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3274 set_mem_align (def, align);
3276 /* If we're dropping a label to the constant pool, make sure we
3278 if (GET_CODE (x) == LABEL_REF)
3279 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3281 return copy_rtx (def);
3284 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3287 get_pool_constant (rtx addr)
3289 return SYMBOL_REF_CONSTANT (addr)->constant;
3292 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3293 and whether it has been output or not. */
3296 get_pool_constant_mark (rtx addr, bool *pmarked)
3298 struct constant_descriptor_rtx *desc;
3300 desc = SYMBOL_REF_CONSTANT (addr);
3301 *pmarked = (desc->mark != 0);
3302 return desc->constant;
3305 /* Similar, return the mode. */
3308 get_pool_mode (rtx addr)
3310 return SYMBOL_REF_CONSTANT (addr)->mode;
3313 /* Return the size of the constant pool. */
3316 get_pool_size (void)
3318 return cfun->varasm->pool->offset;
3321 /* Worker function for output_constant_pool_1. Emit assembly for X
3322 in MODE with known alignment ALIGN. */
3325 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3327 switch (GET_MODE_CLASS (mode))
3330 case MODE_DECIMAL_FLOAT:
3334 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3335 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3336 assemble_real (r, mode, align);
3341 case MODE_PARTIAL_INT:
3342 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3345 case MODE_VECTOR_FLOAT:
3346 case MODE_VECTOR_INT:
3349 enum machine_mode submode = GET_MODE_INNER (mode);
3350 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3352 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3353 units = CONST_VECTOR_NUNITS (x);
3355 for (i = 0; i < units; i++)
3357 rtx elt = CONST_VECTOR_ELT (x, i);
3358 output_constant_pool_2 (submode, elt, i ? subalign : align);
3368 /* Worker function for output_constant_pool. Emit constant DESC,
3369 giving it ALIGN bits of alignment. */
3372 output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3379 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3380 whose CODE_LABEL has been deleted. This can occur if a jump table
3381 is eliminated by optimization. If so, write a constant of zero
3382 instead. Note that this can also happen by turning the
3383 CODE_LABEL into a NOTE. */
3384 /* ??? This seems completely and utterly wrong. Certainly it's
3385 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3386 functioning even with INSN_DELETED_P and friends. */
3389 switch (GET_CODE (x))
3392 if (GET_CODE (XEXP (x, 0)) != PLUS
3393 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3395 tmp = XEXP (XEXP (x, 0), 0);
3400 gcc_assert (!INSN_DELETED_P (tmp));
3401 gcc_assert (!NOTE_P (tmp)
3402 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3409 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3410 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3411 align, desc->labelno, done);
3414 assemble_align (align);
3416 /* Output the label. */
3417 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3419 /* Output the data. */
3420 output_constant_pool_2 (desc->mode, x, align);
3422 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3423 sections have proper size. */
3424 if (align > GET_MODE_BITSIZE (desc->mode)
3426 && (in_section->common.flags & SECTION_MERGE))
3427 assemble_align (align);
3429 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3435 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3436 to as used. Emit referenced deferred strings. This function can
3437 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3440 mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED)
3442 rtx x = *current_rtx;
3444 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3447 if (CONSTANT_POOL_ADDRESS_P (x))
3449 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
3450 if (desc->mark == 0)
3453 for_each_rtx (&desc->constant, mark_constant, NULL);
3456 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3458 tree exp = SYMBOL_REF_DECL (x);
3459 if (!TREE_ASM_WRITTEN (exp))
3461 n_deferred_constants--;
3462 output_constant_def_contents (x);
3469 /* Look through appropriate parts of INSN, marking all entries in the
3470 constant pool which are actually being used. Entries that are only
3471 referenced by other constants are also marked as used. Emit
3472 deferred strings that are used. */
3475 mark_constants (rtx insn)
3480 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3481 insns, not any notes that may be attached. We don't want to mark
3482 a constant just because it happens to appear in a REG_EQUIV note. */
3483 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3485 rtx seq = PATTERN (insn);
3486 int i, n = XVECLEN (seq, 0);
3487 for (i = 0; i < n; ++i)
3489 rtx subinsn = XVECEXP (seq, 0, i);
3490 if (INSN_P (subinsn))
3491 for_each_rtx (&PATTERN (subinsn), mark_constant, NULL);
3495 for_each_rtx (&PATTERN (insn), mark_constant, NULL);
3498 /* Look through the instructions for this function, and mark all the
3499 entries in POOL which are actually being used. Emit deferred constants
3500 which have indeed been used. */
3503 mark_constant_pool (void)
3507 if (!current_function_uses_const_pool && n_deferred_constants == 0)
3510 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3511 mark_constants (insn);
3513 for (link = current_function_epilogue_delay_list;
3515 link = XEXP (link, 1))
3516 mark_constants (XEXP (link, 0));
3519 /* Write all the constants in POOL. */
3522 output_constant_pool_contents (struct rtx_constant_pool *pool)
3524 struct constant_descriptor_rtx *desc;
3526 for (desc = pool->first; desc ; desc = desc->next)
3529 /* If the constant is part of an object_block, make sure that
3530 the constant has been positioned within its block, but do not
3531 write out its definition yet. output_object_blocks will do
3533 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
3534 && SYMBOL_REF_BLOCK (desc->sym))
3535 place_block_symbol (desc->sym);
3538 switch_to_section (targetm.asm_out.select_rtx_section
3539 (desc->mode, desc->constant, desc->align));
3540 output_constant_pool_1 (desc, desc->align);
3545 /* Mark all constants that are used in the current function, then write
3546 out the function's private constant pool. */
3549 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3550 tree fndecl ATTRIBUTE_UNUSED)
3552 struct rtx_constant_pool *pool = cfun->varasm->pool;
3554 /* It is possible for gcc to call force_const_mem and then to later
3555 discard the instructions which refer to the constant. In such a
3556 case we do not need to output the constant. */
3557 mark_constant_pool ();
3559 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3560 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3563 output_constant_pool_contents (pool);
3565 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3566 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3570 /* Write the contents of the shared constant pool. */
3573 output_shared_constant_pool (void)
3575 output_constant_pool_contents (shared_constant_pool);
3578 /* Determine what kind of relocations EXP may need. */
3581 compute_reloc_for_constant (tree exp)
3583 int reloc = 0, reloc2;
3586 /* Give the front-end a chance to convert VALUE to something that
3587 looks more like a constant to the back-end. */
3588 exp = lang_hooks.expand_constant (exp);
3590 switch (TREE_CODE (exp))
3594 /* Go inside any operations that get_inner_reference can handle and see
3595 if what's inside is a constant: no need to do anything here for
3596 addresses of variables or functions. */
3597 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3598 tem = TREE_OPERAND (tem, 0))
3601 if (TREE_PUBLIC (tem))
3608 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3609 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3613 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3614 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3615 /* The difference of two local labels is computable at link time. */
3616 if (reloc == 1 && reloc2 == 1)
3624 case NON_LVALUE_EXPR:
3625 case VIEW_CONVERT_EXPR:
3626 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3631 unsigned HOST_WIDE_INT idx;
3632 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3634 reloc |= compute_reloc_for_constant (tem);
3644 /* Find all the constants whose addresses are referenced inside of EXP,
3645 and make sure assembler code with a label has been output for each one.
3646 Indicate whether an ADDR_EXPR has been encountered. */
3649 output_addressed_constants (tree exp)
3653 /* Give the front-end a chance to convert VALUE to something that
3654 looks more like a constant to the back-end. */
3655 exp = lang_hooks.expand_constant (exp);
3657 switch (TREE_CODE (exp))
3661 /* Go inside any operations that get_inner_reference can handle and see
3662 if what's inside is a constant: no need to do anything here for
3663 addresses of variables or functions. */
3664 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3665 tem = TREE_OPERAND (tem, 0))
3668 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3669 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3670 tem = DECL_INITIAL (tem);
3672 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3673 output_constant_def (tem, 0);
3678 output_addressed_constants (TREE_OPERAND (exp, 1));
3683 case NON_LVALUE_EXPR:
3684 case VIEW_CONVERT_EXPR:
3685 output_addressed_constants (TREE_OPERAND (exp, 0));
3690 unsigned HOST_WIDE_INT idx;
3691 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3693 output_addressed_constants (tem);
3702 /* Return nonzero if VALUE is a valid constant-valued expression
3703 for use in initializing a static variable; one that can be an
3704 element of a "constant" initializer.
3706 Return null_pointer_node if the value is absolute;
3707 if it is relocatable, return the variable that determines the relocation.
3708 We assume that VALUE has been folded as much as possible;
3709 therefore, we do not need to check for such things as
3710 arithmetic-combinations of integers. */
3713 initializer_constant_valid_p (tree value, tree endtype)
3715 /* Give the front-end a chance to convert VALUE to something that
3716 looks more like a constant to the back-end. */
3717 value = lang_hooks.expand_constant (value);
3719 switch (TREE_CODE (value))
3722 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3723 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3724 && TREE_CONSTANT (value)
3725 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value)))
3727 unsigned HOST_WIDE_INT idx;
3729 bool absolute = true;
3731 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
3734 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
3737 if (reloc != null_pointer_node)
3740 /* For a non-absolute relocation, there is no single
3741 variable that can be "the variable that determines the
3743 return absolute ? null_pointer_node : error_mark_node;
3746 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3753 return null_pointer_node;
3757 value = staticp (TREE_OPERAND (value, 0));
3760 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3761 be a constant, this is old-skool offsetof-like nonsense. */
3762 if (TREE_CODE (value) == INDIRECT_REF
3763 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3764 return null_pointer_node;
3765 /* Taking the address of a nested function involves a trampoline. */
3766 if (TREE_CODE (value) == FUNCTION_DECL
3767 && ((decl_function_context (value)
3768 && !DECL_NO_STATIC_CHAIN (value))
3769 || DECL_DLLIMPORT_P (value)))
3771 /* "&{...}" requires a temporary to hold the constructed
3773 if (TREE_CODE (value) == CONSTRUCTOR)
3778 case VIEW_CONVERT_EXPR:
3779 case NON_LVALUE_EXPR:
3780 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3789 src = TREE_OPERAND (value, 0);
3790 src_type = TREE_TYPE (src);
3791 dest_type = TREE_TYPE (value);
3793 /* Allow conversions between pointer types, floating-point
3794 types, and offset types. */
3795 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3796 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3797 || (TREE_CODE (dest_type) == OFFSET_TYPE
3798 && TREE_CODE (src_type) == OFFSET_TYPE))
3799 return initializer_constant_valid_p (src, endtype);
3801 /* Allow length-preserving conversions between integer types. */
3802 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3803 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3804 return initializer_constant_valid_p (src, endtype);
3806 /* Allow conversions between other integer types only if
3808 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3810 tree inner = initializer_constant_valid_p (src, endtype);
3811 if (inner == null_pointer_node)
3812 return null_pointer_node;
3816 /* Allow (int) &foo provided int is as wide as a pointer. */
3817 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3818 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3819 return initializer_constant_valid_p (src, endtype);
3821 /* Likewise conversions from int to pointers, but also allow
3822 conversions from 0. */
3823 if ((POINTER_TYPE_P (dest_type)
3824 || TREE_CODE (dest_type) == OFFSET_TYPE)
3825 && INTEGRAL_TYPE_P (src_type))
3827 if (TREE_CODE (src) == INTEGER_CST
3828 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
3829 return null_pointer_node;
3830 if (integer_zerop (src))
3831 return null_pointer_node;
3832 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3833 return initializer_constant_valid_p (src, endtype);
3836 /* Allow conversions to struct or union types if the value
3838 if (TREE_CODE (dest_type) == RECORD_TYPE
3839 || TREE_CODE (dest_type) == UNION_TYPE)
3840 return initializer_constant_valid_p (src, endtype);
3845 if (! INTEGRAL_TYPE_P (endtype)
3846 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3848 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3850 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3852 /* If either term is absolute, use the other terms relocation. */
3853 if (valid0 == null_pointer_node)
3855 if (valid1 == null_pointer_node)
3861 if (! INTEGRAL_TYPE_P (endtype)
3862 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3864 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3866 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3868 /* Win if second argument is absolute. */
3869 if (valid1 == null_pointer_node)
3871 /* Win if both arguments have the same relocation.
3872 Then the value is absolute. */
3873 if (valid0 == valid1 && valid0 != 0)
3874 return null_pointer_node;
3876 /* Since GCC guarantees that string constants are unique in the
3877 generated code, a subtraction between two copies of the same
3878 constant string is absolute. */
3879 if (valid0 && TREE_CODE (valid0) == STRING_CST
3880 && valid1 && TREE_CODE (valid1) == STRING_CST
3881 && operand_equal_p (valid0, valid1, 1))
3882 return null_pointer_node;
3885 /* Support narrowing differences. */
3886 if (INTEGRAL_TYPE_P (endtype))
3890 op0 = TREE_OPERAND (value, 0);
3891 op1 = TREE_OPERAND (value, 1);
3893 /* Like STRIP_NOPS except allow the operand mode to widen.
3894 This works around a feature of fold that simplifies
3895 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3896 that the narrower operation is cheaper. */
3898 while (TREE_CODE (op0) == NOP_EXPR
3899 || TREE_CODE (op0) == CONVERT_EXPR
3900 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3902 tree inner = TREE_OPERAND (op0, 0);
3903 if (inner == error_mark_node
3904 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3905 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3906 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3911 while (TREE_CODE (op1) == NOP_EXPR
3912 || TREE_CODE (op1) == CONVERT_EXPR
3913 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3915 tree inner = TREE_OPERAND (op1, 0);
3916 if (inner == error_mark_node
3917 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3918 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3919 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3924 op0 = initializer_constant_valid_p (op0, endtype);
3925 op1 = initializer_constant_valid_p (op1, endtype);
3927 /* Both initializers must be known. */
3931 return null_pointer_node;
3933 /* Support differences between labels. */
3934 if (TREE_CODE (op0) == LABEL_DECL
3935 && TREE_CODE (op1) == LABEL_DECL)
3936 return null_pointer_node;
3938 if (TREE_CODE (op0) == STRING_CST
3939 && TREE_CODE (op1) == STRING_CST
3940 && operand_equal_p (op0, op1, 1))
3941 return null_pointer_node;
3953 /* Output assembler code for constant EXP to FILE, with no label.
3954 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3955 Assumes output_addressed_constants has been done on EXP already.
3957 Generate exactly SIZE bytes of assembler data, padding at the end
3958 with zeros if necessary. SIZE must always be specified.
3960 SIZE is important for structure constructors,
3961 since trailing members may have been omitted from the constructor.
3962 It is also important for initialization of arrays from string constants
3963 since the full length of the string constant might not be wanted.
3964 It is also needed for initialization of unions, where the initializer's
3965 type is just one member, and that may not be as long as the union.
3967 There a case in which we would fail to output exactly SIZE bytes:
3968 for a structure constructor that wants to produce more than SIZE bytes.
3969 But such constructors will never be generated for any possible input.
3971 ALIGN is the alignment of the data in bits. */
3974 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3976 enum tree_code code;
3977 unsigned HOST_WIDE_INT thissize;
3979 /* Some front-ends use constants other than the standard language-independent
3980 varieties, but which may still be output directly. Give the front-end a
3981 chance to convert EXP to a language-independent representation. */
3982 exp = lang_hooks.expand_constant (exp);
3984 if (size == 0 || flag_syntax_only)
3987 /* See if we're trying to initialize a pointer in a non-default mode
3988 to the address of some declaration somewhere. If the target says
3989 the mode is valid for pointers, assume the target has a way of
3991 if (TREE_CODE (exp) == NOP_EXPR
3992 && POINTER_TYPE_P (TREE_TYPE (exp))
3993 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3995 tree saved_type = TREE_TYPE (exp);
3997 /* Peel off any intermediate conversions-to-pointer for valid
3999 while (TREE_CODE (exp) == NOP_EXPR
4000 && POINTER_TYPE_P (TREE_TYPE (exp))
4001 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
4002 exp = TREE_OPERAND (exp, 0);
4004 /* If what we're left with is the address of something, we can
4005 convert the address to the final type and output it that
4007 if (TREE_CODE (exp) == ADDR_EXPR)
4008 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
4009 /* Likewise for constant ints. */
4010 else if (TREE_CODE (exp) == INTEGER_CST)
4011 exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
4012 TREE_INT_CST_HIGH (exp));
4016 /* Eliminate any conversions since we'll be outputting the underlying
4018 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4019 || TREE_CODE (exp) == NON_LVALUE_EXPR
4020 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4022 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp));
4023 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)));
4025 /* Make sure eliminating the conversion is really a no-op, except with
4026 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4027 union types to allow for Ada unchecked unions. */
4028 if (type_size > op_size
4029 && TREE_CODE (exp) != VIEW_CONVERT_EXPR
4030 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE)
4031 internal_error ("no-op convert from %wd to %wd bytes in initializer",
4032 op_size, type_size);
4034 exp = TREE_OPERAND (exp, 0);
4037 code = TREE_CODE (TREE_TYPE (exp));
4038 thissize = int_size_in_bytes (TREE_TYPE (exp));
4040 /* Allow a constructor with no elements for any data type.
4041 This means to fill the space with zeros. */
4042 if (TREE_CODE (exp) == CONSTRUCTOR
4043 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
4045 assemble_zeros (size);
4049 if (TREE_CODE (exp) == FDESC_EXPR)
4051 #ifdef ASM_OUTPUT_FDESC
4052 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4053 tree decl = TREE_OPERAND (exp, 0);
4054 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4061 /* Now output the underlying data. If we've handling the padding, return.
4062 Otherwise, break and ensure SIZE is the size written. */
4069 case REFERENCE_TYPE:
4071 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4072 EXPAND_INITIALIZER),
4073 MIN (size, thissize), align, 0))
4074 error ("initializer for integer value is too complicated");
4078 if (TREE_CODE (exp) != REAL_CST)
4079 error ("initializer for floating value is not a floating constant");
4081 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
4085 output_constant (TREE_REALPART (exp), thissize / 2, align);
4086 output_constant (TREE_IMAGPART (exp), thissize / 2,
4087 min_align (align, BITS_PER_UNIT * (thissize / 2)));
4092 switch (TREE_CODE (exp))
4095 output_constructor (exp, size, align);
4098 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
4100 assemble_string (TREE_STRING_POINTER (exp), thissize);
4107 unsigned int nalign;
4108 enum machine_mode inner;
4110 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
4111 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
4113 elt_size = GET_MODE_SIZE (inner);
4115 link = TREE_VECTOR_CST_ELTS (exp);
4116 output_constant (TREE_VALUE (link), elt_size, align);
4117 while ((link = TREE_CHAIN (link)) != NULL)
4118 output_constant (TREE_VALUE (link), elt_size, nalign);
4128 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
4129 output_constructor (exp, size, align);
4139 if (size > thissize)
4140 assemble_zeros (size - thissize);
4144 /* Subroutine of output_constructor, used for computing the size of
4145 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4146 type with an unspecified upper bound. */
4148 static unsigned HOST_WIDE_INT
4149 array_size_for_constructor (tree val)
4152 unsigned HOST_WIDE_INT cnt;
4153 tree index, value, tmp;
4155 /* This code used to attempt to handle string constants that are not
4156 arrays of single-bytes, but nothing else does, so there's no point in
4158 if (TREE_CODE (val) == STRING_CST)
4159 return TREE_STRING_LENGTH (val);
4161 max_index = NULL_TREE;
4162 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
4164 if (TREE_CODE (index) == RANGE_EXPR)
4165 index = TREE_OPERAND (index, 1);
4166 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4170 if (max_index == NULL_TREE)
4173 /* Compute the total number of array elements. */
4174 tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)));
4175 i = size_binop (MINUS_EXPR, fold_convert (sizetype, max_index),
4176 fold_convert (sizetype, tmp));
4177 i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
4179 /* Multiply by the array element unit size to find number of bytes. */
4180 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4182 return tree_low_cst (i, 1);
4185 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4186 Generate at least SIZE bytes, padding if necessary. */
4189 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4192 tree type = TREE_TYPE (exp);
4195 /* Number of bytes output or skipped so far.
4196 In other words, current position within the constructor. */
4197 HOST_WIDE_INT total_bytes = 0;
4198 /* Nonzero means BYTE contains part of a byte, to be output. */
4199 int byte_buffer_in_use = 0;
4201 unsigned HOST_WIDE_INT cnt;
4202 constructor_elt *ce;
4204 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4206 if (TREE_CODE (type) == RECORD_TYPE)
4207 field = TYPE_FIELDS (type);
4209 if (TREE_CODE (type) == ARRAY_TYPE
4210 && TYPE_DOMAIN (type) != 0)
4211 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4213 /* As LINK goes through the elements of the constant,
4214 FIELD goes through the structure fields, if the constant is a structure.
4215 if the constant is a union, then we override this,
4216 by getting the field from the TREE_LIST element.
4217 But the constant could also be an array. Then FIELD is zero.
4219 There is always a maximum of one element in the chain LINK for unions
4220 (even if the initializer in a source program incorrectly contains
4223 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4224 cnt++, field = field ? TREE_CHAIN (field) : 0)
4226 tree val = ce->value;
4229 /* The element in a union constructor specifies the proper field
4231 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4232 || TREE_CODE (type) == QUAL_UNION_TYPE)
4236 else if (TREE_CODE (type) == ARRAY_TYPE)
4239 #ifdef ASM_COMMENT_START
4240 if (field && flag_verbose_asm)
4241 fprintf (asm_out_file, "%s %s:\n",
4244 ? IDENTIFIER_POINTER (DECL_NAME (field))
4248 /* Eliminate the marker that makes a cast not be an lvalue. */
4252 if (index && TREE_CODE (index) == RANGE_EXPR)
4254 unsigned HOST_WIDE_INT fieldsize
4255 = int_size_in_bytes (TREE_TYPE (type));
4256 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4257 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4258 HOST_WIDE_INT index;
4259 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4261 for (index = lo_index; index <= hi_index; index++)
4263 /* Output the element's initial value. */
4265 assemble_zeros (fieldsize);
4267 output_constant (val, fieldsize, align2);
4269 /* Count its size. */
4270 total_bytes += fieldsize;
4273 else if (field == 0 || !DECL_BIT_FIELD (field))
4275 /* An element that is not a bit-field. */
4277 unsigned HOST_WIDE_INT fieldsize;
4278 /* Since this structure is static,
4279 we know the positions are constant. */
4280 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4281 unsigned int align2;
4284 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4285 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4287 /* Output any buffered-up bit-fields preceding this element. */
4288 if (byte_buffer_in_use)
4290 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4292 byte_buffer_in_use = 0;
4295 /* Advance to offset of this element.
4296 Note no alignment needed in an array, since that is guaranteed
4297 if each element has the proper size. */
4298 if ((field != 0 || index != 0) && pos != total_bytes)
4300 gcc_assert (pos >= total_bytes);
4301 assemble_zeros (pos - total_bytes);
4305 /* Find the alignment of this element. */
4306 align2 = min_align (align, BITS_PER_UNIT * pos);
4308 /* Determine size this element should occupy. */
4313 /* If this is an array with an unspecified upper bound,
4314 the initializer determines the size. */
4315 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4316 but we cannot do this until the deprecated support for
4317 initializing zero-length array members is removed. */
4318 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4319 && TYPE_DOMAIN (TREE_TYPE (field))
4320 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4322 fieldsize = array_size_for_constructor (val);
4323 /* Given a non-empty initialization, this field had
4325 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4327 else if (DECL_SIZE_UNIT (field))
4329 /* ??? This can't be right. If the decl size overflows
4330 a host integer we will silently emit no data. */
4331 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4332 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4336 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4338 /* Output the element's initial value. */
4340 assemble_zeros (fieldsize);
4342 output_constant (val, fieldsize, align2);
4344 /* Count its size. */
4345 total_bytes += fieldsize;
4347 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4348 error ("invalid initial value for member %qs",
4349 IDENTIFIER_POINTER (DECL_NAME (field)));
4352 /* Element that is a bit-field. */
4354 HOST_WIDE_INT next_offset = int_bit_position (field);
4355 HOST_WIDE_INT end_offset
4356 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4359 val = integer_zero_node;
4361 /* If this field does not start in this (or, next) byte,
4363 if (next_offset / BITS_PER_UNIT != total_bytes)
4365 /* Output remnant of any bit field in previous bytes. */
4366 if (byte_buffer_in_use)
4368 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4370 byte_buffer_in_use = 0;
4373 /* If still not at proper byte, advance to there. */
4374 if (next_offset / BITS_PER_UNIT != total_bytes)
4376 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4377 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4378 total_bytes = next_offset / BITS_PER_UNIT;
4382 if (! byte_buffer_in_use)
4385 /* We must split the element into pieces that fall within
4386 separate bytes, and combine each byte with previous or
4387 following bit-fields. */
4389 /* next_offset is the offset n fbits from the beginning of
4390 the structure to the next bit of this element to be processed.
4391 end_offset is the offset of the first bit past the end of
4393 while (next_offset < end_offset)
4397 HOST_WIDE_INT value;
4398 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4399 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4401 /* Advance from byte to byte
4402 within this element when necessary. */
4403 while (next_byte != total_bytes)
4405 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4410 /* Number of bits we can process at once
4411 (all part of the same byte). */
4412 this_time = MIN (end_offset - next_offset,
4413 BITS_PER_UNIT - next_bit);
4414 if (BYTES_BIG_ENDIAN)
4416 /* On big-endian machine, take the most significant bits
4417 first (of the bits that are significant)
4418 and put them into bytes from the most significant end. */
4419 shift = end_offset - next_offset - this_time;
4421 /* Don't try to take a bunch of bits that cross
4422 the word boundary in the INTEGER_CST. We can
4423 only select bits from the LOW or HIGH part
4425 if (shift < HOST_BITS_PER_WIDE_INT
4426 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4428 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4429 shift = HOST_BITS_PER_WIDE_INT;
4432 /* Now get the bits from the appropriate constant word. */
4433 if (shift < HOST_BITS_PER_WIDE_INT)
4434 value = TREE_INT_CST_LOW (val);
4437 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4438 value = TREE_INT_CST_HIGH (val);
4439 shift -= HOST_BITS_PER_WIDE_INT;
4442 /* Get the result. This works only when:
4443 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4444 byte |= (((value >> shift)
4445 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4446 << (BITS_PER_UNIT - this_time - next_bit));
4450 /* On little-endian machines,
4451 take first the least significant bits of the value
4452 and pack them starting at the least significant
4453 bits of the bytes. */
4454 shift = next_offset - int_bit_position (field);
4456 /* Don't try to take a bunch of bits that cross
4457 the word boundary in the INTEGER_CST. We can
4458 only select bits from the LOW or HIGH part
4460 if (shift < HOST_BITS_PER_WIDE_INT
4461 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4462 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4464 /* Now get the bits from the appropriate constant word. */
4465 if (shift < HOST_BITS_PER_WIDE_INT)
4466 value = TREE_INT_CST_LOW (val);
4469 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4470 value = TREE_INT_CST_HIGH (val);
4471 shift -= HOST_BITS_PER_WIDE_INT;
4474 /* Get the result. This works only when:
4475 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4476 byte |= (((value >> shift)
4477 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4481 next_offset += this_time;
4482 byte_buffer_in_use = 1;
4487 if (byte_buffer_in_use)
4489 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4493 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4494 assemble_zeros (size - total_bytes);
4497 /* This TREE_LIST contains any weak symbol declarations waiting
4499 static GTY(()) tree weak_decls;
4501 /* Mark DECL as weak. */
4504 mark_weak (tree decl)
4506 DECL_WEAK (decl) = 1;
4508 if (DECL_RTL_SET_P (decl)
4509 && MEM_P (DECL_RTL (decl))
4510 && XEXP (DECL_RTL (decl), 0)
4511 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4512 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4515 /* Merge weak status between NEWDECL and OLDDECL. */
4518 merge_weak (tree newdecl, tree olddecl)
4520 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4522 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4525 /* We put the NEWDECL on the weak_decls list at some point
4526 and OLDDECL as well. Keep just OLDDECL on the list. */
4527 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4528 if (TREE_VALUE (*pwd) == newdecl)
4530 *pwd = TREE_CHAIN (*pwd);
4537 if (DECL_WEAK (newdecl))
4541 /* NEWDECL is weak, but OLDDECL is not. */
4543 /* If we already output the OLDDECL, we're in trouble; we can't
4544 go back and make it weak. This error cannot caught in
4545 declare_weak because the NEWDECL and OLDDECL was not yet
4546 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4547 if (TREE_ASM_WRITTEN (olddecl))
4548 error ("weak declaration of %q+D must precede definition",
4551 /* If we've already generated rtl referencing OLDDECL, we may
4552 have done so in a way that will not function properly with
4554 else if (TREE_USED (olddecl)
4555 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4556 warning (0, "weak declaration of %q+D after first use results "
4557 "in unspecified behavior", newdecl);
4561 /* We put the NEWDECL on the weak_decls list at some point.
4562 Replace it with the OLDDECL. */
4563 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4564 if (TREE_VALUE (wd) == newdecl)
4566 TREE_VALUE (wd) = olddecl;
4569 /* We may not find the entry on the list. If NEWDECL is a
4570 weak alias, then we will have already called
4571 globalize_decl to remove the entry; in that case, we do
4572 not need to do anything. */
4575 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4576 mark_weak (olddecl);
4579 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4580 weak. Just update NEWDECL to indicate that it's weak too. */
4581 mark_weak (newdecl);
4584 /* Declare DECL to be a weak symbol. */
4587 declare_weak (tree decl)
4589 if (! TREE_PUBLIC (decl))
4590 error ("weak declaration of %q+D must be public", decl);
4591 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4592 error ("weak declaration of %q+D must precede definition", decl);
4593 else if (SUPPORTS_WEAK)
4595 if (! DECL_WEAK (decl))
4596 weak_decls = tree_cons (NULL, decl, weak_decls);
4599 warning (0, "weak declaration of %q+D not supported", decl);
4605 weak_finish_1 (tree decl)
4607 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4608 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4611 if (! TREE_USED (decl))
4614 #ifdef ASM_WEAKEN_DECL
4615 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4617 #ifdef ASM_WEAKEN_LABEL
4618 ASM_WEAKEN_LABEL (asm_out_file, name);
4620 #ifdef ASM_OUTPUT_WEAK_ALIAS
4622 static bool warn_once = 0;
4625 warning (0, "only weak aliases are supported in this configuration");
4635 /* This TREE_LIST contains weakref targets. */
4637 static GTY(()) tree weakref_targets;
4639 /* Forward declaration. */
4640 static tree find_decl_and_mark_needed (tree decl, tree target);
4642 /* Emit any pending weak declarations. */
4649 for (t = weakref_targets; t; t = TREE_CHAIN (t))
4651 tree alias_decl = TREE_PURPOSE (t);
4652 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t));
4654 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl)))
4655 /* Remove alias_decl from the weak list, but leave entries for
4656 the target alone. */
4658 #ifndef ASM_OUTPUT_WEAKREF
4659 else if (! TREE_SYMBOL_REFERENCED (target))
4661 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
4662 defined, otherwise we and weak_finish_1 would use a
4663 different macros. */
4664 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
4665 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target));
4667 tree decl = find_decl_and_mark_needed (alias_decl, target);
4671 decl = build_decl (TREE_CODE (alias_decl), target,
4672 TREE_TYPE (alias_decl));
4674 DECL_EXTERNAL (decl) = 1;
4675 TREE_PUBLIC (decl) = 1;
4676 DECL_ARTIFICIAL (decl) = 1;
4677 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl);
4678 TREE_USED (decl) = 1;
4681 weak_finish_1 (decl);
4690 /* Remove the alias and the target from the pending weak list
4691 so that we do not emit any .weak directives for the former,
4692 nor multiple .weak directives for the latter. */
4693 for (p = &weak_decls; (t2 = *p) ; )
4695 if (TREE_VALUE (t2) == alias_decl
4696 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2)))
4697 *p = TREE_CHAIN (t2);
4699 p = &TREE_CHAIN (t2);
4702 /* Remove other weakrefs to the same target, to speed things up. */
4703 for (p = &TREE_CHAIN (t); (t2 = *p) ; )
4705 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2)))
4706 *p = TREE_CHAIN (t2);
4708 p = &TREE_CHAIN (t2);
4713 for (t = weak_decls; t; t = TREE_CHAIN (t))
4715 tree decl = TREE_VALUE (t);
4717 weak_finish_1 (decl);
4721 /* Emit the assembly bits to indicate that DECL is globally visible. */
4724 globalize_decl (tree decl)
4726 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4728 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4729 if (DECL_WEAK (decl))
4733 #ifdef ASM_WEAKEN_DECL
4734 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4736 ASM_WEAKEN_LABEL (asm_out_file, name);
4739 /* Remove this function from the pending weak list so that
4740 we do not emit multiple .weak directives for it. */
4741 for (p = &weak_decls; (t = *p) ; )
4743 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4744 *p = TREE_CHAIN (t);
4746 p = &TREE_CHAIN (t);
4749 /* Remove weakrefs to the same target from the pending weakref
4750 list, for the same reason. */
4751 for (p = &weakref_targets; (t = *p) ; )
4753 if (DECL_ASSEMBLER_NAME (decl)
4754 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4755 *p = TREE_CHAIN (t);
4757 p = &TREE_CHAIN (t);
4762 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4763 if (DECL_ONE_ONLY (decl))
4764 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4767 targetm.asm_out.globalize_label (asm_out_file, name);
4770 /* We have to be able to tell cgraph about the needed-ness of the target
4771 of an alias. This requires that the decl have been defined. Aliases
4772 that precede their definition have to be queued for later processing. */
4774 typedef struct alias_pair GTY(())
4780 /* Define gc'd vector type. */
4781 DEF_VEC_O(alias_pair);
4782 DEF_VEC_ALLOC_O(alias_pair,gc);
4784 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4786 /* Given an assembly name, find the decl it is associated with. At the
4787 same time, mark it needed for cgraph. */
4790 find_decl_and_mark_needed (tree decl, tree target)
4792 struct cgraph_node *fnode = NULL;
4793 struct cgraph_varpool_node *vnode = NULL;
4795 if (TREE_CODE (decl) == FUNCTION_DECL)
4797 fnode = cgraph_node_for_asm (target);
4799 vnode = cgraph_varpool_node_for_asm (target);
4803 vnode = cgraph_varpool_node_for_asm (target);
4805 fnode = cgraph_node_for_asm (target);
4810 /* We can't mark function nodes as used after cgraph global info
4811 is finished. This wouldn't generally be necessary, but C++
4812 virtual table thunks are introduced late in the game and
4813 might seem like they need marking, although in fact they
4815 if (! cgraph_global_info_ready)
4816 cgraph_mark_needed_node (fnode);
4821 cgraph_varpool_mark_needed_node (vnode);
4828 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4829 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4830 tree node is DECL to have the value of the tree node TARGET. */
4833 do_assemble_alias (tree decl, tree target)
4835 if (TREE_ASM_WRITTEN (decl))
4838 TREE_ASM_WRITTEN (decl) = 1;
4839 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4841 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4843 ultimate_transparent_alias_target (&target);
4845 if (!TREE_SYMBOL_REFERENCED (target))
4846 weakref_targets = tree_cons (decl, target, weakref_targets);
4848 #ifdef ASM_OUTPUT_WEAKREF
4849 ASM_OUTPUT_WEAKREF (asm_out_file, decl,
4850 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4851 IDENTIFIER_POINTER (target));
4855 error ("%Jweakref is not supported in this configuration", decl);
4862 #ifdef ASM_OUTPUT_DEF
4863 /* Make name accessible from other files, if appropriate. */
4865 if (TREE_PUBLIC (decl))
4867 globalize_decl (decl);
4868 maybe_assemble_visibility (decl);
4871 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4872 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4874 ASM_OUTPUT_DEF (asm_out_file,
4875 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4876 IDENTIFIER_POINTER (target));
4878 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4883 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4884 # ifdef ASM_WEAKEN_DECL
4885 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4887 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4889 /* Remove this function from the pending weak list so that
4890 we do not emit multiple .weak directives for it. */
4891 for (p = &weak_decls; (t = *p) ; )
4892 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4893 *p = TREE_CHAIN (t);
4895 p = &TREE_CHAIN (t);
4897 /* Remove weakrefs to the same target from the pending weakref
4898 list, for the same reason. */
4899 for (p = &weakref_targets; (t = *p) ; )
4901 if (DECL_ASSEMBLER_NAME (decl)
4902 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4903 *p = TREE_CHAIN (t);
4905 p = &TREE_CHAIN (t);
4911 /* First pass of completing pending aliases. Make sure that cgraph knows
4912 which symbols will be required. */
4915 finish_aliases_1 (void)
4920 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4924 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4925 if (target_decl == NULL)
4927 if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4928 error ("%q+D aliased to undefined symbol %qs",
4929 p->decl, IDENTIFIER_POINTER (p->target));
4931 else if (DECL_EXTERNAL (target_decl)
4932 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4933 error ("%q+D aliased to external symbol %qs",
4934 p->decl, IDENTIFIER_POINTER (p->target));
4938 /* Second pass of completing pending aliases. Emit the actual assembly.
4939 This happens at the end of compilation and thus it is assured that the
4940 target symbol has been emitted. */
4943 finish_aliases_2 (void)
4948 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4949 do_assemble_alias (p->decl, p->target);
4951 VEC_truncate (alias_pair, alias_pairs, 0);
4954 /* Emit an assembler directive to make the symbol for DECL an alias to
4955 the symbol for TARGET. */
4958 assemble_alias (tree decl, tree target)
4961 bool is_weakref = false;
4963 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4965 tree alias = DECL_ASSEMBLER_NAME (decl);
4969 ultimate_transparent_alias_target (&target);
4971 if (alias == target)
4972 error ("weakref %q+D ultimately targets itself", decl);
4975 #ifndef ASM_OUTPUT_WEAKREF
4976 IDENTIFIER_TRANSPARENT_ALIAS (alias) = 1;
4977 TREE_CHAIN (alias) = target;
4980 if (TREE_PUBLIC (decl))
4981 error ("weakref %q+D must have static linkage", decl);
4985 #if !defined (ASM_OUTPUT_DEF)
4986 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4987 error ("%Jalias definitions not supported in this configuration", decl);
4990 if (!DECL_WEAK (decl))
4992 error ("%Jonly weak aliases are supported in this configuration", decl);
4999 /* We must force creation of DECL_RTL for debug info generation, even though
5000 we don't use it here. */
5001 make_decl_rtl (decl);
5002 TREE_USED (decl) = 1;
5004 /* A quirk of the initial implementation of aliases required that the user
5005 add "extern" to all of them. Which is silly, but now historical. Do
5006 note that the symbol is in fact locally defined. */
5008 DECL_EXTERNAL (decl) = 0;
5010 /* Allow aliases to aliases. */
5011 if (TREE_CODE (decl) == FUNCTION_DECL)
5012 cgraph_node (decl)->alias = true;
5014 cgraph_varpool_node (decl)->alias = true;
5016 /* If the target has already been emitted, we don't have to queue the
5017 alias. This saves a tad o memory. */
5018 target_decl = find_decl_and_mark_needed (decl, target);
5019 if (target_decl && TREE_ASM_WRITTEN (target_decl))
5020 do_assemble_alias (decl, target);
5023 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
5029 /* Emit an assembler directive to set symbol for DECL visibility to
5030 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
5033 default_assemble_visibility (tree decl, int vis)
5035 static const char * const visibility_types[] = {
5036 NULL, "protected", "hidden", "internal"
5039 const char *name, *type;
5041 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5042 type = visibility_types[vis];
5044 #ifdef HAVE_GAS_HIDDEN
5045 fprintf (asm_out_file, "\t.%s\t", type);
5046 assemble_name (asm_out_file, name);
5047 fprintf (asm_out_file, "\n");
5049 warning (OPT_Wattributes, "visibility attribute not supported "
5050 "in this configuration; ignored");
5054 /* A helper function to call assemble_visibility when needed for a decl. */
5057 maybe_assemble_visibility (tree decl)
5059 enum symbol_visibility vis = DECL_VISIBILITY (decl);
5061 if (vis != VISIBILITY_DEFAULT)
5062 targetm.asm_out.visibility (decl, vis);
5065 /* Returns 1 if the target configuration supports defining public symbols
5066 so that one of them will be chosen at link time instead of generating a
5067 multiply-defined symbol error, whether through the use of weak symbols or
5068 a target-specific mechanism for having duplicates discarded. */
5071 supports_one_only (void)
5073 if (SUPPORTS_ONE_ONLY)
5075 return SUPPORTS_WEAK;
5078 /* Set up DECL as a public symbol that can be defined in multiple
5079 translation units without generating a linker error. */
5082 make_decl_one_only (tree decl)
5084 gcc_assert (TREE_CODE (decl) == VAR_DECL
5085 || TREE_CODE (decl) == FUNCTION_DECL);
5087 TREE_PUBLIC (decl) = 1;
5089 if (SUPPORTS_ONE_ONLY)
5091 #ifdef MAKE_DECL_ONE_ONLY
5092 MAKE_DECL_ONE_ONLY (decl);
5094 DECL_ONE_ONLY (decl) = 1;
5096 else if (TREE_CODE (decl) == VAR_DECL
5097 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5098 DECL_COMMON (decl) = 1;
5101 gcc_assert (SUPPORTS_WEAK);
5102 DECL_WEAK (decl) = 1;
5107 init_varasm_once (void)
5109 section_htab = htab_create_ggc (31, section_entry_hash,
5110 section_entry_eq, NULL);
5111 object_block_htab = htab_create_ggc (31, object_block_entry_hash,
5112 object_block_entry_eq, NULL);
5113 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
5114 const_desc_eq, NULL);
5116 const_alias_set = new_alias_set ();
5117 shared_constant_pool = create_constant_pool ();
5119 #ifdef TEXT_SECTION_ASM_OP
5120 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op,
5121 TEXT_SECTION_ASM_OP);
5124 #ifdef DATA_SECTION_ASM_OP
5125 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5126 DATA_SECTION_ASM_OP);
5129 #ifdef SDATA_SECTION_ASM_OP
5130 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5131 SDATA_SECTION_ASM_OP);
5134 #ifdef READONLY_DATA_SECTION_ASM_OP
5135 readonly_data_section = get_unnamed_section (0, output_section_asm_op,
5136 READONLY_DATA_SECTION_ASM_OP);
5139 #ifdef CTORS_SECTION_ASM_OP
5140 ctors_section = get_unnamed_section (0, output_section_asm_op,
5141 CTORS_SECTION_ASM_OP);
5144 #ifdef DTORS_SECTION_ASM_OP
5145 dtors_section = get_unnamed_section (0, output_section_asm_op,
5146 DTORS_SECTION_ASM_OP);
5149 #ifdef BSS_SECTION_ASM_OP
5150 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5151 output_section_asm_op,
5152 BSS_SECTION_ASM_OP);
5155 #ifdef SBSS_SECTION_ASM_OP
5156 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5157 output_section_asm_op,
5158 SBSS_SECTION_ASM_OP);
5161 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5162 | SECTION_COMMON, emit_tls_common);
5163 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5164 | SECTION_COMMON, emit_local);
5165 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5166 | SECTION_COMMON, emit_common);
5168 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
5169 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS,
5173 targetm.asm_out.init_sections ();
5175 if (readonly_data_section == NULL)
5176 readonly_data_section = text_section;
5180 decl_default_tls_model (tree decl)
5182 enum tls_model kind;
5185 is_local = targetm.binds_local_p (decl);
5189 kind = TLS_MODEL_LOCAL_EXEC;
5191 kind = TLS_MODEL_INITIAL_EXEC;
5194 /* Local dynamic is inefficient when we're not combining the
5195 parts of the address. */
5196 else if (optimize && is_local)
5197 kind = TLS_MODEL_LOCAL_DYNAMIC;
5199 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5200 if (kind < flag_tls_default)
5201 kind = flag_tls_default;
5206 /* Select a set of attributes for section NAME based on the properties
5207 of DECL and whether or not RELOC indicates that DECL's initializer
5208 might contain runtime relocations.
5210 We make the section read-only and executable for a function decl,
5211 read-only for a const data decl, and writable for a non-const data decl. */
5214 default_section_type_flags (tree decl, const char *name, int reloc)
5216 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
5220 default_section_type_flags_1 (tree decl, const char *name, int reloc,
5225 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5226 flags = SECTION_CODE;
5227 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
5229 else if (current_function_decl
5231 && cfun->unlikely_text_section_name
5232 && strcmp (name, cfun->unlikely_text_section_name) == 0)
5233 flags = SECTION_CODE;
5235 && (!current_function_decl || !cfun)
5236 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5237 flags = SECTION_CODE;
5239 flags = SECTION_WRITE;
5241 if (decl && DECL_ONE_ONLY (decl))
5242 flags |= SECTION_LINKONCE;
5244 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5245 flags |= SECTION_TLS | SECTION_WRITE;
5247 if (strcmp (name, ".bss") == 0
5248 || strncmp (name, ".bss.", 5) == 0
5249 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5250 || strcmp (name, ".sbss") == 0
5251 || strncmp (name, ".sbss.", 6) == 0
5252 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5253 flags |= SECTION_BSS;
5255 if (strcmp (name, ".tdata") == 0
5256 || strncmp (name, ".tdata.", 7) == 0
5257 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
5258 flags |= SECTION_TLS;
5260 if (strcmp (name, ".tbss") == 0
5261 || strncmp (name, ".tbss.", 6) == 0
5262 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
5263 flags |= SECTION_TLS | SECTION_BSS;
5265 /* These three sections have special ELF types. They are neither
5266 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
5267 want to print a section type (@progbits or @nobits). If someone
5268 is silly enough to emit code or TLS variables to one of these
5269 sections, then don't handle them specially. */
5270 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
5271 && (strcmp (name, ".init_array") == 0
5272 || strcmp (name, ".fini_array") == 0
5273 || strcmp (name, ".preinit_array") == 0))
5274 flags |= SECTION_NOTYPE;
5279 /* Return true if the target supports some form of global BSS,
5280 either through bss_noswitch_section, or by selecting a BSS
5281 section in TARGET_ASM_SELECT_SECTION. */
5284 have_global_bss_p (void)
5286 return bss_noswitch_section || targetm.have_switchable_bss_sections;
5289 /* Output assembly to switch to section NAME with attribute FLAGS.
5290 Four variants for common object file formats. */
5293 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
5294 unsigned int flags ATTRIBUTE_UNUSED,
5295 tree decl ATTRIBUTE_UNUSED)
5297 /* Some object formats don't support named sections at all. The
5298 front-end should already have flagged this as an error. */
5303 default_elf_asm_named_section (const char *name, unsigned int flags,
5304 tree decl ATTRIBUTE_UNUSED)
5306 char flagchars[10], *f = flagchars;
5308 /* If we have already declared this section, we can use an
5309 abbreviated form to switch back to it -- unless this section is
5310 part of a COMDAT groups, in which case GAS requires the full
5311 declaration every time. */
5312 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5313 && (flags & SECTION_DECLARED))
5315 fprintf (asm_out_file, "\t.section\t%s\n", name);
5319 if (!(flags & SECTION_DEBUG))
5321 if (flags & SECTION_WRITE)
5323 if (flags & SECTION_CODE)
5325 if (flags & SECTION_SMALL)
5327 if (flags & SECTION_MERGE)
5329 if (flags & SECTION_STRINGS)
5331 if (flags & SECTION_TLS)
5333 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5337 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
5339 if (!(flags & SECTION_NOTYPE))
5344 if (flags & SECTION_BSS)
5350 #ifdef ASM_COMMENT_START
5351 /* On platforms that use "@" as the assembly comment character,
5353 if (strcmp (ASM_COMMENT_START, "@") == 0)
5356 fprintf (asm_out_file, format, type);
5358 if (flags & SECTION_ENTSIZE)
5359 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
5360 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5361 fprintf (asm_out_file, ",%s,comdat",
5362 lang_hooks.decls.comdat_group (decl));
5365 putc ('\n', asm_out_file);
5369 default_coff_asm_named_section (const char *name, unsigned int flags,
5370 tree decl ATTRIBUTE_UNUSED)
5372 char flagchars[8], *f = flagchars;
5374 if (flags & SECTION_WRITE)
5376 if (flags & SECTION_CODE)
5380 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5384 default_pe_asm_named_section (const char *name, unsigned int flags,
5387 default_coff_asm_named_section (name, flags, decl);
5389 if (flags & SECTION_LINKONCE)
5391 /* Functions may have been compiled at various levels of
5392 optimization so we can't use `same_size' here.
5393 Instead, have the linker pick one. */
5394 fprintf (asm_out_file, "\t.linkonce %s\n",
5395 (flags & SECTION_CODE ? "discard" : "same_size"));
5399 /* The lame default section selector. */
5402 default_select_section (tree decl, int reloc,
5403 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5407 if (decl_readonly_section (decl, reloc))
5408 return readonly_data_section;
5410 else if (TREE_CODE (decl) == CONSTRUCTOR)
5412 if (! ((flag_pic && reloc)
5413 || !TREE_READONLY (decl)
5414 || TREE_SIDE_EFFECTS (decl)
5415 || !TREE_CONSTANT (decl)))
5416 return readonly_data_section;
5418 else if (TREE_CODE (decl) == STRING_CST)
5419 return readonly_data_section;
5420 else if (! (flag_pic && reloc))
5421 return readonly_data_section;
5423 return data_section;
5426 enum section_category
5427 categorize_decl_for_section (tree decl, int reloc, int shlib)
5429 enum section_category ret;
5431 if (TREE_CODE (decl) == FUNCTION_DECL)
5433 else if (TREE_CODE (decl) == STRING_CST)
5435 if (flag_mudflap) /* or !flag_merge_constants */
5436 return SECCAT_RODATA;
5438 return SECCAT_RODATA_MERGE_STR;
5440 else if (TREE_CODE (decl) == VAR_DECL)
5442 if (bss_initializer_p (decl))
5444 else if (! TREE_READONLY (decl)
5445 || TREE_SIDE_EFFECTS (decl)
5446 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5448 if (shlib && (reloc & 2))
5449 ret = SECCAT_DATA_REL;
5450 else if (shlib && reloc)
5451 ret = SECCAT_DATA_REL_LOCAL;
5455 else if (shlib && (reloc & 2))
5456 ret = SECCAT_DATA_REL_RO;
5457 else if (shlib && reloc)
5458 ret = SECCAT_DATA_REL_RO_LOCAL;
5459 else if (reloc || flag_merge_constants < 2)
5460 /* C and C++ don't allow different variables to share the same
5461 location. -fmerge-all-constants allows even that (at the
5462 expense of not conforming). */
5463 ret = SECCAT_RODATA;
5464 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5465 ret = SECCAT_RODATA_MERGE_STR_INIT;
5467 ret = SECCAT_RODATA_MERGE_CONST;
5469 else if (TREE_CODE (decl) == CONSTRUCTOR)
5471 if ((shlib && reloc)
5472 || TREE_SIDE_EFFECTS (decl)
5473 || ! TREE_CONSTANT (decl))
5476 ret = SECCAT_RODATA;
5479 ret = SECCAT_RODATA;
5481 /* There are no read-only thread-local sections. */
5482 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5484 /* Note that this would be *just* SECCAT_BSS, except that there's
5485 no concept of a read-only thread-local-data section. */
5486 if (ret == SECCAT_BSS
5487 || (flag_zero_initialized_in_bss
5488 && initializer_zerop (DECL_INITIAL (decl))))
5494 /* If the target uses small data sections, select it. */
5495 else if (targetm.in_small_data_p (decl))
5497 if (ret == SECCAT_BSS)
5499 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5500 ret = SECCAT_SRODATA;
5509 decl_readonly_section (tree decl, int reloc)
5511 return decl_readonly_section_1 (decl, reloc, flag_pic);
5515 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5517 switch (categorize_decl_for_section (decl, reloc, shlib))
5520 case SECCAT_RODATA_MERGE_STR:
5521 case SECCAT_RODATA_MERGE_STR_INIT:
5522 case SECCAT_RODATA_MERGE_CONST:
5523 case SECCAT_SRODATA:
5532 /* Select a section based on the above categorization. */
5535 default_elf_select_section (tree decl, int reloc,
5536 unsigned HOST_WIDE_INT align)
5538 return default_elf_select_section_1 (decl, reloc, align, flag_pic);
5542 default_elf_select_section_1 (tree decl, int reloc,
5543 unsigned HOST_WIDE_INT align, int shlib)
5546 switch (categorize_decl_for_section (decl, reloc, shlib))
5549 /* We're not supposed to be called on FUNCTION_DECLs. */
5552 return readonly_data_section;
5553 case SECCAT_RODATA_MERGE_STR:
5554 return mergeable_string_section (decl, align, 0);
5555 case SECCAT_RODATA_MERGE_STR_INIT:
5556 return mergeable_string_section (DECL_INITIAL (decl), align, 0);
5557 case SECCAT_RODATA_MERGE_CONST:
5558 return mergeable_constant_section (DECL_MODE (decl), align, 0);
5559 case SECCAT_SRODATA:
5563 return data_section;
5564 case SECCAT_DATA_REL:
5565 sname = ".data.rel";
5567 case SECCAT_DATA_REL_LOCAL:
5568 sname = ".data.rel.local";
5570 case SECCAT_DATA_REL_RO:
5571 sname = ".data.rel.ro";
5573 case SECCAT_DATA_REL_RO_LOCAL:
5574 sname = ".data.rel.ro.local";
5599 return get_named_section (decl, sname, reloc);
5602 /* Construct a unique section name based on the decl name and the
5603 categorization performed above. */
5606 default_unique_section (tree decl, int reloc)
5608 default_unique_section_1 (decl, reloc, flag_pic);
5612 default_unique_section_1 (tree decl, int reloc, int shlib)
5614 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5615 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5616 const char *prefix, *name;
5620 switch (categorize_decl_for_section (decl, reloc, shlib))
5623 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5626 case SECCAT_RODATA_MERGE_STR:
5627 case SECCAT_RODATA_MERGE_STR_INIT:
5628 case SECCAT_RODATA_MERGE_CONST:
5629 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5631 case SECCAT_SRODATA:
5632 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5635 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5637 case SECCAT_DATA_REL:
5638 prefix = one_only ? ".gnu.linkonce.d.rel." : ".data.rel.";
5640 case SECCAT_DATA_REL_LOCAL:
5641 prefix = one_only ? ".gnu.linkonce.d.rel.local." : ".data.rel.local.";
5643 case SECCAT_DATA_REL_RO:
5644 prefix = one_only ? ".gnu.linkonce.d.rel.ro." : ".data.rel.ro.";
5646 case SECCAT_DATA_REL_RO_LOCAL:
5647 prefix = one_only ? ".gnu.linkonce.d.rel.ro.local."
5648 : ".data.rel.ro.local.";
5651 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5654 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5657 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5660 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5663 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5668 plen = strlen (prefix);
5670 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5671 name = targetm.strip_name_encoding (name);
5672 nlen = strlen (name);
5674 string = alloca (nlen + plen + 1);
5675 memcpy (string, prefix, plen);
5676 memcpy (string + plen, name, nlen + 1);
5678 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5682 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5684 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5687 switch (GET_CODE (x))
5692 return data_section;
5698 return readonly_data_section;
5702 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5703 unsigned HOST_WIDE_INT align)
5705 /* ??? Handle small data here somehow. */
5708 switch (GET_CODE (x))
5712 return get_named_section (NULL, ".data.rel.ro", 3);
5715 return get_named_section (NULL, ".data.rel.ro.local", 1);
5721 return mergeable_constant_section (mode, align, 0);
5724 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5727 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5732 /* Careful not to prod global register variables. */
5735 symbol = XEXP (rtl, 0);
5736 if (GET_CODE (symbol) != SYMBOL_REF)
5739 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO;
5740 if (TREE_CODE (decl) == FUNCTION_DECL)
5741 flags |= SYMBOL_FLAG_FUNCTION;
5742 if (targetm.binds_local_p (decl))
5743 flags |= SYMBOL_FLAG_LOCAL;
5744 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5745 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
5746 else if (targetm.in_small_data_p (decl))
5747 flags |= SYMBOL_FLAG_SMALL;
5748 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5749 being PUBLIC, the thing *must* be defined in this translation unit.
5750 Prevent this buglet from being propagated into rtl code as well. */
5751 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5752 flags |= SYMBOL_FLAG_EXTERNAL;
5754 SYMBOL_REF_FLAGS (symbol) = flags;
5757 /* By default, we do nothing for encode_section_info, so we need not
5758 do anything but discard the '*' marker. */
5761 default_strip_name_encoding (const char *str)
5763 return str + (*str == '*');
5766 #ifdef ASM_OUTPUT_DEF
5767 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
5768 anchor relative to ".", the current section position. */
5771 default_asm_output_anchor (rtx symbol)
5775 sprintf (buffer, ". + " HOST_WIDE_INT_PRINT_DEC,
5776 SYMBOL_REF_BLOCK_OFFSET (symbol));
5777 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer);
5781 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
5784 default_use_anchors_for_symbol_p (rtx symbol)
5789 /* Don't use anchors for mergeable sections. The linker might move
5790 the objects around. */
5791 sect = SYMBOL_REF_BLOCK (symbol)->sect;
5792 if (sect->common.flags & SECTION_MERGE)
5795 /* Don't use anchors for small data sections. The small data register
5796 acts as an anchor for such sections. */
5797 if (sect->common.flags & SECTION_SMALL)
5800 decl = SYMBOL_REF_DECL (symbol);
5801 if (decl && DECL_P (decl))
5803 /* Don't use section anchors for decls that might be defined by
5805 if (!targetm.binds_local_p (decl))
5808 /* Don't use section anchors for decls that will be placed in a
5809 small data section. */
5810 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
5811 one above. The problem is that we only use SECTION_SMALL for
5812 sections that should be marked as small in the section directive. */
5813 if (targetm.in_small_data_p (decl))
5819 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5820 wrt cross-module name binding. */
5823 default_binds_local_p (tree exp)
5825 return default_binds_local_p_1 (exp, flag_shlib);
5829 default_binds_local_p_1 (tree exp, int shlib)
5833 /* A non-decl is an entry in the constant pool. */
5836 /* Weakrefs may not bind locally, even though the weakref itself is
5837 always static and therefore local. */
5838 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
5840 /* Static variables are always local. */
5841 else if (! TREE_PUBLIC (exp))
5843 /* A variable is local if the user has said explicitly that it will
5845 else if (DECL_VISIBILITY_SPECIFIED (exp)
5846 && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5848 /* Variables defined outside this object might not be local. */
5849 else if (DECL_EXTERNAL (exp))
5851 /* If defined in this object and visibility is not default, must be
5853 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5855 /* Default visibility weak data can be overridden by a strong symbol
5856 in another module and so are not local. */
5857 else if (DECL_WEAK (exp))
5859 /* If PIC, then assume that any global name can be overridden by
5860 symbols resolved from other modules. */
5863 /* Uninitialized COMMON variable may be unified with symbols
5864 resolved from other modules. */
5865 else if (DECL_COMMON (exp)
5866 && (DECL_INITIAL (exp) == NULL
5867 || DECL_INITIAL (exp) == error_mark_node))
5869 /* Otherwise we're left with initialized (or non-common) global data
5870 which is of necessity defined locally. */
5877 /* Determine whether or not a pointer mode is valid. Assume defaults
5878 of ptr_mode or Pmode - can be overridden. */
5880 default_valid_pointer_mode (enum machine_mode mode)
5882 return (mode == ptr_mode || mode == Pmode);
5885 /* Default function to output code that will globalize a label. A
5886 target must define GLOBAL_ASM_OP or provide its own function to
5887 globalize a label. */
5888 #ifdef GLOBAL_ASM_OP
5890 default_globalize_label (FILE * stream, const char *name)
5892 fputs (GLOBAL_ASM_OP, stream);
5893 assemble_name (stream, name);
5894 putc ('\n', stream);
5896 #endif /* GLOBAL_ASM_OP */
5898 /* Default function to output a label for unwind information. The
5899 default is to do nothing. A target that needs nonlocal labels for
5900 unwind information must provide its own function to do this. */
5902 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5903 tree decl ATTRIBUTE_UNUSED,
5904 int for_eh ATTRIBUTE_UNUSED,
5905 int empty ATTRIBUTE_UNUSED)
5909 /* Default function to output a label to divide up the exception table.
5910 The default is to do nothing. A target that needs/wants to divide
5911 up the table must provide it's own function to do this. */
5913 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED)
5917 /* This is how to output an internal numbered label where PREFIX is
5918 the class of label and LABELNO is the number within the class. */
5921 default_internal_label (FILE *stream, const char *prefix,
5922 unsigned long labelno)
5924 char *const buf = alloca (40 + strlen (prefix));
5925 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5926 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5929 /* This is the default behavior at the beginning of a file. It's
5930 controlled by two other target-hook toggles. */
5932 default_file_start (void)
5934 if (targetm.file_start_app_off && !flag_verbose_asm)
5935 fputs (ASM_APP_OFF, asm_out_file);
5937 if (targetm.file_start_file_directive)
5938 output_file_directive (asm_out_file, main_input_filename);
5941 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5942 which emits a special section directive used to indicate whether or
5943 not this object file needs an executable stack. This is primarily
5944 a GNU extension to ELF but could be used on other targets. */
5946 int trampolines_created;
5949 file_end_indicate_exec_stack (void)
5951 unsigned int flags = SECTION_DEBUG;
5952 if (trampolines_created)
5953 flags |= SECTION_CODE;
5955 switch_to_section (get_section (".note.GNU-stack", flags, NULL));
5958 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
5959 a get_unnamed_section callback. */
5962 output_section_asm_op (const void *directive)
5964 fprintf (asm_out_file, "%s\n", (const char *) directive);
5967 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
5968 the current section is NEW_SECTION. */
5971 switch_to_section (section *new_section)
5973 if (in_section == new_section)
5976 if (new_section->common.flags & SECTION_FORGET)
5979 in_section = new_section;
5981 switch (SECTION_STYLE (new_section))
5985 && !cfun->unlikely_text_section_name
5986 && strcmp (new_section->named.name,
5987 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5988 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
5990 targetm.asm_out.named_section (new_section->named.name,
5991 new_section->named.common.flags,
5992 new_section->named.decl);
5995 case SECTION_UNNAMED:
5996 new_section->unnamed.callback (new_section->unnamed.data);
5999 case SECTION_NOSWITCH:
6004 new_section->common.flags |= SECTION_DECLARED;
6007 /* If block symbol SYMBOL has not yet been assigned an offset, place
6008 it at the end of its block. */
6011 place_block_symbol (rtx symbol)
6013 unsigned HOST_WIDE_INT size, mask, offset;
6014 struct constant_descriptor_rtx *desc;
6015 unsigned int alignment;
6016 struct object_block *block;
6019 gcc_assert (SYMBOL_REF_BLOCK (symbol));
6020 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0)
6023 /* Work out the symbol's size and alignment. */
6024 if (CONSTANT_POOL_ADDRESS_P (symbol))
6026 desc = SYMBOL_REF_CONSTANT (symbol);
6027 alignment = desc->align;
6028 size = GET_MODE_SIZE (desc->mode);
6030 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6032 decl = SYMBOL_REF_DECL (symbol);
6033 alignment = get_constant_alignment (decl);
6034 size = get_constant_size (decl);
6038 decl = SYMBOL_REF_DECL (symbol);
6039 alignment = DECL_ALIGN (decl);
6040 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6043 /* Calculate the object's offset from the start of the block. */
6044 block = SYMBOL_REF_BLOCK (symbol);
6045 mask = alignment / BITS_PER_UNIT - 1;
6046 offset = (block->size + mask) & ~mask;
6047 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
6049 /* Record the block's new alignment and size. */
6050 block->alignment = MAX (block->alignment, alignment);
6051 block->size = offset + size;
6053 VEC_safe_push (rtx, gc, block->objects, symbol);
6056 /* Return the anchor that should be used to address byte offset OFFSET
6057 from the first object in BLOCK. MODEL is the TLS model used
6061 get_section_anchor (struct object_block *block, HOST_WIDE_INT offset,
6062 enum tls_model model)
6065 unsigned int begin, middle, end;
6066 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta;
6069 /* Work out the anchor's offset. Use an offset of 0 for the first
6070 anchor so that we don't pessimize the case where we take the address
6071 of a variable at the beginning of the block. This is particularly
6072 useful when a block has only one variable assigned to it.
6074 We try to place anchors RANGE bytes apart, so there can then be
6075 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
6076 a ptr_mode offset. With some target settings, the lowest such
6077 anchor might be out of range for the lowest ptr_mode offset;
6078 likewise the highest anchor for the highest offset. Use anchors
6079 at the extreme ends of the ptr_mode range in such cases.
6081 All arithmetic uses unsigned integers in order to avoid
6083 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset;
6084 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset;
6085 range = max_offset - min_offset + 1;
6090 bias = 1 << (GET_MODE_BITSIZE (ptr_mode) - 1);
6093 delta = -(unsigned HOST_WIDE_INT) offset + max_offset;
6094 delta -= delta % range;
6097 offset = (HOST_WIDE_INT) (-delta);
6101 delta = (unsigned HOST_WIDE_INT) offset - min_offset;
6102 delta -= delta % range;
6103 if (delta > bias - 1)
6105 offset = (HOST_WIDE_INT) delta;
6109 /* Do a binary search to see if there's already an anchor we can use.
6110 Set BEGIN to the new anchor's index if not. */
6112 end = VEC_length (rtx, block->anchors);
6113 while (begin != end)
6115 middle = (end + begin) / 2;
6116 anchor = VEC_index (rtx, block->anchors, middle);
6117 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset)
6119 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset)
6121 else if (SYMBOL_REF_TLS_MODEL (anchor) > model)
6123 else if (SYMBOL_REF_TLS_MODEL (anchor) < model)
6129 /* Create a new anchor with a unique label. */
6130 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++);
6131 anchor = create_block_symbol (ggc_strdup (label), block, offset);
6132 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR;
6133 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT;
6135 /* Insert it at index BEGIN. */
6136 VEC_safe_insert (rtx, gc, block->anchors, begin, anchor);
6140 /* Output the objects in BLOCK. */
6143 output_object_block (struct object_block *block)
6145 struct constant_descriptor_rtx *desc;
6147 HOST_WIDE_INT offset;
6151 if (block->objects == NULL)
6154 /* Switch to the section and make sure that the first byte is
6155 suitably aligned. */
6156 switch_to_section (block->sect);
6157 assemble_align (block->alignment);
6159 /* Define the values of all anchors relative to the current section
6161 for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++)
6162 targetm.asm_out.output_anchor (symbol);
6164 /* Output the objects themselves. */
6166 for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++)
6168 /* Move to the object's offset, padding with zeros if necessary. */
6169 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset);
6170 offset = SYMBOL_REF_BLOCK_OFFSET (symbol);
6171 if (CONSTANT_POOL_ADDRESS_P (symbol))
6173 desc = SYMBOL_REF_CONSTANT (symbol);
6174 output_constant_pool_1 (desc, 1);
6175 offset += GET_MODE_SIZE (desc->mode);
6177 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6179 decl = SYMBOL_REF_DECL (symbol);
6180 assemble_constant_contents (decl, XSTR (symbol, 0),
6181 get_constant_alignment (decl));
6182 offset += get_constant_size (decl);
6186 decl = SYMBOL_REF_DECL (symbol);
6187 assemble_variable_contents (decl, XSTR (symbol, 0), false);
6188 offset += tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6193 /* A htab_traverse callback used to call output_object_block for
6194 each member of object_block_htab. */
6197 output_object_block_htab (void **slot, void *data ATTRIBUTE_UNUSED)
6199 output_object_block ((struct object_block *) (*slot));
6203 /* Output the definitions of all object_blocks. */
6206 output_object_blocks (void)
6208 htab_traverse (object_block_htab, output_object_block_htab, NULL);
6211 #include "gt-varasm.h"