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, 51 Franklin Street, Fifth Floor, Boston, MA
24 /* This file handles generation of all the assembler code
25 *except* the instructions of a function.
26 This includes declarations of variables and their initial values.
28 We also output the assembler code for constants stored in memory
29 and are responsible for combining constants with the same value. */
33 #include "coretypes.h"
40 #include "hard-reg-set.h"
48 #include "langhooks.h"
52 #include "tree-mudflap.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h" /* Needed for external data
59 declarations for e.g. AIX 4.x. */
62 /* The (assembler) name of the first globally-visible object output. */
63 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)
179 const char *stripped_name;
183 gcc_assert (cfun && current_function_decl);
184 if (cfun->unlikely_text_section_name)
187 dsn = DECL_SECTION_NAME (current_function_decl);
188 if (flag_function_sections && dsn)
190 name = alloca (TREE_STRING_LENGTH (dsn) + 1);
191 memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
193 stripped_name = targetm.strip_name_encoding (name);
195 buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
196 cfun->unlikely_text_section_name = ggc_strdup (buffer);
199 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
202 /* Tell assembler to switch to text section. */
207 if (in_section != in_text)
209 in_section = in_text;
210 last_text_section = in_text;
211 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
215 /* Tell assembler to switch to unlikely-to-be-executed text section. */
218 unlikely_text_section (void)
222 if (!cfun->unlikely_text_section_name)
223 initialize_cold_section_name ();
225 if (flag_function_sections
226 || ((in_section != in_unlikely_executed_text)
227 && (in_section != in_named
228 || (strcmp (in_named_name, cfun->unlikely_text_section_name)
231 named_section (NULL_TREE, cfun->unlikely_text_section_name, 0);
232 in_section = in_unlikely_executed_text;
233 last_text_section = in_unlikely_executed_text;
238 named_section (NULL_TREE, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
239 in_section = in_unlikely_executed_text;
240 last_text_section = in_unlikely_executed_text;
244 /* Tell assembler to switch to data section. */
249 if (in_section != in_data)
251 in_section = in_data;
252 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
256 /* Tell assembler to switch to read-only data section. This is normally
260 readonly_data_section (void)
262 #ifdef READONLY_DATA_SECTION
263 READONLY_DATA_SECTION (); /* Note this can call data_section. */
265 #ifdef READONLY_DATA_SECTION_ASM_OP
266 if (in_section != in_readonly_data)
268 in_section = in_readonly_data;
269 fputs (READONLY_DATA_SECTION_ASM_OP, asm_out_file);
270 fputc ('\n', asm_out_file);
278 /* Determine if we're in the text section. */
281 in_text_section (void)
283 return in_section == in_text;
286 /* Determine if we're in the unlikely-to-be-executed text section. */
289 in_unlikely_text_section (void)
295 ret_val = ((in_section == in_unlikely_executed_text)
296 || (in_section == in_named
297 && cfun->unlikely_text_section_name
298 && strcmp (in_named_name,
299 cfun->unlikely_text_section_name) == 0));
303 ret_val = ((in_section == in_unlikely_executed_text)
304 || (in_section == in_named
305 && strcmp (in_named_name,
306 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0));
312 /* Determine if we're in the data section. */
315 in_data_section (void)
317 return in_section == in_data;
320 /* Helper routines for maintaining in_named_htab. */
323 in_named_entry_eq (const void *p1, const void *p2)
325 const struct in_named_entry *old = p1;
326 const char *new = p2;
328 return strcmp (old->name, new) == 0;
332 in_named_entry_hash (const void *p)
334 const struct in_named_entry *old = p;
335 return htab_hash_string (old->name);
338 /* If SECTION has been seen before as a named section, return the flags
339 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
340 set of flags for a section to have, so 0 does not mean that the section
341 has not been seen. */
344 get_named_section_flags (const char *section)
346 struct in_named_entry **slot;
348 slot = (struct in_named_entry **)
349 htab_find_slot_with_hash (in_named_htab, section,
350 htab_hash_string (section), NO_INSERT);
352 return slot ? (*slot)->flags : 0;
355 /* Returns true if the section has been declared before. Sets internal
356 flag on this section in in_named_hash so subsequent calls on this
357 section will return false. */
360 named_section_first_declaration (const char *name)
362 struct in_named_entry **slot;
364 slot = (struct in_named_entry **)
365 htab_find_slot_with_hash (in_named_htab, name,
366 htab_hash_string (name), NO_INSERT);
367 if (! (*slot)->declared)
369 (*slot)->declared = true;
379 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
380 different set of flags, return false. */
383 set_named_section_flags (const char *section, unsigned int flags)
385 struct in_named_entry **slot, *entry;
387 slot = (struct in_named_entry **)
388 htab_find_slot_with_hash (in_named_htab, section,
389 htab_hash_string (section), INSERT);
394 entry = ggc_alloc (sizeof (*entry));
396 entry->name = ggc_strdup (section);
397 entry->flags = flags;
398 entry->declared = false;
400 else if (entry->flags != flags)
406 /* Tell assembler to change to section NAME with attributes FLAGS. If
407 DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with which
408 this section is associated. */
411 named_section_real (const char *name, unsigned int flags, tree decl)
413 if (in_section != in_named || strcmp (name, in_named_name) != 0)
415 bool unchanged = set_named_section_flags (name, flags);
417 gcc_assert (unchanged);
419 targetm.asm_out.named_section (name, flags, decl);
421 if (flags & SECTION_FORGET)
422 in_section = no_section;
425 in_named_name = ggc_strdup (name);
426 in_section = in_named;
430 if (in_text_section () || in_unlikely_text_section ())
432 last_text_section = in_section;
433 last_text_section_name = name;
437 /* Tell assembler to change to section NAME for DECL.
438 If DECL is NULL, just switch to section NAME.
439 If NAME is NULL, get the name from DECL.
440 If RELOC is 1, the initializer for DECL contains relocs. */
443 named_section (tree decl, const char *name, int reloc)
447 gcc_assert (!decl || DECL_P (decl));
449 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
451 if (strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0
453 && ! cfun->unlikely_text_section_name)
454 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
456 flags = targetm.section_type_flags (decl, name, reloc);
458 /* Sanity check user variables for flag changes. Non-user
459 section flag changes will die in named_section_flags.
460 However, don't complain if SECTION_OVERRIDE is set.
461 We trust that the setter knows that it is safe to ignore
462 the default flags for this decl. */
463 if (decl && ! set_named_section_flags (name, flags))
465 flags = get_named_section_flags (name);
466 if ((flags & SECTION_OVERRIDE) == 0)
467 error ("%+D causes a section type conflict", decl);
470 named_section_real (name, flags, decl);
473 /* If required, set DECL_SECTION_NAME to a unique name. */
476 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
477 int flag_function_or_data_sections)
479 if (DECL_SECTION_NAME (decl) == NULL_TREE
480 && targetm.have_named_sections
481 && (flag_function_or_data_sections
482 || DECL_ONE_ONLY (decl)))
483 targetm.asm_out.unique_section (decl, reloc);
486 #ifdef BSS_SECTION_ASM_OP
488 /* Tell the assembler to switch to the bss section. */
493 if (in_section != in_bss)
495 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
500 #ifdef ASM_OUTPUT_BSS
502 /* Utility function for ASM_OUTPUT_BSS for targets to use if
503 they don't support alignments in .bss.
504 ??? It is believed that this function will work in most cases so such
505 support is localized here. */
508 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
510 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
511 unsigned HOST_WIDE_INT rounded)
513 targetm.asm_out.globalize_label (file, name);
515 #ifdef ASM_DECLARE_OBJECT_NAME
516 last_assemble_variable_decl = decl;
517 ASM_DECLARE_OBJECT_NAME (file, name, decl);
519 /* Standard thing is just output label for the object. */
520 ASM_OUTPUT_LABEL (file, name);
521 #endif /* ASM_DECLARE_OBJECT_NAME */
522 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
527 #ifdef ASM_OUTPUT_ALIGNED_BSS
529 /* Utility function for targets to use in implementing
530 ASM_OUTPUT_ALIGNED_BSS.
531 ??? It is believed that this function will work in most cases so such
532 support is localized here. */
535 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
536 const char *name, unsigned HOST_WIDE_INT size,
540 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
541 #ifdef ASM_DECLARE_OBJECT_NAME
542 last_assemble_variable_decl = decl;
543 ASM_DECLARE_OBJECT_NAME (file, name, decl);
545 /* Standard thing is just output label for the object. */
546 ASM_OUTPUT_LABEL (file, name);
547 #endif /* ASM_DECLARE_OBJECT_NAME */
548 ASM_OUTPUT_SKIP (file, size ? size : 1);
553 #endif /* BSS_SECTION_ASM_OP */
555 /* Switch to the section for function DECL.
557 If DECL is NULL_TREE, switch to the text section. We can be passed
558 NULL_TREE under some circumstances by dbxout.c at least. */
561 function_section (tree decl)
565 if (first_function_block_is_cold)
568 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
569 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
571 if (decl != NULL_TREE
572 && DECL_SECTION_NAME (decl) != NULL_TREE
573 && targetm.have_named_sections)
574 named_section (decl, (char *) 0, 0);
581 current_function_section (tree decl)
583 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
586 if (in_unlikely_text_section ()
587 || last_text_section == in_unlikely_executed_text)
590 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
592 if (last_text_section == in_unlikely_executed_text)
593 unlikely_text_section ();
594 else if (last_text_section == in_text)
596 else if (last_text_section == in_named
597 && targetm.have_named_sections)
598 named_section (NULL_TREE, last_text_section_name, 0);
600 function_section (decl);
604 /* Switch to read-only data section associated with function DECL. */
607 default_function_rodata_section (tree decl)
609 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
611 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
613 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
615 size_t len = strlen (name) + 3;
616 char* rname = alloca (len);
618 strcpy (rname, ".rodata");
619 strcat (rname, name + 5);
620 named_section_real (rname, SECTION_LINKONCE, decl);
623 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
624 else if (DECL_ONE_ONLY (decl)
625 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
627 size_t len = strlen (name) + 1;
628 char *rname = alloca (len);
630 memcpy (rname, name, len);
632 named_section_real (rname, SECTION_LINKONCE, decl);
635 /* For .text.foo we want to use .rodata.foo. */
636 else if (flag_function_sections && flag_data_sections
637 && strncmp (name, ".text.", 6) == 0)
639 size_t len = strlen (name) + 1;
640 char *rname = alloca (len + 2);
642 memcpy (rname, ".rodata", 7);
643 memcpy (rname + 7, name + 5, len - 5);
644 named_section_flags (rname, 0);
649 readonly_data_section ();
652 /* Switch to read-only data section associated with function DECL
653 for targets where that section should be always the single
654 readonly data section. */
657 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
659 readonly_data_section ();
662 /* Switch to section for variable DECL. RELOC is the same as the
663 argument to SELECT_SECTION. */
666 variable_section (tree decl, int reloc)
668 if (IN_NAMED_SECTION (decl))
669 named_section (decl, NULL, reloc);
671 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
674 /* Tell assembler to switch to the section for string merging. */
677 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
678 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
679 unsigned int flags ATTRIBUTE_UNUSED)
681 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
682 && TREE_CODE (decl) == STRING_CST
683 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
685 && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
687 enum machine_mode mode;
688 unsigned int modesize;
693 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
694 modesize = GET_MODE_BITSIZE (mode);
695 if (modesize >= 8 && modesize <= 256
696 && (modesize & (modesize - 1)) == 0)
698 if (align < modesize)
701 str = TREE_STRING_POINTER (decl);
702 len = TREE_STRING_LENGTH (decl);
703 unit = GET_MODE_SIZE (mode);
705 /* Check for embedded NUL characters. */
706 for (i = 0; i < len; i += unit)
708 for (j = 0; j < unit; j++)
709 if (str[i + j] != '\0')
716 sprintf (name, ".rodata.str%d.%d", modesize / 8,
718 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
719 if (!i && modesize < align)
721 /* A "" string with requested alignment greater than
722 character size might cause a problem:
723 if some other string required even bigger
724 alignment than "", then linker might think the
725 "" is just part of padding after some other string
726 and not put it into the hash table initially.
727 But this means "" could have smaller alignment
729 #ifdef ASM_OUTPUT_SECTION_START
730 named_section_flags (name, flags);
731 ASM_OUTPUT_SECTION_START (asm_out_file);
733 readonly_data_section ();
738 named_section_flags (name, flags);
744 readonly_data_section ();
747 /* Tell assembler to switch to the section for constant merging. */
750 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
751 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
752 unsigned int flags ATTRIBUTE_UNUSED)
754 unsigned int modesize = GET_MODE_BITSIZE (mode);
756 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
762 && (align & (align - 1)) == 0)
766 sprintf (name, ".rodata.cst%d", (int) (align / 8));
767 flags |= (align / 8) | SECTION_MERGE;
768 named_section_flags (name, flags);
772 readonly_data_section ();
775 /* Given NAME, a putative register name, discard any customary prefixes. */
778 strip_reg_name (const char *name)
780 #ifdef REGISTER_PREFIX
781 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
782 name += strlen (REGISTER_PREFIX);
784 if (name[0] == '%' || name[0] == '#')
789 /* The user has asked for a DECL to have a particular name. Set (or
790 change) it in such a way that we don't prefix an underscore to
793 set_user_assembler_name (tree decl, const char *name)
795 char *starred = alloca (strlen (name) + 2);
797 strcpy (starred + 1, name);
798 change_decl_assembler_name (decl, get_identifier (starred));
799 SET_DECL_RTL (decl, NULL_RTX);
802 /* Decode an `asm' spec for a declaration as a register name.
803 Return the register number, or -1 if nothing specified,
804 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
805 or -3 if ASMSPEC is `cc' and is not recognized,
806 or -4 if ASMSPEC is `memory' and is not recognized.
807 Accept an exact spelling or a decimal number.
808 Prefixes such as % are optional. */
811 decode_reg_name (const char *asmspec)
817 /* Get rid of confusing prefixes. */
818 asmspec = strip_reg_name (asmspec);
820 /* Allow a decimal number as a "register name". */
821 for (i = strlen (asmspec) - 1; i >= 0; i--)
822 if (! ISDIGIT (asmspec[i]))
824 if (asmspec[0] != 0 && i < 0)
827 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
833 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
835 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
838 #ifdef ADDITIONAL_REGISTER_NAMES
840 static const struct { const char *const name; const int number; } table[]
841 = ADDITIONAL_REGISTER_NAMES;
843 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
844 if (! strcmp (asmspec, table[i].name))
845 return table[i].number;
847 #endif /* ADDITIONAL_REGISTER_NAMES */
849 if (!strcmp (asmspec, "memory"))
852 if (!strcmp (asmspec, "cc"))
861 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
862 have static storage duration. In other words, it should not be an
863 automatic variable, including PARM_DECLs.
865 There is, however, one exception: this function handles variables
866 explicitly placed in a particular register by the user.
868 This is never called for PARM_DECL nodes. */
871 make_decl_rtl (tree decl)
873 const char *name = 0;
877 /* Check that we are not being given an automatic variable. */
878 gcc_assert (TREE_CODE (decl) != PARM_DECL
879 && TREE_CODE (decl) != RESULT_DECL);
881 /* A weak alias has TREE_PUBLIC set but not the other bits. */
882 gcc_assert (TREE_CODE (decl) != VAR_DECL
883 || TREE_STATIC (decl)
884 || TREE_PUBLIC (decl)
885 || DECL_EXTERNAL (decl)
886 || DECL_REGISTER (decl));
888 /* And that we were not given a type or a label. */
889 gcc_assert (TREE_CODE (decl) != TYPE_DECL
890 && TREE_CODE (decl) != LABEL_DECL);
892 /* For a duplicate declaration, we can be called twice on the
893 same DECL node. Don't discard the RTL already made. */
894 if (DECL_RTL_SET_P (decl))
896 /* If the old RTL had the wrong mode, fix the mode. */
897 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
898 SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
899 DECL_MODE (decl), 0));
901 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
904 /* ??? Another way to do this would be to maintain a hashed
905 table of such critters. Instead of adding stuff to a DECL
906 to give certain attributes to it, we could use an external
907 hash map from DECL to set of attributes. */
909 /* Let the target reassign the RTL if it wants.
910 This is necessary, for example, when one machine specific
911 decl attribute overrides another. */
912 targetm.encode_section_info (decl, DECL_RTL (decl), false);
914 /* Make this function static known to the mudflap runtime. */
915 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
916 mudflap_enqueue_decl (decl);
921 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
923 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
925 reg_number = decode_reg_name (name);
926 /* First detect errors in declaring global registers. */
927 if (reg_number == -1)
928 error ("register name not specified for %q+D", decl);
929 else if (reg_number < 0)
930 error ("invalid register name for %q+D", decl);
931 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
932 error ("data type of %q+D isn%'t suitable for a register",
934 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
935 error ("register specified for %q+D isn%'t suitable for data type",
937 /* Now handle properly declared static register variables. */
942 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
944 DECL_INITIAL (decl) = 0;
945 error ("global register variable has initial value");
947 if (TREE_THIS_VOLATILE (decl))
948 warning (0, "volatile register variables don%'t "
949 "work as you might wish");
951 /* If the user specified one of the eliminables registers here,
952 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
953 confused with that register and be eliminated. This usage is
954 somewhat suspect... */
956 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
957 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
958 REG_USERVAR_P (DECL_RTL (decl)) = 1;
960 if (TREE_STATIC (decl))
962 /* Make this register global, so not usable for anything
964 #ifdef ASM_DECLARE_REGISTER_GLOBAL
965 name = IDENTIFIER_POINTER (DECL_NAME (decl));
966 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
968 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
970 globalize_reg (reg_number + --nregs);
973 /* As a register variable, it has no section. */
977 /* Now handle ordinary static variables and functions (in memory).
978 Also handle vars declared register invalidly. */
979 else if (name[0] == '*')
981 #ifdef REGISTER_PREFIX
982 if (strlen (REGISTER_PREFIX) != 0)
984 reg_number = decode_reg_name (name);
985 if (reg_number >= 0 || reg_number == -3)
986 error ("register name given for non-register variable %q+D", decl);
991 /* Specifying a section attribute on a variable forces it into a
992 non-.bss section, and thus it cannot be common. */
993 if (TREE_CODE (decl) == VAR_DECL
994 && DECL_SECTION_NAME (decl) != NULL_TREE
995 && DECL_INITIAL (decl) == NULL_TREE
996 && DECL_COMMON (decl))
997 DECL_COMMON (decl) = 0;
999 /* Variables can't be both common and weak. */
1000 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1001 DECL_COMMON (decl) = 0;
1003 x = gen_rtx_SYMBOL_REF (Pmode, name);
1004 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1005 SYMBOL_REF_DECL (x) = decl;
1007 x = gen_rtx_MEM (DECL_MODE (decl), x);
1008 if (TREE_CODE (decl) != FUNCTION_DECL)
1009 set_mem_attributes (x, decl, 1);
1010 SET_DECL_RTL (decl, x);
1012 /* Optionally set flags or add text to the name to record information
1013 such as that it is a function name.
1014 If the name is changed, the macro ASM_OUTPUT_LABELREF
1015 will have to know how to strip this information. */
1016 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1018 /* Make this function static known to the mudflap runtime. */
1019 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1020 mudflap_enqueue_decl (decl);
1023 /* Make the rtl for variable VAR be volatile.
1024 Use this only for static variables. */
1027 make_var_volatile (tree var)
1029 gcc_assert (MEM_P (DECL_RTL (var)));
1031 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1034 /* Output a string of literal assembler code
1035 for an `asm' keyword used between functions. */
1038 assemble_asm (tree string)
1042 if (TREE_CODE (string) == ADDR_EXPR)
1043 string = TREE_OPERAND (string, 0);
1045 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1048 /* Record an element in the table of global destructors. SYMBOL is
1049 a SYMBOL_REF of the function to be called; PRIORITY is a number
1050 between 0 and MAX_INIT_PRIORITY. */
1053 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1054 int priority ATTRIBUTE_UNUSED)
1056 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1057 /* Tell GNU LD that this is part of the static destructor set.
1058 This will work for any system that uses stabs, most usefully
1060 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1061 dbxout_stab_value_label (XSTR (symbol, 0));
1063 sorry ("global destructors not supported on this target");
1068 default_named_section_asm_out_destructor (rtx symbol, int priority)
1070 const char *section = ".dtors";
1073 /* ??? This only works reliably with the GNU linker. */
1074 if (priority != DEFAULT_INIT_PRIORITY)
1076 sprintf (buf, ".dtors.%.5u",
1077 /* Invert the numbering so the linker puts us in the proper
1078 order; constructors are run from right to left, and the
1079 linker sorts in increasing order. */
1080 MAX_INIT_PRIORITY - priority);
1084 named_section_flags (section, SECTION_WRITE);
1085 assemble_align (POINTER_SIZE);
1086 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1089 #ifdef DTORS_SECTION_ASM_OP
1091 dtors_section (void)
1093 if (in_section != in_dtors)
1095 in_section = in_dtors;
1096 fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1097 fputc ('\n', asm_out_file);
1102 default_dtor_section_asm_out_destructor (rtx symbol,
1103 int priority ATTRIBUTE_UNUSED)
1106 assemble_align (POINTER_SIZE);
1107 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1111 /* Likewise for global constructors. */
1114 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1115 int priority ATTRIBUTE_UNUSED)
1117 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1118 /* Tell GNU LD that this is part of the static destructor set.
1119 This will work for any system that uses stabs, most usefully
1121 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1122 dbxout_stab_value_label (XSTR (symbol, 0));
1124 sorry ("global constructors not supported on this target");
1129 default_named_section_asm_out_constructor (rtx symbol, int priority)
1131 const char *section = ".ctors";
1134 /* ??? This only works reliably with the GNU linker. */
1135 if (priority != DEFAULT_INIT_PRIORITY)
1137 sprintf (buf, ".ctors.%.5u",
1138 /* Invert the numbering so the linker puts us in the proper
1139 order; constructors are run from right to left, and the
1140 linker sorts in increasing order. */
1141 MAX_INIT_PRIORITY - priority);
1145 named_section_flags (section, SECTION_WRITE);
1146 assemble_align (POINTER_SIZE);
1147 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1150 #ifdef CTORS_SECTION_ASM_OP
1152 ctors_section (void)
1154 if (in_section != in_ctors)
1156 in_section = in_ctors;
1157 fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1158 fputc ('\n', asm_out_file);
1163 default_ctor_section_asm_out_constructor (rtx symbol,
1164 int priority ATTRIBUTE_UNUSED)
1167 assemble_align (POINTER_SIZE);
1168 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1172 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1173 a nonzero value if the constant pool should be output before the
1174 start of the function, or a zero value if the pool should output
1175 after the end of the function. The default is to put it before the
1178 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1179 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1182 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1183 to be output to assembler.
1184 Set first_global_object_name and weak_global_object_name as appropriate. */
1187 notice_global_symbol (tree decl)
1189 const char **type = &first_global_object_name;
1191 if (first_global_object_name
1192 || !TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
1193 || !DECL_NAME (decl)
1194 || (TREE_CODE (decl) != FUNCTION_DECL
1195 && (TREE_CODE (decl) != VAR_DECL
1196 || (DECL_COMMON (decl)
1197 && (DECL_INITIAL (decl) == 0
1198 || DECL_INITIAL (decl) == error_mark_node))))
1199 || !MEM_P (DECL_RTL (decl)))
1202 /* We win when global object is found, but it is useful to know about weak
1203 symbol as well so we can produce nicer unique names. */
1204 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1205 type = &weak_global_object_name;
1211 rtx decl_rtl = DECL_RTL (decl);
1213 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1220 /* Output assembler code for the constant pool of a function and associated
1221 with defining the name of the function. DECL describes the function.
1222 NAME is the function's name. For the constant pool, we use the current
1223 constant pool data. */
1226 assemble_start_function (tree decl, const char *fnname)
1229 char tmp_label[100];
1230 bool hot_label_written = false;
1232 cfun->unlikely_text_section_name = NULL;
1234 first_function_block_is_cold = false;
1235 if (flag_reorder_blocks_and_partition)
1237 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1238 cfun->hot_section_label = ggc_strdup (tmp_label);
1239 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1240 cfun->cold_section_label = ggc_strdup (tmp_label);
1241 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1242 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1243 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1244 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1249 cfun->hot_section_label = NULL;
1250 cfun->cold_section_label = NULL;
1251 cfun->hot_section_end_label = NULL;
1252 cfun->cold_section_end_label = NULL;
1255 /* The following code does not need preprocessing in the assembler. */
1259 if (CONSTANT_POOL_BEFORE_FUNCTION)
1260 output_constant_pool (fnname, decl);
1262 resolve_unique_section (decl, 0, flag_function_sections);
1264 /* Make sure the not and cold text (code) sections are properly
1265 aligned. This is necessary here in the case where the function
1266 has both hot and cold sections, because we don't want to re-set
1267 the alignment when the section switch happens mid-function. */
1269 if (flag_reorder_blocks_and_partition)
1271 unlikely_text_section ();
1272 assemble_align (FUNCTION_BOUNDARY);
1273 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1274 if (BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1276 /* Since the function starts with a cold section, we need to
1277 explicitly align the hot section and write out the hot
1280 assemble_align (FUNCTION_BOUNDARY);
1281 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1282 hot_label_written = true;
1283 first_function_block_is_cold = true;
1286 else if (DECL_SECTION_NAME (decl))
1288 /* Calls to function_section rely on first_function_block_is_cold
1289 being accurate. The first block may be cold even if we aren't
1290 doing partitioning, if the entire function was decided by
1291 choose_function_section (predict.c) to be cold. */
1293 initialize_cold_section_name ();
1295 if (cfun->unlikely_text_section_name
1296 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1297 cfun->unlikely_text_section_name) == 0)
1298 first_function_block_is_cold = true;
1301 last_text_section = no_section;
1303 /* Switch to the correct text section for the start of the function. */
1305 function_section (decl);
1306 if (flag_reorder_blocks_and_partition
1307 && !hot_label_written)
1308 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1310 /* Tell assembler to move to target machine's alignment for functions. */
1311 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1312 if (align < force_align_functions_log)
1313 align = force_align_functions_log;
1316 ASM_OUTPUT_ALIGN (asm_out_file, align);
1319 /* Handle a user-specified function alignment.
1320 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1321 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1322 if (align_functions_log > align
1323 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1325 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1326 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1327 align_functions_log, align_functions - 1);
1329 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1333 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1334 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1337 (*debug_hooks->begin_function) (decl);
1339 /* Make function name accessible from other files, if appropriate. */
1341 if (TREE_PUBLIC (decl))
1343 notice_global_symbol (decl);
1345 globalize_decl (decl);
1347 maybe_assemble_visibility (decl);
1350 if (DECL_PRESERVE_P (decl))
1351 targetm.asm_out.mark_decl_preserved (fnname);
1353 /* Do any machine/system dependent processing of the function name. */
1354 #ifdef ASM_DECLARE_FUNCTION_NAME
1355 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1357 /* Standard thing is just output label for the function. */
1358 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1359 #endif /* ASM_DECLARE_FUNCTION_NAME */
1361 insert_section_boundary_note ();
1364 /* Output assembler code associated with defining the size of the
1365 function. DECL describes the function. NAME is the function's name. */
1368 assemble_end_function (tree decl, const char *fnname)
1370 #ifdef ASM_DECLARE_FUNCTION_SIZE
1371 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1373 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1375 output_constant_pool (fnname, decl);
1376 function_section (decl); /* need to switch back */
1378 /* Output labels for end of hot/cold text sections (to be used by
1380 if (flag_reorder_blocks_and_partition)
1382 enum in_section save_text_section;
1384 save_text_section = in_section;
1385 unlikely_text_section ();
1386 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1387 if (first_function_block_is_cold)
1390 function_section (decl);
1391 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1392 if (save_text_section == in_unlikely_executed_text)
1393 unlikely_text_section ();
1397 /* Assemble code to leave SIZE bytes of zeros. */
1400 assemble_zeros (unsigned HOST_WIDE_INT size)
1402 /* Do no output if -fsyntax-only. */
1403 if (flag_syntax_only)
1406 #ifdef ASM_NO_SKIP_IN_TEXT
1407 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1408 so we must output 0s explicitly in the text section. */
1409 if ((ASM_NO_SKIP_IN_TEXT && in_text_section ())
1410 || (ASM_NO_SKIP_IN_TEXT && in_unlikely_text_section ()))
1412 unsigned HOST_WIDE_INT i;
1413 for (i = 0; i < size; i++)
1414 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1419 ASM_OUTPUT_SKIP (asm_out_file, size);
1422 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1425 assemble_align (int align)
1427 if (align > BITS_PER_UNIT)
1429 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1433 /* Assemble a string constant with the specified C string as contents. */
1436 assemble_string (const char *p, int size)
1441 /* If the string is very long, split it up. */
1445 int thissize = size - pos;
1446 if (thissize > maximum)
1449 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1457 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1458 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1459 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1461 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1462 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1463 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1465 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1466 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1470 #if defined ASM_OUTPUT_ALIGNED_BSS
1471 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1472 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1474 #if defined ASM_OUTPUT_BSS
1475 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1476 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1482 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1483 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1484 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1486 #if defined ASM_OUTPUT_ALIGNED_COMMON
1487 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1488 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1490 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1491 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1496 asm_emit_uninitialised (tree decl, const char *name,
1497 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1498 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1506 destination = asm_dest_local;
1508 /* ??? We should handle .bss via select_section mechanisms rather than
1509 via special target hooks. That would eliminate this special case. */
1510 if (TREE_PUBLIC (decl))
1512 if (!DECL_COMMON (decl))
1514 destination = asm_dest_bss;
1519 destination = asm_dest_common;
1522 if (destination != asm_dest_common)
1524 resolve_unique_section (decl, 0, flag_data_sections);
1525 /* Custom sections don't belong here. */
1526 if (DECL_SECTION_NAME (decl))
1530 if (destination == asm_dest_bss)
1531 globalize_decl (decl);
1533 if (flag_shared_data)
1535 switch (destination)
1537 #ifdef ASM_OUTPUT_SHARED_BSS
1539 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1542 #ifdef ASM_OUTPUT_SHARED_COMMON
1543 case asm_dest_common:
1544 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1547 #ifdef ASM_OUTPUT_SHARED_LOCAL
1548 case asm_dest_local:
1549 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1557 switch (destination)
1561 ASM_EMIT_BSS (decl, name, size, rounded);
1564 case asm_dest_common:
1565 ASM_EMIT_COMMON (decl, name, size, rounded);
1567 case asm_dest_local:
1568 ASM_EMIT_LOCAL (decl, name, size, rounded);
1577 /* Assemble everything that is needed for a variable or function declaration.
1578 Not used for automatic variables, and not used for function definitions.
1579 Should not be called for variables of incomplete structure type.
1581 TOP_LEVEL is nonzero if this variable has file scope.
1582 AT_END is nonzero if this is the special handling, at end of compilation,
1583 to define things that have had only tentative definitions.
1584 DONT_OUTPUT_DATA if nonzero means don't actually output the
1585 initial value (that will be done by the caller). */
1588 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1589 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1596 if (lang_hooks.decls.prepare_assemble_variable)
1597 lang_hooks.decls.prepare_assemble_variable (decl);
1599 last_assemble_variable_decl = 0;
1601 /* Normally no need to say anything here for external references,
1602 since assemble_external is called by the language-specific code
1603 when a declaration is first seen. */
1605 if (DECL_EXTERNAL (decl))
1608 /* Output no assembler code for a function declaration.
1609 Only definitions of functions output anything. */
1611 if (TREE_CODE (decl) == FUNCTION_DECL)
1614 /* Do nothing for global register variables. */
1615 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1617 TREE_ASM_WRITTEN (decl) = 1;
1621 /* If type was incomplete when the variable was declared,
1622 see if it is complete now. */
1624 if (DECL_SIZE (decl) == 0)
1625 layout_decl (decl, 0);
1627 /* Still incomplete => don't allocate it; treat the tentative defn
1628 (which is what it must have been) as an `extern' reference. */
1630 if (!dont_output_data && DECL_SIZE (decl) == 0)
1632 error ("storage size of %q+D isn%'t known", decl);
1633 TREE_ASM_WRITTEN (decl) = 1;
1637 /* The first declaration of a variable that comes through this function
1638 decides whether it is global (in C, has external linkage)
1639 or local (in C, has internal linkage). So do nothing more
1640 if this function has already run. */
1642 if (TREE_ASM_WRITTEN (decl))
1645 /* Make sure targetm.encode_section_info is invoked before we set
1647 decl_rtl = DECL_RTL (decl);
1649 TREE_ASM_WRITTEN (decl) = 1;
1651 /* Do no output if -fsyntax-only. */
1652 if (flag_syntax_only)
1657 if (! dont_output_data
1658 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1660 error ("size of variable %q+D is too large", decl);
1664 name = XSTR (XEXP (decl_rtl, 0), 0);
1665 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1666 notice_global_symbol (decl);
1668 /* Compute the alignment of this data. */
1670 align = DECL_ALIGN (decl);
1672 /* In the case for initialing an array whose length isn't specified,
1673 where we have not yet been able to do the layout,
1674 figure out the proper alignment now. */
1675 if (dont_output_data && DECL_SIZE (decl) == 0
1676 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1677 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1679 /* Some object file formats have a maximum alignment which they support.
1680 In particular, a.out format supports a maximum alignment of 4. */
1681 if (align > MAX_OFILE_ALIGNMENT)
1683 warning (0, "alignment of %q+D is greater than maximum object "
1684 "file alignment. Using %d", decl,
1685 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1686 align = MAX_OFILE_ALIGNMENT;
1689 /* On some machines, it is good to increase alignment sometimes. */
1690 if (! DECL_USER_ALIGN (decl))
1692 #ifdef DATA_ALIGNMENT
1693 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1695 #ifdef CONSTANT_ALIGNMENT
1696 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1697 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1701 /* Reset the alignment in case we have made it tighter, so we can benefit
1702 from it in get_pointer_alignment. */
1703 DECL_ALIGN (decl) = align;
1704 set_mem_align (decl_rtl, align);
1706 if (TREE_PUBLIC (decl))
1707 maybe_assemble_visibility (decl);
1709 if (DECL_PRESERVE_P (decl))
1710 targetm.asm_out.mark_decl_preserved (name);
1712 /* Handle uninitialized definitions. */
1714 /* If the decl has been given an explicit section name, then it
1715 isn't common, and shouldn't be handled as such. */
1716 if (DECL_SECTION_NAME (decl) || dont_output_data)
1718 /* We don't implement common thread-local data at present. */
1719 else if (DECL_THREAD_LOCAL_P (decl))
1721 if (DECL_COMMON (decl))
1722 sorry ("thread-local COMMON data not implemented");
1724 else if (DECL_INITIAL (decl) == 0
1725 || DECL_INITIAL (decl) == error_mark_node
1726 || (flag_zero_initialized_in_bss
1727 /* Leave constant zeroes in .rodata so they can be shared. */
1728 && !TREE_READONLY (decl)
1729 && initializer_zerop (DECL_INITIAL (decl))))
1731 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1732 unsigned HOST_WIDE_INT rounded = size;
1734 /* Don't allocate zero bytes of common,
1735 since that means "undefined external" in the linker. */
1739 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1740 so that each uninitialized object starts on such a boundary. */
1741 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1742 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1743 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1745 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1746 if ((unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1747 warning (0, "requested alignment for %q+D is greater than "
1748 "implemented alignment of %wu", decl, rounded);
1751 /* If the target cannot output uninitialized but not common global data
1752 in .bss, then we have to use .data, so fall through. */
1753 if (asm_emit_uninitialised (decl, name, size, rounded))
1757 /* Handle initialized definitions.
1758 Also handle uninitialized global definitions if -fno-common and the
1759 target doesn't support ASM_OUTPUT_BSS. */
1761 /* First make the assembler name(s) global if appropriate. */
1762 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1763 globalize_decl (decl);
1765 /* Output any data that we will need to use the address of. */
1766 if (DECL_INITIAL (decl) == error_mark_node)
1767 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1768 else if (DECL_INITIAL (decl))
1770 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1771 output_addressed_constants (DECL_INITIAL (decl));
1774 /* Switch to the appropriate section. */
1775 resolve_unique_section (decl, reloc, flag_data_sections);
1776 variable_section (decl, reloc);
1778 /* dbxout.c needs to know this. */
1779 if (in_text_section () || in_unlikely_text_section ())
1780 DECL_IN_TEXT_SECTION (decl) = 1;
1782 /* Output the alignment of this data. */
1783 if (align > BITS_PER_UNIT)
1784 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1786 /* Do any machine/system dependent processing of the object. */
1787 #ifdef ASM_DECLARE_OBJECT_NAME
1788 last_assemble_variable_decl = decl;
1789 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1791 /* Standard thing is just output label for the object. */
1792 ASM_OUTPUT_LABEL (asm_out_file, name);
1793 #endif /* ASM_DECLARE_OBJECT_NAME */
1795 if (!dont_output_data)
1797 if (DECL_INITIAL (decl)
1798 && DECL_INITIAL (decl) != error_mark_node
1799 && !initializer_zerop (DECL_INITIAL (decl)))
1800 /* Output the actual data. */
1801 output_constant (DECL_INITIAL (decl),
1802 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1805 /* Leave space for it. */
1806 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1810 /* Return 1 if type TYPE contains any pointers. */
1813 contains_pointers_p (tree type)
1815 switch (TREE_CODE (type))
1818 case REFERENCE_TYPE:
1819 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1820 so I'll play safe and return 1. */
1826 case QUAL_UNION_TYPE:
1829 /* For a type that has fields, see if the fields have pointers. */
1830 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1831 if (TREE_CODE (fields) == FIELD_DECL
1832 && contains_pointers_p (TREE_TYPE (fields)))
1838 /* An array type contains pointers if its element type does. */
1839 return contains_pointers_p (TREE_TYPE (type));
1846 /* In unit-at-a-time mode, we delay assemble_external processing until
1847 the compilation unit is finalized. This is the best we can do for
1848 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1849 it all the way to final. See PR 17982 for further discussion. */
1850 static GTY(()) tree pending_assemble_externals;
1852 #ifdef ASM_OUTPUT_EXTERNAL
1853 /* True if DECL is a function decl for which no out-of-line copy exists.
1854 It is assumed that DECL's assembler name has been set. */
1857 incorporeal_function_p (tree decl)
1859 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1863 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1864 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1867 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1868 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1874 /* Actually do the tests to determine if this is necessary, and invoke
1875 ASM_OUTPUT_EXTERNAL. */
1877 assemble_external_real (tree decl)
1879 rtx rtl = DECL_RTL (decl);
1881 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1882 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1883 && !incorporeal_function_p (decl))
1885 /* Some systems do require some output. */
1886 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1887 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1893 process_pending_assemble_externals (void)
1895 #ifdef ASM_OUTPUT_EXTERNAL
1897 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1898 assemble_external_real (TREE_VALUE (list));
1900 pending_assemble_externals = 0;
1904 /* Output something to declare an external symbol to the assembler.
1905 (Most assemblers don't need this, so we normally output nothing.)
1906 Do nothing if DECL is not external. */
1909 assemble_external (tree decl ATTRIBUTE_UNUSED)
1911 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1912 main body of this code is only rarely exercised. To provide some
1913 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1914 open. If it's not, we should not be calling this function. */
1915 gcc_assert (asm_out_file);
1917 #ifdef ASM_OUTPUT_EXTERNAL
1918 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1921 if (flag_unit_at_a_time)
1922 pending_assemble_externals = tree_cons (0, decl,
1923 pending_assemble_externals);
1925 assemble_external_real (decl);
1929 /* Similar, for calling a library function FUN. */
1932 assemble_external_libcall (rtx fun)
1934 /* Declare library function name external when first used, if nec. */
1935 if (! SYMBOL_REF_USED (fun))
1937 SYMBOL_REF_USED (fun) = 1;
1938 targetm.asm_out.external_libcall (fun);
1942 /* Assemble a label named NAME. */
1945 assemble_label (const char *name)
1947 ASM_OUTPUT_LABEL (asm_out_file, name);
1950 /* Set the symbol_referenced flag for ID. */
1952 mark_referenced (tree id)
1954 TREE_SYMBOL_REFERENCED (id) = 1;
1957 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1959 mark_decl_referenced (tree decl)
1961 if (TREE_CODE (decl) == FUNCTION_DECL)
1963 /* Extern inline functions don't become needed when referenced.
1964 If we know a method will be emitted in other TU and no new
1965 functions can be marked reachable, just use the external
1967 struct cgraph_node *node = cgraph_node (decl);
1968 if (!DECL_EXTERNAL (decl)
1969 && (!node->local.vtable_method || !cgraph_global_info_ready
1970 || !node->local.finalized))
1971 cgraph_mark_needed_node (node);
1973 else if (TREE_CODE (decl) == VAR_DECL)
1975 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
1976 cgraph_varpool_mark_needed_node (node);
1977 /* C++ frontend use mark_decl_references to force COMDAT variables
1978 to be output that might appear dead otherwise. */
1979 node->force_output = true;
1981 /* else do nothing - we can get various sorts of CST nodes here,
1982 which do not need to be marked. */
1985 /* Output to FILE (an assembly file) a reference to NAME. If NAME
1986 starts with a *, the rest of NAME is output verbatim. Otherwise
1987 NAME is transformed in a target-specific way (usually by the
1988 addition of an underscore). */
1991 assemble_name_raw (FILE *file, const char *name)
1994 fputs (&name[1], file);
1996 ASM_OUTPUT_LABELREF (file, name);
1999 /* Like assemble_name_raw, but should be used when NAME might refer to
2000 an entity that is also represented as a tree (like a function or
2001 variable). If NAME does refer to such an entity, that entity will
2002 be marked as referenced. */
2005 assemble_name (FILE *file, const char *name)
2007 const char *real_name;
2010 real_name = targetm.strip_name_encoding (name);
2012 id = maybe_get_identifier (real_name);
2014 mark_referenced (id);
2016 assemble_name_raw (file, name);
2019 /* Allocate SIZE bytes writable static space with a gensym name
2020 and return an RTX to refer to its address. */
2023 assemble_static_space (unsigned HOST_WIDE_INT size)
2026 const char *namestring;
2030 if (flag_shared_data)
2034 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2036 namestring = ggc_strdup (name);
2038 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2039 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2041 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2042 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2045 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2046 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2049 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2050 so that each uninitialized object starts on such a boundary. */
2051 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2052 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2053 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2054 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2055 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2056 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2063 /* Assemble the static constant template for function entry trampolines.
2064 This is done at most once per compilation.
2065 Returns an RTX for the address of the template. */
2067 static GTY(()) rtx initial_trampoline;
2069 #ifdef TRAMPOLINE_TEMPLATE
2071 assemble_trampoline_template (void)
2078 if (initial_trampoline)
2079 return initial_trampoline;
2081 /* By default, put trampoline templates in read-only data section. */
2083 #ifdef TRAMPOLINE_SECTION
2084 TRAMPOLINE_SECTION ();
2086 readonly_data_section ();
2089 /* Write the assembler code to define one. */
2090 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2093 ASM_OUTPUT_ALIGN (asm_out_file, align);
2096 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2097 TRAMPOLINE_TEMPLATE (asm_out_file);
2099 /* Record the rtl to refer to it. */
2100 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2101 name = ggc_strdup (label);
2102 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2103 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2105 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2106 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2108 return initial_trampoline;
2112 /* A and B are either alignments or offsets. Return the minimum alignment
2113 that may be assumed after adding the two together. */
2115 static inline unsigned
2116 min_align (unsigned int a, unsigned int b)
2118 return (a | b) & -(a | b);
2121 /* Return the assembler directive for creating a given kind of integer
2122 object. SIZE is the number of bytes in the object and ALIGNED_P
2123 indicates whether it is known to be aligned. Return NULL if the
2124 assembly dialect has no such directive.
2126 The returned string should be printed at the start of a new line and
2127 be followed immediately by the object's initial value. */
2130 integer_asm_op (int size, int aligned_p)
2132 struct asm_int_op *ops;
2135 ops = &targetm.asm_out.aligned_op;
2137 ops = &targetm.asm_out.unaligned_op;
2142 return targetm.asm_out.byte_op;
2156 /* Use directive OP to assemble an integer object X. Print OP at the
2157 start of the line, followed immediately by the value of X. */
2160 assemble_integer_with_op (const char *op, rtx x)
2162 fputs (op, asm_out_file);
2163 output_addr_const (asm_out_file, x);
2164 fputc ('\n', asm_out_file);
2167 /* The default implementation of the asm_out.integer target hook. */
2170 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2171 unsigned int size ATTRIBUTE_UNUSED,
2172 int aligned_p ATTRIBUTE_UNUSED)
2174 const char *op = integer_asm_op (size, aligned_p);
2175 /* Avoid GAS bugs for large values. Specifically negative values whose
2176 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2177 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2179 return op && (assemble_integer_with_op (op, x), true);
2182 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2183 the alignment of the integer in bits. Return 1 if we were able to output
2184 the constant, otherwise 0. We must be able to output the constant,
2185 if FORCE is nonzero. */
2188 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2192 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2194 /* See if the target hook can handle this kind of object. */
2195 if (targetm.asm_out.integer (x, size, aligned_p))
2198 /* If the object is a multi-byte one, try splitting it up. Split
2199 it into words it if is multi-word, otherwise split it into bytes. */
2202 enum machine_mode omode, imode;
2203 unsigned int subalign;
2204 unsigned int subsize, i;
2206 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2207 subalign = MIN (align, subsize * BITS_PER_UNIT);
2208 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2209 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2211 for (i = 0; i < size; i += subsize)
2213 rtx partial = simplify_subreg (omode, x, imode, i);
2214 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2220 /* If we've printed some of it, but not all of it, there's no going
2225 gcc_assert (!force);
2231 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2235 int bitsize, nelts, nunits, units_per;
2237 /* This is hairy. We have a quantity of known size. real_to_target
2238 will put it into an array of *host* longs, 32 bits per element
2239 (even if long is more than 32 bits). We need to determine the
2240 number of array elements that are occupied (nelts) and the number
2241 of *target* min-addressable units that will be occupied in the
2242 object file (nunits). We cannot assume that 32 divides the
2243 mode's bitsize (size * BITS_PER_UNIT) evenly.
2245 size * BITS_PER_UNIT is used here to make sure that padding bits
2246 (which might appear at either end of the value; real_to_target
2247 will include the padding bits in its output array) are included. */
2249 nunits = GET_MODE_SIZE (mode);
2250 bitsize = nunits * BITS_PER_UNIT;
2251 nelts = CEIL (bitsize, 32);
2252 units_per = 32 / BITS_PER_UNIT;
2254 real_to_target (data, &d, mode);
2256 /* Put out the first word with the specified alignment. */
2257 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2258 nunits -= units_per;
2260 /* Subsequent words need only 32-bit alignment. */
2261 align = min_align (align, 32);
2263 for (i = 1; i < nelts; i++)
2265 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2266 nunits -= units_per;
2270 /* Given an expression EXP with a constant value,
2271 reduce it to the sum of an assembler symbol and an integer.
2272 Store them both in the structure *VALUE.
2273 EXP must be reducible. */
2275 struct addr_const GTY(())
2278 HOST_WIDE_INT offset;
2282 decode_addr_const (tree exp, struct addr_const *value)
2284 tree target = TREE_OPERAND (exp, 0);
2290 if (TREE_CODE (target) == COMPONENT_REF
2291 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2294 offset += int_byte_position (TREE_OPERAND (target, 1));
2295 target = TREE_OPERAND (target, 0);
2297 else if (TREE_CODE (target) == ARRAY_REF
2298 || TREE_CODE (target) == ARRAY_RANGE_REF)
2300 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2301 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2302 target = TREE_OPERAND (target, 0);
2308 switch (TREE_CODE (target))
2312 x = DECL_RTL (target);
2316 x = gen_rtx_MEM (FUNCTION_MODE,
2317 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2325 x = output_constant_def (target, 1);
2332 gcc_assert (MEM_P (x));
2336 value->offset = offset;
2339 /* Uniquize all constants that appear in memory.
2340 Each constant in memory thus far output is recorded
2341 in `const_desc_table'. */
2343 struct constant_descriptor_tree GTY(())
2345 /* A MEM for the constant. */
2348 /* The value of the constant. */
2351 /* Hash of value. Computing the hash from value each time
2352 hashfn is called can't work properly, as that means recursive
2353 use of the hash table during hash table expansion. */
2357 static GTY((param_is (struct constant_descriptor_tree)))
2358 htab_t const_desc_htab;
2360 static struct constant_descriptor_tree * build_constant_desc (tree);
2361 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2363 /* Compute a hash code for a constant expression. */
2366 const_desc_hash (const void *ptr)
2368 return ((struct constant_descriptor_tree *)ptr)->hash;
2372 const_hash_1 (const tree exp)
2377 enum tree_code code = TREE_CODE (exp);
2379 /* Either set P and LEN to the address and len of something to hash and
2380 exit the switch or return a value. */
2385 p = (char *) &TREE_INT_CST (exp);
2386 len = sizeof TREE_INT_CST (exp);
2390 return real_hash (TREE_REAL_CST_PTR (exp));
2393 p = TREE_STRING_POINTER (exp);
2394 len = TREE_STRING_LENGTH (exp);
2398 return (const_hash_1 (TREE_REALPART (exp)) * 5
2399 + const_hash_1 (TREE_IMAGPART (exp)));
2403 unsigned HOST_WIDE_INT idx;
2406 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2408 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2410 hi = hi * 603 + const_hash_1 (value);
2418 struct addr_const value;
2420 decode_addr_const (exp, &value);
2421 switch (GET_CODE (value.base))
2424 /* Don't hash the address of the SYMBOL_REF;
2425 only use the offset and the symbol name. */
2427 p = XSTR (value.base, 0);
2428 for (i = 0; p[i] != 0; i++)
2429 hi = ((hi * 613) + (unsigned) (p[i]));
2433 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2444 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2445 + const_hash_1 (TREE_OPERAND (exp, 1)));
2449 case NON_LVALUE_EXPR:
2450 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2453 /* A language specific constant. Just hash the code. */
2457 /* Compute hashing function. */
2459 for (i = 0; i < len; i++)
2460 hi = ((hi * 613) + (unsigned) (p[i]));
2465 /* Wrapper of compare_constant, for the htab interface. */
2467 const_desc_eq (const void *p1, const void *p2)
2469 const struct constant_descriptor_tree *c1 = p1;
2470 const struct constant_descriptor_tree *c2 = p2;
2471 if (c1->hash != c2->hash)
2473 return compare_constant (c1->value, c2->value);
2476 /* Compare t1 and t2, and return 1 only if they are known to result in
2477 the same bit pattern on output. */
2480 compare_constant (const tree t1, const tree t2)
2482 enum tree_code typecode;
2484 if (t1 == NULL_TREE)
2485 return t2 == NULL_TREE;
2486 if (t2 == NULL_TREE)
2489 if (TREE_CODE (t1) != TREE_CODE (t2))
2492 switch (TREE_CODE (t1))
2495 /* Integer constants are the same only if the same width of type. */
2496 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2498 return tree_int_cst_equal (t1, t2);
2501 /* Real constants are the same only if the same width of type. */
2502 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2505 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2508 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2511 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2512 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2513 TREE_STRING_LENGTH (t1)));
2516 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2517 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2521 VEC(constructor_elt, gc) *v1, *v2;
2522 unsigned HOST_WIDE_INT idx;
2524 typecode = TREE_CODE (TREE_TYPE (t1));
2525 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2528 if (typecode == ARRAY_TYPE)
2530 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2531 /* For arrays, check that the sizes all match. */
2532 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2534 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2539 /* For record and union constructors, require exact type
2541 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2545 v1 = CONSTRUCTOR_ELTS (t1);
2546 v2 = CONSTRUCTOR_ELTS (t2);
2547 if (VEC_length (constructor_elt, v1)
2548 != VEC_length (constructor_elt, v2))
2551 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2553 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2554 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2556 /* Check that each value is the same... */
2557 if (!compare_constant (c1->value, c2->value))
2559 /* ... and that they apply to the same fields! */
2560 if (typecode == ARRAY_TYPE)
2562 if (!compare_constant (c1->index, c2->index))
2567 if (c1->index != c2->index)
2578 struct addr_const value1, value2;
2580 decode_addr_const (t1, &value1);
2581 decode_addr_const (t2, &value2);
2582 return (value1.offset == value2.offset
2583 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2589 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2590 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2594 case NON_LVALUE_EXPR:
2595 case VIEW_CONVERT_EXPR:
2596 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2601 nt1 = lang_hooks.expand_constant (t1);
2602 nt2 = lang_hooks.expand_constant (t2);
2603 if (nt1 != t1 || nt2 != t2)
2604 return compare_constant (nt1, nt2);
2613 /* Make a copy of the whole tree structure for a constant. This
2614 handles the same types of nodes that compare_constant handles. */
2617 copy_constant (tree exp)
2619 switch (TREE_CODE (exp))
2622 /* For ADDR_EXPR, we do not want to copy the decl whose address
2623 is requested. We do want to copy constants though. */
2624 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2625 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2626 copy_constant (TREE_OPERAND (exp, 0)));
2628 return copy_node (exp);
2633 return copy_node (exp);
2636 return build_complex (TREE_TYPE (exp),
2637 copy_constant (TREE_REALPART (exp)),
2638 copy_constant (TREE_IMAGPART (exp)));
2642 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2643 copy_constant (TREE_OPERAND (exp, 0)),
2644 copy_constant (TREE_OPERAND (exp, 1)));
2648 case NON_LVALUE_EXPR:
2649 case VIEW_CONVERT_EXPR:
2650 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2651 copy_constant (TREE_OPERAND (exp, 0)));
2655 tree copy = copy_node (exp);
2656 VEC(constructor_elt, gc) *v;
2657 unsigned HOST_WIDE_INT idx;
2658 tree purpose, value;
2660 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
2661 CONSTRUCTOR_ELTS (exp)));
2662 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
2664 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
2665 ce->index = purpose;
2666 ce->value = copy_constant (value);
2668 CONSTRUCTOR_ELTS (copy) = v;
2674 tree t = lang_hooks.expand_constant (exp);
2676 gcc_assert (t == exp);
2677 return copy_constant (t);
2682 /* Subroutine of output_constant_def:
2683 No constant equal to EXP is known to have been output.
2684 Make a constant descriptor to enter EXP in the hash table.
2685 Assign the label number and construct RTL to refer to the
2686 constant's location in memory.
2687 Caller is responsible for updating the hash table. */
2689 static struct constant_descriptor_tree *
2690 build_constant_desc (tree exp)
2696 struct constant_descriptor_tree *desc;
2698 desc = ggc_alloc (sizeof (*desc));
2699 desc->value = copy_constant (exp);
2701 /* Propagate marked-ness to copied constant. */
2702 if (flag_mudflap && mf_marked_p (exp))
2703 mf_mark (desc->value);
2705 /* Create a string containing the label name, in LABEL. */
2706 labelno = const_labelno++;
2707 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2709 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2710 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2711 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2712 SYMBOL_REF_DECL (symbol) = desc->value;
2713 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2715 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2716 set_mem_attributes (rtl, exp, 1);
2717 set_mem_alias_set (rtl, 0);
2718 set_mem_alias_set (rtl, const_alias_set);
2720 /* Set flags or add text to the name to record information, such as
2721 that it is a local symbol. If the name is changed, the macro
2722 ASM_OUTPUT_LABELREF will have to know how to strip this
2723 information. This call might invalidate our local variable
2724 SYMBOL; we can't use it afterward. */
2726 targetm.encode_section_info (exp, rtl, true);
2733 /* Return an rtx representing a reference to constant data in memory
2734 for the constant expression EXP.
2736 If assembler code for such a constant has already been output,
2737 return an rtx to refer to it.
2738 Otherwise, output such a constant in memory
2739 and generate an rtx for it.
2741 If DEFER is nonzero, this constant can be deferred and output only
2742 if referenced in the function after all optimizations.
2744 `const_desc_table' records which constants already have label strings. */
2747 output_constant_def (tree exp, int defer)
2749 struct constant_descriptor_tree *desc;
2750 struct constant_descriptor_tree key;
2753 /* Look up EXP in the table of constant descriptors. If we didn't find
2754 it, create a new one. */
2756 key.hash = const_hash_1 (exp);
2757 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
2762 desc = build_constant_desc (exp);
2763 desc->hash = key.hash;
2767 maybe_output_constant_def_contents (desc, defer);
2771 /* Subroutine of output_constant_def: Decide whether or not we need to
2772 output the constant DESC now, and if so, do it. */
2774 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2777 rtx symbol = XEXP (desc->rtl, 0);
2778 tree exp = desc->value;
2780 if (flag_syntax_only)
2783 if (TREE_ASM_WRITTEN (exp))
2784 /* Already output; don't do it again. */
2787 /* We can always defer constants as long as the context allows
2791 /* Increment n_deferred_constants if it exists. It needs to be at
2792 least as large as the number of constants actually referred to
2793 by the function. If it's too small we'll stop looking too early
2794 and fail to emit constants; if it's too large we'll only look
2795 through the entire function when we could have stopped earlier. */
2797 n_deferred_constants++;
2801 output_constant_def_contents (symbol);
2804 /* We must output the constant data referred to by SYMBOL; do so. */
2807 output_constant_def_contents (rtx symbol)
2809 tree exp = SYMBOL_REF_DECL (symbol);
2810 const char *label = XSTR (symbol, 0);
2813 /* Make sure any other constants whose addresses appear in EXP
2814 are assigned label numbers. */
2815 int reloc = compute_reloc_for_constant (exp);
2817 /* Align the location counter as required by EXP's data type. */
2818 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
2819 #ifdef CONSTANT_ALIGNMENT
2820 align = CONSTANT_ALIGNMENT (exp, align);
2823 output_addressed_constants (exp);
2825 /* We are no longer deferring this constant. */
2826 TREE_ASM_WRITTEN (exp) = 1;
2828 if (IN_NAMED_SECTION (exp))
2829 named_section (exp, NULL, reloc);
2831 targetm.asm_out.select_section (exp, reloc, align);
2833 if (align > BITS_PER_UNIT)
2835 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2838 size = int_size_in_bytes (TREE_TYPE (exp));
2839 if (TREE_CODE (exp) == STRING_CST)
2840 size = MAX (TREE_STRING_LENGTH (exp), size);
2842 /* Do any machine/system dependent processing of the constant. */
2843 #ifdef ASM_DECLARE_CONSTANT_NAME
2844 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2846 /* Standard thing is just output label for the constant. */
2847 ASM_OUTPUT_LABEL (asm_out_file, label);
2848 #endif /* ASM_DECLARE_CONSTANT_NAME */
2850 /* Output the value of EXP. */
2851 output_constant (exp, size, align);
2853 mudflap_enqueue_constant (exp);
2856 /* Look up EXP in the table of constant descriptors. Return the rtl
2857 if it has been emitted, else null. */
2860 lookup_constant_def (tree exp)
2862 struct constant_descriptor_tree *desc;
2863 struct constant_descriptor_tree key;
2866 key.hash = const_hash_1 (exp);
2867 desc = htab_find_with_hash (const_desc_htab, &key, key.hash);
2869 return (desc ? desc->rtl : NULL_RTX);
2872 /* Used in the hash tables to avoid outputting the same constant
2873 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2874 are output once per function, not once per file. */
2875 /* ??? Only a few targets need per-function constant pools. Most
2876 can use one per-file pool. Should add a targetm bit to tell the
2879 struct rtx_constant_pool GTY(())
2881 /* Pointers to first and last constant in pool, as ordered by offset. */
2882 struct constant_descriptor_rtx *first;
2883 struct constant_descriptor_rtx *last;
2885 /* Hash facility for making memory-constants from constant rtl-expressions.
2886 It is used on RISC machines where immediate integer arguments and
2887 constant addresses are restricted so that such constants must be stored
2889 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
2890 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_sym_htab;
2892 /* Current offset in constant pool (does not include any
2893 machine-specific header). */
2894 HOST_WIDE_INT offset;
2897 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
2899 struct constant_descriptor_rtx *next;
2903 HOST_WIDE_INT offset;
2905 enum machine_mode mode;
2911 /* Hash and compare functions for const_rtx_htab. */
2914 const_desc_rtx_hash (const void *ptr)
2916 const struct constant_descriptor_rtx *desc = ptr;
2921 const_desc_rtx_eq (const void *a, const void *b)
2923 const struct constant_descriptor_rtx *x = a;
2924 const struct constant_descriptor_rtx *y = b;
2926 if (x->mode != y->mode)
2928 return rtx_equal_p (x->constant, y->constant);
2931 /* Hash and compare functions for const_rtx_sym_htab. */
2934 const_desc_rtx_sym_hash (const void *ptr)
2936 const struct constant_descriptor_rtx *desc = ptr;
2937 return htab_hash_string (XSTR (desc->sym, 0));
2941 const_desc_rtx_sym_eq (const void *a, const void *b)
2943 const struct constant_descriptor_rtx *x = a;
2944 const struct constant_descriptor_rtx *y = b;
2945 return XSTR (x->sym, 0) == XSTR (y->sym, 0);
2948 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
2951 const_rtx_hash_1 (rtx *xp, void *data)
2953 unsigned HOST_WIDE_INT hwi;
2954 enum machine_mode mode;
2960 code = GET_CODE (x);
2961 mode = GET_MODE (x);
2962 h = (hashval_t) code * 1048573 + mode;
2970 const int shift = sizeof (hashval_t) * CHAR_BIT;
2971 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
2974 h ^= (hashval_t) hwi;
2975 for (i = 1; i < n; ++i)
2978 h ^= (hashval_t) hwi;
2984 if (mode == VOIDmode)
2986 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
2990 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
2996 for (i = XVECLEN (x, 0); i-- > 0; )
2997 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3002 h ^= htab_hash_string (XSTR (x, 0));
3006 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3010 case UNSPEC_VOLATILE:
3011 h = h * 251 + XINT (x, 1);
3019 *hp = *hp * 509 + h;
3023 /* Compute a hash value for X, which should be a constant. */
3026 const_rtx_hash (rtx x)
3029 for_each_rtx (&x, const_rtx_hash_1, &h);
3034 /* Initialize constant pool hashing for a new function. */
3037 init_varasm_status (struct function *f)
3039 struct varasm_status *p;
3040 struct rtx_constant_pool *pool;
3042 p = ggc_alloc (sizeof (struct varasm_status));
3045 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3047 p->deferred_constants = 0;
3049 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3050 const_desc_rtx_eq, NULL);
3051 pool->const_rtx_sym_htab = htab_create_ggc (31, const_desc_rtx_sym_hash,
3052 const_desc_rtx_sym_eq, NULL);
3053 pool->first = pool->last = NULL;
3057 /* Given a MINUS expression, simplify it if both sides
3058 include the same symbol. */
3061 simplify_subtraction (rtx x)
3063 rtx r = simplify_rtx (x);
3067 /* Given a constant rtx X, make (or find) a memory constant for its value
3068 and return a MEM rtx to refer to it in memory. */
3071 force_const_mem (enum machine_mode mode, rtx x)
3073 struct constant_descriptor_rtx *desc, tmp;
3074 struct rtx_constant_pool *pool = cfun->varasm->pool;
3081 /* If we're not allowed to drop X into the constant pool, don't. */
3082 if (targetm.cannot_force_const_mem (x))
3085 /* Lookup the value in the hashtable. */
3088 hash = const_rtx_hash (x);
3089 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3092 /* If the constant was already present, return its memory. */
3094 return copy_rtx (desc->mem);
3096 /* Otherwise, create a new descriptor. */
3097 desc = ggc_alloc (sizeof (*desc));
3100 /* Align the location counter as required by EXP's data type. */
3101 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3102 #ifdef CONSTANT_ALIGNMENT
3104 tree type = lang_hooks.types.type_for_mode (mode, 0);
3105 if (type != NULL_TREE)
3106 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3110 pool->offset += (align / BITS_PER_UNIT) - 1;
3111 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3114 desc->constant = tmp.constant;
3115 desc->offset = pool->offset;
3118 desc->align = align;
3119 desc->labelno = const_labelno;
3122 pool->offset += GET_MODE_SIZE (mode);
3124 pool->last->next = desc;
3126 pool->first = pool->last = desc;
3129 /* Create a string containing the label name, in LABEL. */
3130 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3133 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3134 the constants pool. */
3135 desc->sym = symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3136 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
3137 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3138 current_function_uses_const_pool = 1;
3140 /* Insert the descriptor into the symbol cross-reference table too. */
3141 slot = htab_find_slot (pool->const_rtx_sym_htab, desc, INSERT);
3142 gcc_assert (!*slot);
3145 /* Construct the MEM. */
3146 desc->mem = def = gen_const_mem (mode, symbol);
3147 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3148 set_mem_align (def, align);
3150 /* If we're dropping a label to the constant pool, make sure we
3152 if (GET_CODE (x) == LABEL_REF)
3153 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3155 return copy_rtx (def);
3158 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3159 the corresponding constant_descriptor_rtx structure. */
3161 static struct constant_descriptor_rtx *
3162 find_pool_constant (struct rtx_constant_pool *pool, rtx sym)
3164 struct constant_descriptor_rtx tmp;
3166 return htab_find (pool->const_rtx_sym_htab, &tmp);
3169 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3172 get_pool_constant (rtx addr)
3174 return find_pool_constant (cfun->varasm->pool, addr)->constant;
3177 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3178 and whether it has been output or not. */
3181 get_pool_constant_mark (rtx addr, bool *pmarked)
3183 struct constant_descriptor_rtx *desc;
3185 desc = find_pool_constant (cfun->varasm->pool, addr);
3186 *pmarked = (desc->mark != 0);
3187 return desc->constant;
3190 /* Likewise, but for the constant pool of a specific function. */
3193 get_pool_constant_for_function (struct function *f, rtx addr)
3195 return find_pool_constant (f->varasm->pool, addr)->constant;
3198 /* Similar, return the mode. */
3201 get_pool_mode (rtx addr)
3203 return find_pool_constant (cfun->varasm->pool, addr)->mode;
3206 /* Return the size of the constant pool. */
3209 get_pool_size (void)
3211 return cfun->varasm->pool->offset;
3214 /* Worker function for output_constant_pool_1. Emit assembly for X
3215 in MODE with known alignment ALIGN. */
3218 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3220 switch (GET_MODE_CLASS (mode))
3226 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3227 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3228 assemble_real (r, mode, align);
3233 case MODE_PARTIAL_INT:
3234 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3237 case MODE_VECTOR_FLOAT:
3238 case MODE_VECTOR_INT:
3241 enum machine_mode submode = GET_MODE_INNER (mode);
3242 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3244 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3245 units = CONST_VECTOR_NUNITS (x);
3247 for (i = 0; i < units; i++)
3249 rtx elt = CONST_VECTOR_ELT (x, i);
3250 output_constant_pool_2 (submode, elt, i ? subalign : align);
3260 /* Worker function for output_constant_pool. Emit POOL. */
3263 output_constant_pool_1 (struct constant_descriptor_rtx *desc)
3271 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3272 whose CODE_LABEL has been deleted. This can occur if a jump table
3273 is eliminated by optimization. If so, write a constant of zero
3274 instead. Note that this can also happen by turning the
3275 CODE_LABEL into a NOTE. */
3276 /* ??? This seems completely and utterly wrong. Certainly it's
3277 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3278 functioning even with INSN_DELETED_P and friends. */
3281 switch (GET_CODE (x))
3284 if (GET_CODE (XEXP (x, 0)) != PLUS
3285 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3287 tmp = XEXP (XEXP (x, 0), 0);
3292 gcc_assert (!INSN_DELETED_P (tmp));
3293 gcc_assert (!NOTE_P (tmp)
3294 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3301 /* First switch to correct section. */
3302 targetm.asm_out.select_rtx_section (desc->mode, x, desc->align);
3304 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3305 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3306 desc->align, desc->labelno, done);
3309 assemble_align (desc->align);
3311 /* Output the label. */
3312 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3314 /* Output the data. */
3315 output_constant_pool_2 (desc->mode, x, desc->align);
3317 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3318 sections have proper size. */
3319 if (desc->align > GET_MODE_BITSIZE (desc->mode)
3320 && in_section == in_named
3321 && get_named_section_flags (in_named_name) & SECTION_MERGE)
3322 assemble_align (desc->align);
3324 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3330 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3331 to as used. Emit referenced deferred strings. This function can
3332 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3335 mark_constant (rtx *current_rtx, void *data)
3337 struct rtx_constant_pool *pool = data;
3338 rtx x = *current_rtx;
3340 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3343 if (CONSTANT_POOL_ADDRESS_P (x))
3345 struct constant_descriptor_rtx *desc = find_pool_constant (pool, x);
3346 if (desc->mark == 0)
3349 for_each_rtx (&desc->constant, mark_constant, pool);
3352 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3354 tree exp = SYMBOL_REF_DECL (x);
3355 if (!TREE_ASM_WRITTEN (exp))
3357 n_deferred_constants--;
3358 output_constant_def_contents (x);
3365 /* Look through appropriate parts of INSN, marking all entries in the
3366 constant pool which are actually being used. Entries that are only
3367 referenced by other constants are also marked as used. Emit
3368 deferred strings that are used. */
3371 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3376 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3377 insns, not any notes that may be attached. We don't want to mark
3378 a constant just because it happens to appear in a REG_EQUIV note. */
3379 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3381 rtx seq = PATTERN (insn);
3382 int i, n = XVECLEN (seq, 0);
3383 for (i = 0; i < n; ++i)
3385 rtx subinsn = XVECEXP (seq, 0, i);
3386 if (INSN_P (subinsn))
3387 for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3391 for_each_rtx (&PATTERN (insn), mark_constant, pool);
3394 /* Look through the instructions for this function, and mark all the
3395 entries in POOL which are actually being used. Emit deferred constants
3396 which have indeed been used. */
3399 mark_constant_pool (struct rtx_constant_pool *pool)
3403 if (pool->first == 0 && n_deferred_constants == 0)
3406 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3407 mark_constants (pool, insn);
3409 for (link = current_function_epilogue_delay_list;
3411 link = XEXP (link, 1))
3412 mark_constants (pool, XEXP (link, 0));
3415 /* Write all the constants in the constant pool. */
3418 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3419 tree fndecl ATTRIBUTE_UNUSED)
3421 struct rtx_constant_pool *pool = cfun->varasm->pool;
3422 struct constant_descriptor_rtx *desc;
3424 /* It is possible for gcc to call force_const_mem and then to later
3425 discard the instructions which refer to the constant. In such a
3426 case we do not need to output the constant. */
3427 mark_constant_pool (pool);
3429 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3430 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3433 for (desc = pool->first; desc ; desc = desc->next)
3434 output_constant_pool_1 (desc);
3436 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3437 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3441 /* Determine what kind of relocations EXP may need. */
3444 compute_reloc_for_constant (tree exp)
3446 int reloc = 0, reloc2;
3449 /* Give the front-end a chance to convert VALUE to something that
3450 looks more like a constant to the back-end. */
3451 exp = lang_hooks.expand_constant (exp);
3453 switch (TREE_CODE (exp))
3457 /* Go inside any operations that get_inner_reference can handle and see
3458 if what's inside is a constant: no need to do anything here for
3459 addresses of variables or functions. */
3460 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3461 tem = TREE_OPERAND (tem, 0))
3464 if (TREE_PUBLIC (tem))
3471 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3472 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3476 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3477 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3478 /* The difference of two local labels is computable at link time. */
3479 if (reloc == 1 && reloc2 == 1)
3487 case NON_LVALUE_EXPR:
3488 case VIEW_CONVERT_EXPR:
3489 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3494 unsigned HOST_WIDE_INT idx;
3495 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3497 reloc |= compute_reloc_for_constant (tem);
3507 /* Find all the constants whose addresses are referenced inside of EXP,
3508 and make sure assembler code with a label has been output for each one.
3509 Indicate whether an ADDR_EXPR has been encountered. */
3512 output_addressed_constants (tree exp)
3516 /* Give the front-end a chance to convert VALUE to something that
3517 looks more like a constant to the back-end. */
3518 exp = lang_hooks.expand_constant (exp);
3520 switch (TREE_CODE (exp))
3524 /* Go inside any operations that get_inner_reference can handle and see
3525 if what's inside is a constant: no need to do anything here for
3526 addresses of variables or functions. */
3527 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3528 tem = TREE_OPERAND (tem, 0))
3531 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3532 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3533 tem = DECL_INITIAL (tem);
3535 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3536 output_constant_def (tem, 0);
3541 output_addressed_constants (TREE_OPERAND (exp, 1));
3546 case NON_LVALUE_EXPR:
3547 case VIEW_CONVERT_EXPR:
3548 output_addressed_constants (TREE_OPERAND (exp, 0));
3553 unsigned HOST_WIDE_INT idx;
3554 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3556 output_addressed_constants (tem);
3565 /* Return nonzero if VALUE is a valid constant-valued expression
3566 for use in initializing a static variable; one that can be an
3567 element of a "constant" initializer.
3569 Return null_pointer_node if the value is absolute;
3570 if it is relocatable, return the variable that determines the relocation.
3571 We assume that VALUE has been folded as much as possible;
3572 therefore, we do not need to check for such things as
3573 arithmetic-combinations of integers. */
3576 initializer_constant_valid_p (tree value, tree endtype)
3578 /* Give the front-end a chance to convert VALUE to something that
3579 looks more like a constant to the back-end. */
3580 value = lang_hooks.expand_constant (value);
3582 switch (TREE_CODE (value))
3585 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3586 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3587 && TREE_CONSTANT (value)
3588 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value)))
3590 unsigned HOST_WIDE_INT idx;
3592 bool absolute = true;
3594 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
3597 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
3600 if (reloc != null_pointer_node)
3603 /* For a non-absolute relocation, there is no single
3604 variable that can be "the variable that determines the
3606 return absolute ? null_pointer_node : error_mark_node;
3609 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3616 return null_pointer_node;
3620 value = staticp (TREE_OPERAND (value, 0));
3621 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3622 be a constant, this is old-skool offsetof-like nonsense. */
3624 && TREE_CODE (value) == INDIRECT_REF
3625 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3626 return null_pointer_node;
3627 /* Taking the address of a nested function involves a trampoline. */
3629 && TREE_CODE (value) == FUNCTION_DECL
3630 && ((decl_function_context (value) && !DECL_NO_STATIC_CHAIN (value))
3631 || DECL_NON_ADDR_CONST_P (value)))
3635 case VIEW_CONVERT_EXPR:
3636 case NON_LVALUE_EXPR:
3637 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3646 src = TREE_OPERAND (value, 0);
3647 src_type = TREE_TYPE (src);
3648 dest_type = TREE_TYPE (value);
3650 /* Allow conversions between pointer types, floating-point
3651 types, and offset types. */
3652 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3653 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3654 || (TREE_CODE (dest_type) == OFFSET_TYPE
3655 && TREE_CODE (src_type) == OFFSET_TYPE))
3656 return initializer_constant_valid_p (src, endtype);
3658 /* Allow length-preserving conversions between integer types. */
3659 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3660 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3661 return initializer_constant_valid_p (src, endtype);
3663 /* Allow conversions between other integer types only if
3665 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3667 tree inner = initializer_constant_valid_p (src, endtype);
3668 if (inner == null_pointer_node)
3669 return null_pointer_node;
3673 /* Allow (int) &foo provided int is as wide as a pointer. */
3674 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3675 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3676 return initializer_constant_valid_p (src, endtype);
3678 /* Likewise conversions from int to pointers, but also allow
3679 conversions from 0. */
3680 if ((POINTER_TYPE_P (dest_type)
3681 || TREE_CODE (dest_type) == OFFSET_TYPE)
3682 && INTEGRAL_TYPE_P (src_type))
3684 if (integer_zerop (src))
3685 return null_pointer_node;
3686 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3687 return initializer_constant_valid_p (src, endtype);
3690 /* Allow conversions to struct or union types if the value
3692 if (TREE_CODE (dest_type) == RECORD_TYPE
3693 || TREE_CODE (dest_type) == UNION_TYPE)
3694 return initializer_constant_valid_p (src, endtype);
3699 if (! INTEGRAL_TYPE_P (endtype)
3700 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3702 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3704 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3706 /* If either term is absolute, use the other terms relocation. */
3707 if (valid0 == null_pointer_node)
3709 if (valid1 == null_pointer_node)
3715 if (! INTEGRAL_TYPE_P (endtype)
3716 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3718 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3720 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3722 /* Win if second argument is absolute. */
3723 if (valid1 == null_pointer_node)
3725 /* Win if both arguments have the same relocation.
3726 Then the value is absolute. */
3727 if (valid0 == valid1 && valid0 != 0)
3728 return null_pointer_node;
3730 /* Since GCC guarantees that string constants are unique in the
3731 generated code, a subtraction between two copies of the same
3732 constant string is absolute. */
3733 if (valid0 && TREE_CODE (valid0) == STRING_CST
3734 && valid1 && TREE_CODE (valid1) == STRING_CST
3735 && operand_equal_p (valid0, valid1, 1))
3736 return null_pointer_node;
3739 /* Support narrowing differences. */
3740 if (INTEGRAL_TYPE_P (endtype))
3744 op0 = TREE_OPERAND (value, 0);
3745 op1 = TREE_OPERAND (value, 1);
3747 /* Like STRIP_NOPS except allow the operand mode to widen.
3748 This works around a feature of fold that simplifies
3749 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3750 that the narrower operation is cheaper. */
3752 while (TREE_CODE (op0) == NOP_EXPR
3753 || TREE_CODE (op0) == CONVERT_EXPR
3754 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3756 tree inner = TREE_OPERAND (op0, 0);
3757 if (inner == error_mark_node
3758 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3759 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3760 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3765 while (TREE_CODE (op1) == NOP_EXPR
3766 || TREE_CODE (op1) == CONVERT_EXPR
3767 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3769 tree inner = TREE_OPERAND (op1, 0);
3770 if (inner == error_mark_node
3771 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3772 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3773 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3778 op0 = initializer_constant_valid_p (op0, endtype);
3779 op1 = initializer_constant_valid_p (op1, endtype);
3781 /* Both initializers must be known. */
3785 return null_pointer_node;
3787 /* Support differences between labels. */
3788 if (TREE_CODE (op0) == LABEL_DECL
3789 && TREE_CODE (op1) == LABEL_DECL)
3790 return null_pointer_node;
3792 if (TREE_CODE (op0) == STRING_CST
3793 && TREE_CODE (op1) == STRING_CST
3794 && operand_equal_p (op0, op1, 1))
3795 return null_pointer_node;
3807 /* Output assembler code for constant EXP to FILE, with no label.
3808 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3809 Assumes output_addressed_constants has been done on EXP already.
3811 Generate exactly SIZE bytes of assembler data, padding at the end
3812 with zeros if necessary. SIZE must always be specified.
3814 SIZE is important for structure constructors,
3815 since trailing members may have been omitted from the constructor.
3816 It is also important for initialization of arrays from string constants
3817 since the full length of the string constant might not be wanted.
3818 It is also needed for initialization of unions, where the initializer's
3819 type is just one member, and that may not be as long as the union.
3821 There a case in which we would fail to output exactly SIZE bytes:
3822 for a structure constructor that wants to produce more than SIZE bytes.
3823 But such constructors will never be generated for any possible input.
3825 ALIGN is the alignment of the data in bits. */
3828 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3830 enum tree_code code;
3831 unsigned HOST_WIDE_INT thissize;
3833 /* Some front-ends use constants other than the standard language-independent
3834 varieties, but which may still be output directly. Give the front-end a
3835 chance to convert EXP to a language-independent representation. */
3836 exp = lang_hooks.expand_constant (exp);
3838 if (size == 0 || flag_syntax_only)
3841 /* Eliminate any conversions since we'll be outputting the underlying
3843 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3844 || TREE_CODE (exp) == NON_LVALUE_EXPR
3845 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3846 exp = TREE_OPERAND (exp, 0);
3848 code = TREE_CODE (TREE_TYPE (exp));
3849 thissize = int_size_in_bytes (TREE_TYPE (exp));
3851 /* Allow a constructor with no elements for any data type.
3852 This means to fill the space with zeros. */
3853 if (TREE_CODE (exp) == CONSTRUCTOR
3854 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
3856 assemble_zeros (size);
3860 if (TREE_CODE (exp) == FDESC_EXPR)
3862 #ifdef ASM_OUTPUT_FDESC
3863 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
3864 tree decl = TREE_OPERAND (exp, 0);
3865 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
3872 /* Now output the underlying data. If we've handling the padding, return.
3873 Otherwise, break and ensure SIZE is the size written. */
3881 case REFERENCE_TYPE:
3883 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3884 EXPAND_INITIALIZER),
3885 MIN (size, thissize), align, 0))
3886 error ("initializer for integer value is too complicated");
3890 if (TREE_CODE (exp) != REAL_CST)
3891 error ("initializer for floating value is not a floating constant");
3893 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
3897 output_constant (TREE_REALPART (exp), thissize / 2, align);
3898 output_constant (TREE_IMAGPART (exp), thissize / 2,
3899 min_align (align, BITS_PER_UNIT * (thissize / 2)));
3904 switch (TREE_CODE (exp))
3907 output_constructor (exp, size, align);
3910 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
3912 assemble_string (TREE_STRING_POINTER (exp), thissize);
3919 unsigned int nalign;
3920 enum machine_mode inner;
3922 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
3923 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
3925 elt_size = GET_MODE_SIZE (inner);
3927 link = TREE_VECTOR_CST_ELTS (exp);
3928 output_constant (TREE_VALUE (link), elt_size, align);
3929 while ((link = TREE_CHAIN (link)) != NULL)
3930 output_constant (TREE_VALUE (link), elt_size, nalign);
3940 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
3941 output_constructor (exp, size, align);
3951 if (size > thissize)
3952 assemble_zeros (size - thissize);
3956 /* Subroutine of output_constructor, used for computing the size of
3957 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3958 type with an unspecified upper bound. */
3960 static unsigned HOST_WIDE_INT
3961 array_size_for_constructor (tree val)
3964 unsigned HOST_WIDE_INT cnt;
3967 /* This code used to attempt to handle string constants that are not
3968 arrays of single-bytes, but nothing else does, so there's no point in
3970 if (TREE_CODE (val) == STRING_CST)
3971 return TREE_STRING_LENGTH (val);
3973 max_index = NULL_TREE;
3974 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
3976 if (TREE_CODE (index) == RANGE_EXPR)
3977 index = TREE_OPERAND (index, 1);
3978 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
3982 if (max_index == NULL_TREE)
3985 /* Compute the total number of array elements. */
3986 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
3988 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
3989 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
3991 /* Multiply by the array element unit size to find number of bytes. */
3992 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
3994 return tree_low_cst (i, 1);
3997 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3998 Generate at least SIZE bytes, padding if necessary. */
4001 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4004 tree type = TREE_TYPE (exp);
4007 /* Number of bytes output or skipped so far.
4008 In other words, current position within the constructor. */
4009 HOST_WIDE_INT total_bytes = 0;
4010 /* Nonzero means BYTE contains part of a byte, to be output. */
4011 int byte_buffer_in_use = 0;
4013 unsigned HOST_WIDE_INT cnt;
4014 constructor_elt *ce;
4016 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4018 if (TREE_CODE (type) == RECORD_TYPE)
4019 field = TYPE_FIELDS (type);
4021 if (TREE_CODE (type) == ARRAY_TYPE
4022 && TYPE_DOMAIN (type) != 0)
4023 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4025 /* As LINK goes through the elements of the constant,
4026 FIELD goes through the structure fields, if the constant is a structure.
4027 if the constant is a union, then we override this,
4028 by getting the field from the TREE_LIST element.
4029 But the constant could also be an array. Then FIELD is zero.
4031 There is always a maximum of one element in the chain LINK for unions
4032 (even if the initializer in a source program incorrectly contains
4035 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4036 cnt++, field = field ? TREE_CHAIN (field) : 0)
4038 tree val = ce->value;
4041 /* The element in a union constructor specifies the proper field
4043 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4044 || TREE_CODE (type) == QUAL_UNION_TYPE)
4048 else if (TREE_CODE (type) == ARRAY_TYPE)
4051 #ifdef ASM_COMMENT_START
4052 if (field && flag_verbose_asm)
4053 fprintf (asm_out_file, "%s %s:\n",
4056 ? IDENTIFIER_POINTER (DECL_NAME (field))
4060 /* Eliminate the marker that makes a cast not be an lvalue. */
4064 if (index && TREE_CODE (index) == RANGE_EXPR)
4066 unsigned HOST_WIDE_INT fieldsize
4067 = int_size_in_bytes (TREE_TYPE (type));
4068 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4069 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4070 HOST_WIDE_INT index;
4071 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4073 for (index = lo_index; index <= hi_index; index++)
4075 /* Output the element's initial value. */
4077 assemble_zeros (fieldsize);
4079 output_constant (val, fieldsize, align2);
4081 /* Count its size. */
4082 total_bytes += fieldsize;
4085 else if (field == 0 || !DECL_BIT_FIELD (field))
4087 /* An element that is not a bit-field. */
4089 unsigned HOST_WIDE_INT fieldsize;
4090 /* Since this structure is static,
4091 we know the positions are constant. */
4092 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4093 unsigned int align2;
4096 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4097 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4099 /* Output any buffered-up bit-fields preceding this element. */
4100 if (byte_buffer_in_use)
4102 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4104 byte_buffer_in_use = 0;
4107 /* Advance to offset of this element.
4108 Note no alignment needed in an array, since that is guaranteed
4109 if each element has the proper size. */
4110 if ((field != 0 || index != 0) && pos != total_bytes)
4112 gcc_assert (pos >= total_bytes);
4113 assemble_zeros (pos - total_bytes);
4117 /* Find the alignment of this element. */
4118 align2 = min_align (align, BITS_PER_UNIT * pos);
4120 /* Determine size this element should occupy. */
4125 /* If this is an array with an unspecified upper bound,
4126 the initializer determines the size. */
4127 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4128 but we cannot do this until the deprecated support for
4129 initializing zero-length array members is removed. */
4130 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4131 && TYPE_DOMAIN (TREE_TYPE (field))
4132 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4134 fieldsize = array_size_for_constructor (val);
4135 /* Given a non-empty initialization, this field had
4137 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4139 else if (DECL_SIZE_UNIT (field))
4141 /* ??? This can't be right. If the decl size overflows
4142 a host integer we will silently emit no data. */
4143 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4144 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4148 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4150 /* Output the element's initial value. */
4152 assemble_zeros (fieldsize);
4154 output_constant (val, fieldsize, align2);
4156 /* Count its size. */
4157 total_bytes += fieldsize;
4159 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4160 error ("invalid initial value for member %qs",
4161 IDENTIFIER_POINTER (DECL_NAME (field)));
4164 /* Element that is a bit-field. */
4166 HOST_WIDE_INT next_offset = int_bit_position (field);
4167 HOST_WIDE_INT end_offset
4168 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4171 val = integer_zero_node;
4173 /* If this field does not start in this (or, next) byte,
4175 if (next_offset / BITS_PER_UNIT != total_bytes)
4177 /* Output remnant of any bit field in previous bytes. */
4178 if (byte_buffer_in_use)
4180 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4182 byte_buffer_in_use = 0;
4185 /* If still not at proper byte, advance to there. */
4186 if (next_offset / BITS_PER_UNIT != total_bytes)
4188 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4189 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4190 total_bytes = next_offset / BITS_PER_UNIT;
4194 if (! byte_buffer_in_use)
4197 /* We must split the element into pieces that fall within
4198 separate bytes, and combine each byte with previous or
4199 following bit-fields. */
4201 /* next_offset is the offset n fbits from the beginning of
4202 the structure to the next bit of this element to be processed.
4203 end_offset is the offset of the first bit past the end of
4205 while (next_offset < end_offset)
4209 HOST_WIDE_INT value;
4210 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4211 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4213 /* Advance from byte to byte
4214 within this element when necessary. */
4215 while (next_byte != total_bytes)
4217 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4222 /* Number of bits we can process at once
4223 (all part of the same byte). */
4224 this_time = MIN (end_offset - next_offset,
4225 BITS_PER_UNIT - next_bit);
4226 if (BYTES_BIG_ENDIAN)
4228 /* On big-endian machine, take the most significant bits
4229 first (of the bits that are significant)
4230 and put them into bytes from the most significant end. */
4231 shift = end_offset - next_offset - this_time;
4233 /* Don't try to take a bunch of bits that cross
4234 the word boundary in the INTEGER_CST. We can
4235 only select bits from the LOW or HIGH part
4237 if (shift < HOST_BITS_PER_WIDE_INT
4238 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4240 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4241 shift = HOST_BITS_PER_WIDE_INT;
4244 /* Now get the bits from the appropriate constant word. */
4245 if (shift < HOST_BITS_PER_WIDE_INT)
4246 value = TREE_INT_CST_LOW (val);
4249 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4250 value = TREE_INT_CST_HIGH (val);
4251 shift -= HOST_BITS_PER_WIDE_INT;
4254 /* Get the result. This works only when:
4255 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4256 byte |= (((value >> shift)
4257 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4258 << (BITS_PER_UNIT - this_time - next_bit));
4262 /* On little-endian machines,
4263 take first the least significant bits of the value
4264 and pack them starting at the least significant
4265 bits of the bytes. */
4266 shift = next_offset - int_bit_position (field);
4268 /* Don't try to take a bunch of bits that cross
4269 the word boundary in the INTEGER_CST. We can
4270 only select bits from the LOW or HIGH part
4272 if (shift < HOST_BITS_PER_WIDE_INT
4273 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4274 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4276 /* Now get the bits from the appropriate constant word. */
4277 if (shift < HOST_BITS_PER_WIDE_INT)
4278 value = TREE_INT_CST_LOW (val);
4281 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4282 value = TREE_INT_CST_HIGH (val);
4283 shift -= HOST_BITS_PER_WIDE_INT;
4286 /* Get the result. This works only when:
4287 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4288 byte |= (((value >> shift)
4289 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4293 next_offset += this_time;
4294 byte_buffer_in_use = 1;
4299 if (byte_buffer_in_use)
4301 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4305 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4306 assemble_zeros (size - total_bytes);
4309 /* This TREE_LIST contains any weak symbol declarations waiting
4311 static GTY(()) tree weak_decls;
4313 /* Mark DECL as weak. */
4316 mark_weak (tree decl)
4318 DECL_WEAK (decl) = 1;
4320 if (DECL_RTL_SET_P (decl)
4321 && MEM_P (DECL_RTL (decl))
4322 && XEXP (DECL_RTL (decl), 0)
4323 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4324 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4327 /* Merge weak status between NEWDECL and OLDDECL. */
4330 merge_weak (tree newdecl, tree olddecl)
4332 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4334 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4337 /* We put the NEWDECL on the weak_decls list at some point
4338 and OLDDECL as well. Keep just OLDDECL on the list. */
4339 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4340 if (TREE_VALUE (*pwd) == newdecl)
4342 *pwd = TREE_CHAIN (*pwd);
4349 if (DECL_WEAK (newdecl))
4353 /* NEWDECL is weak, but OLDDECL is not. */
4355 /* If we already output the OLDDECL, we're in trouble; we can't
4356 go back and make it weak. This error cannot caught in
4357 declare_weak because the NEWDECL and OLDDECL was not yet
4358 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4359 if (TREE_ASM_WRITTEN (olddecl))
4360 error ("weak declaration of %q+D must precede definition",
4363 /* If we've already generated rtl referencing OLDDECL, we may
4364 have done so in a way that will not function properly with
4366 else if (TREE_USED (olddecl)
4367 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4368 warning (0, "weak declaration of %q+D after first use results "
4369 "in unspecified behavior", newdecl);
4373 /* We put the NEWDECL on the weak_decls list at some point.
4374 Replace it with the OLDDECL. */
4375 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4376 if (TREE_VALUE (wd) == newdecl)
4378 TREE_VALUE (wd) = olddecl;
4381 /* We may not find the entry on the list. If NEWDECL is a
4382 weak alias, then we will have already called
4383 globalize_decl to remove the entry; in that case, we do
4384 not need to do anything. */
4387 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4388 mark_weak (olddecl);
4391 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4392 weak. Just update NEWDECL to indicate that it's weak too. */
4393 mark_weak (newdecl);
4396 /* Declare DECL to be a weak symbol. */
4399 declare_weak (tree decl)
4401 if (! TREE_PUBLIC (decl))
4402 error ("weak declaration of %q+D must be public", decl);
4403 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4404 error ("weak declaration of %q+D must precede definition", decl);
4405 else if (SUPPORTS_WEAK)
4407 if (! DECL_WEAK (decl))
4408 weak_decls = tree_cons (NULL, decl, weak_decls);
4411 warning (0, "weak declaration of %q+D not supported", decl);
4416 /* Emit any pending weak declarations. */
4423 for (t = weak_decls; t; t = TREE_CHAIN (t))
4425 tree decl = TREE_VALUE (t);
4426 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4427 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4430 if (! TREE_USED (decl))
4433 #ifdef ASM_WEAKEN_DECL
4434 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4436 #ifdef ASM_WEAKEN_LABEL
4437 ASM_WEAKEN_LABEL (asm_out_file, name);
4439 #ifdef ASM_OUTPUT_WEAK_ALIAS
4440 warning (0, "only weak aliases are supported in this configuration");
4448 /* Emit the assembly bits to indicate that DECL is globally visible. */
4451 globalize_decl (tree decl)
4453 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4455 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4456 if (DECL_WEAK (decl))
4460 #ifdef ASM_WEAKEN_DECL
4461 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4463 ASM_WEAKEN_LABEL (asm_out_file, name);
4466 /* Remove this function from the pending weak list so that
4467 we do not emit multiple .weak directives for it. */
4468 for (p = &weak_decls; (t = *p) ; )
4470 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4471 *p = TREE_CHAIN (t);
4473 p = &TREE_CHAIN (t);
4477 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4478 if (DECL_ONE_ONLY (decl))
4479 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4482 targetm.asm_out.globalize_label (asm_out_file, name);
4485 /* We have to be able to tell cgraph about the needed-ness of the target
4486 of an alias. This requires that the decl have been defined. Aliases
4487 that precede their definition have to be queued for later processing. */
4489 typedef struct alias_pair GTY(())
4495 /* Define gc'd vector type. */
4496 DEF_VEC_O(alias_pair);
4497 DEF_VEC_ALLOC_O(alias_pair,gc);
4499 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4501 /* Given an assembly name, find the decl it is associated with. At the
4502 same time, mark it needed for cgraph. */
4505 find_decl_and_mark_needed (tree decl, tree target)
4507 struct cgraph_node *fnode = NULL;
4508 struct cgraph_varpool_node *vnode = NULL;
4510 /* C++ thunk emitting code produces aliases late in the game.
4511 Avoid confusing cgraph code in that case. */
4512 if (!cgraph_global_info_ready)
4514 if (TREE_CODE (decl) == FUNCTION_DECL)
4516 fnode = cgraph_node_for_asm (target);
4518 vnode = cgraph_varpool_node_for_asm (target);
4522 vnode = cgraph_varpool_node_for_asm (target);
4524 fnode = cgraph_node_for_asm (target);
4530 cgraph_mark_needed_node (fnode);
4535 cgraph_varpool_mark_needed_node (vnode);
4542 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4543 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4544 tree node is DECL to have the value of the tree node TARGET. */
4547 do_assemble_alias (tree decl, tree target ATTRIBUTE_UNUSED)
4549 if (TREE_ASM_WRITTEN (decl))
4552 TREE_ASM_WRITTEN (decl) = 1;
4553 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4555 #ifdef ASM_OUTPUT_DEF
4556 /* Make name accessible from other files, if appropriate. */
4558 if (TREE_PUBLIC (decl))
4560 globalize_decl (decl);
4561 maybe_assemble_visibility (decl);
4564 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4565 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4567 ASM_OUTPUT_DEF (asm_out_file,
4568 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4569 IDENTIFIER_POINTER (target));
4571 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4576 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4577 # ifdef ASM_WEAKEN_DECL
4578 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4580 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4582 /* Remove this function from the pending weak list so that
4583 we do not emit multiple .weak directives for it. */
4584 for (p = &weak_decls; (t = *p) ; )
4585 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4586 *p = TREE_CHAIN (t);
4588 p = &TREE_CHAIN (t);
4593 /* First pass of completing pending aliases. Make sure that cgraph knows
4594 which symbols will be required. */
4597 finish_aliases_1 (void)
4602 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4606 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4607 if (target_decl == NULL)
4608 error ("%q+D aliased to undefined symbol %qs",
4609 p->decl, IDENTIFIER_POINTER (p->target));
4610 else if (DECL_EXTERNAL (target_decl))
4611 error ("%q+D aliased to external symbol %qs",
4612 p->decl, IDENTIFIER_POINTER (p->target));
4616 /* Second pass of completing pending aliases. Emit the actual assembly.
4617 This happens at the end of compilation and thus it is assured that the
4618 target symbol has been emitted. */
4621 finish_aliases_2 (void)
4626 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4627 do_assemble_alias (p->decl, p->target);
4629 VEC_truncate (alias_pair, alias_pairs, 0);
4632 /* Emit an assembler directive to make the symbol for DECL an alias to
4633 the symbol for TARGET. */
4636 assemble_alias (tree decl, tree target)
4640 #if !defined (ASM_OUTPUT_DEF)
4641 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4642 error ("%Jalias definitions not supported in this configuration", decl);
4645 if (!DECL_WEAK (decl))
4647 error ("%Jonly weak aliases are supported in this configuration", decl);
4653 /* We must force creation of DECL_RTL for debug info generation, even though
4654 we don't use it here. */
4655 make_decl_rtl (decl);
4656 TREE_USED (decl) = 1;
4658 /* A quirk of the initial implementation of aliases required that the user
4659 add "extern" to all of them. Which is silly, but now historical. Do
4660 note that the symbol is in fact locally defined. */
4661 DECL_EXTERNAL (decl) = 0;
4663 /* Allow aliases to aliases. */
4664 if (TREE_CODE (decl) == FUNCTION_DECL)
4665 cgraph_node (decl)->alias = true;
4667 cgraph_varpool_node (decl)->alias = true;
4669 /* If the target has already been emitted, we don't have to queue the
4670 alias. This saves a tad o memory. */
4671 target_decl = find_decl_and_mark_needed (decl, target);
4672 if (target_decl && TREE_ASM_WRITTEN (target_decl))
4673 do_assemble_alias (decl, target);
4676 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
4682 /* Emit an assembler directive to set symbol for DECL visibility to
4683 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4686 default_assemble_visibility (tree decl, int vis)
4688 static const char * const visibility_types[] = {
4689 NULL, "internal", "hidden", "protected"
4692 const char *name, *type;
4694 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4695 type = visibility_types[vis];
4697 #ifdef HAVE_GAS_HIDDEN
4698 fprintf (asm_out_file, "\t.%s\t", type);
4699 assemble_name (asm_out_file, name);
4700 fprintf (asm_out_file, "\n");
4702 warning (OPT_Wattributes, "visibility attribute not supported "
4703 "in this configuration; ignored");
4707 /* A helper function to call assemble_visibility when needed for a decl. */
4710 maybe_assemble_visibility (tree decl)
4712 enum symbol_visibility vis = DECL_VISIBILITY (decl);
4714 if (vis != VISIBILITY_DEFAULT)
4715 targetm.asm_out.visibility (decl, vis);
4718 /* Returns 1 if the target configuration supports defining public symbols
4719 so that one of them will be chosen at link time instead of generating a
4720 multiply-defined symbol error, whether through the use of weak symbols or
4721 a target-specific mechanism for having duplicates discarded. */
4724 supports_one_only (void)
4726 if (SUPPORTS_ONE_ONLY)
4728 return SUPPORTS_WEAK;
4731 /* Set up DECL as a public symbol that can be defined in multiple
4732 translation units without generating a linker error. */
4735 make_decl_one_only (tree decl)
4737 gcc_assert (TREE_CODE (decl) == VAR_DECL
4738 || TREE_CODE (decl) == FUNCTION_DECL);
4740 TREE_PUBLIC (decl) = 1;
4742 if (SUPPORTS_ONE_ONLY)
4744 #ifdef MAKE_DECL_ONE_ONLY
4745 MAKE_DECL_ONE_ONLY (decl);
4747 DECL_ONE_ONLY (decl) = 1;
4749 else if (TREE_CODE (decl) == VAR_DECL
4750 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4751 DECL_COMMON (decl) = 1;
4754 gcc_assert (SUPPORTS_WEAK);
4755 DECL_WEAK (decl) = 1;
4760 init_varasm_once (void)
4762 in_named_htab = htab_create_ggc (31, in_named_entry_hash,
4763 in_named_entry_eq, NULL);
4764 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
4765 const_desc_eq, NULL);
4767 const_alias_set = new_alias_set ();
4771 decl_default_tls_model (tree decl)
4773 enum tls_model kind;
4776 is_local = targetm.binds_local_p (decl);
4780 kind = TLS_MODEL_LOCAL_EXEC;
4782 kind = TLS_MODEL_INITIAL_EXEC;
4785 /* Local dynamic is inefficient when we're not combining the
4786 parts of the address. */
4787 else if (optimize && is_local)
4788 kind = TLS_MODEL_LOCAL_DYNAMIC;
4790 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4791 if (kind < flag_tls_default)
4792 kind = flag_tls_default;
4797 /* Select a set of attributes for section NAME based on the properties
4798 of DECL and whether or not RELOC indicates that DECL's initializer
4799 might contain runtime relocations.
4801 We make the section read-only and executable for a function decl,
4802 read-only for a const data decl, and writable for a non-const data decl. */
4805 default_section_type_flags (tree decl, const char *name, int reloc)
4807 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
4811 default_section_type_flags_1 (tree decl, const char *name, int reloc,
4816 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
4817 flags = SECTION_CODE;
4818 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
4820 else if (current_function_decl
4822 && cfun->unlikely_text_section_name
4823 && strcmp (name, cfun->unlikely_text_section_name) == 0)
4824 flags = SECTION_CODE;
4826 && (!current_function_decl || !cfun)
4827 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
4828 flags = SECTION_CODE;
4830 flags = SECTION_WRITE;
4832 if (decl && DECL_ONE_ONLY (decl))
4833 flags |= SECTION_LINKONCE;
4835 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
4836 flags |= SECTION_TLS | SECTION_WRITE;
4838 if (strcmp (name, ".bss") == 0
4839 || strncmp (name, ".bss.", 5) == 0
4840 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
4841 || strcmp (name, ".sbss") == 0
4842 || strncmp (name, ".sbss.", 6) == 0
4843 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
4844 flags |= SECTION_BSS;
4846 if (strcmp (name, ".tdata") == 0
4847 || strncmp (name, ".tdata.", 7) == 0
4848 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
4849 flags |= SECTION_TLS;
4851 if (strcmp (name, ".tbss") == 0
4852 || strncmp (name, ".tbss.", 6) == 0
4853 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
4854 flags |= SECTION_TLS | SECTION_BSS;
4856 /* These three sections have special ELF types. They are neither
4857 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4858 want to print a section type (@progbits or @nobits). If someone
4859 is silly enough to emit code or TLS variables to one of these
4860 sections, then don't handle them specially. */
4861 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
4862 && (strcmp (name, ".init_array") == 0
4863 || strcmp (name, ".fini_array") == 0
4864 || strcmp (name, ".preinit_array") == 0))
4865 flags |= SECTION_NOTYPE;
4870 /* Output assembly to switch to section NAME with attribute FLAGS.
4871 Four variants for common object file formats. */
4874 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
4875 unsigned int flags ATTRIBUTE_UNUSED,
4876 tree decl ATTRIBUTE_UNUSED)
4878 /* Some object formats don't support named sections at all. The
4879 front-end should already have flagged this as an error. */
4884 default_elf_asm_named_section (const char *name, unsigned int flags,
4885 tree decl ATTRIBUTE_UNUSED)
4887 char flagchars[10], *f = flagchars;
4889 /* If we have already declared this section, we can use an
4890 abbreviated form to switch back to it -- unless this section is
4891 part of a COMDAT groups, in which case GAS requires the full
4892 declaration every time. */
4893 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4894 && ! named_section_first_declaration (name))
4896 fprintf (asm_out_file, "\t.section\t%s\n", name);
4900 if (!(flags & SECTION_DEBUG))
4902 if (flags & SECTION_WRITE)
4904 if (flags & SECTION_CODE)
4906 if (flags & SECTION_SMALL)
4908 if (flags & SECTION_MERGE)
4910 if (flags & SECTION_STRINGS)
4912 if (flags & SECTION_TLS)
4914 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4918 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
4920 if (!(flags & SECTION_NOTYPE))
4925 if (flags & SECTION_BSS)
4931 #ifdef ASM_COMMENT_START
4932 /* On platforms that use "@" as the assembly comment character,
4934 if (strcmp (ASM_COMMENT_START, "@") == 0)
4937 fprintf (asm_out_file, format, type);
4939 if (flags & SECTION_ENTSIZE)
4940 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
4941 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4942 fprintf (asm_out_file, ",%s,comdat",
4943 lang_hooks.decls.comdat_group (decl));
4946 putc ('\n', asm_out_file);
4950 default_coff_asm_named_section (const char *name, unsigned int flags,
4951 tree decl ATTRIBUTE_UNUSED)
4953 char flagchars[8], *f = flagchars;
4955 if (flags & SECTION_WRITE)
4957 if (flags & SECTION_CODE)
4961 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
4965 default_pe_asm_named_section (const char *name, unsigned int flags,
4968 default_coff_asm_named_section (name, flags, decl);
4970 if (flags & SECTION_LINKONCE)
4972 /* Functions may have been compiled at various levels of
4973 optimization so we can't use `same_size' here.
4974 Instead, have the linker pick one. */
4975 fprintf (asm_out_file, "\t.linkonce %s\n",
4976 (flags & SECTION_CODE ? "discard" : "same_size"));
4980 /* The lame default section selector. */
4983 default_select_section (tree decl, int reloc,
4984 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
4986 bool readonly = false;
4990 if (decl_readonly_section (decl, reloc))
4993 else if (TREE_CODE (decl) == CONSTRUCTOR)
4995 if (! ((flag_pic && reloc)
4996 || !TREE_READONLY (decl)
4997 || TREE_SIDE_EFFECTS (decl)
4998 || !TREE_CONSTANT (decl)))
5001 else if (TREE_CODE (decl) == STRING_CST)
5003 else if (! (flag_pic && reloc))
5007 readonly_data_section ();
5012 /* A helper function for default_elf_select_section and
5013 default_elf_unique_section. Categorizes the DECL. */
5015 enum section_category
5020 SECCAT_RODATA_MERGE_STR,
5021 SECCAT_RODATA_MERGE_STR_INIT,
5022 SECCAT_RODATA_MERGE_CONST,
5027 /* To optimize loading of shared programs, define following subsections
5029 _REL Contains data that has relocations, so they get grouped
5030 together and dynamic linker will visit fewer pages in memory.
5031 _RO Contains data that is otherwise read-only. This is useful
5032 with prelinking as most relocations won't be dynamically
5033 linked and thus stay read only.
5034 _LOCAL Marks data containing relocations only to local objects.
5035 These relocations will get fully resolved by prelinking. */
5037 SECCAT_DATA_REL_LOCAL,
5039 SECCAT_DATA_REL_RO_LOCAL,
5049 static enum section_category
5050 categorize_decl_for_section (tree, int, int);
5052 static enum section_category
5053 categorize_decl_for_section (tree decl, int reloc, int shlib)
5055 enum section_category ret;
5057 if (TREE_CODE (decl) == FUNCTION_DECL)
5059 else if (TREE_CODE (decl) == STRING_CST)
5061 if (flag_mudflap) /* or !flag_merge_constants */
5062 return SECCAT_RODATA;
5064 return SECCAT_RODATA_MERGE_STR;
5066 else if (TREE_CODE (decl) == VAR_DECL)
5068 if (DECL_INITIAL (decl) == NULL
5069 || DECL_INITIAL (decl) == error_mark_node
5070 || (flag_zero_initialized_in_bss
5071 /* Leave constant zeroes in .rodata so they can be shared. */
5072 && !TREE_READONLY (decl)
5073 && initializer_zerop (DECL_INITIAL (decl))))
5075 else if (! TREE_READONLY (decl)
5076 || TREE_SIDE_EFFECTS (decl)
5077 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5079 if (shlib && (reloc & 2))
5080 ret = SECCAT_DATA_REL;
5081 else if (shlib && reloc)
5082 ret = SECCAT_DATA_REL_LOCAL;
5086 else if (shlib && (reloc & 2))
5087 ret = SECCAT_DATA_REL_RO;
5088 else if (shlib && reloc)
5089 ret = SECCAT_DATA_REL_RO_LOCAL;
5090 else if (reloc || flag_merge_constants < 2)
5091 /* C and C++ don't allow different variables to share the same
5092 location. -fmerge-all-constants allows even that (at the
5093 expense of not conforming). */
5094 ret = SECCAT_RODATA;
5095 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5096 ret = SECCAT_RODATA_MERGE_STR_INIT;
5098 ret = SECCAT_RODATA_MERGE_CONST;
5100 else if (TREE_CODE (decl) == CONSTRUCTOR)
5102 if ((shlib && reloc)
5103 || TREE_SIDE_EFFECTS (decl)
5104 || ! TREE_CONSTANT (decl))
5107 ret = SECCAT_RODATA;
5110 ret = SECCAT_RODATA;
5112 /* There are no read-only thread-local sections. */
5113 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5115 /* Note that this would be *just* SECCAT_BSS, except that there's
5116 no concept of a read-only thread-local-data section. */
5117 if (ret == SECCAT_BSS
5118 || (flag_zero_initialized_in_bss
5119 && initializer_zerop (DECL_INITIAL (decl))))
5125 /* If the target uses small data sections, select it. */
5126 else if (targetm.in_small_data_p (decl))
5128 if (ret == SECCAT_BSS)
5130 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5131 ret = SECCAT_SRODATA;
5140 decl_readonly_section (tree decl, int reloc)
5142 return decl_readonly_section_1 (decl, reloc, flag_pic);
5146 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5148 switch (categorize_decl_for_section (decl, reloc, shlib))
5151 case SECCAT_RODATA_MERGE_STR:
5152 case SECCAT_RODATA_MERGE_STR_INIT:
5153 case SECCAT_RODATA_MERGE_CONST:
5154 case SECCAT_SRODATA:
5163 /* Select a section based on the above categorization. */
5166 default_elf_select_section (tree decl, int reloc,
5167 unsigned HOST_WIDE_INT align)
5169 default_elf_select_section_1 (decl, reloc, align, flag_pic);
5173 default_elf_select_section_1 (tree decl, int reloc,
5174 unsigned HOST_WIDE_INT align, int shlib)
5177 switch (categorize_decl_for_section (decl, reloc, shlib))
5180 /* We're not supposed to be called on FUNCTION_DECLs. */
5183 readonly_data_section ();
5185 case SECCAT_RODATA_MERGE_STR:
5186 mergeable_string_section (decl, align, 0);
5188 case SECCAT_RODATA_MERGE_STR_INIT:
5189 mergeable_string_section (DECL_INITIAL (decl), align, 0);
5191 case SECCAT_RODATA_MERGE_CONST:
5192 mergeable_constant_section (DECL_MODE (decl), align, 0);
5194 case SECCAT_SRODATA:
5200 case SECCAT_DATA_REL:
5201 sname = ".data.rel";
5203 case SECCAT_DATA_REL_LOCAL:
5204 sname = ".data.rel.local";
5206 case SECCAT_DATA_REL_RO:
5207 sname = ".data.rel.ro";
5209 case SECCAT_DATA_REL_RO_LOCAL:
5210 sname = ".data.rel.ro.local";
5219 #ifdef BSS_SECTION_ASM_OP
5238 named_section (decl, sname, reloc);
5241 /* Construct a unique section name based on the decl name and the
5242 categorization performed above. */
5245 default_unique_section (tree decl, int reloc)
5247 default_unique_section_1 (decl, reloc, flag_pic);
5251 default_unique_section_1 (tree decl, int reloc, int shlib)
5253 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5254 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5255 const char *prefix, *name;
5259 switch (categorize_decl_for_section (decl, reloc, shlib))
5262 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5265 case SECCAT_RODATA_MERGE_STR:
5266 case SECCAT_RODATA_MERGE_STR_INIT:
5267 case SECCAT_RODATA_MERGE_CONST:
5268 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5270 case SECCAT_SRODATA:
5271 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5274 case SECCAT_DATA_REL:
5275 case SECCAT_DATA_REL_LOCAL:
5276 case SECCAT_DATA_REL_RO:
5277 case SECCAT_DATA_REL_RO_LOCAL:
5278 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5281 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5284 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5287 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5290 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5293 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5298 plen = strlen (prefix);
5300 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5301 name = targetm.strip_name_encoding (name);
5302 nlen = strlen (name);
5304 string = alloca (nlen + plen + 1);
5305 memcpy (string, prefix, plen);
5306 memcpy (string + plen, name, nlen + 1);
5308 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5312 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5314 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5317 switch (GET_CODE (x))
5329 readonly_data_section ();
5333 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5334 unsigned HOST_WIDE_INT align)
5336 /* ??? Handle small data here somehow. */
5339 switch (GET_CODE (x))
5343 named_section (NULL_TREE, ".data.rel.ro", 3);
5347 named_section (NULL_TREE, ".data.rel.ro.local", 1);
5354 mergeable_constant_section (mode, align, 0);
5357 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5360 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5365 /* Careful not to prod global register variables. */
5368 symbol = XEXP (rtl, 0);
5369 if (GET_CODE (symbol) != SYMBOL_REF)
5373 if (TREE_CODE (decl) == FUNCTION_DECL)
5374 flags |= SYMBOL_FLAG_FUNCTION;
5375 if (targetm.binds_local_p (decl))
5376 flags |= SYMBOL_FLAG_LOCAL;
5377 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5378 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
5379 else if (targetm.in_small_data_p (decl))
5380 flags |= SYMBOL_FLAG_SMALL;
5381 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5382 being PUBLIC, the thing *must* be defined in this translation unit.
5383 Prevent this buglet from being propagated into rtl code as well. */
5384 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5385 flags |= SYMBOL_FLAG_EXTERNAL;
5387 SYMBOL_REF_FLAGS (symbol) = flags;
5390 /* By default, we do nothing for encode_section_info, so we need not
5391 do anything but discard the '*' marker. */
5394 default_strip_name_encoding (const char *str)
5396 return str + (*str == '*');
5399 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5400 wrt cross-module name binding. */
5403 default_binds_local_p (tree exp)
5405 return default_binds_local_p_1 (exp, flag_shlib);
5409 default_binds_local_p_1 (tree exp, int shlib)
5413 /* A non-decl is an entry in the constant pool. */
5416 /* Static variables are always local. */
5417 else if (! TREE_PUBLIC (exp))
5419 /* A variable is local if the user explicitly tells us so. */
5420 else if (DECL_VISIBILITY_SPECIFIED (exp) && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5422 /* Otherwise, variables defined outside this object may not be local. */
5423 else if (DECL_EXTERNAL (exp))
5425 /* Linkonce and weak data are never local. */
5426 else if (DECL_ONE_ONLY (exp) || DECL_WEAK (exp))
5428 /* If none of the above and visibility is not default, make local. */
5429 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5431 /* If PIC, then assume that any global name can be overridden by
5432 symbols resolved from other modules. */
5435 /* Uninitialized COMMON variable may be unified with symbols
5436 resolved from other modules. */
5437 else if (DECL_COMMON (exp)
5438 && (DECL_INITIAL (exp) == NULL
5439 || DECL_INITIAL (exp) == error_mark_node))
5441 /* Otherwise we're left with initialized (or non-common) global data
5442 which is of necessity defined locally. */
5449 /* Determine whether or not a pointer mode is valid. Assume defaults
5450 of ptr_mode or Pmode - can be overridden. */
5452 default_valid_pointer_mode (enum machine_mode mode)
5454 return (mode == ptr_mode || mode == Pmode);
5457 /* Default function to output code that will globalize a label. A
5458 target must define GLOBAL_ASM_OP or provide its own function to
5459 globalize a label. */
5460 #ifdef GLOBAL_ASM_OP
5462 default_globalize_label (FILE * stream, const char *name)
5464 fputs (GLOBAL_ASM_OP, stream);
5465 assemble_name (stream, name);
5466 putc ('\n', stream);
5468 #endif /* GLOBAL_ASM_OP */
5470 /* Default function to output a label for unwind information. The
5471 default is to do nothing. A target that needs nonlocal labels for
5472 unwind information must provide its own function to do this. */
5474 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5475 tree decl ATTRIBUTE_UNUSED,
5476 int for_eh ATTRIBUTE_UNUSED,
5477 int empty ATTRIBUTE_UNUSED)
5481 /* This is how to output an internal numbered label where PREFIX is
5482 the class of label and LABELNO is the number within the class. */
5485 default_internal_label (FILE *stream, const char *prefix,
5486 unsigned long labelno)
5488 char *const buf = alloca (40 + strlen (prefix));
5489 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5490 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5493 /* This is the default behavior at the beginning of a file. It's
5494 controlled by two other target-hook toggles. */
5496 default_file_start (void)
5498 if (targetm.file_start_app_off && !flag_verbose_asm)
5499 fputs (ASM_APP_OFF, asm_out_file);
5501 if (targetm.file_start_file_directive)
5502 output_file_directive (asm_out_file, main_input_filename);
5505 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5506 which emits a special section directive used to indicate whether or
5507 not this object file needs an executable stack. This is primarily
5508 a GNU extension to ELF but could be used on other targets. */
5510 int trampolines_created;
5513 file_end_indicate_exec_stack (void)
5515 unsigned int flags = SECTION_DEBUG;
5516 if (trampolines_created)
5517 flags |= SECTION_CODE;
5519 named_section_flags (".note.GNU-stack", flags);
5522 #include "gt-varasm.h"