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
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, 59 Temple Place - Suite 330, 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 const char *first_global_object_name;
64 const char *weak_global_object_name;
67 struct constant_descriptor_rtx;
68 struct rtx_constant_pool;
70 struct varasm_status GTY(())
72 /* If we're using a per-function constant pool, this is it. */
73 struct rtx_constant_pool *pool;
75 /* Number of tree-constants deferred during the expansion of this
77 unsigned int deferred_constants;
80 #define n_deferred_constants (cfun->varasm->deferred_constants)
82 /* Number for making the label on the next
83 constant that is stored in memory. */
85 static GTY(()) int const_labelno;
87 /* Carry information from ASM_DECLARE_OBJECT_NAME
88 to ASM_FINISH_DECLARE_OBJECT. */
90 int size_directive_output;
92 /* The last decl for which assemble_variable was called,
93 if it did ASM_DECLARE_OBJECT_NAME.
94 If the last call to assemble_variable didn't do that,
97 tree last_assemble_variable_decl;
99 /* The following global variable indicates if the first basic block
100 in a function belongs to the cold partition or not. */
102 bool first_function_block_is_cold;
104 /* We give all constants their own alias set. Perhaps redundant with
105 MEM_READONLY_P, but pre-dates it. */
107 static HOST_WIDE_INT const_alias_set;
109 static const char *strip_reg_name (const char *);
110 static int contains_pointers_p (tree);
111 #ifdef ASM_OUTPUT_EXTERNAL
112 static bool incorporeal_function_p (tree);
114 static void decode_addr_const (tree, struct addr_const *);
115 static hashval_t const_desc_hash (const void *);
116 static int const_desc_eq (const void *, const void *);
117 static hashval_t const_hash_1 (const tree);
118 static int compare_constant (const tree, const tree);
119 static tree copy_constant (tree);
120 static void output_constant_def_contents (rtx);
121 static void output_addressed_constants (tree);
122 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
123 static unsigned min_align (unsigned, unsigned);
124 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
125 static void globalize_decl (tree);
126 static void maybe_assemble_visibility (tree);
127 static int in_named_entry_eq (const void *, const void *);
128 static hashval_t in_named_entry_hash (const void *);
129 static void initialize_cold_section_name (void);
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 bool asm_emit_uninitialised (tree, const char*,
142 unsigned HOST_WIDE_INT,
143 unsigned HOST_WIDE_INT);
144 static void mark_weak (tree);
146 static GTY(()) enum in_section in_section = no_section;
147 enum in_section last_text_section;
149 /* Return a nonzero value if DECL has a section attribute. */
150 #ifndef IN_NAMED_SECTION
151 #define IN_NAMED_SECTION(DECL) \
152 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
153 && DECL_SECTION_NAME (DECL) != NULL_TREE)
156 /* Text of section name when in_section == in_named. */
157 static GTY(()) const char *in_named_name;
158 const char *last_text_section_name;
160 /* Hash table of flags that have been used for a particular named section. */
162 struct in_named_entry GTY(())
169 static GTY((param_is (struct in_named_entry))) htab_t in_named_htab;
171 /* Define functions like text_section for any extra sections. */
172 #ifdef EXTRA_SECTION_FUNCTIONS
173 EXTRA_SECTION_FUNCTIONS
177 initialize_cold_section_name (void)
180 const char *stripped_name;
183 gcc_assert (cfun && current_function_decl);
184 if (cfun->unlikely_text_section_name)
187 if (flag_function_sections && DECL_SECTION_NAME (current_function_decl))
189 name = alloca (TREE_STRING_LENGTH (DECL_SECTION_NAME
190 (current_function_decl)));
191 strcpy ((char *) name, TREE_STRING_POINTER (DECL_SECTION_NAME
192 (current_function_decl)));
193 stripped_name = targetm.strip_name_encoding (name);
194 buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
195 cfun->unlikely_text_section_name = ggc_strdup (buffer);
198 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
201 /* Tell assembler to switch to text section. */
206 if (in_section != in_text)
208 in_section = in_text;
209 last_text_section = in_text;
210 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
214 /* Tell assembler to switch to unlikely-to-be-executed text section. */
217 unlikely_text_section (void)
221 if (!cfun->unlikely_text_section_name)
222 initialize_cold_section_name ();
224 if (flag_function_sections
225 || ((in_section != in_unlikely_executed_text)
226 && (in_section != in_named
227 || (strcmp (in_named_name, cfun->unlikely_text_section_name)
230 named_section (NULL_TREE, cfun->unlikely_text_section_name, 0);
231 in_section = in_unlikely_executed_text;
232 last_text_section = in_unlikely_executed_text;
237 named_section (NULL_TREE, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
238 in_section = in_unlikely_executed_text;
239 last_text_section = in_unlikely_executed_text;
243 /* Tell assembler to switch to data section. */
248 if (in_section != in_data)
250 in_section = in_data;
251 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
255 /* Tell assembler to switch to read-only data section. This is normally
259 readonly_data_section (void)
261 #ifdef READONLY_DATA_SECTION
262 READONLY_DATA_SECTION (); /* Note this can call data_section. */
264 #ifdef READONLY_DATA_SECTION_ASM_OP
265 if (in_section != in_readonly_data)
267 in_section = in_readonly_data;
268 fputs (READONLY_DATA_SECTION_ASM_OP, asm_out_file);
269 fputc ('\n', asm_out_file);
277 /* Determine if we're in the text section. */
280 in_text_section (void)
282 return in_section == in_text;
285 /* Determine if we're in the unlikely-to-be-executed text section. */
288 in_unlikely_text_section (void)
294 ret_val = ((in_section == in_unlikely_executed_text)
295 || (in_section == in_named
296 && cfun->unlikely_text_section_name
297 && strcmp (in_named_name,
298 cfun->unlikely_text_section_name) == 0));
302 ret_val = ((in_section == in_unlikely_executed_text)
303 || (in_section == in_named
304 && strcmp (in_named_name,
305 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0));
311 /* Determine if we're in the data section. */
314 in_data_section (void)
316 return in_section == in_data;
319 /* Helper routines for maintaining in_named_htab. */
322 in_named_entry_eq (const void *p1, const void *p2)
324 const struct in_named_entry *old = p1;
325 const char *new = p2;
327 return strcmp (old->name, new) == 0;
331 in_named_entry_hash (const void *p)
333 const struct in_named_entry *old = p;
334 return htab_hash_string (old->name);
337 /* If SECTION has been seen before as a named section, return the flags
338 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
339 set of flags for a section to have, so 0 does not mean that the section
340 has not been seen. */
343 get_named_section_flags (const char *section)
345 struct in_named_entry **slot;
347 slot = (struct in_named_entry **)
348 htab_find_slot_with_hash (in_named_htab, section,
349 htab_hash_string (section), NO_INSERT);
351 return slot ? (*slot)->flags : 0;
354 /* Returns true if the section has been declared before. Sets internal
355 flag on this section in in_named_hash so subsequent calls on this
356 section will return false. */
359 named_section_first_declaration (const char *name)
361 struct in_named_entry **slot;
363 slot = (struct in_named_entry **)
364 htab_find_slot_with_hash (in_named_htab, name,
365 htab_hash_string (name), NO_INSERT);
366 if (! (*slot)->declared)
368 (*slot)->declared = true;
378 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
379 different set of flags, return false. */
382 set_named_section_flags (const char *section, unsigned int flags)
384 struct in_named_entry **slot, *entry;
386 slot = (struct in_named_entry **)
387 htab_find_slot_with_hash (in_named_htab, section,
388 htab_hash_string (section), INSERT);
393 entry = ggc_alloc (sizeof (*entry));
395 entry->name = ggc_strdup (section);
396 entry->flags = flags;
397 entry->declared = false;
399 else if (entry->flags != flags)
405 /* Tell assembler to change to section NAME with attributes FLAGS. If
406 DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with which
407 this section is associated. */
410 named_section_real (const char *name, unsigned int flags, tree decl)
412 if (in_section != in_named || strcmp (name, in_named_name) != 0)
414 bool unchanged = set_named_section_flags (name, flags);
416 gcc_assert (unchanged);
418 targetm.asm_out.named_section (name, flags, decl);
420 if (flags & SECTION_FORGET)
421 in_section = no_section;
424 in_named_name = ggc_strdup (name);
425 in_section = in_named;
429 if (in_text_section () || in_unlikely_text_section ())
431 last_text_section = in_section;
432 last_text_section_name = name;
436 /* Tell assembler to change to section NAME for DECL.
437 If DECL is NULL, just switch to section NAME.
438 If NAME is NULL, get the name from DECL.
439 If RELOC is 1, the initializer for DECL contains relocs. */
442 named_section (tree decl, const char *name, int reloc)
446 gcc_assert (!decl || DECL_P (decl));
448 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
450 if (strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0
452 && ! cfun->unlikely_text_section_name)
453 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
455 flags = targetm.section_type_flags (decl, name, reloc);
457 /* Sanity check user variables for flag changes. Non-user
458 section flag changes will die in named_section_flags.
459 However, don't complain if SECTION_OVERRIDE is set.
460 We trust that the setter knows that it is safe to ignore
461 the default flags for this decl. */
462 if (decl && ! set_named_section_flags (name, flags))
464 flags = get_named_section_flags (name);
465 if ((flags & SECTION_OVERRIDE) == 0)
466 error ("%J%D causes a section type conflict", decl, decl);
469 named_section_real (name, flags, decl);
472 /* If required, set DECL_SECTION_NAME to a unique name. */
475 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
476 int flag_function_or_data_sections)
478 if (DECL_SECTION_NAME (decl) == NULL_TREE
479 && targetm.have_named_sections
480 && (flag_function_or_data_sections
481 || DECL_ONE_ONLY (decl)))
482 targetm.asm_out.unique_section (decl, reloc);
485 #ifdef BSS_SECTION_ASM_OP
487 /* Tell the assembler to switch to the bss section. */
492 if (in_section != in_bss)
494 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
499 #ifdef ASM_OUTPUT_BSS
501 /* Utility function for ASM_OUTPUT_BSS for targets to use if
502 they don't support alignments in .bss.
503 ??? It is believed that this function will work in most cases so such
504 support is localized here. */
507 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
509 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
510 unsigned HOST_WIDE_INT rounded)
512 targetm.asm_out.globalize_label (file, name);
514 #ifdef ASM_DECLARE_OBJECT_NAME
515 last_assemble_variable_decl = decl;
516 ASM_DECLARE_OBJECT_NAME (file, name, decl);
518 /* Standard thing is just output label for the object. */
519 ASM_OUTPUT_LABEL (file, name);
520 #endif /* ASM_DECLARE_OBJECT_NAME */
521 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
526 #ifdef ASM_OUTPUT_ALIGNED_BSS
528 /* Utility function for targets to use in implementing
529 ASM_OUTPUT_ALIGNED_BSS.
530 ??? It is believed that this function will work in most cases so such
531 support is localized here. */
534 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
535 const char *name, unsigned HOST_WIDE_INT size,
539 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
540 #ifdef ASM_DECLARE_OBJECT_NAME
541 last_assemble_variable_decl = decl;
542 ASM_DECLARE_OBJECT_NAME (file, name, decl);
544 /* Standard thing is just output label for the object. */
545 ASM_OUTPUT_LABEL (file, name);
546 #endif /* ASM_DECLARE_OBJECT_NAME */
547 ASM_OUTPUT_SKIP (file, size ? size : 1);
552 #endif /* BSS_SECTION_ASM_OP */
554 /* Switch to the section for function DECL.
556 If DECL is NULL_TREE, switch to the text section. We can be passed
557 NULL_TREE under some circumstances by dbxout.c at least. */
560 function_section (tree decl)
564 if (first_function_block_is_cold)
567 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
568 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
570 if (decl != NULL_TREE
571 && DECL_SECTION_NAME (decl) != NULL_TREE
572 && targetm.have_named_sections)
573 named_section (decl, (char *) 0, 0);
580 current_function_section (tree decl)
582 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
585 if (in_unlikely_text_section ()
586 || last_text_section == in_unlikely_executed_text)
589 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
591 if (last_text_section == in_unlikely_executed_text)
592 unlikely_text_section ();
593 else if (last_text_section == in_text)
595 else if (last_text_section == in_named
596 && targetm.have_named_sections)
597 named_section (NULL_TREE, last_text_section_name, 0);
599 function_section (decl);
603 /* Switch to read-only data section associated with function DECL. */
606 default_function_rodata_section (tree decl)
608 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
610 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
612 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
614 size_t len = strlen (name) + 3;
615 char* rname = alloca (len);
617 strcpy (rname, ".rodata");
618 strcat (rname, name + 5);
619 named_section_real (rname, SECTION_LINKONCE, decl);
622 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
623 else if (DECL_ONE_ONLY (decl)
624 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
626 size_t len = strlen (name) + 1;
627 char *rname = alloca (len);
629 memcpy (rname, name, len);
631 named_section_real (rname, SECTION_LINKONCE, decl);
634 /* For .text.foo we want to use .rodata.foo. */
635 else if (flag_function_sections && flag_data_sections
636 && strncmp (name, ".text.", 6) == 0)
638 size_t len = strlen (name) + 1;
639 char *rname = alloca (len + 2);
641 memcpy (rname, ".rodata", 7);
642 memcpy (rname + 7, name + 5, len - 5);
643 named_section_flags (rname, 0);
648 readonly_data_section ();
651 /* Switch to read-only data section associated with function DECL
652 for targets where that section should be always the single
653 readonly data section. */
656 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
658 readonly_data_section ();
661 /* Switch to section for variable DECL. RELOC is the same as the
662 argument to SELECT_SECTION. */
665 variable_section (tree decl, int reloc)
667 if (IN_NAMED_SECTION (decl))
668 named_section (decl, NULL, reloc);
670 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
673 /* Tell assembler to switch to the section for string merging. */
676 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
677 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
678 unsigned int flags ATTRIBUTE_UNUSED)
680 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
681 && TREE_CODE (decl) == STRING_CST
682 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
684 && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
686 enum machine_mode mode;
687 unsigned int modesize;
692 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
693 modesize = GET_MODE_BITSIZE (mode);
694 if (modesize >= 8 && modesize <= 256
695 && (modesize & (modesize - 1)) == 0)
697 if (align < modesize)
700 str = TREE_STRING_POINTER (decl);
701 len = TREE_STRING_LENGTH (decl);
702 unit = GET_MODE_SIZE (mode);
704 /* Check for embedded NUL characters. */
705 for (i = 0; i < len; i += unit)
707 for (j = 0; j < unit; j++)
708 if (str[i + j] != '\0')
715 sprintf (name, ".rodata.str%d.%d", modesize / 8,
717 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
718 if (!i && modesize < align)
720 /* A "" string with requested alignment greater than
721 character size might cause a problem:
722 if some other string required even bigger
723 alignment than "", then linker might think the
724 "" is just part of padding after some other string
725 and not put it into the hash table initially.
726 But this means "" could have smaller alignment
728 #ifdef ASM_OUTPUT_SECTION_START
729 named_section_flags (name, flags);
730 ASM_OUTPUT_SECTION_START (asm_out_file);
732 readonly_data_section ();
737 named_section_flags (name, flags);
743 readonly_data_section ();
746 /* Tell assembler to switch to the section for constant merging. */
749 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
750 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
751 unsigned int flags ATTRIBUTE_UNUSED)
753 unsigned int modesize = GET_MODE_BITSIZE (mode);
755 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
761 && (align & (align - 1)) == 0)
765 sprintf (name, ".rodata.cst%d", (int) (align / 8));
766 flags |= (align / 8) | SECTION_MERGE;
767 named_section_flags (name, flags);
771 readonly_data_section ();
774 /* Given NAME, a putative register name, discard any customary prefixes. */
777 strip_reg_name (const char *name)
779 #ifdef REGISTER_PREFIX
780 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
781 name += strlen (REGISTER_PREFIX);
783 if (name[0] == '%' || name[0] == '#')
788 /* The user has asked for a DECL to have a particular name. Set (or
789 change) it in such a way that we don't prefix an underscore to
792 set_user_assembler_name (tree decl, const char *name)
794 char *starred = alloca (strlen (name) + 2);
796 strcpy (starred + 1, name);
797 change_decl_assembler_name (decl, get_identifier (starred));
798 SET_DECL_RTL (decl, NULL_RTX);
801 /* Decode an `asm' spec for a declaration as a register name.
802 Return the register number, or -1 if nothing specified,
803 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
804 or -3 if ASMSPEC is `cc' and is not recognized,
805 or -4 if ASMSPEC is `memory' and is not recognized.
806 Accept an exact spelling or a decimal number.
807 Prefixes such as % are optional. */
810 decode_reg_name (const char *asmspec)
816 /* Get rid of confusing prefixes. */
817 asmspec = strip_reg_name (asmspec);
819 /* Allow a decimal number as a "register name". */
820 for (i = strlen (asmspec) - 1; i >= 0; i--)
821 if (! ISDIGIT (asmspec[i]))
823 if (asmspec[0] != 0 && i < 0)
826 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
832 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
834 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
837 #ifdef ADDITIONAL_REGISTER_NAMES
839 static const struct { const char *const name; const int number; } table[]
840 = ADDITIONAL_REGISTER_NAMES;
842 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
843 if (! strcmp (asmspec, table[i].name))
844 return table[i].number;
846 #endif /* ADDITIONAL_REGISTER_NAMES */
848 if (!strcmp (asmspec, "memory"))
851 if (!strcmp (asmspec, "cc"))
860 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
861 have static storage duration. In other words, it should not be an
862 automatic variable, including PARM_DECLs.
864 There is, however, one exception: this function handles variables
865 explicitly placed in a particular register by the user.
867 This is never called for PARM_DECL nodes. */
870 make_decl_rtl (tree decl)
872 const char *name = 0;
876 /* Check that we are not being given an automatic variable. */
877 gcc_assert (TREE_CODE (decl) != PARM_DECL
878 && TREE_CODE (decl) != RESULT_DECL);
880 /* A weak alias has TREE_PUBLIC set but not the other bits. */
881 gcc_assert (TREE_CODE (decl) != VAR_DECL
882 || TREE_STATIC (decl)
883 || TREE_PUBLIC (decl)
884 || DECL_EXTERNAL (decl)
885 || DECL_REGISTER (decl));
887 /* And that we were not given a type or a label. */
888 gcc_assert (TREE_CODE (decl) != TYPE_DECL
889 && TREE_CODE (decl) != LABEL_DECL);
891 /* For a duplicate declaration, we can be called twice on the
892 same DECL node. Don't discard the RTL already made. */
893 if (DECL_RTL_SET_P (decl))
895 /* If the old RTL had the wrong mode, fix the mode. */
896 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
897 SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
898 DECL_MODE (decl), 0));
900 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
903 /* ??? Another way to do this would be to maintain a hashed
904 table of such critters. Instead of adding stuff to a DECL
905 to give certain attributes to it, we could use an external
906 hash map from DECL to set of attributes. */
908 /* Let the target reassign the RTL if it wants.
909 This is necessary, for example, when one machine specific
910 decl attribute overrides another. */
911 targetm.encode_section_info (decl, DECL_RTL (decl), false);
913 /* Make this function static known to the mudflap runtime. */
914 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
915 mudflap_enqueue_decl (decl);
920 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
922 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
924 reg_number = decode_reg_name (name);
925 /* First detect errors in declaring global registers. */
926 if (reg_number == -1)
927 error ("%Jregister name not specified for %qD", decl, decl);
928 else if (reg_number < 0)
929 error ("%Jinvalid register name for %qD", decl, decl);
930 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
931 error ("%Jdata type of %qD isn%'t suitable for a register",
933 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
934 error ("%Jregister specified for %qD isn%'t suitable for data type",
936 /* Now handle properly declared static register variables. */
941 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
943 DECL_INITIAL (decl) = 0;
944 error ("global register variable has initial value");
946 if (TREE_THIS_VOLATILE (decl))
947 warning (0, "volatile register variables don%'t "
948 "work as you might wish");
950 /* If the user specified one of the eliminables registers here,
951 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
952 confused with that register and be eliminated. This usage is
953 somewhat suspect... */
955 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
956 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
957 REG_USERVAR_P (DECL_RTL (decl)) = 1;
959 if (TREE_STATIC (decl))
961 /* Make this register global, so not usable for anything
963 #ifdef ASM_DECLARE_REGISTER_GLOBAL
964 name = IDENTIFIER_POINTER (DECL_NAME (decl));
965 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
967 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
969 globalize_reg (reg_number + --nregs);
972 /* As a register variable, it has no section. */
976 /* Now handle ordinary static variables and functions (in memory).
977 Also handle vars declared register invalidly. */
978 else if (name[0] == '*')
980 #ifdef REGISTER_PREFIX
981 if (strlen (REGISTER_PREFIX) != 0)
983 reg_number = decode_reg_name (name);
984 if (reg_number >= 0 || reg_number == -3)
985 error ("%Jregister name given for non-register variable %qD", decl, decl);
990 /* Specifying a section attribute on a variable forces it into a
991 non-.bss section, and thus it cannot be common. */
992 if (TREE_CODE (decl) == VAR_DECL
993 && DECL_SECTION_NAME (decl) != NULL_TREE
994 && DECL_INITIAL (decl) == NULL_TREE
995 && DECL_COMMON (decl))
996 DECL_COMMON (decl) = 0;
998 /* Variables can't be both common and weak. */
999 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1000 DECL_COMMON (decl) = 0;
1002 x = gen_rtx_SYMBOL_REF (Pmode, name);
1003 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1004 SYMBOL_REF_DECL (x) = decl;
1006 x = gen_rtx_MEM (DECL_MODE (decl), x);
1007 if (TREE_CODE (decl) != FUNCTION_DECL)
1008 set_mem_attributes (x, decl, 1);
1009 SET_DECL_RTL (decl, x);
1011 /* Optionally set flags or add text to the name to record information
1012 such as that it is a function name.
1013 If the name is changed, the macro ASM_OUTPUT_LABELREF
1014 will have to know how to strip this information. */
1015 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1017 /* Make this function static known to the mudflap runtime. */
1018 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1019 mudflap_enqueue_decl (decl);
1022 /* Make the rtl for variable VAR be volatile.
1023 Use this only for static variables. */
1026 make_var_volatile (tree var)
1028 gcc_assert (MEM_P (DECL_RTL (var)));
1030 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1033 /* Output a string of literal assembler code
1034 for an `asm' keyword used between functions. */
1037 assemble_asm (tree string)
1041 if (TREE_CODE (string) == ADDR_EXPR)
1042 string = TREE_OPERAND (string, 0);
1044 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1047 /* Record an element in the table of global destructors. SYMBOL is
1048 a SYMBOL_REF of the function to be called; PRIORITY is a number
1049 between 0 and MAX_INIT_PRIORITY. */
1052 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1053 int priority ATTRIBUTE_UNUSED)
1055 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1056 /* Tell GNU LD that this is part of the static destructor set.
1057 This will work for any system that uses stabs, most usefully
1059 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1060 dbxout_stab_value_label (XSTR (symbol, 0));
1062 sorry ("global destructors not supported on this target");
1067 default_named_section_asm_out_destructor (rtx symbol, int priority)
1069 const char *section = ".dtors";
1072 /* ??? This only works reliably with the GNU linker. */
1073 if (priority != DEFAULT_INIT_PRIORITY)
1075 sprintf (buf, ".dtors.%.5u",
1076 /* Invert the numbering so the linker puts us in the proper
1077 order; constructors are run from right to left, and the
1078 linker sorts in increasing order. */
1079 MAX_INIT_PRIORITY - priority);
1083 named_section_flags (section, SECTION_WRITE);
1084 assemble_align (POINTER_SIZE);
1085 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1088 #ifdef DTORS_SECTION_ASM_OP
1090 dtors_section (void)
1092 if (in_section != in_dtors)
1094 in_section = in_dtors;
1095 fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1096 fputc ('\n', asm_out_file);
1101 default_dtor_section_asm_out_destructor (rtx symbol,
1102 int priority ATTRIBUTE_UNUSED)
1105 assemble_align (POINTER_SIZE);
1106 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1110 /* Likewise for global constructors. */
1113 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1114 int priority ATTRIBUTE_UNUSED)
1116 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1117 /* Tell GNU LD that this is part of the static destructor set.
1118 This will work for any system that uses stabs, most usefully
1120 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1121 dbxout_stab_value_label (XSTR (symbol, 0));
1123 sorry ("global constructors not supported on this target");
1128 default_named_section_asm_out_constructor (rtx symbol, int priority)
1130 const char *section = ".ctors";
1133 /* ??? This only works reliably with the GNU linker. */
1134 if (priority != DEFAULT_INIT_PRIORITY)
1136 sprintf (buf, ".ctors.%.5u",
1137 /* Invert the numbering so the linker puts us in the proper
1138 order; constructors are run from right to left, and the
1139 linker sorts in increasing order. */
1140 MAX_INIT_PRIORITY - priority);
1144 named_section_flags (section, SECTION_WRITE);
1145 assemble_align (POINTER_SIZE);
1146 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1149 #ifdef CTORS_SECTION_ASM_OP
1151 ctors_section (void)
1153 if (in_section != in_ctors)
1155 in_section = in_ctors;
1156 fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1157 fputc ('\n', asm_out_file);
1162 default_ctor_section_asm_out_constructor (rtx symbol,
1163 int priority ATTRIBUTE_UNUSED)
1166 assemble_align (POINTER_SIZE);
1167 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1171 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1172 a nonzero value if the constant pool should be output before the
1173 start of the function, or a zero value if the pool should output
1174 after the end of the function. The default is to put it before the
1177 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1178 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1181 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1182 to be output to assembler.
1183 Set first_global_object_name and weak_global_object_name as appropriate. */
1186 notice_global_symbol (tree decl)
1188 const char **type = &first_global_object_name;
1190 if (first_global_object_name
1191 || !TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
1192 || !DECL_NAME (decl)
1193 || (TREE_CODE (decl) != FUNCTION_DECL
1194 && (TREE_CODE (decl) != VAR_DECL
1195 || (DECL_COMMON (decl)
1196 && (DECL_INITIAL (decl) == 0
1197 || DECL_INITIAL (decl) == error_mark_node))))
1198 || !MEM_P (DECL_RTL (decl)))
1201 /* We win when global object is found, but it is useful to know about weak
1202 symbol as well so we can produce nicer unique names. */
1203 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1204 type = &weak_global_object_name;
1210 rtx decl_rtl = DECL_RTL (decl);
1212 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1219 /* Output assembler code for the constant pool of a function and associated
1220 with defining the name of the function. DECL describes the function.
1221 NAME is the function's name. For the constant pool, we use the current
1222 constant pool data. */
1225 assemble_start_function (tree decl, const char *fnname)
1228 char tmp_label[100];
1229 bool hot_label_written = false;
1231 cfun->unlikely_text_section_name = NULL;
1233 first_function_block_is_cold = false;
1234 if (flag_reorder_blocks_and_partition)
1236 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "HOTB", const_labelno);
1237 cfun->hot_section_label = ggc_strdup (tmp_label);
1238 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "COLDB", const_labelno);
1239 cfun->cold_section_label = ggc_strdup (tmp_label);
1240 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "HOTE", const_labelno);
1241 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1242 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "COLDE", const_labelno);
1243 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1248 cfun->hot_section_label = NULL;
1249 cfun->cold_section_label = NULL;
1250 cfun->hot_section_end_label = NULL;
1251 cfun->cold_section_end_label = NULL;
1254 /* The following code does not need preprocessing in the assembler. */
1258 if (CONSTANT_POOL_BEFORE_FUNCTION)
1259 output_constant_pool (fnname, decl);
1261 resolve_unique_section (decl, 0, flag_function_sections);
1263 /* Make sure the not and cold text (code) sections are properly
1264 aligned. This is necessary here in the case where the function
1265 has both hot and cold sections, because we don't want to re-set
1266 the alignment when the section switch happens mid-function. */
1268 if (flag_reorder_blocks_and_partition)
1270 unlikely_text_section ();
1271 assemble_align (FUNCTION_BOUNDARY);
1272 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1273 if (BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1275 /* Since the function starts with a cold section, we need to
1276 explicitly align the hot section and write out the hot
1279 assemble_align (FUNCTION_BOUNDARY);
1280 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1281 hot_label_written = true;
1282 first_function_block_is_cold = true;
1285 else if (DECL_SECTION_NAME (decl))
1287 /* Calls to function_section rely on first_function_block_is_cold
1288 being accurate. The first block may be cold even if we aren't
1289 doing partitioning, if the entire function was decided by
1290 choose_function_section (predict.c) to be cold. */
1296 initialize_cold_section_name ();
1298 /* The following is necessary, because 'strcmp
1299 (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), blah)' always
1300 fails, presumably because TREE_STRING_POINTER is declared to
1301 be an array of size 1 of char. */
1303 len = TREE_STRING_LENGTH (DECL_SECTION_NAME (decl));
1304 s = (char *) xmalloc (len + 1);
1306 for (i = 0; i < len; i ++)
1307 s[i] = (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)))[i];
1310 if (cfun->unlikely_text_section_name
1311 && (strcmp (s, cfun->unlikely_text_section_name) == 0))
1312 first_function_block_is_cold = true;
1315 last_text_section = no_section;
1317 /* Switch to the correct text section for the start of the function. */
1319 function_section (decl);
1320 if (flag_reorder_blocks_and_partition
1321 && !hot_label_written)
1322 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1324 /* Tell assembler to move to target machine's alignment for functions. */
1325 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1326 if (align < force_align_functions_log)
1327 align = force_align_functions_log;
1330 ASM_OUTPUT_ALIGN (asm_out_file, align);
1333 /* Handle a user-specified function alignment.
1334 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1335 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1336 if (align_functions_log > align
1337 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1339 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1340 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1341 align_functions_log, align_functions - 1);
1343 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1347 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1348 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1351 (*debug_hooks->begin_function) (decl);
1353 /* Make function name accessible from other files, if appropriate. */
1355 if (TREE_PUBLIC (decl))
1357 notice_global_symbol (decl);
1359 globalize_decl (decl);
1361 maybe_assemble_visibility (decl);
1364 if (DECL_PRESERVE_P (decl))
1365 targetm.asm_out.mark_decl_preserved (fnname);
1367 /* Do any machine/system dependent processing of the function name. */
1368 #ifdef ASM_DECLARE_FUNCTION_NAME
1369 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1371 /* Standard thing is just output label for the function. */
1372 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1373 #endif /* ASM_DECLARE_FUNCTION_NAME */
1375 insert_section_boundary_note ();
1378 /* Output assembler code associated with defining the size of the
1379 function. DECL describes the function. NAME is the function's name. */
1382 assemble_end_function (tree decl, const char *fnname)
1384 #ifdef ASM_DECLARE_FUNCTION_SIZE
1385 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1387 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1389 output_constant_pool (fnname, decl);
1390 function_section (decl); /* need to switch back */
1392 /* Output labels for end of hot/cold text sections (to be used by
1394 if (flag_reorder_blocks_and_partition)
1396 enum in_section save_text_section;
1398 save_text_section = in_section;
1399 unlikely_text_section ();
1400 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1401 if (first_function_block_is_cold)
1404 function_section (decl);
1405 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1406 if (save_text_section == in_unlikely_executed_text)
1407 unlikely_text_section ();
1411 /* Assemble code to leave SIZE bytes of zeros. */
1414 assemble_zeros (unsigned HOST_WIDE_INT size)
1416 /* Do no output if -fsyntax-only. */
1417 if (flag_syntax_only)
1420 #ifdef ASM_NO_SKIP_IN_TEXT
1421 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1422 so we must output 0s explicitly in the text section. */
1423 if ((ASM_NO_SKIP_IN_TEXT && in_text_section ())
1424 || (ASM_NO_SKIP_IN_TEXT && in_unlikely_text_section ()))
1426 unsigned HOST_WIDE_INT i;
1427 for (i = 0; i < size; i++)
1428 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1433 ASM_OUTPUT_SKIP (asm_out_file, size);
1436 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1439 assemble_align (int align)
1441 if (align > BITS_PER_UNIT)
1443 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1447 /* Assemble a string constant with the specified C string as contents. */
1450 assemble_string (const char *p, int size)
1455 /* If the string is very long, split it up. */
1459 int thissize = size - pos;
1460 if (thissize > maximum)
1463 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1471 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1472 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1473 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1475 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1476 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1477 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1479 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1480 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1484 #if defined ASM_OUTPUT_ALIGNED_BSS
1485 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1486 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1488 #if defined ASM_OUTPUT_BSS
1489 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1490 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1496 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1497 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1498 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1500 #if defined ASM_OUTPUT_ALIGNED_COMMON
1501 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1502 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1504 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1505 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1510 asm_emit_uninitialised (tree decl, const char *name,
1511 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1512 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1520 destination = asm_dest_local;
1522 /* ??? We should handle .bss via select_section mechanisms rather than
1523 via special target hooks. That would eliminate this special case. */
1524 if (TREE_PUBLIC (decl))
1526 if (!DECL_COMMON (decl))
1528 destination = asm_dest_bss;
1533 destination = asm_dest_common;
1536 if (destination != asm_dest_common)
1538 resolve_unique_section (decl, 0, flag_data_sections);
1539 /* Custom sections don't belong here. */
1540 if (DECL_SECTION_NAME (decl))
1544 if (destination == asm_dest_bss)
1545 globalize_decl (decl);
1547 if (flag_shared_data)
1549 switch (destination)
1551 #ifdef ASM_OUTPUT_SHARED_BSS
1553 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1556 #ifdef ASM_OUTPUT_SHARED_COMMON
1557 case asm_dest_common:
1558 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1561 #ifdef ASM_OUTPUT_SHARED_LOCAL
1562 case asm_dest_local:
1563 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1571 switch (destination)
1575 ASM_EMIT_BSS (decl, name, size, rounded);
1578 case asm_dest_common:
1579 ASM_EMIT_COMMON (decl, name, size, rounded);
1581 case asm_dest_local:
1582 ASM_EMIT_LOCAL (decl, name, size, rounded);
1591 /* Assemble everything that is needed for a variable or function declaration.
1592 Not used for automatic variables, and not used for function definitions.
1593 Should not be called for variables of incomplete structure type.
1595 TOP_LEVEL is nonzero if this variable has file scope.
1596 AT_END is nonzero if this is the special handling, at end of compilation,
1597 to define things that have had only tentative definitions.
1598 DONT_OUTPUT_DATA if nonzero means don't actually output the
1599 initial value (that will be done by the caller). */
1602 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1603 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1610 if (lang_hooks.decls.prepare_assemble_variable)
1611 lang_hooks.decls.prepare_assemble_variable (decl);
1613 last_assemble_variable_decl = 0;
1615 /* Normally no need to say anything here for external references,
1616 since assemble_external is called by the language-specific code
1617 when a declaration is first seen. */
1619 if (DECL_EXTERNAL (decl))
1622 /* Output no assembler code for a function declaration.
1623 Only definitions of functions output anything. */
1625 if (TREE_CODE (decl) == FUNCTION_DECL)
1628 /* Do nothing for global register variables. */
1629 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1631 TREE_ASM_WRITTEN (decl) = 1;
1635 /* If type was incomplete when the variable was declared,
1636 see if it is complete now. */
1638 if (DECL_SIZE (decl) == 0)
1639 layout_decl (decl, 0);
1641 /* Still incomplete => don't allocate it; treat the tentative defn
1642 (which is what it must have been) as an `extern' reference. */
1644 if (!dont_output_data && DECL_SIZE (decl) == 0)
1646 error ("%Jstorage size of %qD isn%'t known", decl, decl);
1647 TREE_ASM_WRITTEN (decl) = 1;
1651 /* The first declaration of a variable that comes through this function
1652 decides whether it is global (in C, has external linkage)
1653 or local (in C, has internal linkage). So do nothing more
1654 if this function has already run. */
1656 if (TREE_ASM_WRITTEN (decl))
1659 /* Make sure targetm.encode_section_info is invoked before we set
1661 decl_rtl = DECL_RTL (decl);
1663 TREE_ASM_WRITTEN (decl) = 1;
1665 /* Do no output if -fsyntax-only. */
1666 if (flag_syntax_only)
1671 if (! dont_output_data
1672 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1674 error ("%Jsize of variable %qD is too large", decl, decl);
1678 name = XSTR (XEXP (decl_rtl, 0), 0);
1679 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1680 notice_global_symbol (decl);
1682 /* Compute the alignment of this data. */
1684 align = DECL_ALIGN (decl);
1686 /* In the case for initialing an array whose length isn't specified,
1687 where we have not yet been able to do the layout,
1688 figure out the proper alignment now. */
1689 if (dont_output_data && DECL_SIZE (decl) == 0
1690 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1691 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1693 /* Some object file formats have a maximum alignment which they support.
1694 In particular, a.out format supports a maximum alignment of 4. */
1695 if (align > MAX_OFILE_ALIGNMENT)
1697 warning (0, "%Jalignment of %qD is greater than maximum object "
1698 "file alignment. Using %d", decl, decl,
1699 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1700 align = MAX_OFILE_ALIGNMENT;
1703 /* On some machines, it is good to increase alignment sometimes. */
1704 if (! DECL_USER_ALIGN (decl))
1706 #ifdef DATA_ALIGNMENT
1707 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1709 #ifdef CONSTANT_ALIGNMENT
1710 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1711 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1715 /* Reset the alignment in case we have made it tighter, so we can benefit
1716 from it in get_pointer_alignment. */
1717 DECL_ALIGN (decl) = align;
1718 set_mem_align (decl_rtl, align);
1720 if (TREE_PUBLIC (decl))
1721 maybe_assemble_visibility (decl);
1723 if (DECL_PRESERVE_P (decl))
1724 targetm.asm_out.mark_decl_preserved (name);
1726 /* Handle uninitialized definitions. */
1728 /* If the decl has been given an explicit section name, then it
1729 isn't common, and shouldn't be handled as such. */
1730 if (DECL_SECTION_NAME (decl) || dont_output_data)
1732 /* We don't implement common thread-local data at present. */
1733 else if (DECL_THREAD_LOCAL (decl))
1735 if (DECL_COMMON (decl))
1736 sorry ("thread-local COMMON data not implemented");
1738 else if (DECL_INITIAL (decl) == 0
1739 || DECL_INITIAL (decl) == error_mark_node
1740 || (flag_zero_initialized_in_bss
1741 /* Leave constant zeroes in .rodata so they can be shared. */
1742 && !TREE_READONLY (decl)
1743 && initializer_zerop (DECL_INITIAL (decl))))
1745 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1746 unsigned HOST_WIDE_INT rounded = size;
1748 /* Don't allocate zero bytes of common,
1749 since that means "undefined external" in the linker. */
1753 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1754 so that each uninitialized object starts on such a boundary. */
1755 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1756 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1757 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1759 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1760 if ((unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1761 warning (0, "%Jrequested alignment for %qD is greater than "
1762 "implemented alignment of %d", decl, decl, rounded);
1765 /* If the target cannot output uninitialized but not common global data
1766 in .bss, then we have to use .data, so fall through. */
1767 if (asm_emit_uninitialised (decl, name, size, rounded))
1771 /* Handle initialized definitions.
1772 Also handle uninitialized global definitions if -fno-common and the
1773 target doesn't support ASM_OUTPUT_BSS. */
1775 /* First make the assembler name(s) global if appropriate. */
1776 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1777 globalize_decl (decl);
1779 /* Output any data that we will need to use the address of. */
1780 if (DECL_INITIAL (decl) == error_mark_node)
1781 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1782 else if (DECL_INITIAL (decl))
1784 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1785 output_addressed_constants (DECL_INITIAL (decl));
1788 /* Switch to the appropriate section. */
1789 resolve_unique_section (decl, reloc, flag_data_sections);
1790 variable_section (decl, reloc);
1792 /* dbxout.c needs to know this. */
1793 if (in_text_section () || in_unlikely_text_section ())
1794 DECL_IN_TEXT_SECTION (decl) = 1;
1796 /* Output the alignment of this data. */
1797 if (align > BITS_PER_UNIT)
1798 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1800 /* Do any machine/system dependent processing of the object. */
1801 #ifdef ASM_DECLARE_OBJECT_NAME
1802 last_assemble_variable_decl = decl;
1803 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1805 /* Standard thing is just output label for the object. */
1806 ASM_OUTPUT_LABEL (asm_out_file, name);
1807 #endif /* ASM_DECLARE_OBJECT_NAME */
1809 if (!dont_output_data)
1811 if (DECL_INITIAL (decl)
1812 && DECL_INITIAL (decl) != error_mark_node
1813 && !initializer_zerop (DECL_INITIAL (decl)))
1814 /* Output the actual data. */
1815 output_constant (DECL_INITIAL (decl),
1816 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1819 /* Leave space for it. */
1820 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1824 /* Return 1 if type TYPE contains any pointers. */
1827 contains_pointers_p (tree type)
1829 switch (TREE_CODE (type))
1832 case REFERENCE_TYPE:
1833 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1834 so I'll play safe and return 1. */
1840 case QUAL_UNION_TYPE:
1843 /* For a type that has fields, see if the fields have pointers. */
1844 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1845 if (TREE_CODE (fields) == FIELD_DECL
1846 && contains_pointers_p (TREE_TYPE (fields)))
1852 /* An array type contains pointers if its element type does. */
1853 return contains_pointers_p (TREE_TYPE (type));
1860 /* In unit-at-a-time mode, we delay assemble_external processing until
1861 the compilation unit is finalized. This is the best we can do for
1862 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1863 it all the way to final. See PR 17982 for further discussion. */
1864 static GTY(()) tree pending_assemble_externals;
1866 #ifdef ASM_OUTPUT_EXTERNAL
1867 /* True if DECL is a function decl for which no out-of-line copy exists.
1868 It is assumed that DECL's assembler name has been set. */
1871 incorporeal_function_p (tree decl)
1873 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1877 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1878 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1881 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1882 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1888 /* Actually do the tests to determine if this is necessary, and invoke
1889 ASM_OUTPUT_EXTERNAL. */
1891 assemble_external_real (tree decl)
1893 rtx rtl = DECL_RTL (decl);
1895 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1896 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1897 && !incorporeal_function_p (decl))
1899 /* Some systems do require some output. */
1900 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1901 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1907 process_pending_assemble_externals (void)
1909 #ifdef ASM_OUTPUT_EXTERNAL
1911 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1912 assemble_external_real (TREE_VALUE (list));
1914 pending_assemble_externals = 0;
1918 /* Output something to declare an external symbol to the assembler.
1919 (Most assemblers don't need this, so we normally output nothing.)
1920 Do nothing if DECL is not external. */
1923 assemble_external (tree decl ATTRIBUTE_UNUSED)
1925 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1926 main body of this code is only rarely exercised. To provide some
1927 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1928 open. If it's not, we should not be calling this function. */
1929 gcc_assert (asm_out_file);
1931 #ifdef ASM_OUTPUT_EXTERNAL
1932 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1935 if (flag_unit_at_a_time)
1936 pending_assemble_externals = tree_cons (0, decl,
1937 pending_assemble_externals);
1939 assemble_external_real (decl);
1943 /* Similar, for calling a library function FUN. */
1946 assemble_external_libcall (rtx fun)
1948 /* Declare library function name external when first used, if nec. */
1949 if (! SYMBOL_REF_USED (fun))
1951 SYMBOL_REF_USED (fun) = 1;
1952 targetm.asm_out.external_libcall (fun);
1956 /* Assemble a label named NAME. */
1959 assemble_label (const char *name)
1961 ASM_OUTPUT_LABEL (asm_out_file, name);
1964 /* Set the symbol_referenced flag for ID. */
1966 mark_referenced (tree id)
1968 TREE_SYMBOL_REFERENCED (id) = 1;
1971 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1973 mark_decl_referenced (tree decl)
1975 if (TREE_CODE (decl) == FUNCTION_DECL)
1977 /* Extern inline functions don't become needed when referenced.
1978 If we know a method will be emitted in other TU and no new
1979 functions can be marked reachable, just use the external
1981 struct cgraph_node *node = cgraph_node (decl);
1982 if (!DECL_EXTERNAL (decl)
1983 && (!node->local.vtable_method || !cgraph_global_info_ready
1984 || !node->local.finalized))
1985 cgraph_mark_needed_node (node);
1987 else if (TREE_CODE (decl) == VAR_DECL)
1989 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
1990 cgraph_varpool_mark_needed_node (node);
1991 /* C++ frontend use mark_decl_references to force COMDAT variables
1992 to be output that might appear dead otherwise. */
1993 node->force_output = true;
1995 /* else do nothing - we can get various sorts of CST nodes here,
1996 which do not need to be marked. */
1999 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2000 starts with a *, the rest of NAME is output verbatim. Otherwise
2001 NAME is transformed in a target-specific way (usually by the
2002 addition of an underscore). */
2005 assemble_name_raw (FILE *file, const char *name)
2008 fputs (&name[1], file);
2010 ASM_OUTPUT_LABELREF (file, name);
2013 /* Like assemble_name_raw, but should be used when NAME might refer to
2014 an entity that is also represented as a tree (like a function or
2015 variable). If NAME does refer to such an entity, that entity will
2016 be marked as referenced. */
2019 assemble_name (FILE *file, const char *name)
2021 const char *real_name;
2024 real_name = targetm.strip_name_encoding (name);
2026 id = maybe_get_identifier (real_name);
2028 mark_referenced (id);
2030 assemble_name_raw (file, name);
2033 /* Allocate SIZE bytes writable static space with a gensym name
2034 and return an RTX to refer to its address. */
2037 assemble_static_space (unsigned HOST_WIDE_INT size)
2040 const char *namestring;
2044 if (flag_shared_data)
2048 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2050 namestring = ggc_strdup (name);
2052 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2053 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2055 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2056 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2059 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2060 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2063 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2064 so that each uninitialized object starts on such a boundary. */
2065 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2066 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2067 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2068 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2069 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2070 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2077 /* Assemble the static constant template for function entry trampolines.
2078 This is done at most once per compilation.
2079 Returns an RTX for the address of the template. */
2081 static GTY(()) rtx initial_trampoline;
2083 #ifdef TRAMPOLINE_TEMPLATE
2085 assemble_trampoline_template (void)
2092 if (initial_trampoline)
2093 return initial_trampoline;
2095 /* By default, put trampoline templates in read-only data section. */
2097 #ifdef TRAMPOLINE_SECTION
2098 TRAMPOLINE_SECTION ();
2100 readonly_data_section ();
2103 /* Write the assembler code to define one. */
2104 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2107 ASM_OUTPUT_ALIGN (asm_out_file, align);
2110 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2111 TRAMPOLINE_TEMPLATE (asm_out_file);
2113 /* Record the rtl to refer to it. */
2114 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2115 name = ggc_strdup (label);
2116 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2117 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2119 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2120 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2122 return initial_trampoline;
2126 /* A and B are either alignments or offsets. Return the minimum alignment
2127 that may be assumed after adding the two together. */
2129 static inline unsigned
2130 min_align (unsigned int a, unsigned int b)
2132 return (a | b) & -(a | b);
2135 /* Return the assembler directive for creating a given kind of integer
2136 object. SIZE is the number of bytes in the object and ALIGNED_P
2137 indicates whether it is known to be aligned. Return NULL if the
2138 assembly dialect has no such directive.
2140 The returned string should be printed at the start of a new line and
2141 be followed immediately by the object's initial value. */
2144 integer_asm_op (int size, int aligned_p)
2146 struct asm_int_op *ops;
2149 ops = &targetm.asm_out.aligned_op;
2151 ops = &targetm.asm_out.unaligned_op;
2156 return targetm.asm_out.byte_op;
2170 /* Use directive OP to assemble an integer object X. Print OP at the
2171 start of the line, followed immediately by the value of X. */
2174 assemble_integer_with_op (const char *op, rtx x)
2176 fputs (op, asm_out_file);
2177 output_addr_const (asm_out_file, x);
2178 fputc ('\n', asm_out_file);
2181 /* The default implementation of the asm_out.integer target hook. */
2184 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2185 unsigned int size ATTRIBUTE_UNUSED,
2186 int aligned_p ATTRIBUTE_UNUSED)
2188 const char *op = integer_asm_op (size, aligned_p);
2189 /* Avoid GAS bugs for large values. Specifically negative values whose
2190 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2191 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2193 return op && (assemble_integer_with_op (op, x), true);
2196 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2197 the alignment of the integer in bits. Return 1 if we were able to output
2198 the constant, otherwise 0. We must be able to output the constant,
2199 if FORCE is nonzero. */
2202 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2206 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2208 /* See if the target hook can handle this kind of object. */
2209 if (targetm.asm_out.integer (x, size, aligned_p))
2212 /* If the object is a multi-byte one, try splitting it up. Split
2213 it into words it if is multi-word, otherwise split it into bytes. */
2216 enum machine_mode omode, imode;
2217 unsigned int subalign;
2218 unsigned int subsize, i;
2220 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2221 subalign = MIN (align, subsize * BITS_PER_UNIT);
2222 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2223 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2225 for (i = 0; i < size; i += subsize)
2227 rtx partial = simplify_subreg (omode, x, imode, i);
2228 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2234 /* If we've printed some of it, but not all of it, there's no going
2239 gcc_assert (!force);
2245 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2249 int bitsize, nelts, nunits, units_per;
2251 /* This is hairy. We have a quantity of known size. real_to_target
2252 will put it into an array of *host* longs, 32 bits per element
2253 (even if long is more than 32 bits). We need to determine the
2254 number of array elements that are occupied (nelts) and the number
2255 of *target* min-addressable units that will be occupied in the
2256 object file (nunits). We cannot assume that 32 divides the
2257 mode's bitsize (size * BITS_PER_UNIT) evenly.
2259 size * BITS_PER_UNIT is used here to make sure that padding bits
2260 (which might appear at either end of the value; real_to_target
2261 will include the padding bits in its output array) are included. */
2263 nunits = GET_MODE_SIZE (mode);
2264 bitsize = nunits * BITS_PER_UNIT;
2265 nelts = CEIL (bitsize, 32);
2266 units_per = 32 / BITS_PER_UNIT;
2268 real_to_target (data, &d, mode);
2270 /* Put out the first word with the specified alignment. */
2271 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2272 nunits -= units_per;
2274 /* Subsequent words need only 32-bit alignment. */
2275 align = min_align (align, 32);
2277 for (i = 1; i < nelts; i++)
2279 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2280 nunits -= units_per;
2284 /* Given an expression EXP with a constant value,
2285 reduce it to the sum of an assembler symbol and an integer.
2286 Store them both in the structure *VALUE.
2287 EXP must be reducible. */
2289 struct addr_const GTY(())
2292 HOST_WIDE_INT offset;
2296 decode_addr_const (tree exp, struct addr_const *value)
2298 tree target = TREE_OPERAND (exp, 0);
2304 if (TREE_CODE (target) == COMPONENT_REF
2305 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2308 offset += int_byte_position (TREE_OPERAND (target, 1));
2309 target = TREE_OPERAND (target, 0);
2311 else if (TREE_CODE (target) == ARRAY_REF
2312 || TREE_CODE (target) == ARRAY_RANGE_REF)
2314 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2315 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2316 target = TREE_OPERAND (target, 0);
2322 switch (TREE_CODE (target))
2326 x = DECL_RTL (target);
2330 x = gen_rtx_MEM (FUNCTION_MODE,
2331 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2339 x = output_constant_def (target, 1);
2346 gcc_assert (MEM_P (x));
2350 value->offset = offset;
2353 /* Uniquize all constants that appear in memory.
2354 Each constant in memory thus far output is recorded
2355 in `const_desc_table'. */
2357 struct constant_descriptor_tree GTY(())
2359 /* A MEM for the constant. */
2362 /* The value of the constant. */
2366 static GTY((param_is (struct constant_descriptor_tree)))
2367 htab_t const_desc_htab;
2369 static struct constant_descriptor_tree * build_constant_desc (tree);
2370 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2372 /* Compute a hash code for a constant expression. */
2375 const_desc_hash (const void *ptr)
2377 return const_hash_1 (((struct constant_descriptor_tree *)ptr)->value);
2381 const_hash_1 (const tree exp)
2386 enum tree_code code = TREE_CODE (exp);
2388 /* Either set P and LEN to the address and len of something to hash and
2389 exit the switch or return a value. */
2394 p = (char *) &TREE_INT_CST (exp);
2395 len = sizeof TREE_INT_CST (exp);
2399 return real_hash (TREE_REAL_CST_PTR (exp));
2402 p = TREE_STRING_POINTER (exp);
2403 len = TREE_STRING_LENGTH (exp);
2407 return (const_hash_1 (TREE_REALPART (exp)) * 5
2408 + const_hash_1 (TREE_IMAGPART (exp)));
2414 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2416 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2417 if (TREE_VALUE (link))
2418 hi = hi * 603 + const_hash_1 (TREE_VALUE (link));
2426 struct addr_const value;
2428 decode_addr_const (exp, &value);
2429 switch (GET_CODE (value.base))
2432 /* Don't hash the address of the SYMBOL_REF;
2433 only use the offset and the symbol name. */
2435 p = XSTR (value.base, 0);
2436 for (i = 0; p[i] != 0; i++)
2437 hi = ((hi * 613) + (unsigned) (p[i]));
2441 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2452 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2453 + const_hash_1 (TREE_OPERAND (exp, 1)));
2457 case NON_LVALUE_EXPR:
2458 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2461 /* A language specific constant. Just hash the code. */
2465 /* Compute hashing function. */
2467 for (i = 0; i < len; i++)
2468 hi = ((hi * 613) + (unsigned) (p[i]));
2473 /* Wrapper of compare_constant, for the htab interface. */
2475 const_desc_eq (const void *p1, const void *p2)
2477 return compare_constant (((struct constant_descriptor_tree *)p1)->value,
2478 ((struct constant_descriptor_tree *)p2)->value);
2481 /* Compare t1 and t2, and return 1 only if they are known to result in
2482 the same bit pattern on output. */
2485 compare_constant (const tree t1, const tree t2)
2487 enum tree_code typecode;
2489 if (t1 == NULL_TREE)
2490 return t2 == NULL_TREE;
2491 if (t2 == NULL_TREE)
2494 if (TREE_CODE (t1) != TREE_CODE (t2))
2497 switch (TREE_CODE (t1))
2500 /* Integer constants are the same only if the same width of type. */
2501 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2503 return tree_int_cst_equal (t1, t2);
2506 /* Real constants are the same only if the same width of type. */
2507 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2510 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2513 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2516 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2517 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2518 TREE_STRING_LENGTH (t1)));
2521 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2522 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2528 typecode = TREE_CODE (TREE_TYPE (t1));
2529 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2532 if (typecode == ARRAY_TYPE)
2534 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2535 /* For arrays, check that the sizes all match. */
2536 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2538 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2543 /* For record and union constructors, require exact type
2545 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2549 for (l1 = CONSTRUCTOR_ELTS (t1), l2 = CONSTRUCTOR_ELTS (t2);
2551 l1 = TREE_CHAIN (l1), l2 = TREE_CHAIN (l2))
2553 /* Check that each value is the same... */
2554 if (! compare_constant (TREE_VALUE (l1), TREE_VALUE (l2)))
2556 /* ... and that they apply to the same fields! */
2557 if (typecode == ARRAY_TYPE)
2559 if (! compare_constant (TREE_PURPOSE (l1),
2565 if (TREE_PURPOSE (l1) != TREE_PURPOSE (l2))
2570 return l1 == NULL_TREE && l2 == NULL_TREE;
2576 struct addr_const value1, value2;
2578 decode_addr_const (t1, &value1);
2579 decode_addr_const (t2, &value2);
2580 return (value1.offset == value2.offset
2581 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2587 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2588 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2592 case NON_LVALUE_EXPR:
2593 case VIEW_CONVERT_EXPR:
2594 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2599 nt1 = lang_hooks.expand_constant (t1);
2600 nt2 = lang_hooks.expand_constant (t2);
2601 if (nt1 != t1 || nt2 != t2)
2602 return compare_constant (nt1, nt2);
2611 /* Make a copy of the whole tree structure for a constant. This
2612 handles the same types of nodes that compare_constant handles. */
2615 copy_constant (tree exp)
2617 switch (TREE_CODE (exp))
2620 /* For ADDR_EXPR, we do not want to copy the decl whose address
2621 is requested. We do want to copy constants though. */
2622 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2623 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2624 copy_constant (TREE_OPERAND (exp, 0)));
2626 return copy_node (exp);
2631 return copy_node (exp);
2634 return build_complex (TREE_TYPE (exp),
2635 copy_constant (TREE_REALPART (exp)),
2636 copy_constant (TREE_IMAGPART (exp)));
2640 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2641 copy_constant (TREE_OPERAND (exp, 0)),
2642 copy_constant (TREE_OPERAND (exp, 1)));
2646 case NON_LVALUE_EXPR:
2647 case VIEW_CONVERT_EXPR:
2648 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2649 copy_constant (TREE_OPERAND (exp, 0)));
2653 tree copy = copy_node (exp);
2654 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2657 CONSTRUCTOR_ELTS (copy) = list;
2658 for (tail = list; tail; tail = TREE_CHAIN (tail))
2659 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2666 tree t = lang_hooks.expand_constant (exp);
2668 gcc_assert (t == exp);
2669 return copy_constant (t);
2674 /* Subroutine of output_constant_def:
2675 No constant equal to EXP is known to have been output.
2676 Make a constant descriptor to enter EXP in the hash table.
2677 Assign the label number and construct RTL to refer to the
2678 constant's location in memory.
2679 Caller is responsible for updating the hash table. */
2681 static struct constant_descriptor_tree *
2682 build_constant_desc (tree exp)
2688 struct constant_descriptor_tree *desc;
2690 desc = ggc_alloc (sizeof (*desc));
2691 desc->value = copy_constant (exp);
2693 /* Propagate marked-ness to copied constant. */
2694 if (flag_mudflap && mf_marked_p (exp))
2695 mf_mark (desc->value);
2697 /* Create a string containing the label name, in LABEL. */
2698 labelno = const_labelno++;
2699 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2701 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2702 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2703 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2704 SYMBOL_REF_DECL (symbol) = desc->value;
2705 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2707 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2708 set_mem_attributes (rtl, exp, 1);
2709 set_mem_alias_set (rtl, 0);
2710 set_mem_alias_set (rtl, const_alias_set);
2712 /* Set flags or add text to the name to record information, such as
2713 that it is a local symbol. If the name is changed, the macro
2714 ASM_OUTPUT_LABELREF will have to know how to strip this
2715 information. This call might invalidate our local variable
2716 SYMBOL; we can't use it afterward. */
2718 targetm.encode_section_info (exp, rtl, true);
2725 /* Return an rtx representing a reference to constant data in memory
2726 for the constant expression EXP.
2728 If assembler code for such a constant has already been output,
2729 return an rtx to refer to it.
2730 Otherwise, output such a constant in memory
2731 and generate an rtx for it.
2733 If DEFER is nonzero, this constant can be deferred and output only
2734 if referenced in the function after all optimizations.
2736 `const_desc_table' records which constants already have label strings. */
2739 output_constant_def (tree exp, int defer)
2741 struct constant_descriptor_tree *desc;
2742 struct constant_descriptor_tree key;
2745 /* Look up EXP in the table of constant descriptors. If we didn't find
2746 it, create a new one. */
2748 loc = htab_find_slot (const_desc_htab, &key, INSERT);
2753 desc = build_constant_desc (exp);
2757 maybe_output_constant_def_contents (desc, defer);
2761 /* Subroutine of output_constant_def: Decide whether or not we need to
2762 output the constant DESC now, and if so, do it. */
2764 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2767 rtx symbol = XEXP (desc->rtl, 0);
2768 tree exp = desc->value;
2770 if (flag_syntax_only)
2773 if (TREE_ASM_WRITTEN (exp))
2774 /* Already output; don't do it again. */
2777 /* We can always defer constants as long as the context allows
2781 /* Increment n_deferred_constants if it exists. It needs to be at
2782 least as large as the number of constants actually referred to
2783 by the function. If it's too small we'll stop looking too early
2784 and fail to emit constants; if it's too large we'll only look
2785 through the entire function when we could have stopped earlier. */
2787 n_deferred_constants++;
2791 output_constant_def_contents (symbol);
2794 /* We must output the constant data referred to by SYMBOL; do so. */
2797 output_constant_def_contents (rtx symbol)
2799 tree exp = SYMBOL_REF_DECL (symbol);
2800 const char *label = XSTR (symbol, 0);
2803 /* Make sure any other constants whose addresses appear in EXP
2804 are assigned label numbers. */
2805 int reloc = compute_reloc_for_constant (exp);
2807 /* Align the location counter as required by EXP's data type. */
2808 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
2809 #ifdef CONSTANT_ALIGNMENT
2810 align = CONSTANT_ALIGNMENT (exp, align);
2813 output_addressed_constants (exp);
2815 /* We are no longer deferring this constant. */
2816 TREE_ASM_WRITTEN (exp) = 1;
2818 if (IN_NAMED_SECTION (exp))
2819 named_section (exp, NULL, reloc);
2821 targetm.asm_out.select_section (exp, reloc, align);
2823 if (align > BITS_PER_UNIT)
2825 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2828 size = int_size_in_bytes (TREE_TYPE (exp));
2829 if (TREE_CODE (exp) == STRING_CST)
2830 size = MAX (TREE_STRING_LENGTH (exp), size);
2832 /* Do any machine/system dependent processing of the constant. */
2833 #ifdef ASM_DECLARE_CONSTANT_NAME
2834 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2836 /* Standard thing is just output label for the constant. */
2837 ASM_OUTPUT_LABEL (asm_out_file, label);
2838 #endif /* ASM_DECLARE_CONSTANT_NAME */
2840 /* Output the value of EXP. */
2841 output_constant (exp, size, align);
2843 mudflap_enqueue_constant (exp);
2846 /* Look up EXP in the table of constant descriptors. Return the rtl
2847 if it has been emitted, else null. */
2850 lookup_constant_def (tree exp)
2852 struct constant_descriptor_tree *desc;
2853 struct constant_descriptor_tree key;
2856 desc = htab_find (const_desc_htab, &key);
2858 return (desc ? desc->rtl : NULL_RTX);
2861 /* Used in the hash tables to avoid outputting the same constant
2862 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2863 are output once per function, not once per file. */
2864 /* ??? Only a few targets need per-function constant pools. Most
2865 can use one per-file pool. Should add a targetm bit to tell the
2868 struct rtx_constant_pool GTY(())
2870 /* Pointers to first and last constant in pool, as ordered by offset. */
2871 struct constant_descriptor_rtx *first;
2872 struct constant_descriptor_rtx *last;
2874 /* Hash facility for making memory-constants from constant rtl-expressions.
2875 It is used on RISC machines where immediate integer arguments and
2876 constant addresses are restricted so that such constants must be stored
2878 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
2879 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_sym_htab;
2881 /* Current offset in constant pool (does not include any
2882 machine-specific header). */
2883 HOST_WIDE_INT offset;
2886 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
2888 struct constant_descriptor_rtx *next;
2892 HOST_WIDE_INT offset;
2894 enum machine_mode mode;
2900 /* Hash and compare functions for const_rtx_htab. */
2903 const_desc_rtx_hash (const void *ptr)
2905 const struct constant_descriptor_rtx *desc = ptr;
2910 const_desc_rtx_eq (const void *a, const void *b)
2912 const struct constant_descriptor_rtx *x = a;
2913 const struct constant_descriptor_rtx *y = b;
2915 if (x->mode != y->mode)
2917 return rtx_equal_p (x->constant, y->constant);
2920 /* Hash and compare functions for const_rtx_sym_htab. */
2923 const_desc_rtx_sym_hash (const void *ptr)
2925 const struct constant_descriptor_rtx *desc = ptr;
2926 return htab_hash_string (XSTR (desc->sym, 0));
2930 const_desc_rtx_sym_eq (const void *a, const void *b)
2932 const struct constant_descriptor_rtx *x = a;
2933 const struct constant_descriptor_rtx *y = b;
2934 return XSTR (x->sym, 0) == XSTR (y->sym, 0);
2937 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
2940 const_rtx_hash_1 (rtx *xp, void *data)
2942 unsigned HOST_WIDE_INT hwi;
2943 enum machine_mode mode;
2949 code = GET_CODE (x);
2950 mode = GET_MODE (x);
2951 h = (hashval_t) code * 1048573 + mode;
2959 const int shift = sizeof (hashval_t) * CHAR_BIT;
2960 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
2963 h ^= (hashval_t) hwi;
2964 for (i = 1; i < n; ++i)
2967 h ^= (hashval_t) hwi;
2973 if (mode == VOIDmode)
2975 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
2979 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
2985 for (i = XVECLEN (x, 0); i-- > 0; )
2986 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
2991 h ^= htab_hash_string (XSTR (x, 0));
2995 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
2999 case UNSPEC_VOLATILE:
3000 h = h * 251 + XINT (x, 1);
3008 *hp = *hp * 509 + h;
3012 /* Compute a hash value for X, which should be a constant. */
3015 const_rtx_hash (rtx x)
3018 for_each_rtx (&x, const_rtx_hash_1, &h);
3023 /* Initialize constant pool hashing for a new function. */
3026 init_varasm_status (struct function *f)
3028 struct varasm_status *p;
3029 struct rtx_constant_pool *pool;
3031 p = ggc_alloc (sizeof (struct varasm_status));
3034 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3036 p->deferred_constants = 0;
3038 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3039 const_desc_rtx_eq, NULL);
3040 pool->const_rtx_sym_htab = htab_create_ggc (31, const_desc_rtx_sym_hash,
3041 const_desc_rtx_sym_eq, NULL);
3042 pool->first = pool->last = NULL;
3046 /* Given a MINUS expression, simplify it if both sides
3047 include the same symbol. */
3050 simplify_subtraction (rtx x)
3052 rtx r = simplify_rtx (x);
3056 /* Given a constant rtx X, make (or find) a memory constant for its value
3057 and return a MEM rtx to refer to it in memory. */
3060 force_const_mem (enum machine_mode mode, rtx x)
3062 struct constant_descriptor_rtx *desc, tmp;
3063 struct rtx_constant_pool *pool = cfun->varasm->pool;
3070 /* If we're not allowed to drop X into the constant pool, don't. */
3071 if (targetm.cannot_force_const_mem (x))
3074 /* Lookup the value in the hashtable. */
3077 hash = const_rtx_hash (x);
3078 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3081 /* If the constant was already present, return its memory. */
3083 return copy_rtx (desc->mem);
3085 /* Otherwise, create a new descriptor. */
3086 desc = ggc_alloc (sizeof (*desc));
3089 /* Align the location counter as required by EXP's data type. */
3090 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3091 #ifdef CONSTANT_ALIGNMENT
3093 tree type = lang_hooks.types.type_for_mode (mode, 0);
3094 if (type != NULL_TREE)
3095 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3099 pool->offset += (align / BITS_PER_UNIT) - 1;
3100 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3103 desc->constant = tmp.constant;
3104 desc->offset = pool->offset;
3107 desc->align = align;
3108 desc->labelno = const_labelno;
3111 pool->offset += GET_MODE_SIZE (mode);
3113 pool->last->next = desc;
3115 pool->first = pool->last = desc;
3118 /* Create a string containing the label name, in LABEL. */
3119 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3122 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3123 the constants pool. */
3124 desc->sym = symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3125 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
3126 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3127 current_function_uses_const_pool = 1;
3129 /* Insert the descriptor into the symbol cross-reference table too. */
3130 slot = htab_find_slot (pool->const_rtx_sym_htab, desc, INSERT);
3131 gcc_assert (!*slot);
3134 /* Construct the MEM. */
3135 desc->mem = def = gen_const_mem (mode, symbol);
3136 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3137 set_mem_align (def, align);
3139 /* If we're dropping a label to the constant pool, make sure we
3141 if (GET_CODE (x) == LABEL_REF)
3142 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3144 return copy_rtx (def);
3147 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3148 the corresponding constant_descriptor_rtx structure. */
3150 static struct constant_descriptor_rtx *
3151 find_pool_constant (struct rtx_constant_pool *pool, rtx sym)
3153 struct constant_descriptor_rtx tmp;
3155 return htab_find (pool->const_rtx_sym_htab, &tmp);
3158 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3161 get_pool_constant (rtx addr)
3163 return find_pool_constant (cfun->varasm->pool, addr)->constant;
3166 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3167 and whether it has been output or not. */
3170 get_pool_constant_mark (rtx addr, bool *pmarked)
3172 struct constant_descriptor_rtx *desc;
3174 desc = find_pool_constant (cfun->varasm->pool, addr);
3175 *pmarked = (desc->mark != 0);
3176 return desc->constant;
3179 /* Likewise, but for the constant pool of a specific function. */
3182 get_pool_constant_for_function (struct function *f, rtx addr)
3184 return find_pool_constant (f->varasm->pool, addr)->constant;
3187 /* Similar, return the mode. */
3190 get_pool_mode (rtx addr)
3192 return find_pool_constant (cfun->varasm->pool, addr)->mode;
3195 /* Return the size of the constant pool. */
3198 get_pool_size (void)
3200 return cfun->varasm->pool->offset;
3203 /* Worker function for output_constant_pool_1. Emit assembly for X
3204 in MODE with known alignment ALIGN. */
3207 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3209 switch (GET_MODE_CLASS (mode))
3215 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3216 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3217 assemble_real (r, mode, align);
3222 case MODE_PARTIAL_INT:
3223 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3226 case MODE_VECTOR_FLOAT:
3227 case MODE_VECTOR_INT:
3230 enum machine_mode submode = GET_MODE_INNER (mode);
3231 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3233 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3234 units = CONST_VECTOR_NUNITS (x);
3236 for (i = 0; i < units; i++)
3238 rtx elt = CONST_VECTOR_ELT (x, i);
3239 output_constant_pool_2 (submode, elt, i ? subalign : align);
3249 /* Worker function for output_constant_pool. Emit POOL. */
3252 output_constant_pool_1 (struct constant_descriptor_rtx *desc)
3260 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3261 whose CODE_LABEL has been deleted. This can occur if a jump table
3262 is eliminated by optimization. If so, write a constant of zero
3263 instead. Note that this can also happen by turning the
3264 CODE_LABEL into a NOTE. */
3265 /* ??? This seems completely and utterly wrong. Certainly it's
3266 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3267 functioning even with INSN_DELETED_P and friends. */
3270 switch (GET_CODE (x))
3273 if (GET_CODE (XEXP (x, 0)) != PLUS
3274 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3276 tmp = XEXP (XEXP (x, 0), 0);
3281 gcc_assert (!INSN_DELETED_P (tmp));
3282 gcc_assert (!NOTE_P (tmp)
3283 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3290 /* First switch to correct section. */
3291 targetm.asm_out.select_rtx_section (desc->mode, x, desc->align);
3293 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3294 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3295 desc->align, desc->labelno, done);
3298 assemble_align (desc->align);
3300 /* Output the label. */
3301 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3303 /* Output the data. */
3304 output_constant_pool_2 (desc->mode, x, desc->align);
3306 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3307 sections have proper size. */
3308 if (desc->align > GET_MODE_BITSIZE (desc->mode)
3309 && in_section == in_named
3310 && get_named_section_flags (in_named_name) & SECTION_MERGE)
3311 assemble_align (desc->align);
3313 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3319 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3320 to as used. Emit referenced deferred strings. This function can
3321 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3324 mark_constant (rtx *current_rtx, void *data)
3326 struct rtx_constant_pool *pool = data;
3327 rtx x = *current_rtx;
3329 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3332 if (CONSTANT_POOL_ADDRESS_P (x))
3334 struct constant_descriptor_rtx *desc = find_pool_constant (pool, x);
3335 if (desc->mark == 0)
3338 for_each_rtx (&desc->constant, mark_constant, pool);
3341 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3343 tree exp = SYMBOL_REF_DECL (x);
3344 if (!TREE_ASM_WRITTEN (exp))
3346 n_deferred_constants--;
3347 output_constant_def_contents (x);
3354 /* Look through appropriate parts of INSN, marking all entries in the
3355 constant pool which are actually being used. Entries that are only
3356 referenced by other constants are also marked as used. Emit
3357 deferred strings that are used. */
3360 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3365 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3366 insns, not any notes that may be attached. We don't want to mark
3367 a constant just because it happens to appear in a REG_EQUIV note. */
3368 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3370 rtx seq = PATTERN (insn);
3371 int i, n = XVECLEN (seq, 0);
3372 for (i = 0; i < n; ++i)
3374 rtx subinsn = XVECEXP (seq, 0, i);
3375 if (INSN_P (subinsn))
3376 for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3380 for_each_rtx (&PATTERN (insn), mark_constant, pool);
3383 /* Look through the instructions for this function, and mark all the
3384 entries in POOL which are actually being used. Emit deferred constants
3385 which have indeed been used. */
3388 mark_constant_pool (struct rtx_constant_pool *pool)
3392 if (pool->first == 0 && n_deferred_constants == 0)
3395 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3396 mark_constants (pool, insn);
3398 for (link = current_function_epilogue_delay_list;
3400 link = XEXP (link, 1))
3401 mark_constants (pool, XEXP (link, 0));
3404 /* Write all the constants in the constant pool. */
3407 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3408 tree fndecl ATTRIBUTE_UNUSED)
3410 struct rtx_constant_pool *pool = cfun->varasm->pool;
3411 struct constant_descriptor_rtx *desc;
3413 /* It is possible for gcc to call force_const_mem and then to later
3414 discard the instructions which refer to the constant. In such a
3415 case we do not need to output the constant. */
3416 mark_constant_pool (pool);
3418 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3419 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3422 for (desc = pool->first; desc ; desc = desc->next)
3423 output_constant_pool_1 (desc);
3425 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3426 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3430 /* Determine what kind of relocations EXP may need. */
3433 compute_reloc_for_constant (tree exp)
3435 int reloc = 0, reloc2;
3438 /* Give the front-end a chance to convert VALUE to something that
3439 looks more like a constant to the back-end. */
3440 exp = lang_hooks.expand_constant (exp);
3442 switch (TREE_CODE (exp))
3446 /* Go inside any operations that get_inner_reference can handle and see
3447 if what's inside is a constant: no need to do anything here for
3448 addresses of variables or functions. */
3449 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3450 tem = TREE_OPERAND (tem, 0))
3453 if (TREE_PUBLIC (tem))
3460 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3461 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3465 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3466 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3467 /* The difference of two local labels is computable at link time. */
3468 if (reloc == 1 && reloc2 == 1)
3476 case NON_LVALUE_EXPR:
3477 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3481 for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3482 if (TREE_VALUE (tem) != 0)
3483 reloc |= compute_reloc_for_constant (TREE_VALUE (tem));
3493 /* Find all the constants whose addresses are referenced inside of EXP,
3494 and make sure assembler code with a label has been output for each one.
3495 Indicate whether an ADDR_EXPR has been encountered. */
3498 output_addressed_constants (tree exp)
3502 /* Give the front-end a chance to convert VALUE to something that
3503 looks more like a constant to the back-end. */
3504 exp = lang_hooks.expand_constant (exp);
3506 switch (TREE_CODE (exp))
3510 /* Go inside any operations that get_inner_reference can handle and see
3511 if what's inside is a constant: no need to do anything here for
3512 addresses of variables or functions. */
3513 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3514 tem = TREE_OPERAND (tem, 0))
3517 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3518 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3519 tem = DECL_INITIAL (tem);
3521 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3522 output_constant_def (tem, 0);
3527 output_addressed_constants (TREE_OPERAND (exp, 1));
3532 case NON_LVALUE_EXPR:
3533 output_addressed_constants (TREE_OPERAND (exp, 0));
3537 for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3538 if (TREE_VALUE (tem) != 0)
3539 output_addressed_constants (TREE_VALUE (tem));
3548 /* Return nonzero if VALUE is a valid constant-valued expression
3549 for use in initializing a static variable; one that can be an
3550 element of a "constant" initializer.
3552 Return null_pointer_node if the value is absolute;
3553 if it is relocatable, return the variable that determines the relocation.
3554 We assume that VALUE has been folded as much as possible;
3555 therefore, we do not need to check for such things as
3556 arithmetic-combinations of integers. */
3559 initializer_constant_valid_p (tree value, tree endtype)
3561 /* Give the front-end a chance to convert VALUE to something that
3562 looks more like a constant to the back-end. */
3563 value = lang_hooks.expand_constant (value);
3565 switch (TREE_CODE (value))
3568 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3569 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3570 && TREE_CONSTANT (value)
3571 && CONSTRUCTOR_ELTS (value))
3574 bool absolute = true;
3576 for (elt = CONSTRUCTOR_ELTS (value); elt; elt = TREE_CHAIN (elt))
3579 value = TREE_VALUE (elt);
3580 reloc = initializer_constant_valid_p (value, TREE_TYPE (value));
3583 if (reloc != null_pointer_node)
3586 /* For a non-absolute relocation, there is no single
3587 variable that can be "the variable that determines the
3589 return absolute ? null_pointer_node : error_mark_node;
3592 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3599 return null_pointer_node;
3603 value = staticp (TREE_OPERAND (value, 0));
3604 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3605 be a constant, this is old-skool offsetof-like nonsense. */
3607 && TREE_CODE (value) == INDIRECT_REF
3608 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3609 return null_pointer_node;
3610 /* Taking the address of a nested function involves a trampoline. */
3612 && TREE_CODE (value) == FUNCTION_DECL
3613 && ((decl_function_context (value) && !DECL_NO_STATIC_CHAIN (value))
3614 || DECL_NON_ADDR_CONST_P (value)))
3618 case VIEW_CONVERT_EXPR:
3619 case NON_LVALUE_EXPR:
3620 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3629 src = TREE_OPERAND (value, 0);
3630 src_type = TREE_TYPE (src);
3631 dest_type = TREE_TYPE (value);
3633 /* Allow conversions between pointer types, floating-point
3634 types, and offset types. */
3635 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3636 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3637 || (TREE_CODE (dest_type) == OFFSET_TYPE
3638 && TREE_CODE (src_type) == OFFSET_TYPE))
3639 return initializer_constant_valid_p (src, endtype);
3641 /* Allow length-preserving conversions between integer types. */
3642 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3643 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3644 return initializer_constant_valid_p (src, endtype);
3646 /* Allow conversions between other integer types only if
3648 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3650 tree inner = initializer_constant_valid_p (src, endtype);
3651 if (inner == null_pointer_node)
3652 return null_pointer_node;
3656 /* Allow (int) &foo provided int is as wide as a pointer. */
3657 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3658 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3659 return initializer_constant_valid_p (src, endtype);
3661 /* Likewise conversions from int to pointers, but also allow
3662 conversions from 0. */
3663 if ((POINTER_TYPE_P (dest_type)
3664 || TREE_CODE (dest_type) == OFFSET_TYPE)
3665 && INTEGRAL_TYPE_P (src_type))
3667 if (integer_zerop (src))
3668 return null_pointer_node;
3669 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3670 return initializer_constant_valid_p (src, endtype);
3673 /* Allow conversions to struct or union types if the value
3675 if (TREE_CODE (dest_type) == RECORD_TYPE
3676 || TREE_CODE (dest_type) == UNION_TYPE)
3677 return initializer_constant_valid_p (src, endtype);
3682 if (! INTEGRAL_TYPE_P (endtype)
3683 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3685 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3687 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3689 /* If either term is absolute, use the other terms relocation. */
3690 if (valid0 == null_pointer_node)
3692 if (valid1 == null_pointer_node)
3698 if (! INTEGRAL_TYPE_P (endtype)
3699 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3701 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3703 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3705 /* Win if second argument is absolute. */
3706 if (valid1 == null_pointer_node)
3708 /* Win if both arguments have the same relocation.
3709 Then the value is absolute. */
3710 if (valid0 == valid1 && valid0 != 0)
3711 return null_pointer_node;
3713 /* Since GCC guarantees that string constants are unique in the
3714 generated code, a subtraction between two copies of the same
3715 constant string is absolute. */
3716 if (valid0 && TREE_CODE (valid0) == STRING_CST
3717 && valid1 && TREE_CODE (valid1) == STRING_CST
3718 && operand_equal_p (valid0, valid1, 1))
3719 return null_pointer_node;
3722 /* Support narrowing differences. */
3723 if (INTEGRAL_TYPE_P (endtype))
3727 op0 = TREE_OPERAND (value, 0);
3728 op1 = TREE_OPERAND (value, 1);
3730 /* Like STRIP_NOPS except allow the operand mode to widen.
3731 This works around a feature of fold that simplifies
3732 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3733 that the narrower operation is cheaper. */
3735 while (TREE_CODE (op0) == NOP_EXPR
3736 || TREE_CODE (op0) == CONVERT_EXPR
3737 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3739 tree inner = TREE_OPERAND (op0, 0);
3740 if (inner == error_mark_node
3741 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3742 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3743 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3748 while (TREE_CODE (op1) == NOP_EXPR
3749 || TREE_CODE (op1) == CONVERT_EXPR
3750 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3752 tree inner = TREE_OPERAND (op1, 0);
3753 if (inner == error_mark_node
3754 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3755 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3756 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3761 op0 = initializer_constant_valid_p (op0, endtype);
3762 op1 = initializer_constant_valid_p (op1, endtype);
3764 /* Both initializers must be known. */
3768 return null_pointer_node;
3770 /* Support differences between labels. */
3771 if (TREE_CODE (op0) == LABEL_DECL
3772 && TREE_CODE (op1) == LABEL_DECL)
3773 return null_pointer_node;
3775 if (TREE_CODE (op0) == STRING_CST
3776 && TREE_CODE (op1) == STRING_CST
3777 && operand_equal_p (op0, op1, 1))
3778 return null_pointer_node;
3790 /* Output assembler code for constant EXP to FILE, with no label.
3791 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3792 Assumes output_addressed_constants has been done on EXP already.
3794 Generate exactly SIZE bytes of assembler data, padding at the end
3795 with zeros if necessary. SIZE must always be specified.
3797 SIZE is important for structure constructors,
3798 since trailing members may have been omitted from the constructor.
3799 It is also important for initialization of arrays from string constants
3800 since the full length of the string constant might not be wanted.
3801 It is also needed for initialization of unions, where the initializer's
3802 type is just one member, and that may not be as long as the union.
3804 There a case in which we would fail to output exactly SIZE bytes:
3805 for a structure constructor that wants to produce more than SIZE bytes.
3806 But such constructors will never be generated for any possible input.
3808 ALIGN is the alignment of the data in bits. */
3811 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3813 enum tree_code code;
3814 unsigned HOST_WIDE_INT thissize;
3816 /* Some front-ends use constants other than the standard language-independent
3817 varieties, but which may still be output directly. Give the front-end a
3818 chance to convert EXP to a language-independent representation. */
3819 exp = lang_hooks.expand_constant (exp);
3821 if (size == 0 || flag_syntax_only)
3824 /* Eliminate any conversions since we'll be outputting the underlying
3826 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3827 || TREE_CODE (exp) == NON_LVALUE_EXPR
3828 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3829 exp = TREE_OPERAND (exp, 0);
3831 code = TREE_CODE (TREE_TYPE (exp));
3832 thissize = int_size_in_bytes (TREE_TYPE (exp));
3834 /* Allow a constructor with no elements for any data type.
3835 This means to fill the space with zeros. */
3836 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3838 assemble_zeros (size);
3842 if (TREE_CODE (exp) == FDESC_EXPR)
3844 #ifdef ASM_OUTPUT_FDESC
3845 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
3846 tree decl = TREE_OPERAND (exp, 0);
3847 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
3854 /* Now output the underlying data. If we've handling the padding, return.
3855 Otherwise, break and ensure SIZE is the size written. */
3863 case REFERENCE_TYPE:
3865 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3866 EXPAND_INITIALIZER),
3867 MIN (size, thissize), align, 0))
3868 error ("initializer for integer value is too complicated");
3872 if (TREE_CODE (exp) != REAL_CST)
3873 error ("initializer for floating value is not a floating constant");
3875 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
3879 output_constant (TREE_REALPART (exp), thissize / 2, align);
3880 output_constant (TREE_IMAGPART (exp), thissize / 2,
3881 min_align (align, BITS_PER_UNIT * (thissize / 2)));
3886 switch (TREE_CODE (exp))
3889 output_constructor (exp, size, align);
3892 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
3894 assemble_string (TREE_STRING_POINTER (exp), thissize);
3901 unsigned int nalign;
3902 enum machine_mode inner;
3904 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
3905 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
3907 elt_size = GET_MODE_SIZE (inner);
3909 link = TREE_VECTOR_CST_ELTS (exp);
3910 output_constant (TREE_VALUE (link), elt_size, align);
3911 while ((link = TREE_CHAIN (link)) != NULL)
3912 output_constant (TREE_VALUE (link), elt_size, nalign);
3922 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
3923 output_constructor (exp, size, align);
3933 if (size > thissize)
3934 assemble_zeros (size - thissize);
3938 /* Subroutine of output_constructor, used for computing the size of
3939 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3940 type with an unspecified upper bound. */
3942 static unsigned HOST_WIDE_INT
3943 array_size_for_constructor (tree val)
3947 /* This code used to attempt to handle string constants that are not
3948 arrays of single-bytes, but nothing else does, so there's no point in
3950 if (TREE_CODE (val) == STRING_CST)
3951 return TREE_STRING_LENGTH (val);
3953 max_index = NULL_TREE;
3954 for (i = CONSTRUCTOR_ELTS (val); i; i = TREE_CHAIN (i))
3956 tree index = TREE_PURPOSE (i);
3958 if (TREE_CODE (index) == RANGE_EXPR)
3959 index = TREE_OPERAND (index, 1);
3960 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
3964 if (max_index == NULL_TREE)
3967 /* Compute the total number of array elements. */
3968 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
3970 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
3971 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
3973 /* Multiply by the array element unit size to find number of bytes. */
3974 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
3976 return tree_low_cst (i, 1);
3979 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3980 Generate at least SIZE bytes, padding if necessary. */
3983 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
3986 tree type = TREE_TYPE (exp);
3987 tree link, field = 0;
3989 /* Number of bytes output or skipped so far.
3990 In other words, current position within the constructor. */
3991 HOST_WIDE_INT total_bytes = 0;
3992 /* Nonzero means BYTE contains part of a byte, to be output. */
3993 int byte_buffer_in_use = 0;
3996 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
3998 if (TREE_CODE (type) == RECORD_TYPE)
3999 field = TYPE_FIELDS (type);
4001 if (TREE_CODE (type) == ARRAY_TYPE
4002 && TYPE_DOMAIN (type) != 0)
4003 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4005 /* As LINK goes through the elements of the constant,
4006 FIELD goes through the structure fields, if the constant is a structure.
4007 if the constant is a union, then we override this,
4008 by getting the field from the TREE_LIST element.
4009 But the constant could also be an array. Then FIELD is zero.
4011 There is always a maximum of one element in the chain LINK for unions
4012 (even if the initializer in a source program incorrectly contains
4014 for (link = CONSTRUCTOR_ELTS (exp);
4016 link = TREE_CHAIN (link),
4017 field = field ? TREE_CHAIN (field) : 0)
4019 tree val = TREE_VALUE (link);
4022 /* The element in a union constructor specifies the proper field
4024 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4025 || TREE_CODE (type) == QUAL_UNION_TYPE)
4026 && TREE_PURPOSE (link) != 0)
4027 field = TREE_PURPOSE (link);
4029 else if (TREE_CODE (type) == ARRAY_TYPE)
4030 index = TREE_PURPOSE (link);
4032 #ifdef ASM_COMMENT_START
4033 if (field && flag_verbose_asm)
4034 fprintf (asm_out_file, "%s %s:\n",
4037 ? IDENTIFIER_POINTER (DECL_NAME (field))
4041 /* Eliminate the marker that makes a cast not be an lvalue. */
4045 if (index && TREE_CODE (index) == RANGE_EXPR)
4047 unsigned HOST_WIDE_INT fieldsize
4048 = int_size_in_bytes (TREE_TYPE (type));
4049 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4050 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4051 HOST_WIDE_INT index;
4052 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4054 for (index = lo_index; index <= hi_index; index++)
4056 /* Output the element's initial value. */
4058 assemble_zeros (fieldsize);
4060 output_constant (val, fieldsize, align2);
4062 /* Count its size. */
4063 total_bytes += fieldsize;
4066 else if (field == 0 || !DECL_BIT_FIELD (field))
4068 /* An element that is not a bit-field. */
4070 unsigned HOST_WIDE_INT fieldsize;
4071 /* Since this structure is static,
4072 we know the positions are constant. */
4073 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4074 unsigned int align2;
4077 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4078 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4080 /* Output any buffered-up bit-fields preceding this element. */
4081 if (byte_buffer_in_use)
4083 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4085 byte_buffer_in_use = 0;
4088 /* Advance to offset of this element.
4089 Note no alignment needed in an array, since that is guaranteed
4090 if each element has the proper size. */
4091 if ((field != 0 || index != 0) && pos != total_bytes)
4093 assemble_zeros (pos - total_bytes);
4097 /* Find the alignment of this element. */
4098 align2 = min_align (align, BITS_PER_UNIT * pos);
4100 /* Determine size this element should occupy. */
4105 /* If this is an array with an unspecified upper bound,
4106 the initializer determines the size. */
4107 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4108 but we cannot do this until the deprecated support for
4109 initializing zero-length array members is removed. */
4110 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4111 && TYPE_DOMAIN (TREE_TYPE (field))
4112 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4114 fieldsize = array_size_for_constructor (val);
4115 /* Given a non-empty initialization, this field had
4117 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4119 else if (DECL_SIZE_UNIT (field))
4121 /* ??? This can't be right. If the decl size overflows
4122 a host integer we will silently emit no data. */
4123 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4124 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4128 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4130 /* Output the element's initial value. */
4132 assemble_zeros (fieldsize);
4134 output_constant (val, fieldsize, align2);
4136 /* Count its size. */
4137 total_bytes += fieldsize;
4139 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4140 error ("invalid initial value for member %qs",
4141 IDENTIFIER_POINTER (DECL_NAME (field)));
4144 /* Element that is a bit-field. */
4146 HOST_WIDE_INT next_offset = int_bit_position (field);
4147 HOST_WIDE_INT end_offset
4148 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4151 val = integer_zero_node;
4153 /* If this field does not start in this (or, next) byte,
4155 if (next_offset / BITS_PER_UNIT != total_bytes)
4157 /* Output remnant of any bit field in previous bytes. */
4158 if (byte_buffer_in_use)
4160 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4162 byte_buffer_in_use = 0;
4165 /* If still not at proper byte, advance to there. */
4166 if (next_offset / BITS_PER_UNIT != total_bytes)
4168 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4169 total_bytes = next_offset / BITS_PER_UNIT;
4173 if (! byte_buffer_in_use)
4176 /* We must split the element into pieces that fall within
4177 separate bytes, and combine each byte with previous or
4178 following bit-fields. */
4180 /* next_offset is the offset n fbits from the beginning of
4181 the structure to the next bit of this element to be processed.
4182 end_offset is the offset of the first bit past the end of
4184 while (next_offset < end_offset)
4188 HOST_WIDE_INT value;
4189 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4190 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4192 /* Advance from byte to byte
4193 within this element when necessary. */
4194 while (next_byte != total_bytes)
4196 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4201 /* Number of bits we can process at once
4202 (all part of the same byte). */
4203 this_time = MIN (end_offset - next_offset,
4204 BITS_PER_UNIT - next_bit);
4205 if (BYTES_BIG_ENDIAN)
4207 /* On big-endian machine, take the most significant bits
4208 first (of the bits that are significant)
4209 and put them into bytes from the most significant end. */
4210 shift = end_offset - next_offset - this_time;
4212 /* Don't try to take a bunch of bits that cross
4213 the word boundary in the INTEGER_CST. We can
4214 only select bits from the LOW or HIGH part
4216 if (shift < HOST_BITS_PER_WIDE_INT
4217 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4219 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4220 shift = HOST_BITS_PER_WIDE_INT;
4223 /* Now get the bits from the appropriate constant word. */
4224 if (shift < HOST_BITS_PER_WIDE_INT)
4225 value = TREE_INT_CST_LOW (val);
4228 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4229 value = TREE_INT_CST_HIGH (val);
4230 shift -= HOST_BITS_PER_WIDE_INT;
4233 /* Get the result. This works only when:
4234 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4235 byte |= (((value >> shift)
4236 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4237 << (BITS_PER_UNIT - this_time - next_bit));
4241 /* On little-endian machines,
4242 take first the least significant bits of the value
4243 and pack them starting at the least significant
4244 bits of the bytes. */
4245 shift = next_offset - int_bit_position (field);
4247 /* Don't try to take a bunch of bits that cross
4248 the word boundary in the INTEGER_CST. We can
4249 only select bits from the LOW or HIGH part
4251 if (shift < HOST_BITS_PER_WIDE_INT
4252 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4253 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4255 /* Now get the bits from the appropriate constant word. */
4256 if (shift < HOST_BITS_PER_WIDE_INT)
4257 value = TREE_INT_CST_LOW (val);
4260 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4261 value = TREE_INT_CST_HIGH (val);
4262 shift -= HOST_BITS_PER_WIDE_INT;
4265 /* Get the result. This works only when:
4266 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4267 byte |= (((value >> shift)
4268 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4272 next_offset += this_time;
4273 byte_buffer_in_use = 1;
4278 if (byte_buffer_in_use)
4280 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4284 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4285 assemble_zeros (size - total_bytes);
4288 /* This TREE_LIST contains any weak symbol declarations waiting
4290 static GTY(()) tree weak_decls;
4292 /* Mark DECL as weak. */
4295 mark_weak (tree decl)
4297 DECL_WEAK (decl) = 1;
4299 if (DECL_RTL_SET_P (decl)
4300 && MEM_P (DECL_RTL (decl))
4301 && XEXP (DECL_RTL (decl), 0)
4302 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4303 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4306 /* Merge weak status between NEWDECL and OLDDECL. */
4309 merge_weak (tree newdecl, tree olddecl)
4311 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4313 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4316 /* We put the NEWDECL on the weak_decls list at some point
4317 and OLDDECL as well. Keep just OLDDECL on the list. */
4318 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4319 if (TREE_VALUE (*pwd) == newdecl)
4321 *pwd = TREE_CHAIN (*pwd);
4328 if (DECL_WEAK (newdecl))
4332 /* NEWDECL is weak, but OLDDECL is not. */
4334 /* If we already output the OLDDECL, we're in trouble; we can't
4335 go back and make it weak. This error cannot caught in
4336 declare_weak because the NEWDECL and OLDDECL was not yet
4337 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4338 if (TREE_ASM_WRITTEN (olddecl))
4339 error ("%Jweak declaration of %qD must precede definition",
4342 /* If we've already generated rtl referencing OLDDECL, we may
4343 have done so in a way that will not function properly with
4345 else if (TREE_USED (olddecl)
4346 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4347 warning (0, "%Jweak declaration of %qD after first use results "
4348 "in unspecified behavior", newdecl, newdecl);
4352 /* We put the NEWDECL on the weak_decls list at some point.
4353 Replace it with the OLDDECL. */
4354 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4355 if (TREE_VALUE (wd) == newdecl)
4357 TREE_VALUE (wd) = olddecl;
4360 /* We may not find the entry on the list. If NEWDECL is a
4361 weak alias, then we will have already called
4362 globalize_decl to remove the entry; in that case, we do
4363 not need to do anything. */
4366 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4367 mark_weak (olddecl);
4370 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4371 weak. Just update NEWDECL to indicate that it's weak too. */
4372 mark_weak (newdecl);
4375 /* Declare DECL to be a weak symbol. */
4378 declare_weak (tree decl)
4380 if (! TREE_PUBLIC (decl))
4381 error ("%Jweak declaration of %qD must be public", decl, decl);
4382 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4383 error ("%Jweak declaration of %qD must precede definition", decl, decl);
4384 else if (SUPPORTS_WEAK)
4386 if (! DECL_WEAK (decl))
4387 weak_decls = tree_cons (NULL, decl, weak_decls);
4390 warning (0, "%Jweak declaration of %qD not supported", decl, decl);
4395 /* Emit any pending weak declarations. */
4402 for (t = weak_decls; t; t = TREE_CHAIN (t))
4404 tree decl = TREE_VALUE (t);
4405 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4406 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4409 if (! TREE_USED (decl))
4412 #ifdef ASM_WEAKEN_DECL
4413 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4415 #ifdef ASM_WEAKEN_LABEL
4416 ASM_WEAKEN_LABEL (asm_out_file, name);
4418 #ifdef ASM_OUTPUT_WEAK_ALIAS
4419 warning (0, "only weak aliases are supported in this configuration");
4427 /* Emit the assembly bits to indicate that DECL is globally visible. */
4430 globalize_decl (tree decl)
4432 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4434 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4435 if (DECL_WEAK (decl))
4439 #ifdef ASM_WEAKEN_DECL
4440 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4442 ASM_WEAKEN_LABEL (asm_out_file, name);
4445 /* Remove this function from the pending weak list so that
4446 we do not emit multiple .weak directives for it. */
4447 for (p = &weak_decls; (t = *p) ; )
4449 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4450 *p = TREE_CHAIN (t);
4452 p = &TREE_CHAIN (t);
4456 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4457 if (DECL_ONE_ONLY (decl))
4458 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4461 targetm.asm_out.globalize_label (asm_out_file, name);
4464 /* We have to be able to tell cgraph about the needed-ness of the target
4465 of an alias. This requires that the decl have been defined. Aliases
4466 that precede their definition have to be queued for later processing. */
4468 typedef struct alias_pair GTY(())
4474 /* Define gc'd vector type. */
4475 DEF_VEC_O(alias_pair);
4476 DEF_VEC_ALLOC_O(alias_pair,gc);
4478 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4480 /* Given an assembly name, find the decl it is associated with. At the
4481 same time, mark it needed for cgraph. */
4484 find_decl_and_mark_needed (tree decl, tree target)
4486 struct cgraph_node *fnode = NULL;
4487 struct cgraph_varpool_node *vnode = NULL;
4489 /* C++ thunk emitting code produces aliases late in the game.
4490 Avoid confusing cgraph code in that case. */
4491 if (!cgraph_global_info_ready)
4493 if (TREE_CODE (decl) == FUNCTION_DECL)
4495 fnode = cgraph_node_for_asm (target);
4497 vnode = cgraph_varpool_node_for_asm (target);
4501 vnode = cgraph_varpool_node_for_asm (target);
4503 fnode = cgraph_node_for_asm (target);
4509 cgraph_mark_needed_node (fnode);
4514 cgraph_varpool_mark_needed_node (vnode);
4521 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4522 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4523 tree node is DECL to have the value of the tree node TARGET. */
4526 do_assemble_alias (tree decl, tree target ATTRIBUTE_UNUSED)
4528 if (TREE_ASM_WRITTEN (decl))
4531 TREE_ASM_WRITTEN (decl) = 1;
4532 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4534 #ifdef ASM_OUTPUT_DEF
4535 /* Make name accessible from other files, if appropriate. */
4537 if (TREE_PUBLIC (decl))
4539 globalize_decl (decl);
4540 maybe_assemble_visibility (decl);
4543 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4544 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4546 ASM_OUTPUT_DEF (asm_out_file,
4547 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4548 IDENTIFIER_POINTER (target));
4550 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4555 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4556 # ifdef ASM_WEAKEN_DECL
4557 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4559 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4561 /* Remove this function from the pending weak list so that
4562 we do not emit multiple .weak directives for it. */
4563 for (p = &weak_decls; (t = *p) ; )
4564 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4565 *p = TREE_CHAIN (t);
4567 p = &TREE_CHAIN (t);
4572 /* First pass of completing pending aliases. Make sure that cgraph knows
4573 which symbols will be required. */
4576 finish_aliases_1 (void)
4581 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4585 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4586 if (target_decl == NULL)
4587 error ("%J%qD aliased to undefined symbol %qE",
4588 p->decl, p->decl, p->target);
4589 else if (DECL_EXTERNAL (target_decl))
4590 error ("%J%qD aliased to external symbol %qE",
4591 p->decl, p->decl, p->target);
4595 /* Second pass of completing pending aliases. Emit the actual assembly.
4596 This happens at the end of compilation and thus it is assured that the
4597 target symbol has been emitted. */
4600 finish_aliases_2 (void)
4605 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4606 do_assemble_alias (p->decl, p->target);
4608 VEC_truncate (alias_pair, alias_pairs, 0);
4611 /* Emit an assembler directive to make the symbol for DECL an alias to
4612 the symbol for TARGET. */
4615 assemble_alias (tree decl, tree target)
4619 #if !defined (ASM_OUTPUT_DEF)
4620 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4621 error ("%Jalias definitions not supported in this configuration", decl);
4624 if (!DECL_WEAK (decl))
4626 error ("%Jonly weak aliases are supported in this configuration", decl);
4632 /* We must force creation of DECL_RTL for debug info generation, even though
4633 we don't use it here. */
4634 make_decl_rtl (decl);
4635 TREE_USED (decl) = 1;
4637 /* A quirk of the initial implementation of aliases required that the user
4638 add "extern" to all of them. Which is silly, but now historical. Do
4639 note that the symbol is in fact locally defined. */
4640 DECL_EXTERNAL (decl) = 0;
4642 /* Allow aliases to aliases. */
4643 if (TREE_CODE (decl) == FUNCTION_DECL)
4644 cgraph_node (decl)->alias = true;
4646 cgraph_varpool_node (decl)->alias = true;
4648 /* If the target has already been emitted, we don't have to queue the
4649 alias. This saves a tad o memory. */
4650 target_decl = find_decl_and_mark_needed (decl, target);
4651 if (target_decl && TREE_ASM_WRITTEN (target_decl))
4652 do_assemble_alias (decl, target);
4655 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
4661 /* Emit an assembler directive to set symbol for DECL visibility to
4662 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4665 default_assemble_visibility (tree decl, int vis)
4667 static const char * const visibility_types[] = {
4668 NULL, "internal", "hidden", "protected"
4671 const char *name, *type;
4673 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4674 type = visibility_types[vis];
4676 #ifdef HAVE_GAS_HIDDEN
4677 fprintf (asm_out_file, "\t.%s\t", type);
4678 assemble_name (asm_out_file, name);
4679 fprintf (asm_out_file, "\n");
4681 warning (0, "visibility attribute not supported in this configuration; ignored");
4685 /* A helper function to call assemble_visibility when needed for a decl. */
4688 maybe_assemble_visibility (tree decl)
4690 enum symbol_visibility vis = DECL_VISIBILITY (decl);
4692 if (vis != VISIBILITY_DEFAULT)
4693 targetm.asm_out.visibility (decl, vis);
4696 /* Returns 1 if the target configuration supports defining public symbols
4697 so that one of them will be chosen at link time instead of generating a
4698 multiply-defined symbol error, whether through the use of weak symbols or
4699 a target-specific mechanism for having duplicates discarded. */
4702 supports_one_only (void)
4704 if (SUPPORTS_ONE_ONLY)
4706 return SUPPORTS_WEAK;
4709 /* Set up DECL as a public symbol that can be defined in multiple
4710 translation units without generating a linker error. */
4713 make_decl_one_only (tree decl)
4715 gcc_assert (TREE_CODE (decl) == VAR_DECL
4716 || TREE_CODE (decl) == FUNCTION_DECL);
4718 TREE_PUBLIC (decl) = 1;
4720 if (SUPPORTS_ONE_ONLY)
4722 #ifdef MAKE_DECL_ONE_ONLY
4723 MAKE_DECL_ONE_ONLY (decl);
4725 DECL_ONE_ONLY (decl) = 1;
4727 else if (TREE_CODE (decl) == VAR_DECL
4728 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4729 DECL_COMMON (decl) = 1;
4732 gcc_assert (SUPPORTS_WEAK);
4733 DECL_WEAK (decl) = 1;
4738 init_varasm_once (void)
4740 in_named_htab = htab_create_ggc (31, in_named_entry_hash,
4741 in_named_entry_eq, NULL);
4742 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
4743 const_desc_eq, NULL);
4745 const_alias_set = new_alias_set ();
4748 static enum tls_model
4749 decl_tls_model (tree decl)
4751 enum tls_model kind;
4752 tree attr = lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl));
4757 attr = TREE_VALUE (TREE_VALUE (attr));
4758 gcc_assert (TREE_CODE (attr) == STRING_CST);
4760 if (!strcmp (TREE_STRING_POINTER (attr), "local-exec"))
4761 kind = TLS_MODEL_LOCAL_EXEC;
4762 else if (!strcmp (TREE_STRING_POINTER (attr), "initial-exec"))
4763 kind = TLS_MODEL_INITIAL_EXEC;
4764 else if (!strcmp (TREE_STRING_POINTER (attr), "local-dynamic"))
4765 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
4766 else if (!strcmp (TREE_STRING_POINTER (attr), "global-dynamic"))
4767 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4773 is_local = targetm.binds_local_p (decl);
4777 kind = TLS_MODEL_LOCAL_EXEC;
4779 kind = TLS_MODEL_INITIAL_EXEC;
4781 /* Local dynamic is inefficient when we're not combining the
4782 parts of the address. */
4783 else if (optimize && is_local)
4784 kind = TLS_MODEL_LOCAL_DYNAMIC;
4786 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4787 if (kind < flag_tls_default)
4788 kind = flag_tls_default;
4793 /* Select a set of attributes for section NAME based on the properties
4794 of DECL and whether or not RELOC indicates that DECL's initializer
4795 might contain runtime relocations.
4797 We make the section read-only and executable for a function decl,
4798 read-only for a const data decl, and writable for a non-const data decl. */
4801 default_section_type_flags (tree decl, const char *name, int reloc)
4803 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
4807 default_section_type_flags_1 (tree decl, const char *name, int reloc,
4812 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
4813 flags = SECTION_CODE;
4814 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
4816 else if (current_function_decl
4818 && cfun->unlikely_text_section_name
4819 && strcmp (name, cfun->unlikely_text_section_name) == 0)
4820 flags = SECTION_CODE;
4822 && (!current_function_decl || !cfun)
4823 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
4824 flags = SECTION_CODE;
4826 flags = SECTION_WRITE;
4828 if (decl && DECL_ONE_ONLY (decl))
4829 flags |= SECTION_LINKONCE;
4831 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
4832 flags |= SECTION_TLS | SECTION_WRITE;
4834 if (strcmp (name, ".bss") == 0
4835 || strncmp (name, ".bss.", 5) == 0
4836 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
4837 || strcmp (name, ".sbss") == 0
4838 || strncmp (name, ".sbss.", 6) == 0
4839 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
4840 flags |= SECTION_BSS;
4842 if (strcmp (name, ".tdata") == 0
4843 || strncmp (name, ".tdata.", 7) == 0
4844 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
4845 flags |= SECTION_TLS;
4847 if (strcmp (name, ".tbss") == 0
4848 || strncmp (name, ".tbss.", 6) == 0
4849 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
4850 flags |= SECTION_TLS | SECTION_BSS;
4852 /* These three sections have special ELF types. They are neither
4853 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4854 want to print a section type (@progbits or @nobits). If someone
4855 is silly enough to emit code or TLS variables to one of these
4856 sections, then don't handle them specially. */
4857 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
4858 && (strcmp (name, ".init_array") == 0
4859 || strcmp (name, ".fini_array") == 0
4860 || strcmp (name, ".preinit_array") == 0))
4861 flags |= SECTION_NOTYPE;
4866 /* Output assembly to switch to section NAME with attribute FLAGS.
4867 Four variants for common object file formats. */
4870 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
4871 unsigned int flags ATTRIBUTE_UNUSED,
4872 tree decl ATTRIBUTE_UNUSED)
4874 /* Some object formats don't support named sections at all. The
4875 front-end should already have flagged this as an error. */
4880 default_elf_asm_named_section (const char *name, unsigned int flags,
4881 tree decl ATTRIBUTE_UNUSED)
4883 char flagchars[10], *f = flagchars;
4885 /* If we have already declared this section, we can use an
4886 abbreviated form to switch back to it -- unless this section is
4887 part of a COMDAT groups, in which case GAS requires the full
4888 declaration every time. */
4889 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4890 && ! named_section_first_declaration (name))
4892 fprintf (asm_out_file, "\t.section\t%s\n", name);
4896 if (!(flags & SECTION_DEBUG))
4898 if (flags & SECTION_WRITE)
4900 if (flags & SECTION_CODE)
4902 if (flags & SECTION_SMALL)
4904 if (flags & SECTION_MERGE)
4906 if (flags & SECTION_STRINGS)
4908 if (flags & SECTION_TLS)
4910 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4914 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
4916 if (!(flags & SECTION_NOTYPE))
4921 if (flags & SECTION_BSS)
4927 #ifdef ASM_COMMENT_START
4928 /* On platforms that use "@" as the assembly comment character,
4930 if (strcmp (ASM_COMMENT_START, "@") == 0)
4933 fprintf (asm_out_file, format, type);
4935 if (flags & SECTION_ENTSIZE)
4936 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
4937 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4938 fprintf (asm_out_file, ",%s,comdat",
4939 lang_hooks.decls.comdat_group (decl));
4942 putc ('\n', asm_out_file);
4946 default_coff_asm_named_section (const char *name, unsigned int flags,
4947 tree decl ATTRIBUTE_UNUSED)
4949 char flagchars[8], *f = flagchars;
4951 if (flags & SECTION_WRITE)
4953 if (flags & SECTION_CODE)
4957 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
4961 default_pe_asm_named_section (const char *name, unsigned int flags,
4964 default_coff_asm_named_section (name, flags, decl);
4966 if (flags & SECTION_LINKONCE)
4968 /* Functions may have been compiled at various levels of
4969 optimization so we can't use `same_size' here.
4970 Instead, have the linker pick one. */
4971 fprintf (asm_out_file, "\t.linkonce %s\n",
4972 (flags & SECTION_CODE ? "discard" : "same_size"));
4976 /* The lame default section selector. */
4979 default_select_section (tree decl, int reloc,
4980 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
4982 bool readonly = false;
4986 if (decl_readonly_section (decl, reloc))
4989 else if (TREE_CODE (decl) == CONSTRUCTOR)
4991 if (! ((flag_pic && reloc)
4992 || !TREE_READONLY (decl)
4993 || TREE_SIDE_EFFECTS (decl)
4994 || !TREE_CONSTANT (decl)))
4997 else if (TREE_CODE (decl) == STRING_CST)
4999 else if (! (flag_pic && reloc))
5003 readonly_data_section ();
5008 /* A helper function for default_elf_select_section and
5009 default_elf_unique_section. Categorizes the DECL. */
5011 enum section_category
5016 SECCAT_RODATA_MERGE_STR,
5017 SECCAT_RODATA_MERGE_STR_INIT,
5018 SECCAT_RODATA_MERGE_CONST,
5023 /* To optimize loading of shared programs, define following subsections
5025 _REL Contains data that has relocations, so they get grouped
5026 together and dynamic linker will visit fewer pages in memory.
5027 _RO Contains data that is otherwise read-only. This is useful
5028 with prelinking as most relocations won't be dynamically
5029 linked and thus stay read only.
5030 _LOCAL Marks data containing relocations only to local objects.
5031 These relocations will get fully resolved by prelinking. */
5033 SECCAT_DATA_REL_LOCAL,
5035 SECCAT_DATA_REL_RO_LOCAL,
5045 static enum section_category
5046 categorize_decl_for_section (tree, int, int);
5048 static enum section_category
5049 categorize_decl_for_section (tree decl, int reloc, int shlib)
5051 enum section_category ret;
5053 if (TREE_CODE (decl) == FUNCTION_DECL)
5055 else if (TREE_CODE (decl) == STRING_CST)
5057 if (flag_mudflap) /* or !flag_merge_constants */
5058 return SECCAT_RODATA;
5060 return SECCAT_RODATA_MERGE_STR;
5062 else if (TREE_CODE (decl) == VAR_DECL)
5064 if (DECL_INITIAL (decl) == NULL
5065 || DECL_INITIAL (decl) == error_mark_node
5066 || (flag_zero_initialized_in_bss
5067 /* Leave constant zeroes in .rodata so they can be shared. */
5068 && !TREE_READONLY (decl)
5069 && initializer_zerop (DECL_INITIAL (decl))))
5071 else if (! TREE_READONLY (decl)
5072 || TREE_SIDE_EFFECTS (decl)
5073 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5075 if (shlib && (reloc & 2))
5076 ret = SECCAT_DATA_REL;
5077 else if (shlib && reloc)
5078 ret = SECCAT_DATA_REL_LOCAL;
5082 else if (shlib && (reloc & 2))
5083 ret = SECCAT_DATA_REL_RO;
5084 else if (shlib && reloc)
5085 ret = SECCAT_DATA_REL_RO_LOCAL;
5086 else if (reloc || flag_merge_constants < 2)
5087 /* C and C++ don't allow different variables to share the same
5088 location. -fmerge-all-constants allows even that (at the
5089 expense of not conforming). */
5090 ret = SECCAT_RODATA;
5091 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5092 ret = SECCAT_RODATA_MERGE_STR_INIT;
5094 ret = SECCAT_RODATA_MERGE_CONST;
5096 else if (TREE_CODE (decl) == CONSTRUCTOR)
5098 if ((shlib && reloc)
5099 || TREE_SIDE_EFFECTS (decl)
5100 || ! TREE_CONSTANT (decl))
5103 ret = SECCAT_RODATA;
5106 ret = SECCAT_RODATA;
5108 /* There are no read-only thread-local sections. */
5109 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
5111 /* Note that this would be *just* SECCAT_BSS, except that there's
5112 no concept of a read-only thread-local-data section. */
5113 if (ret == SECCAT_BSS
5114 || (flag_zero_initialized_in_bss
5115 && initializer_zerop (DECL_INITIAL (decl))))
5121 /* If the target uses small data sections, select it. */
5122 else if (targetm.in_small_data_p (decl))
5124 if (ret == SECCAT_BSS)
5126 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5127 ret = SECCAT_SRODATA;
5136 decl_readonly_section (tree decl, int reloc)
5138 return decl_readonly_section_1 (decl, reloc, flag_pic);
5142 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5144 switch (categorize_decl_for_section (decl, reloc, shlib))
5147 case SECCAT_RODATA_MERGE_STR:
5148 case SECCAT_RODATA_MERGE_STR_INIT:
5149 case SECCAT_RODATA_MERGE_CONST:
5150 case SECCAT_SRODATA:
5159 /* Select a section based on the above categorization. */
5162 default_elf_select_section (tree decl, int reloc,
5163 unsigned HOST_WIDE_INT align)
5165 default_elf_select_section_1 (decl, reloc, align, flag_pic);
5169 default_elf_select_section_1 (tree decl, int reloc,
5170 unsigned HOST_WIDE_INT align, int shlib)
5173 switch (categorize_decl_for_section (decl, reloc, shlib))
5176 /* We're not supposed to be called on FUNCTION_DECLs. */
5179 readonly_data_section ();
5181 case SECCAT_RODATA_MERGE_STR:
5182 mergeable_string_section (decl, align, 0);
5184 case SECCAT_RODATA_MERGE_STR_INIT:
5185 mergeable_string_section (DECL_INITIAL (decl), align, 0);
5187 case SECCAT_RODATA_MERGE_CONST:
5188 mergeable_constant_section (DECL_MODE (decl), align, 0);
5190 case SECCAT_SRODATA:
5196 case SECCAT_DATA_REL:
5197 sname = ".data.rel";
5199 case SECCAT_DATA_REL_LOCAL:
5200 sname = ".data.rel.local";
5202 case SECCAT_DATA_REL_RO:
5203 sname = ".data.rel.ro";
5205 case SECCAT_DATA_REL_RO_LOCAL:
5206 sname = ".data.rel.ro.local";
5215 #ifdef BSS_SECTION_ASM_OP
5234 named_section (decl, sname, reloc);
5237 /* Construct a unique section name based on the decl name and the
5238 categorization performed above. */
5241 default_unique_section (tree decl, int reloc)
5243 default_unique_section_1 (decl, reloc, flag_pic);
5247 default_unique_section_1 (tree decl, int reloc, int shlib)
5249 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5250 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5251 const char *prefix, *name;
5255 switch (categorize_decl_for_section (decl, reloc, shlib))
5258 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5261 case SECCAT_RODATA_MERGE_STR:
5262 case SECCAT_RODATA_MERGE_STR_INIT:
5263 case SECCAT_RODATA_MERGE_CONST:
5264 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5266 case SECCAT_SRODATA:
5267 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5270 case SECCAT_DATA_REL:
5271 case SECCAT_DATA_REL_LOCAL:
5272 case SECCAT_DATA_REL_RO:
5273 case SECCAT_DATA_REL_RO_LOCAL:
5274 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5277 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5280 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5283 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5286 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5289 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5294 plen = strlen (prefix);
5296 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5297 name = targetm.strip_name_encoding (name);
5298 nlen = strlen (name);
5300 string = alloca (nlen + plen + 1);
5301 memcpy (string, prefix, plen);
5302 memcpy (string + plen, name, nlen + 1);
5304 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5308 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5310 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5313 switch (GET_CODE (x))
5325 readonly_data_section ();
5329 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5330 unsigned HOST_WIDE_INT align)
5332 /* ??? Handle small data here somehow. */
5335 switch (GET_CODE (x))
5339 named_section (NULL_TREE, ".data.rel.ro", 3);
5343 named_section (NULL_TREE, ".data.rel.ro.local", 1);
5350 mergeable_constant_section (mode, align, 0);
5353 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5356 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5361 /* Careful not to prod global register variables. */
5364 symbol = XEXP (rtl, 0);
5365 if (GET_CODE (symbol) != SYMBOL_REF)
5369 if (TREE_CODE (decl) == FUNCTION_DECL)
5370 flags |= SYMBOL_FLAG_FUNCTION;
5371 if (targetm.binds_local_p (decl))
5372 flags |= SYMBOL_FLAG_LOCAL;
5373 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
5374 flags |= decl_tls_model (decl) << SYMBOL_FLAG_TLS_SHIFT;
5375 else if (targetm.in_small_data_p (decl))
5376 flags |= SYMBOL_FLAG_SMALL;
5377 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5378 being PUBLIC, the thing *must* be defined in this translation unit.
5379 Prevent this buglet from being propagated into rtl code as well. */
5380 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5381 flags |= SYMBOL_FLAG_EXTERNAL;
5383 SYMBOL_REF_FLAGS (symbol) = flags;
5386 /* By default, we do nothing for encode_section_info, so we need not
5387 do anything but discard the '*' marker. */
5390 default_strip_name_encoding (const char *str)
5392 return str + (*str == '*');
5395 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5396 wrt cross-module name binding. */
5399 default_binds_local_p (tree exp)
5401 return default_binds_local_p_1 (exp, flag_shlib);
5405 default_binds_local_p_1 (tree exp, int shlib)
5409 /* A non-decl is an entry in the constant pool. */
5412 /* Static variables are always local. */
5413 else if (! TREE_PUBLIC (exp))
5415 /* A variable is local if the user explicitly tells us so. */
5416 else if (DECL_VISIBILITY_SPECIFIED (exp) && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5418 /* Otherwise, variables defined outside this object may not be local. */
5419 else if (DECL_EXTERNAL (exp))
5421 /* Linkonce and weak data are never local. */
5422 else if (DECL_ONE_ONLY (exp) || DECL_WEAK (exp))
5424 /* If none of the above and visibility is not default, make local. */
5425 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5427 /* If PIC, then assume that any global name can be overridden by
5428 symbols resolved from other modules. */
5431 /* Uninitialized COMMON variable may be unified with symbols
5432 resolved from other modules. */
5433 else if (DECL_COMMON (exp)
5434 && (DECL_INITIAL (exp) == NULL
5435 || DECL_INITIAL (exp) == error_mark_node))
5437 /* Otherwise we're left with initialized (or non-common) global data
5438 which is of necessity defined locally. */
5445 /* Determine whether or not a pointer mode is valid. Assume defaults
5446 of ptr_mode or Pmode - can be overridden. */
5448 default_valid_pointer_mode (enum machine_mode mode)
5450 return (mode == ptr_mode || mode == Pmode);
5453 /* Default function to output code that will globalize a label. A
5454 target must define GLOBAL_ASM_OP or provide its own function to
5455 globalize a label. */
5456 #ifdef GLOBAL_ASM_OP
5458 default_globalize_label (FILE * stream, const char *name)
5460 fputs (GLOBAL_ASM_OP, stream);
5461 assemble_name (stream, name);
5462 putc ('\n', stream);
5464 #endif /* GLOBAL_ASM_OP */
5466 /* Default function to output a label for unwind information. The
5467 default is to do nothing. A target that needs nonlocal labels for
5468 unwind information must provide its own function to do this. */
5470 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5471 tree decl ATTRIBUTE_UNUSED,
5472 int for_eh ATTRIBUTE_UNUSED,
5473 int empty ATTRIBUTE_UNUSED)
5477 /* This is how to output an internal numbered label where PREFIX is
5478 the class of label and LABELNO is the number within the class. */
5481 default_internal_label (FILE *stream, const char *prefix,
5482 unsigned long labelno)
5484 char *const buf = alloca (40 + strlen (prefix));
5485 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5486 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5489 /* This is the default behavior at the beginning of a file. It's
5490 controlled by two other target-hook toggles. */
5492 default_file_start (void)
5494 if (targetm.file_start_app_off && !flag_verbose_asm)
5495 fputs (ASM_APP_OFF, asm_out_file);
5497 if (targetm.file_start_file_directive)
5498 output_file_directive (asm_out_file, main_input_filename);
5501 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5502 which emits a special section directive used to indicate whether or
5503 not this object file needs an executable stack. This is primarily
5504 a GNU extension to ELF but could be used on other targets. */
5506 int trampolines_created;
5509 file_end_indicate_exec_stack (void)
5511 unsigned int flags = SECTION_DEBUG;
5512 if (trampolines_created)
5513 flags |= SECTION_CODE;
5515 named_section_flags (".note.GNU-stack", flags);
5518 #include "gt-varasm.h"