1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 /* This file handles generation of all the assembler code
25 *except* the instructions of a function.
26 This includes declarations of variables and their initial values.
28 We also output the assembler code for constants stored in memory
29 and are responsible for combining constants with the same value. */
33 #include "coretypes.h"
40 #include "hard-reg-set.h"
48 #include "langhooks.h"
52 #include "tree-mudflap.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h" /* Needed for external data
59 declarations for e.g. AIX 4.x. */
62 /* The (assembler) name of the first globally-visible object output. */
63 const char *first_global_object_name;
64 const char *weak_global_object_name;
67 struct constant_descriptor_rtx;
68 struct rtx_constant_pool;
70 struct varasm_status GTY(())
72 /* If we're using a per-function constant pool, this is it. */
73 struct rtx_constant_pool *pool;
75 /* Number of tree-constants deferred during the expansion of this
77 unsigned int deferred_constants;
80 #define n_deferred_constants (cfun->varasm->deferred_constants)
82 /* Number for making the label on the next
83 constant that is stored in memory. */
85 static GTY(()) int const_labelno;
87 /* Carry information from ASM_DECLARE_OBJECT_NAME
88 to ASM_FINISH_DECLARE_OBJECT. */
90 int size_directive_output;
92 /* The last decl for which assemble_variable was called,
93 if it did ASM_DECLARE_OBJECT_NAME.
94 If the last call to assemble_variable didn't do that,
97 tree last_assemble_variable_decl;
99 /* The following global variable indicates if the first basic block
100 in a function belongs to the cold partition or not. */
102 bool first_function_block_is_cold;
104 /* We give all constants their own alias set. Perhaps redundant with
105 MEM_READONLY_P, but pre-dates it. */
107 static HOST_WIDE_INT const_alias_set;
109 static const char *strip_reg_name (const char *);
110 static int contains_pointers_p (tree);
111 #ifdef ASM_OUTPUT_EXTERNAL
112 static bool incorporeal_function_p (tree);
114 static void decode_addr_const (tree, struct addr_const *);
115 static hashval_t const_desc_hash (const void *);
116 static int const_desc_eq (const void *, const void *);
117 static hashval_t const_hash_1 (const tree);
118 static int compare_constant (const tree, const tree);
119 static tree copy_constant (tree);
120 static void output_constant_def_contents (rtx);
121 static void output_addressed_constants (tree);
122 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
123 static unsigned min_align (unsigned, unsigned);
124 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
125 static void globalize_decl (tree);
126 static void maybe_assemble_visibility (tree);
127 static int in_named_entry_eq (const void *, const void *);
128 static hashval_t in_named_entry_hash (const void *);
129 static void initialize_cold_section_name (void);
130 #ifdef BSS_SECTION_ASM_OP
131 #ifdef ASM_OUTPUT_BSS
132 static void asm_output_bss (FILE *, tree, const char *,
133 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
135 #ifdef ASM_OUTPUT_ALIGNED_BSS
136 static void asm_output_aligned_bss (FILE *, tree, const char *,
137 unsigned HOST_WIDE_INT, int)
140 #endif /* BSS_SECTION_ASM_OP */
141 static bool asm_emit_uninitialised (tree, const char*,
142 unsigned HOST_WIDE_INT,
143 unsigned HOST_WIDE_INT);
144 static void mark_weak (tree);
146 static GTY(()) enum in_section in_section = no_section;
147 enum in_section last_text_section;
149 /* Return a nonzero value if DECL has a section attribute. */
150 #ifndef IN_NAMED_SECTION
151 #define IN_NAMED_SECTION(DECL) \
152 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
153 && DECL_SECTION_NAME (DECL) != NULL_TREE)
156 /* Text of section name when in_section == in_named. */
157 static GTY(()) const char *in_named_name;
158 const char *last_text_section_name;
160 /* Hash table of flags that have been used for a particular named section. */
162 struct in_named_entry GTY(())
169 static GTY((param_is (struct in_named_entry))) htab_t in_named_htab;
171 /* Define functions like text_section for any extra sections. */
172 #ifdef EXTRA_SECTION_FUNCTIONS
173 EXTRA_SECTION_FUNCTIONS
177 initialize_cold_section_name (void)
180 const char *stripped_name;
185 && current_function_decl)
187 if (!cfun->unlikely_text_section_name)
189 if (flag_function_sections
190 && DECL_SECTION_NAME (current_function_decl))
192 name = xstrdup (TREE_STRING_POINTER (DECL_SECTION_NAME
193 (current_function_decl)));
194 stripped_name = targetm.strip_name_encoding (name);
195 len = strlen (stripped_name);
196 buffer = (char *) xmalloc (len + 10);
197 sprintf (buffer, "%s%s", stripped_name, "_unlikely");
198 cfun->unlikely_text_section_name = ggc_strdup (buffer);
200 free ((char *) name);
203 cfun->unlikely_text_section_name =
204 UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
209 ("initialize_cold_section_name called without valid current_function_decl.");
212 /* Tell assembler to switch to text section. */
217 if (in_section != in_text)
219 in_section = in_text;
220 last_text_section = in_text;
221 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
225 /* Tell assembler to switch to unlikely-to-be-executed text section. */
228 unlikely_text_section (void)
232 if (!cfun->unlikely_text_section_name)
233 initialize_cold_section_name ();
235 if ((in_section != in_unlikely_executed_text)
236 && (in_section != in_named
237 || strcmp (in_named_name, cfun->unlikely_text_section_name) != 0))
239 named_section (NULL_TREE, cfun->unlikely_text_section_name, 0);
240 in_section = in_unlikely_executed_text;
241 last_text_section = in_unlikely_executed_text;
246 named_section (NULL_TREE, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
247 in_section = in_unlikely_executed_text;
248 last_text_section = in_unlikely_executed_text;
252 /* Tell assembler to switch to data section. */
257 if (in_section != in_data)
259 in_section = in_data;
260 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
264 /* Tell assembler to switch to read-only data section. This is normally
268 readonly_data_section (void)
270 #ifdef READONLY_DATA_SECTION
271 READONLY_DATA_SECTION (); /* Note this can call data_section. */
273 #ifdef READONLY_DATA_SECTION_ASM_OP
274 if (in_section != in_readonly_data)
276 in_section = in_readonly_data;
277 fputs (READONLY_DATA_SECTION_ASM_OP, asm_out_file);
278 fputc ('\n', asm_out_file);
286 /* Determine if we're in the text section. */
289 in_text_section (void)
291 return in_section == in_text;
294 /* Determine if we're in the unlikely-to-be-executed text section. */
297 in_unlikely_text_section (void)
303 ret_val = ((in_section == in_unlikely_executed_text)
304 || (in_section == in_named
305 && cfun->unlikely_text_section_name
306 && strcmp (in_named_name,
307 cfun->unlikely_text_section_name) == 0));
311 ret_val = ((in_section == in_unlikely_executed_text)
312 || (in_section == in_named
313 && strcmp (in_named_name,
314 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0));
320 /* Determine if we're in the data section. */
323 in_data_section (void)
325 return in_section == in_data;
328 /* Helper routines for maintaining in_named_htab. */
331 in_named_entry_eq (const void *p1, const void *p2)
333 const struct in_named_entry *old = p1;
334 const char *new = p2;
336 return strcmp (old->name, new) == 0;
340 in_named_entry_hash (const void *p)
342 const struct in_named_entry *old = p;
343 return htab_hash_string (old->name);
346 /* If SECTION has been seen before as a named section, return the flags
347 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
348 set of flags for a section to have, so 0 does not mean that the section
349 has not been seen. */
352 get_named_section_flags (const char *section)
354 struct in_named_entry **slot;
356 slot = (struct in_named_entry **)
357 htab_find_slot_with_hash (in_named_htab, section,
358 htab_hash_string (section), NO_INSERT);
360 return slot ? (*slot)->flags : 0;
363 /* Returns true if the section has been declared before. Sets internal
364 flag on this section in in_named_hash so subsequent calls on this
365 section will return false. */
368 named_section_first_declaration (const char *name)
370 struct in_named_entry **slot;
372 slot = (struct in_named_entry **)
373 htab_find_slot_with_hash (in_named_htab, name,
374 htab_hash_string (name), NO_INSERT);
375 if (! (*slot)->declared)
377 (*slot)->declared = true;
387 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
388 different set of flags, return false. */
391 set_named_section_flags (const char *section, unsigned int flags)
393 struct in_named_entry **slot, *entry;
395 slot = (struct in_named_entry **)
396 htab_find_slot_with_hash (in_named_htab, section,
397 htab_hash_string (section), INSERT);
402 entry = ggc_alloc (sizeof (*entry));
404 entry->name = ggc_strdup (section);
405 entry->flags = flags;
406 entry->declared = false;
408 else if (entry->flags != flags)
414 /* Tell assembler to change to section NAME with attributes FLAGS. If
415 DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with which
416 this section is associated. */
419 named_section_real (const char *name, unsigned int flags, tree decl)
421 if (in_section != in_named || strcmp (name, in_named_name) != 0)
423 bool unchanged = set_named_section_flags (name, flags);
425 gcc_assert (unchanged);
427 targetm.asm_out.named_section (name, flags, decl);
429 if (flags & SECTION_FORGET)
430 in_section = no_section;
433 in_named_name = ggc_strdup (name);
434 in_section = in_named;
438 if (in_text_section () || in_unlikely_text_section ())
440 last_text_section = in_section;
441 last_text_section_name = name;
445 /* Tell assembler to change to section NAME for DECL.
446 If DECL is NULL, just switch to section NAME.
447 If NAME is NULL, get the name from DECL.
448 If RELOC is 1, the initializer for DECL contains relocs. */
451 named_section (tree decl, const char *name, int reloc)
455 gcc_assert (!decl || DECL_P (decl));
457 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
459 if (strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0
461 && ! cfun->unlikely_text_section_name)
462 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
464 flags = targetm.section_type_flags (decl, name, reloc);
466 /* Sanity check user variables for flag changes. Non-user
467 section flag changes will die in named_section_flags.
468 However, don't complain if SECTION_OVERRIDE is set.
469 We trust that the setter knows that it is safe to ignore
470 the default flags for this decl. */
471 if (decl && ! set_named_section_flags (name, flags))
473 flags = get_named_section_flags (name);
474 if ((flags & SECTION_OVERRIDE) == 0)
475 error ("%J%D causes a section type conflict", decl, decl);
478 named_section_real (name, flags, decl);
481 /* If required, set DECL_SECTION_NAME to a unique name. */
484 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
485 int flag_function_or_data_sections)
487 if (DECL_SECTION_NAME (decl) == NULL_TREE
488 && targetm.have_named_sections
489 && (flag_function_or_data_sections
490 || DECL_ONE_ONLY (decl)))
491 targetm.asm_out.unique_section (decl, reloc);
494 #ifdef BSS_SECTION_ASM_OP
496 /* Tell the assembler to switch to the bss section. */
501 if (in_section != in_bss)
503 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
508 #ifdef ASM_OUTPUT_BSS
510 /* Utility function for ASM_OUTPUT_BSS for targets to use if
511 they don't support alignments in .bss.
512 ??? It is believed that this function will work in most cases so such
513 support is localized here. */
516 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
518 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
519 unsigned HOST_WIDE_INT rounded)
521 targetm.asm_out.globalize_label (file, name);
523 #ifdef ASM_DECLARE_OBJECT_NAME
524 last_assemble_variable_decl = decl;
525 ASM_DECLARE_OBJECT_NAME (file, name, decl);
527 /* Standard thing is just output label for the object. */
528 ASM_OUTPUT_LABEL (file, name);
529 #endif /* ASM_DECLARE_OBJECT_NAME */
530 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
535 #ifdef ASM_OUTPUT_ALIGNED_BSS
537 /* Utility function for targets to use in implementing
538 ASM_OUTPUT_ALIGNED_BSS.
539 ??? It is believed that this function will work in most cases so such
540 support is localized here. */
543 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
544 const char *name, unsigned HOST_WIDE_INT size,
548 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
549 #ifdef ASM_DECLARE_OBJECT_NAME
550 last_assemble_variable_decl = decl;
551 ASM_DECLARE_OBJECT_NAME (file, name, decl);
553 /* Standard thing is just output label for the object. */
554 ASM_OUTPUT_LABEL (file, name);
555 #endif /* ASM_DECLARE_OBJECT_NAME */
556 ASM_OUTPUT_SKIP (file, size ? size : 1);
561 #endif /* BSS_SECTION_ASM_OP */
563 /* Switch to the section for function DECL.
565 If DECL is NULL_TREE, switch to the text section. We can be passed
566 NULL_TREE under some circumstances by dbxout.c at least. */
569 function_section (tree decl)
573 if (first_function_block_is_cold)
576 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
577 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
579 if (decl != NULL_TREE
580 && DECL_SECTION_NAME (decl) != NULL_TREE
581 && targetm.have_named_sections)
582 named_section (decl, (char *) 0, 0);
589 current_function_section (tree decl)
591 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
594 if (in_unlikely_text_section ()
595 || last_text_section == in_unlikely_executed_text)
598 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
600 if (last_text_section == in_unlikely_executed_text)
601 unlikely_text_section ();
602 else if (last_text_section == in_text)
604 else if (last_text_section == in_named
605 && targetm.have_named_sections)
606 named_section (NULL_TREE, last_text_section_name, 0);
608 function_section (decl);
612 /* Switch to read-only data section associated with function DECL. */
615 default_function_rodata_section (tree decl)
617 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
619 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
621 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
623 size_t len = strlen (name) + 3;
624 char* rname = alloca (len);
626 strcpy (rname, ".rodata");
627 strcat (rname, name + 5);
628 named_section_real (rname, SECTION_LINKONCE, decl);
631 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
632 else if (DECL_ONE_ONLY (decl)
633 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
635 size_t len = strlen (name) + 1;
636 char *rname = alloca (len);
638 memcpy (rname, name, len);
640 named_section_real (rname, SECTION_LINKONCE, decl);
643 /* For .text.foo we want to use .rodata.foo. */
644 else if (flag_function_sections && flag_data_sections
645 && strncmp (name, ".text.", 6) == 0)
647 size_t len = strlen (name) + 1;
648 char *rname = alloca (len + 2);
650 memcpy (rname, ".rodata", 7);
651 memcpy (rname + 7, name + 5, len - 5);
652 named_section_flags (rname, 0);
657 readonly_data_section ();
660 /* Switch to read-only data section associated with function DECL
661 for targets where that section should be always the single
662 readonly data section. */
665 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
667 readonly_data_section ();
670 /* Switch to section for variable DECL. RELOC is the same as the
671 argument to SELECT_SECTION. */
674 variable_section (tree decl, int reloc)
676 if (IN_NAMED_SECTION (decl))
677 named_section (decl, NULL, reloc);
679 targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
682 /* Tell assembler to switch to the section for string merging. */
685 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
686 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
687 unsigned int flags ATTRIBUTE_UNUSED)
689 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
690 && TREE_CODE (decl) == STRING_CST
691 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
693 && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
695 enum machine_mode mode;
696 unsigned int modesize;
701 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
702 modesize = GET_MODE_BITSIZE (mode);
703 if (modesize >= 8 && modesize <= 256
704 && (modesize & (modesize - 1)) == 0)
706 if (align < modesize)
709 str = TREE_STRING_POINTER (decl);
710 len = TREE_STRING_LENGTH (decl);
711 unit = GET_MODE_SIZE (mode);
713 /* Check for embedded NUL characters. */
714 for (i = 0; i < len; i += unit)
716 for (j = 0; j < unit; j++)
717 if (str[i + j] != '\0')
724 sprintf (name, ".rodata.str%d.%d", modesize / 8,
726 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
727 if (!i && modesize < align)
729 /* A "" string with requested alignment greater than
730 character size might cause a problem:
731 if some other string required even bigger
732 alignment than "", then linker might think the
733 "" is just part of padding after some other string
734 and not put it into the hash table initially.
735 But this means "" could have smaller alignment
737 #ifdef ASM_OUTPUT_SECTION_START
738 named_section_flags (name, flags);
739 ASM_OUTPUT_SECTION_START (asm_out_file);
741 readonly_data_section ();
746 named_section_flags (name, flags);
752 readonly_data_section ();
755 /* Tell assembler to switch to the section for constant merging. */
758 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
759 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
760 unsigned int flags ATTRIBUTE_UNUSED)
762 unsigned int modesize = GET_MODE_BITSIZE (mode);
764 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
770 && (align & (align - 1)) == 0)
774 sprintf (name, ".rodata.cst%d", (int) (align / 8));
775 flags |= (align / 8) | SECTION_MERGE;
776 named_section_flags (name, flags);
780 readonly_data_section ();
783 /* Given NAME, a putative register name, discard any customary prefixes. */
786 strip_reg_name (const char *name)
788 #ifdef REGISTER_PREFIX
789 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
790 name += strlen (REGISTER_PREFIX);
792 if (name[0] == '%' || name[0] == '#')
797 /* The user has asked for a DECL to have a particular name. Set (or
798 change) it in such a way that we don't prefix an underscore to
801 set_user_assembler_name (tree decl, const char *name)
803 char *starred = alloca (strlen (name) + 2);
805 strcpy (starred + 1, name);
806 change_decl_assembler_name (decl, get_identifier (starred));
807 SET_DECL_RTL (decl, NULL_RTX);
810 /* Decode an `asm' spec for a declaration as a register name.
811 Return the register number, or -1 if nothing specified,
812 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
813 or -3 if ASMSPEC is `cc' and is not recognized,
814 or -4 if ASMSPEC is `memory' and is not recognized.
815 Accept an exact spelling or a decimal number.
816 Prefixes such as % are optional. */
819 decode_reg_name (const char *asmspec)
825 /* Get rid of confusing prefixes. */
826 asmspec = strip_reg_name (asmspec);
828 /* Allow a decimal number as a "register name". */
829 for (i = strlen (asmspec) - 1; i >= 0; i--)
830 if (! ISDIGIT (asmspec[i]))
832 if (asmspec[0] != 0 && i < 0)
835 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
841 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
843 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
846 #ifdef ADDITIONAL_REGISTER_NAMES
848 static const struct { const char *const name; const int number; } table[]
849 = ADDITIONAL_REGISTER_NAMES;
851 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
852 if (! strcmp (asmspec, table[i].name))
853 return table[i].number;
855 #endif /* ADDITIONAL_REGISTER_NAMES */
857 if (!strcmp (asmspec, "memory"))
860 if (!strcmp (asmspec, "cc"))
869 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
870 have static storage duration. In other words, it should not be an
871 automatic variable, including PARM_DECLs.
873 There is, however, one exception: this function handles variables
874 explicitly placed in a particular register by the user.
876 This is never called for PARM_DECL nodes. */
879 make_decl_rtl (tree decl)
881 const char *name = 0;
885 /* Check that we are not being given an automatic variable. */
886 gcc_assert (TREE_CODE (decl) != PARM_DECL
887 && TREE_CODE (decl) != RESULT_DECL);
889 /* A weak alias has TREE_PUBLIC set but not the other bits. */
890 gcc_assert (TREE_CODE (decl) != VAR_DECL
891 || TREE_STATIC (decl)
892 || TREE_PUBLIC (decl)
893 || DECL_EXTERNAL (decl)
894 || DECL_REGISTER (decl));
896 /* And that we were not given a type or a label. */
897 gcc_assert (TREE_CODE (decl) != TYPE_DECL
898 && TREE_CODE (decl) != LABEL_DECL);
900 /* For a duplicate declaration, we can be called twice on the
901 same DECL node. Don't discard the RTL already made. */
902 if (DECL_RTL_SET_P (decl))
904 /* If the old RTL had the wrong mode, fix the mode. */
905 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
906 SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
907 DECL_MODE (decl), 0));
909 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
912 /* ??? Another way to do this would be to maintain a hashed
913 table of such critters. Instead of adding stuff to a DECL
914 to give certain attributes to it, we could use an external
915 hash map from DECL to set of attributes. */
917 /* Let the target reassign the RTL if it wants.
918 This is necessary, for example, when one machine specific
919 decl attribute overrides another. */
920 targetm.encode_section_info (decl, DECL_RTL (decl), false);
922 /* Make this function static known to the mudflap runtime. */
923 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
924 mudflap_enqueue_decl (decl);
929 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
931 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
933 reg_number = decode_reg_name (name);
934 /* First detect errors in declaring global registers. */
935 if (reg_number == -1)
936 error ("%Jregister name not specified for %qD", decl, decl);
937 else if (reg_number < 0)
938 error ("%Jinvalid register name for %qD", decl, decl);
939 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
940 error ("%Jdata type of %qD isn%'t suitable for a register",
942 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
943 error ("%Jregister specified for %qD isn%'t suitable for data type",
945 /* Now handle properly declared static register variables. */
950 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
952 DECL_INITIAL (decl) = 0;
953 error ("global register variable has initial value");
955 if (TREE_THIS_VOLATILE (decl))
956 warning (0, "volatile register variables don%'t "
957 "work as you might wish");
959 /* If the user specified one of the eliminables registers here,
960 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
961 confused with that register and be eliminated. This usage is
962 somewhat suspect... */
964 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
965 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
966 REG_USERVAR_P (DECL_RTL (decl)) = 1;
968 if (TREE_STATIC (decl))
970 /* Make this register global, so not usable for anything
972 #ifdef ASM_DECLARE_REGISTER_GLOBAL
973 name = IDENTIFIER_POINTER (DECL_NAME (decl));
974 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
976 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
978 globalize_reg (reg_number + --nregs);
981 /* As a register variable, it has no section. */
985 /* Now handle ordinary static variables and functions (in memory).
986 Also handle vars declared register invalidly. */
987 else if (name[0] == '*')
989 #ifdef REGISTER_PREFIX
990 if (strlen (REGISTER_PREFIX) != 0)
992 reg_number = decode_reg_name (name);
993 if (reg_number >= 0 || reg_number == -3)
994 error ("%Jregister name given for non-register variable %qD", decl, decl);
999 /* Specifying a section attribute on a variable forces it into a
1000 non-.bss section, and thus it cannot be common. */
1001 if (TREE_CODE (decl) == VAR_DECL
1002 && DECL_SECTION_NAME (decl) != NULL_TREE
1003 && DECL_INITIAL (decl) == NULL_TREE
1004 && DECL_COMMON (decl))
1005 DECL_COMMON (decl) = 0;
1007 /* Variables can't be both common and weak. */
1008 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1009 DECL_COMMON (decl) = 0;
1011 x = gen_rtx_SYMBOL_REF (Pmode, name);
1012 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1013 SYMBOL_REF_DECL (x) = decl;
1015 x = gen_rtx_MEM (DECL_MODE (decl), x);
1016 if (TREE_CODE (decl) != FUNCTION_DECL)
1017 set_mem_attributes (x, decl, 1);
1018 SET_DECL_RTL (decl, x);
1020 /* Optionally set flags or add text to the name to record information
1021 such as that it is a function name.
1022 If the name is changed, the macro ASM_OUTPUT_LABELREF
1023 will have to know how to strip this information. */
1024 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1026 /* Make this function static known to the mudflap runtime. */
1027 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1028 mudflap_enqueue_decl (decl);
1031 /* Make the rtl for variable VAR be volatile.
1032 Use this only for static variables. */
1035 make_var_volatile (tree var)
1037 gcc_assert (MEM_P (DECL_RTL (var)));
1039 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1042 /* Output a string of literal assembler code
1043 for an `asm' keyword used between functions. */
1046 assemble_asm (tree string)
1050 if (TREE_CODE (string) == ADDR_EXPR)
1051 string = TREE_OPERAND (string, 0);
1053 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1056 /* Record an element in the table of global destructors. SYMBOL is
1057 a SYMBOL_REF of the function to be called; PRIORITY is a number
1058 between 0 and MAX_INIT_PRIORITY. */
1061 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1062 int priority ATTRIBUTE_UNUSED)
1064 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1065 /* Tell GNU LD that this is part of the static destructor set.
1066 This will work for any system that uses stabs, most usefully
1068 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1069 dbxout_stab_value_label (XSTR (symbol, 0));
1071 sorry ("global destructors not supported on this target");
1076 default_named_section_asm_out_destructor (rtx symbol, int priority)
1078 const char *section = ".dtors";
1081 /* ??? This only works reliably with the GNU linker. */
1082 if (priority != DEFAULT_INIT_PRIORITY)
1084 sprintf (buf, ".dtors.%.5u",
1085 /* Invert the numbering so the linker puts us in the proper
1086 order; constructors are run from right to left, and the
1087 linker sorts in increasing order. */
1088 MAX_INIT_PRIORITY - priority);
1092 named_section_flags (section, SECTION_WRITE);
1093 assemble_align (POINTER_SIZE);
1094 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1097 #ifdef DTORS_SECTION_ASM_OP
1099 dtors_section (void)
1101 if (in_section != in_dtors)
1103 in_section = in_dtors;
1104 fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1105 fputc ('\n', asm_out_file);
1110 default_dtor_section_asm_out_destructor (rtx symbol,
1111 int priority ATTRIBUTE_UNUSED)
1114 assemble_align (POINTER_SIZE);
1115 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1119 /* Likewise for global constructors. */
1122 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1123 int priority ATTRIBUTE_UNUSED)
1125 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1126 /* Tell GNU LD that this is part of the static destructor set.
1127 This will work for any system that uses stabs, most usefully
1129 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1130 dbxout_stab_value_label (XSTR (symbol, 0));
1132 sorry ("global constructors not supported on this target");
1137 default_named_section_asm_out_constructor (rtx symbol, int priority)
1139 const char *section = ".ctors";
1142 /* ??? This only works reliably with the GNU linker. */
1143 if (priority != DEFAULT_INIT_PRIORITY)
1145 sprintf (buf, ".ctors.%.5u",
1146 /* Invert the numbering so the linker puts us in the proper
1147 order; constructors are run from right to left, and the
1148 linker sorts in increasing order. */
1149 MAX_INIT_PRIORITY - priority);
1153 named_section_flags (section, SECTION_WRITE);
1154 assemble_align (POINTER_SIZE);
1155 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1158 #ifdef CTORS_SECTION_ASM_OP
1160 ctors_section (void)
1162 if (in_section != in_ctors)
1164 in_section = in_ctors;
1165 fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1166 fputc ('\n', asm_out_file);
1171 default_ctor_section_asm_out_constructor (rtx symbol,
1172 int priority ATTRIBUTE_UNUSED)
1175 assemble_align (POINTER_SIZE);
1176 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1180 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1181 a nonzero value if the constant pool should be output before the
1182 start of the function, or a zero value if the pool should output
1183 after the end of the function. The default is to put it before the
1186 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1187 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1190 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1191 to be output to assembler.
1192 Set first_global_object_name and weak_global_object_name as appropriate. */
1195 notice_global_symbol (tree decl)
1197 const char **type = &first_global_object_name;
1199 if (first_global_object_name
1200 || !TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
1201 || !DECL_NAME (decl)
1202 || (TREE_CODE (decl) != FUNCTION_DECL
1203 && (TREE_CODE (decl) != VAR_DECL
1204 || (DECL_COMMON (decl)
1205 && (DECL_INITIAL (decl) == 0
1206 || DECL_INITIAL (decl) == error_mark_node))))
1207 || !MEM_P (DECL_RTL (decl)))
1210 /* We win when global object is found, but it is useful to know about weak
1211 symbol as well so we can produce nicer unique names. */
1212 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1213 type = &weak_global_object_name;
1219 rtx decl_rtl = DECL_RTL (decl);
1221 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1228 /* Output assembler code for the constant pool of a function and associated
1229 with defining the name of the function. DECL describes the function.
1230 NAME is the function's name. For the constant pool, we use the current
1231 constant pool data. */
1234 assemble_start_function (tree decl, const char *fnname)
1237 char tmp_label[100];
1238 bool hot_label_written = false;
1240 cfun->unlikely_text_section_name = NULL;
1242 first_function_block_is_cold = false;
1243 if (flag_reorder_blocks_and_partition)
1245 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "HOTB", const_labelno);
1246 cfun->hot_section_label = ggc_strdup (tmp_label);
1247 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "COLDB", const_labelno);
1248 cfun->cold_section_label = ggc_strdup (tmp_label);
1249 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "HOTE", const_labelno);
1250 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1251 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "COLDE", const_labelno);
1252 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1257 cfun->hot_section_label = NULL;
1258 cfun->cold_section_label = NULL;
1259 cfun->hot_section_end_label = NULL;
1260 cfun->cold_section_end_label = NULL;
1263 /* The following code does not need preprocessing in the assembler. */
1267 if (CONSTANT_POOL_BEFORE_FUNCTION)
1268 output_constant_pool (fnname, decl);
1270 /* Make sure the not and cold text (code) sections are properly
1271 aligned. This is necessary here in the case where the function
1272 has both hot and cold sections, because we don't want to re-set
1273 the alignment when the section switch happens mid-function. */
1275 if (flag_reorder_blocks_and_partition)
1277 unlikely_text_section ();
1278 assemble_align (FUNCTION_BOUNDARY);
1279 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1280 if (BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1282 /* Since the function starts with a cold section, we need to
1283 explicitly align the hot section and write out the hot
1286 assemble_align (FUNCTION_BOUNDARY);
1287 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1288 hot_label_written = true;
1289 first_function_block_is_cold = true;
1292 else if (DECL_SECTION_NAME (decl))
1294 /* Calls to function_section rely on first_function_block_is_cold
1295 being accurate. The first block may be cold even if we aren't
1296 doing partitioning, if the entire function was decided by
1297 choose_function_section (predict.c) to be cold. */
1303 initialize_cold_section_name ();
1305 /* The following is necessary, because 'strcmp
1306 (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), blah)' always
1307 fails, presumably because TREE_STRING_POINTER is declared to
1308 be an array of size 1 of char. */
1310 len = TREE_STRING_LENGTH (DECL_SECTION_NAME (decl));
1311 s = (char *) xmalloc (len + 1);
1313 for (i = 0; i < len; i ++)
1314 s[i] = (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)))[i];
1317 if (cfun->unlikely_text_section_name
1318 && (strcmp (s, cfun->unlikely_text_section_name) == 0))
1319 first_function_block_is_cold = true;
1322 last_text_section = no_section;
1323 resolve_unique_section (decl, 0, flag_function_sections);
1325 /* Switch to the correct text section for the start of the function. */
1327 function_section (decl);
1328 if (flag_reorder_blocks_and_partition
1329 && !hot_label_written)
1330 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1332 /* Tell assembler to move to target machine's alignment for functions. */
1333 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1334 if (align < force_align_functions_log)
1335 align = force_align_functions_log;
1338 ASM_OUTPUT_ALIGN (asm_out_file, align);
1341 /* Handle a user-specified function alignment.
1342 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1343 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1344 if (align_functions_log > align
1345 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1347 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1348 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1349 align_functions_log, align_functions - 1);
1351 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1355 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1356 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1359 (*debug_hooks->begin_function) (decl);
1361 /* Make function name accessible from other files, if appropriate. */
1363 if (TREE_PUBLIC (decl))
1365 notice_global_symbol (decl);
1367 globalize_decl (decl);
1369 maybe_assemble_visibility (decl);
1372 if (DECL_PRESERVE_P (decl))
1373 targetm.asm_out.mark_decl_preserved (fnname);
1375 /* Do any machine/system dependent processing of the function name. */
1376 #ifdef ASM_DECLARE_FUNCTION_NAME
1377 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1379 /* Standard thing is just output label for the function. */
1380 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1381 #endif /* ASM_DECLARE_FUNCTION_NAME */
1383 insert_section_boundary_note ();
1386 /* Output assembler code associated with defining the size of the
1387 function. DECL describes the function. NAME is the function's name. */
1390 assemble_end_function (tree decl, const char *fnname)
1392 #ifdef ASM_DECLARE_FUNCTION_SIZE
1393 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1395 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1397 output_constant_pool (fnname, decl);
1398 function_section (decl); /* need to switch back */
1400 /* Output labels for end of hot/cold text sections (to be used by
1402 if (flag_reorder_blocks_and_partition)
1404 enum in_section save_text_section;
1406 save_text_section = in_section;
1407 unlikely_text_section ();
1408 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1410 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1411 if (save_text_section == in_unlikely_executed_text)
1412 unlikely_text_section ();
1416 /* Assemble code to leave SIZE bytes of zeros. */
1419 assemble_zeros (unsigned HOST_WIDE_INT size)
1421 /* Do no output if -fsyntax-only. */
1422 if (flag_syntax_only)
1425 #ifdef ASM_NO_SKIP_IN_TEXT
1426 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1427 so we must output 0s explicitly in the text section. */
1428 if ((ASM_NO_SKIP_IN_TEXT && in_text_section ())
1429 || (ASM_NO_SKIP_IN_TEXT && in_unlikely_text_section ()))
1431 unsigned HOST_WIDE_INT i;
1432 for (i = 0; i < size; i++)
1433 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1438 ASM_OUTPUT_SKIP (asm_out_file, size);
1441 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1444 assemble_align (int align)
1446 if (align > BITS_PER_UNIT)
1448 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1452 /* Assemble a string constant with the specified C string as contents. */
1455 assemble_string (const char *p, int size)
1460 /* If the string is very long, split it up. */
1464 int thissize = size - pos;
1465 if (thissize > maximum)
1468 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1476 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1477 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1478 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1480 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1481 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1482 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1484 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1485 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1489 #if defined ASM_OUTPUT_ALIGNED_BSS
1490 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1491 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1493 #if defined ASM_OUTPUT_BSS
1494 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1495 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1501 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1502 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1503 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1505 #if defined ASM_OUTPUT_ALIGNED_COMMON
1506 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1507 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1509 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1510 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1515 asm_emit_uninitialised (tree decl, const char *name,
1516 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1517 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1525 destination = asm_dest_local;
1527 /* ??? We should handle .bss via select_section mechanisms rather than
1528 via special target hooks. That would eliminate this special case. */
1529 if (TREE_PUBLIC (decl))
1531 if (!DECL_COMMON (decl))
1533 destination = asm_dest_bss;
1538 destination = asm_dest_common;
1541 if (destination != asm_dest_common)
1543 resolve_unique_section (decl, 0, flag_data_sections);
1544 /* Custom sections don't belong here. */
1545 if (DECL_SECTION_NAME (decl))
1549 if (destination == asm_dest_bss)
1550 globalize_decl (decl);
1552 if (flag_shared_data)
1554 switch (destination)
1556 #ifdef ASM_OUTPUT_SHARED_BSS
1558 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1561 #ifdef ASM_OUTPUT_SHARED_COMMON
1562 case asm_dest_common:
1563 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1566 #ifdef ASM_OUTPUT_SHARED_LOCAL
1567 case asm_dest_local:
1568 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1576 switch (destination)
1580 ASM_EMIT_BSS (decl, name, size, rounded);
1583 case asm_dest_common:
1584 ASM_EMIT_COMMON (decl, name, size, rounded);
1586 case asm_dest_local:
1587 ASM_EMIT_LOCAL (decl, name, size, rounded);
1596 /* Assemble everything that is needed for a variable or function declaration.
1597 Not used for automatic variables, and not used for function definitions.
1598 Should not be called for variables of incomplete structure type.
1600 TOP_LEVEL is nonzero if this variable has file scope.
1601 AT_END is nonzero if this is the special handling, at end of compilation,
1602 to define things that have had only tentative definitions.
1603 DONT_OUTPUT_DATA if nonzero means don't actually output the
1604 initial value (that will be done by the caller). */
1607 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1608 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1615 if (lang_hooks.decls.prepare_assemble_variable)
1616 lang_hooks.decls.prepare_assemble_variable (decl);
1618 last_assemble_variable_decl = 0;
1620 /* Normally no need to say anything here for external references,
1621 since assemble_external is called by the language-specific code
1622 when a declaration is first seen. */
1624 if (DECL_EXTERNAL (decl))
1627 /* Output no assembler code for a function declaration.
1628 Only definitions of functions output anything. */
1630 if (TREE_CODE (decl) == FUNCTION_DECL)
1633 /* Do nothing for global register variables. */
1634 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1636 TREE_ASM_WRITTEN (decl) = 1;
1640 /* If type was incomplete when the variable was declared,
1641 see if it is complete now. */
1643 if (DECL_SIZE (decl) == 0)
1644 layout_decl (decl, 0);
1646 /* Still incomplete => don't allocate it; treat the tentative defn
1647 (which is what it must have been) as an `extern' reference. */
1649 if (!dont_output_data && DECL_SIZE (decl) == 0)
1651 error ("%Jstorage size of %qD isn%'t known", decl, decl);
1652 TREE_ASM_WRITTEN (decl) = 1;
1656 /* The first declaration of a variable that comes through this function
1657 decides whether it is global (in C, has external linkage)
1658 or local (in C, has internal linkage). So do nothing more
1659 if this function has already run. */
1661 if (TREE_ASM_WRITTEN (decl))
1664 /* Make sure targetm.encode_section_info is invoked before we set
1666 decl_rtl = DECL_RTL (decl);
1668 TREE_ASM_WRITTEN (decl) = 1;
1670 /* Do no output if -fsyntax-only. */
1671 if (flag_syntax_only)
1676 if (! dont_output_data
1677 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1679 error ("%Jsize of variable %qD is too large", decl, decl);
1683 name = XSTR (XEXP (decl_rtl, 0), 0);
1684 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1685 notice_global_symbol (decl);
1687 /* Compute the alignment of this data. */
1689 align = DECL_ALIGN (decl);
1691 /* In the case for initialing an array whose length isn't specified,
1692 where we have not yet been able to do the layout,
1693 figure out the proper alignment now. */
1694 if (dont_output_data && DECL_SIZE (decl) == 0
1695 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1696 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1698 /* Some object file formats have a maximum alignment which they support.
1699 In particular, a.out format supports a maximum alignment of 4. */
1700 if (align > MAX_OFILE_ALIGNMENT)
1702 warning (0, "%Jalignment of %qD is greater than maximum object "
1703 "file alignment. Using %d", decl, decl,
1704 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1705 align = MAX_OFILE_ALIGNMENT;
1708 /* On some machines, it is good to increase alignment sometimes. */
1709 if (! DECL_USER_ALIGN (decl))
1711 #ifdef DATA_ALIGNMENT
1712 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1714 #ifdef CONSTANT_ALIGNMENT
1715 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1716 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1720 /* Reset the alignment in case we have made it tighter, so we can benefit
1721 from it in get_pointer_alignment. */
1722 DECL_ALIGN (decl) = align;
1723 set_mem_align (decl_rtl, align);
1725 if (TREE_PUBLIC (decl))
1726 maybe_assemble_visibility (decl);
1728 if (DECL_PRESERVE_P (decl))
1729 targetm.asm_out.mark_decl_preserved (name);
1731 /* Handle uninitialized definitions. */
1733 /* If the decl has been given an explicit section name, then it
1734 isn't common, and shouldn't be handled as such. */
1735 if (DECL_SECTION_NAME (decl) || dont_output_data)
1737 /* We don't implement common thread-local data at present. */
1738 else if (DECL_THREAD_LOCAL (decl))
1740 if (DECL_COMMON (decl))
1741 sorry ("thread-local COMMON data not implemented");
1743 else if (DECL_INITIAL (decl) == 0
1744 || DECL_INITIAL (decl) == error_mark_node
1745 || (flag_zero_initialized_in_bss
1746 /* Leave constant zeroes in .rodata so they can be shared. */
1747 && !TREE_READONLY (decl)
1748 && initializer_zerop (DECL_INITIAL (decl))))
1750 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1751 unsigned HOST_WIDE_INT rounded = size;
1753 /* Don't allocate zero bytes of common,
1754 since that means "undefined external" in the linker. */
1758 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1759 so that each uninitialized object starts on such a boundary. */
1760 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1761 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1762 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1764 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1765 if ((unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1766 warning (0, "%Jrequested alignment for %qD is greater than "
1767 "implemented alignment of %d", decl, decl, rounded);
1770 /* If the target cannot output uninitialized but not common global data
1771 in .bss, then we have to use .data, so fall through. */
1772 if (asm_emit_uninitialised (decl, name, size, rounded))
1776 /* Handle initialized definitions.
1777 Also handle uninitialized global definitions if -fno-common and the
1778 target doesn't support ASM_OUTPUT_BSS. */
1780 /* First make the assembler name(s) global if appropriate. */
1781 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1782 globalize_decl (decl);
1784 /* Output any data that we will need to use the address of. */
1785 if (DECL_INITIAL (decl) == error_mark_node)
1786 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1787 else if (DECL_INITIAL (decl))
1789 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1790 output_addressed_constants (DECL_INITIAL (decl));
1793 /* Switch to the appropriate section. */
1794 resolve_unique_section (decl, reloc, flag_data_sections);
1795 variable_section (decl, reloc);
1797 /* dbxout.c needs to know this. */
1798 if (in_text_section () || in_unlikely_text_section ())
1799 DECL_IN_TEXT_SECTION (decl) = 1;
1801 /* Output the alignment of this data. */
1802 if (align > BITS_PER_UNIT)
1803 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1805 /* Do any machine/system dependent processing of the object. */
1806 #ifdef ASM_DECLARE_OBJECT_NAME
1807 last_assemble_variable_decl = decl;
1808 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1810 /* Standard thing is just output label for the object. */
1811 ASM_OUTPUT_LABEL (asm_out_file, name);
1812 #endif /* ASM_DECLARE_OBJECT_NAME */
1814 if (!dont_output_data)
1816 if (DECL_INITIAL (decl)
1817 && DECL_INITIAL (decl) != error_mark_node
1818 && !initializer_zerop (DECL_INITIAL (decl)))
1819 /* Output the actual data. */
1820 output_constant (DECL_INITIAL (decl),
1821 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1824 /* Leave space for it. */
1825 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1829 /* Return 1 if type TYPE contains any pointers. */
1832 contains_pointers_p (tree type)
1834 switch (TREE_CODE (type))
1837 case REFERENCE_TYPE:
1838 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1839 so I'll play safe and return 1. */
1845 case QUAL_UNION_TYPE:
1848 /* For a type that has fields, see if the fields have pointers. */
1849 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1850 if (TREE_CODE (fields) == FIELD_DECL
1851 && contains_pointers_p (TREE_TYPE (fields)))
1857 /* An array type contains pointers if its element type does. */
1858 return contains_pointers_p (TREE_TYPE (type));
1865 /* In unit-at-a-time mode, we delay assemble_external processing until
1866 the compilation unit is finalized. This is the best we can do for
1867 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1868 it all the way to final. See PR 17982 for further discussion. */
1869 static GTY(()) tree pending_assemble_externals;
1871 #ifdef ASM_OUTPUT_EXTERNAL
1872 /* True if DECL is a function decl for which no out-of-line copy exists.
1873 It is assumed that DECL's assembler name has been set. */
1876 incorporeal_function_p (tree decl)
1878 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1882 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1883 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1886 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1887 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1893 /* Actually do the tests to determine if this is necessary, and invoke
1894 ASM_OUTPUT_EXTERNAL. */
1896 assemble_external_real (tree decl)
1898 rtx rtl = DECL_RTL (decl);
1900 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1901 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1902 && !incorporeal_function_p (decl))
1904 /* Some systems do require some output. */
1905 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1906 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1912 process_pending_assemble_externals (void)
1914 #ifdef ASM_OUTPUT_EXTERNAL
1916 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1917 assemble_external_real (TREE_VALUE (list));
1919 pending_assemble_externals = 0;
1923 /* Output something to declare an external symbol to the assembler.
1924 (Most assemblers don't need this, so we normally output nothing.)
1925 Do nothing if DECL is not external. */
1928 assemble_external (tree decl ATTRIBUTE_UNUSED)
1930 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1931 main body of this code is only rarely exercised. To provide some
1932 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1933 open. If it's not, we should not be calling this function. */
1934 gcc_assert (asm_out_file);
1936 #ifdef ASM_OUTPUT_EXTERNAL
1937 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1940 if (flag_unit_at_a_time)
1941 pending_assemble_externals = tree_cons (0, decl,
1942 pending_assemble_externals);
1944 assemble_external_real (decl);
1948 /* Similar, for calling a library function FUN. */
1951 assemble_external_libcall (rtx fun)
1953 /* Declare library function name external when first used, if nec. */
1954 if (! SYMBOL_REF_USED (fun))
1956 SYMBOL_REF_USED (fun) = 1;
1957 targetm.asm_out.external_libcall (fun);
1961 /* Assemble a label named NAME. */
1964 assemble_label (const char *name)
1966 ASM_OUTPUT_LABEL (asm_out_file, name);
1969 /* Set the symbol_referenced flag for ID. */
1971 mark_referenced (tree id)
1973 TREE_SYMBOL_REFERENCED (id) = 1;
1976 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1978 mark_decl_referenced (tree decl)
1980 if (TREE_CODE (decl) == FUNCTION_DECL)
1982 /* Extern inline functions don't become needed when referenced.
1983 If we know a method will be emitted in other TU and no new
1984 functions can be marked reachable, just use the external
1986 struct cgraph_node *node = cgraph_node (decl);
1987 if (!DECL_EXTERNAL (decl)
1988 && (!node->local.vtable_method || !cgraph_global_info_ready
1989 || !node->local.finalized))
1990 cgraph_mark_needed_node (node);
1992 else if (TREE_CODE (decl) == VAR_DECL)
1994 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
1995 cgraph_varpool_mark_needed_node (node);
1996 /* C++ frontend use mark_decl_references to force COMDAT variables
1997 to be output that might appear dead otherwise. */
1998 node->force_output = true;
2000 /* else do nothing - we can get various sorts of CST nodes here,
2001 which do not need to be marked. */
2004 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2005 starts with a *, the rest of NAME is output verbatim. Otherwise
2006 NAME is transformed in a target-specific way (usually by the
2007 addition of an underscore). */
2010 assemble_name_raw (FILE *file, const char *name)
2013 fputs (&name[1], file);
2015 ASM_OUTPUT_LABELREF (file, name);
2018 /* Like assemble_name_raw, but should be used when NAME might refer to
2019 an entity that is also represented as a tree (like a function or
2020 variable). If NAME does refer to such an entity, that entity will
2021 be marked as referenced. */
2024 assemble_name (FILE *file, const char *name)
2026 const char *real_name;
2029 real_name = targetm.strip_name_encoding (name);
2031 id = maybe_get_identifier (real_name);
2033 mark_referenced (id);
2035 assemble_name_raw (file, name);
2038 /* Allocate SIZE bytes writable static space with a gensym name
2039 and return an RTX to refer to its address. */
2042 assemble_static_space (unsigned HOST_WIDE_INT size)
2045 const char *namestring;
2049 if (flag_shared_data)
2053 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2055 namestring = ggc_strdup (name);
2057 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2058 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2060 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2061 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2064 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2065 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2068 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2069 so that each uninitialized object starts on such a boundary. */
2070 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2071 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2072 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2073 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2074 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2075 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2082 /* Assemble the static constant template for function entry trampolines.
2083 This is done at most once per compilation.
2084 Returns an RTX for the address of the template. */
2086 static GTY(()) rtx initial_trampoline;
2088 #ifdef TRAMPOLINE_TEMPLATE
2090 assemble_trampoline_template (void)
2097 if (initial_trampoline)
2098 return initial_trampoline;
2100 /* By default, put trampoline templates in read-only data section. */
2102 #ifdef TRAMPOLINE_SECTION
2103 TRAMPOLINE_SECTION ();
2105 readonly_data_section ();
2108 /* Write the assembler code to define one. */
2109 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2112 ASM_OUTPUT_ALIGN (asm_out_file, align);
2115 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2116 TRAMPOLINE_TEMPLATE (asm_out_file);
2118 /* Record the rtl to refer to it. */
2119 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2120 name = ggc_strdup (label);
2121 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2122 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2124 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2125 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2127 return initial_trampoline;
2131 /* A and B are either alignments or offsets. Return the minimum alignment
2132 that may be assumed after adding the two together. */
2134 static inline unsigned
2135 min_align (unsigned int a, unsigned int b)
2137 return (a | b) & -(a | b);
2140 /* Return the assembler directive for creating a given kind of integer
2141 object. SIZE is the number of bytes in the object and ALIGNED_P
2142 indicates whether it is known to be aligned. Return NULL if the
2143 assembly dialect has no such directive.
2145 The returned string should be printed at the start of a new line and
2146 be followed immediately by the object's initial value. */
2149 integer_asm_op (int size, int aligned_p)
2151 struct asm_int_op *ops;
2154 ops = &targetm.asm_out.aligned_op;
2156 ops = &targetm.asm_out.unaligned_op;
2161 return targetm.asm_out.byte_op;
2175 /* Use directive OP to assemble an integer object X. Print OP at the
2176 start of the line, followed immediately by the value of X. */
2179 assemble_integer_with_op (const char *op, rtx x)
2181 fputs (op, asm_out_file);
2182 output_addr_const (asm_out_file, x);
2183 fputc ('\n', asm_out_file);
2186 /* The default implementation of the asm_out.integer target hook. */
2189 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2190 unsigned int size ATTRIBUTE_UNUSED,
2191 int aligned_p ATTRIBUTE_UNUSED)
2193 const char *op = integer_asm_op (size, aligned_p);
2194 /* Avoid GAS bugs for large values. Specifically negative values whose
2195 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2196 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2198 return op && (assemble_integer_with_op (op, x), true);
2201 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2202 the alignment of the integer in bits. Return 1 if we were able to output
2203 the constant, otherwise 0. We must be able to output the constant,
2204 if FORCE is nonzero. */
2207 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2211 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2213 /* See if the target hook can handle this kind of object. */
2214 if (targetm.asm_out.integer (x, size, aligned_p))
2217 /* If the object is a multi-byte one, try splitting it up. Split
2218 it into words it if is multi-word, otherwise split it into bytes. */
2221 enum machine_mode omode, imode;
2222 unsigned int subalign;
2223 unsigned int subsize, i;
2225 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2226 subalign = MIN (align, subsize * BITS_PER_UNIT);
2227 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2228 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2230 for (i = 0; i < size; i += subsize)
2232 rtx partial = simplify_subreg (omode, x, imode, i);
2233 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2239 /* If we've printed some of it, but not all of it, there's no going
2244 gcc_assert (!force);
2250 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2254 int bitsize, nelts, nunits, units_per;
2256 /* This is hairy. We have a quantity of known size. real_to_target
2257 will put it into an array of *host* longs, 32 bits per element
2258 (even if long is more than 32 bits). We need to determine the
2259 number of array elements that are occupied (nelts) and the number
2260 of *target* min-addressable units that will be occupied in the
2261 object file (nunits). We cannot assume that 32 divides the
2262 mode's bitsize (size * BITS_PER_UNIT) evenly.
2264 size * BITS_PER_UNIT is used here to make sure that padding bits
2265 (which might appear at either end of the value; real_to_target
2266 will include the padding bits in its output array) are included. */
2268 nunits = GET_MODE_SIZE (mode);
2269 bitsize = nunits * BITS_PER_UNIT;
2270 nelts = CEIL (bitsize, 32);
2271 units_per = 32 / BITS_PER_UNIT;
2273 real_to_target (data, &d, mode);
2275 /* Put out the first word with the specified alignment. */
2276 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2277 nunits -= units_per;
2279 /* Subsequent words need only 32-bit alignment. */
2280 align = min_align (align, 32);
2282 for (i = 1; i < nelts; i++)
2284 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2285 nunits -= units_per;
2289 /* Given an expression EXP with a constant value,
2290 reduce it to the sum of an assembler symbol and an integer.
2291 Store them both in the structure *VALUE.
2292 EXP must be reducible. */
2294 struct addr_const GTY(())
2297 HOST_WIDE_INT offset;
2301 decode_addr_const (tree exp, struct addr_const *value)
2303 tree target = TREE_OPERAND (exp, 0);
2309 if (TREE_CODE (target) == COMPONENT_REF
2310 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2313 offset += int_byte_position (TREE_OPERAND (target, 1));
2314 target = TREE_OPERAND (target, 0);
2316 else if (TREE_CODE (target) == ARRAY_REF
2317 || TREE_CODE (target) == ARRAY_RANGE_REF)
2319 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2320 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2321 target = TREE_OPERAND (target, 0);
2327 switch (TREE_CODE (target))
2331 x = DECL_RTL (target);
2335 x = gen_rtx_MEM (FUNCTION_MODE,
2336 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2344 x = output_constant_def (target, 1);
2351 gcc_assert (MEM_P (x));
2355 value->offset = offset;
2358 /* Uniquize all constants that appear in memory.
2359 Each constant in memory thus far output is recorded
2360 in `const_desc_table'. */
2362 struct constant_descriptor_tree GTY(())
2364 /* A MEM for the constant. */
2367 /* The value of the constant. */
2371 static GTY((param_is (struct constant_descriptor_tree)))
2372 htab_t const_desc_htab;
2374 static struct constant_descriptor_tree * build_constant_desc (tree);
2375 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2377 /* Compute a hash code for a constant expression. */
2380 const_desc_hash (const void *ptr)
2382 return const_hash_1 (((struct constant_descriptor_tree *)ptr)->value);
2386 const_hash_1 (const tree exp)
2391 enum tree_code code = TREE_CODE (exp);
2393 /* Either set P and LEN to the address and len of something to hash and
2394 exit the switch or return a value. */
2399 p = (char *) &TREE_INT_CST (exp);
2400 len = sizeof TREE_INT_CST (exp);
2404 return real_hash (TREE_REAL_CST_PTR (exp));
2407 p = TREE_STRING_POINTER (exp);
2408 len = TREE_STRING_LENGTH (exp);
2412 return (const_hash_1 (TREE_REALPART (exp)) * 5
2413 + const_hash_1 (TREE_IMAGPART (exp)));
2419 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2421 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2422 if (TREE_VALUE (link))
2423 hi = hi * 603 + const_hash_1 (TREE_VALUE (link));
2431 struct addr_const value;
2433 decode_addr_const (exp, &value);
2434 switch (GET_CODE (value.base))
2437 /* Don't hash the address of the SYMBOL_REF;
2438 only use the offset and the symbol name. */
2440 p = XSTR (value.base, 0);
2441 for (i = 0; p[i] != 0; i++)
2442 hi = ((hi * 613) + (unsigned) (p[i]));
2446 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2457 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2458 + const_hash_1 (TREE_OPERAND (exp, 1)));
2462 case NON_LVALUE_EXPR:
2463 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2466 /* A language specific constant. Just hash the code. */
2470 /* Compute hashing function. */
2472 for (i = 0; i < len; i++)
2473 hi = ((hi * 613) + (unsigned) (p[i]));
2478 /* Wrapper of compare_constant, for the htab interface. */
2480 const_desc_eq (const void *p1, const void *p2)
2482 return compare_constant (((struct constant_descriptor_tree *)p1)->value,
2483 ((struct constant_descriptor_tree *)p2)->value);
2486 /* Compare t1 and t2, and return 1 only if they are known to result in
2487 the same bit pattern on output. */
2490 compare_constant (const tree t1, const tree t2)
2492 enum tree_code typecode;
2494 if (t1 == NULL_TREE)
2495 return t2 == NULL_TREE;
2496 if (t2 == NULL_TREE)
2499 if (TREE_CODE (t1) != TREE_CODE (t2))
2502 switch (TREE_CODE (t1))
2505 /* Integer constants are the same only if the same width of type. */
2506 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2508 return tree_int_cst_equal (t1, t2);
2511 /* Real constants are the same only if the same width of type. */
2512 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2515 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2518 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2521 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2522 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2523 TREE_STRING_LENGTH (t1)));
2526 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2527 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2533 typecode = TREE_CODE (TREE_TYPE (t1));
2534 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2537 if (typecode == ARRAY_TYPE)
2539 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2540 /* For arrays, check that the sizes all match. */
2541 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2543 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2548 /* For record and union constructors, require exact type
2550 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2554 for (l1 = CONSTRUCTOR_ELTS (t1), l2 = CONSTRUCTOR_ELTS (t2);
2556 l1 = TREE_CHAIN (l1), l2 = TREE_CHAIN (l2))
2558 /* Check that each value is the same... */
2559 if (! compare_constant (TREE_VALUE (l1), TREE_VALUE (l2)))
2561 /* ... and that they apply to the same fields! */
2562 if (typecode == ARRAY_TYPE)
2564 if (! compare_constant (TREE_PURPOSE (l1),
2570 if (TREE_PURPOSE (l1) != TREE_PURPOSE (l2))
2575 return l1 == NULL_TREE && l2 == NULL_TREE;
2581 struct addr_const value1, value2;
2583 decode_addr_const (t1, &value1);
2584 decode_addr_const (t2, &value2);
2585 return (value1.offset == value2.offset
2586 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2592 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2593 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2597 case NON_LVALUE_EXPR:
2598 case VIEW_CONVERT_EXPR:
2599 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2604 nt1 = lang_hooks.expand_constant (t1);
2605 nt2 = lang_hooks.expand_constant (t2);
2606 if (nt1 != t1 || nt2 != t2)
2607 return compare_constant (nt1, nt2);
2616 /* Make a copy of the whole tree structure for a constant. This
2617 handles the same types of nodes that compare_constant handles. */
2620 copy_constant (tree exp)
2622 switch (TREE_CODE (exp))
2625 /* For ADDR_EXPR, we do not want to copy the decl whose address
2626 is requested. We do want to copy constants though. */
2627 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2628 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2629 copy_constant (TREE_OPERAND (exp, 0)));
2631 return copy_node (exp);
2636 return copy_node (exp);
2639 return build_complex (TREE_TYPE (exp),
2640 copy_constant (TREE_REALPART (exp)),
2641 copy_constant (TREE_IMAGPART (exp)));
2645 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2646 copy_constant (TREE_OPERAND (exp, 0)),
2647 copy_constant (TREE_OPERAND (exp, 1)));
2651 case NON_LVALUE_EXPR:
2652 case VIEW_CONVERT_EXPR:
2653 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2654 copy_constant (TREE_OPERAND (exp, 0)));
2658 tree copy = copy_node (exp);
2659 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2662 CONSTRUCTOR_ELTS (copy) = list;
2663 for (tail = list; tail; tail = TREE_CHAIN (tail))
2664 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2671 tree t = lang_hooks.expand_constant (exp);
2673 gcc_assert (t == exp);
2674 return copy_constant (t);
2679 /* Subroutine of output_constant_def:
2680 No constant equal to EXP is known to have been output.
2681 Make a constant descriptor to enter EXP in the hash table.
2682 Assign the label number and construct RTL to refer to the
2683 constant's location in memory.
2684 Caller is responsible for updating the hash table. */
2686 static struct constant_descriptor_tree *
2687 build_constant_desc (tree exp)
2693 struct constant_descriptor_tree *desc;
2695 desc = ggc_alloc (sizeof (*desc));
2696 desc->value = copy_constant (exp);
2698 /* Propagate marked-ness to copied constant. */
2699 if (flag_mudflap && mf_marked_p (exp))
2700 mf_mark (desc->value);
2702 /* Create a string containing the label name, in LABEL. */
2703 labelno = const_labelno++;
2704 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2706 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2707 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2708 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2709 SYMBOL_REF_DECL (symbol) = desc->value;
2710 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2712 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2713 set_mem_attributes (rtl, exp, 1);
2714 set_mem_alias_set (rtl, 0);
2715 set_mem_alias_set (rtl, const_alias_set);
2717 /* Set flags or add text to the name to record information, such as
2718 that it is a local symbol. If the name is changed, the macro
2719 ASM_OUTPUT_LABELREF will have to know how to strip this
2720 information. This call might invalidate our local variable
2721 SYMBOL; we can't use it afterward. */
2723 targetm.encode_section_info (exp, rtl, true);
2730 /* Return an rtx representing a reference to constant data in memory
2731 for the constant expression EXP.
2733 If assembler code for such a constant has already been output,
2734 return an rtx to refer to it.
2735 Otherwise, output such a constant in memory
2736 and generate an rtx for it.
2738 If DEFER is nonzero, this constant can be deferred and output only
2739 if referenced in the function after all optimizations.
2741 `const_desc_table' records which constants already have label strings. */
2744 output_constant_def (tree exp, int defer)
2746 struct constant_descriptor_tree *desc;
2747 struct constant_descriptor_tree key;
2750 /* Look up EXP in the table of constant descriptors. If we didn't find
2751 it, create a new one. */
2753 loc = htab_find_slot (const_desc_htab, &key, INSERT);
2758 desc = build_constant_desc (exp);
2762 maybe_output_constant_def_contents (desc, defer);
2766 /* Subroutine of output_constant_def: Decide whether or not we need to
2767 output the constant DESC now, and if so, do it. */
2769 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2772 rtx symbol = XEXP (desc->rtl, 0);
2773 tree exp = desc->value;
2775 if (flag_syntax_only)
2778 if (TREE_ASM_WRITTEN (exp))
2779 /* Already output; don't do it again. */
2782 /* We can always defer constants as long as the context allows
2786 /* Increment n_deferred_constants if it exists. It needs to be at
2787 least as large as the number of constants actually referred to
2788 by the function. If it's too small we'll stop looking too early
2789 and fail to emit constants; if it's too large we'll only look
2790 through the entire function when we could have stopped earlier. */
2792 n_deferred_constants++;
2796 output_constant_def_contents (symbol);
2799 /* We must output the constant data referred to by SYMBOL; do so. */
2802 output_constant_def_contents (rtx symbol)
2804 tree exp = SYMBOL_REF_DECL (symbol);
2805 const char *label = XSTR (symbol, 0);
2808 /* Make sure any other constants whose addresses appear in EXP
2809 are assigned label numbers. */
2810 int reloc = compute_reloc_for_constant (exp);
2812 /* Align the location counter as required by EXP's data type. */
2813 unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
2814 #ifdef CONSTANT_ALIGNMENT
2815 align = CONSTANT_ALIGNMENT (exp, align);
2818 output_addressed_constants (exp);
2820 /* We are no longer deferring this constant. */
2821 TREE_ASM_WRITTEN (exp) = 1;
2823 if (IN_NAMED_SECTION (exp))
2824 named_section (exp, NULL, reloc);
2826 targetm.asm_out.select_section (exp, reloc, align);
2828 if (align > BITS_PER_UNIT)
2830 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2833 size = int_size_in_bytes (TREE_TYPE (exp));
2834 if (TREE_CODE (exp) == STRING_CST)
2835 size = MAX (TREE_STRING_LENGTH (exp), size);
2837 /* Do any machine/system dependent processing of the constant. */
2838 #ifdef ASM_DECLARE_CONSTANT_NAME
2839 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2841 /* Standard thing is just output label for the constant. */
2842 ASM_OUTPUT_LABEL (asm_out_file, label);
2843 #endif /* ASM_DECLARE_CONSTANT_NAME */
2845 /* Output the value of EXP. */
2846 output_constant (exp, size, align);
2848 mudflap_enqueue_constant (exp);
2851 /* Look up EXP in the table of constant descriptors. Return the rtl
2852 if it has been emitted, else null. */
2855 lookup_constant_def (tree exp)
2857 struct constant_descriptor_tree *desc;
2858 struct constant_descriptor_tree key;
2861 desc = htab_find (const_desc_htab, &key);
2863 return (desc ? desc->rtl : NULL_RTX);
2866 /* Used in the hash tables to avoid outputting the same constant
2867 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2868 are output once per function, not once per file. */
2869 /* ??? Only a few targets need per-function constant pools. Most
2870 can use one per-file pool. Should add a targetm bit to tell the
2873 struct rtx_constant_pool GTY(())
2875 /* Pointers to first and last constant in pool, as ordered by offset. */
2876 struct constant_descriptor_rtx *first;
2877 struct constant_descriptor_rtx *last;
2879 /* Hash facility for making memory-constants from constant rtl-expressions.
2880 It is used on RISC machines where immediate integer arguments and
2881 constant addresses are restricted so that such constants must be stored
2883 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
2884 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_sym_htab;
2886 /* Current offset in constant pool (does not include any
2887 machine-specific header). */
2888 HOST_WIDE_INT offset;
2891 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
2893 struct constant_descriptor_rtx *next;
2897 HOST_WIDE_INT offset;
2899 enum machine_mode mode;
2905 /* Hash and compare functions for const_rtx_htab. */
2908 const_desc_rtx_hash (const void *ptr)
2910 const struct constant_descriptor_rtx *desc = ptr;
2915 const_desc_rtx_eq (const void *a, const void *b)
2917 const struct constant_descriptor_rtx *x = a;
2918 const struct constant_descriptor_rtx *y = b;
2920 if (x->mode != y->mode)
2922 return rtx_equal_p (x->constant, y->constant);
2925 /* Hash and compare functions for const_rtx_sym_htab. */
2928 const_desc_rtx_sym_hash (const void *ptr)
2930 const struct constant_descriptor_rtx *desc = ptr;
2931 return htab_hash_string (XSTR (desc->sym, 0));
2935 const_desc_rtx_sym_eq (const void *a, const void *b)
2937 const struct constant_descriptor_rtx *x = a;
2938 const struct constant_descriptor_rtx *y = b;
2939 return XSTR (x->sym, 0) == XSTR (y->sym, 0);
2942 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
2945 const_rtx_hash_1 (rtx *xp, void *data)
2947 unsigned HOST_WIDE_INT hwi;
2948 enum machine_mode mode;
2954 code = GET_CODE (x);
2955 mode = GET_MODE (x);
2956 h = (hashval_t) code * 1048573 + mode;
2964 const int shift = sizeof (hashval_t) * CHAR_BIT;
2965 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
2968 h ^= (hashval_t) hwi;
2969 for (i = 1; i < n; ++i)
2972 h ^= (hashval_t) hwi;
2978 if (mode == VOIDmode)
2980 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
2984 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
2990 for (i = XVECLEN (x, 0); i-- > 0; )
2991 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
2996 h ^= htab_hash_string (XSTR (x, 0));
3000 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3004 case UNSPEC_VOLATILE:
3005 h = h * 251 + XINT (x, 1);
3013 *hp = *hp * 509 + h;
3017 /* Compute a hash value for X, which should be a constant. */
3020 const_rtx_hash (rtx x)
3023 for_each_rtx (&x, const_rtx_hash_1, &h);
3028 /* Initialize constant pool hashing for a new function. */
3031 init_varasm_status (struct function *f)
3033 struct varasm_status *p;
3034 struct rtx_constant_pool *pool;
3036 p = ggc_alloc (sizeof (struct varasm_status));
3039 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3041 p->deferred_constants = 0;
3043 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3044 const_desc_rtx_eq, NULL);
3045 pool->const_rtx_sym_htab = htab_create_ggc (31, const_desc_rtx_sym_hash,
3046 const_desc_rtx_sym_eq, NULL);
3047 pool->first = pool->last = NULL;
3051 /* Given a MINUS expression, simplify it if both sides
3052 include the same symbol. */
3055 simplify_subtraction (rtx x)
3057 rtx r = simplify_rtx (x);
3061 /* Given a constant rtx X, make (or find) a memory constant for its value
3062 and return a MEM rtx to refer to it in memory. */
3065 force_const_mem (enum machine_mode mode, rtx x)
3067 struct constant_descriptor_rtx *desc, tmp;
3068 struct rtx_constant_pool *pool = cfun->varasm->pool;
3075 /* If we're not allowed to drop X into the constant pool, don't. */
3076 if (targetm.cannot_force_const_mem (x))
3079 /* Lookup the value in the hashtable. */
3082 hash = const_rtx_hash (x);
3083 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3086 /* If the constant was already present, return its memory. */
3088 return copy_rtx (desc->mem);
3090 /* Otherwise, create a new descriptor. */
3091 desc = ggc_alloc (sizeof (*desc));
3094 /* Align the location counter as required by EXP's data type. */
3095 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3096 #ifdef CONSTANT_ALIGNMENT
3098 tree type = lang_hooks.types.type_for_mode (mode, 0);
3099 if (type != NULL_TREE)
3100 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3104 pool->offset += (align / BITS_PER_UNIT) - 1;
3105 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3108 desc->constant = tmp.constant;
3109 desc->offset = pool->offset;
3112 desc->align = align;
3113 desc->labelno = const_labelno;
3116 pool->offset += GET_MODE_SIZE (mode);
3118 pool->last->next = desc;
3120 pool->first = pool->last = desc;
3123 /* Create a string containing the label name, in LABEL. */
3124 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3127 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3128 the constants pool. */
3129 desc->sym = symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3130 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
3131 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3132 current_function_uses_const_pool = 1;
3134 /* Insert the descriptor into the symbol cross-reference table too. */
3135 slot = htab_find_slot (pool->const_rtx_sym_htab, desc, INSERT);
3136 gcc_assert (!*slot);
3139 /* Construct the MEM. */
3140 desc->mem = def = gen_const_mem (mode, symbol);
3141 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3142 set_mem_align (def, align);
3144 /* If we're dropping a label to the constant pool, make sure we
3146 if (GET_CODE (x) == LABEL_REF)
3147 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3149 return copy_rtx (def);
3152 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3153 the corresponding constant_descriptor_rtx structure. */
3155 static struct constant_descriptor_rtx *
3156 find_pool_constant (struct rtx_constant_pool *pool, rtx sym)
3158 struct constant_descriptor_rtx tmp;
3160 return htab_find (pool->const_rtx_sym_htab, &tmp);
3163 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3166 get_pool_constant (rtx addr)
3168 return find_pool_constant (cfun->varasm->pool, addr)->constant;
3171 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3172 and whether it has been output or not. */
3175 get_pool_constant_mark (rtx addr, bool *pmarked)
3177 struct constant_descriptor_rtx *desc;
3179 desc = find_pool_constant (cfun->varasm->pool, addr);
3180 *pmarked = (desc->mark != 0);
3181 return desc->constant;
3184 /* Likewise, but for the constant pool of a specific function. */
3187 get_pool_constant_for_function (struct function *f, rtx addr)
3189 return find_pool_constant (f->varasm->pool, addr)->constant;
3192 /* Similar, return the mode. */
3195 get_pool_mode (rtx addr)
3197 return find_pool_constant (cfun->varasm->pool, addr)->mode;
3200 /* Return the size of the constant pool. */
3203 get_pool_size (void)
3205 return cfun->varasm->pool->offset;
3208 /* Worker function for output_constant_pool_1. Emit assembly for X
3209 in MODE with known alignment ALIGN. */
3212 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3214 switch (GET_MODE_CLASS (mode))
3220 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3221 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3222 assemble_real (r, mode, align);
3227 case MODE_PARTIAL_INT:
3228 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3231 case MODE_VECTOR_FLOAT:
3232 case MODE_VECTOR_INT:
3235 enum machine_mode submode = GET_MODE_INNER (mode);
3236 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3238 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3239 units = CONST_VECTOR_NUNITS (x);
3241 for (i = 0; i < units; i++)
3243 rtx elt = CONST_VECTOR_ELT (x, i);
3244 output_constant_pool_2 (submode, elt, i ? subalign : align);
3254 /* Worker function for output_constant_pool. Emit POOL. */
3257 output_constant_pool_1 (struct constant_descriptor_rtx *desc)
3265 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3266 whose CODE_LABEL has been deleted. This can occur if a jump table
3267 is eliminated by optimization. If so, write a constant of zero
3268 instead. Note that this can also happen by turning the
3269 CODE_LABEL into a NOTE. */
3270 /* ??? This seems completely and utterly wrong. Certainly it's
3271 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3272 functioning even with INSN_DELETED_P and friends. */
3275 switch (GET_CODE (x))
3278 if (GET_CODE (XEXP (x, 0)) != PLUS
3279 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3281 tmp = XEXP (XEXP (x, 0), 0);
3286 gcc_assert (!INSN_DELETED_P (tmp));
3287 gcc_assert (!NOTE_P (tmp)
3288 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3295 /* First switch to correct section. */
3296 targetm.asm_out.select_rtx_section (desc->mode, x, desc->align);
3298 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3299 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3300 desc->align, desc->labelno, done);
3303 assemble_align (desc->align);
3305 /* Output the label. */
3306 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3308 /* Output the data. */
3309 output_constant_pool_2 (desc->mode, x, desc->align);
3311 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3312 sections have proper size. */
3313 if (desc->align > GET_MODE_BITSIZE (desc->mode)
3314 && in_section == in_named
3315 && get_named_section_flags (in_named_name) & SECTION_MERGE)
3316 assemble_align (desc->align);
3318 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3324 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3325 to as used. Emit referenced deferred strings. This function can
3326 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3329 mark_constant (rtx *current_rtx, void *data)
3331 struct rtx_constant_pool *pool = data;
3332 rtx x = *current_rtx;
3334 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3337 if (CONSTANT_POOL_ADDRESS_P (x))
3339 struct constant_descriptor_rtx *desc = find_pool_constant (pool, x);
3340 if (desc->mark == 0)
3343 for_each_rtx (&desc->constant, mark_constant, pool);
3346 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3348 tree exp = SYMBOL_REF_DECL (x);
3349 if (!TREE_ASM_WRITTEN (exp))
3351 n_deferred_constants--;
3352 output_constant_def_contents (x);
3359 /* Look through appropriate parts of INSN, marking all entries in the
3360 constant pool which are actually being used. Entries that are only
3361 referenced by other constants are also marked as used. Emit
3362 deferred strings that are used. */
3365 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3370 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3371 insns, not any notes that may be attached. We don't want to mark
3372 a constant just because it happens to appear in a REG_EQUIV note. */
3373 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3375 rtx seq = PATTERN (insn);
3376 int i, n = XVECLEN (seq, 0);
3377 for (i = 0; i < n; ++i)
3379 rtx subinsn = XVECEXP (seq, 0, i);
3380 if (INSN_P (subinsn))
3381 for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3385 for_each_rtx (&PATTERN (insn), mark_constant, pool);
3388 /* Look through the instructions for this function, and mark all the
3389 entries in POOL which are actually being used. Emit deferred constants
3390 which have indeed been used. */
3393 mark_constant_pool (struct rtx_constant_pool *pool)
3397 if (pool->first == 0 && n_deferred_constants == 0)
3400 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3401 mark_constants (pool, insn);
3403 for (link = current_function_epilogue_delay_list;
3405 link = XEXP (link, 1))
3406 mark_constants (pool, XEXP (link, 0));
3409 /* Write all the constants in the constant pool. */
3412 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3413 tree fndecl ATTRIBUTE_UNUSED)
3415 struct rtx_constant_pool *pool = cfun->varasm->pool;
3416 struct constant_descriptor_rtx *desc;
3418 /* It is possible for gcc to call force_const_mem and then to later
3419 discard the instructions which refer to the constant. In such a
3420 case we do not need to output the constant. */
3421 mark_constant_pool (pool);
3423 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3424 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3427 for (desc = pool->first; desc ; desc = desc->next)
3428 output_constant_pool_1 (desc);
3430 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3431 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3435 /* Determine what kind of relocations EXP may need. */
3438 compute_reloc_for_constant (tree exp)
3440 int reloc = 0, reloc2;
3443 /* Give the front-end a chance to convert VALUE to something that
3444 looks more like a constant to the back-end. */
3445 exp = lang_hooks.expand_constant (exp);
3447 switch (TREE_CODE (exp))
3451 /* Go inside any operations that get_inner_reference can handle and see
3452 if what's inside is a constant: no need to do anything here for
3453 addresses of variables or functions. */
3454 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3455 tem = TREE_OPERAND (tem, 0))
3458 if (TREE_PUBLIC (tem))
3465 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3466 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3470 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3471 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3472 /* The difference of two local labels is computable at link time. */
3473 if (reloc == 1 && reloc2 == 1)
3481 case NON_LVALUE_EXPR:
3482 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3486 for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3487 if (TREE_VALUE (tem) != 0)
3488 reloc |= compute_reloc_for_constant (TREE_VALUE (tem));
3498 /* Find all the constants whose addresses are referenced inside of EXP,
3499 and make sure assembler code with a label has been output for each one.
3500 Indicate whether an ADDR_EXPR has been encountered. */
3503 output_addressed_constants (tree exp)
3507 /* Give the front-end a chance to convert VALUE to something that
3508 looks more like a constant to the back-end. */
3509 exp = lang_hooks.expand_constant (exp);
3511 switch (TREE_CODE (exp))
3515 /* Go inside any operations that get_inner_reference can handle and see
3516 if what's inside is a constant: no need to do anything here for
3517 addresses of variables or functions. */
3518 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3519 tem = TREE_OPERAND (tem, 0))
3522 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3523 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3524 tem = DECL_INITIAL (tem);
3526 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3527 output_constant_def (tem, 0);
3532 output_addressed_constants (TREE_OPERAND (exp, 1));
3537 case NON_LVALUE_EXPR:
3538 output_addressed_constants (TREE_OPERAND (exp, 0));
3542 for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3543 if (TREE_VALUE (tem) != 0)
3544 output_addressed_constants (TREE_VALUE (tem));
3553 /* Return nonzero if VALUE is a valid constant-valued expression
3554 for use in initializing a static variable; one that can be an
3555 element of a "constant" initializer.
3557 Return null_pointer_node if the value is absolute;
3558 if it is relocatable, return the variable that determines the relocation.
3559 We assume that VALUE has been folded as much as possible;
3560 therefore, we do not need to check for such things as
3561 arithmetic-combinations of integers. */
3564 initializer_constant_valid_p (tree value, tree endtype)
3566 /* Give the front-end a chance to convert VALUE to something that
3567 looks more like a constant to the back-end. */
3568 value = lang_hooks.expand_constant (value);
3570 switch (TREE_CODE (value))
3573 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3574 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3575 && TREE_CONSTANT (value)
3576 && CONSTRUCTOR_ELTS (value))
3579 bool absolute = true;
3581 for (elt = CONSTRUCTOR_ELTS (value); elt; elt = TREE_CHAIN (elt))
3584 value = TREE_VALUE (elt);
3585 reloc = initializer_constant_valid_p (value, TREE_TYPE (value));
3588 if (reloc != null_pointer_node)
3591 /* For a non-absolute relocation, there is no single
3592 variable that can be "the variable that determines the
3594 return absolute ? null_pointer_node : error_mark_node;
3597 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3604 return null_pointer_node;
3608 value = staticp (TREE_OPERAND (value, 0));
3609 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3610 be a constant, this is old-skool offsetof-like nonsense. */
3612 && TREE_CODE (value) == INDIRECT_REF
3613 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3614 return null_pointer_node;
3615 /* Taking the address of a nested function involves a trampoline. */
3617 && TREE_CODE (value) == FUNCTION_DECL
3618 && ((decl_function_context (value) && !DECL_NO_STATIC_CHAIN (value))
3619 || DECL_NON_ADDR_CONST_P (value)))
3623 case VIEW_CONVERT_EXPR:
3624 case NON_LVALUE_EXPR:
3625 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3634 src = TREE_OPERAND (value, 0);
3635 src_type = TREE_TYPE (src);
3636 dest_type = TREE_TYPE (value);
3638 /* Allow conversions between pointer types, floating-point
3639 types, and offset types. */
3640 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3641 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3642 || (TREE_CODE (dest_type) == OFFSET_TYPE
3643 && TREE_CODE (src_type) == OFFSET_TYPE))
3644 return initializer_constant_valid_p (src, endtype);
3646 /* Allow length-preserving conversions between integer types. */
3647 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3648 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3649 return initializer_constant_valid_p (src, endtype);
3651 /* Allow conversions between other integer types only if
3653 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3655 tree inner = initializer_constant_valid_p (src, endtype);
3656 if (inner == null_pointer_node)
3657 return null_pointer_node;
3661 /* Allow (int) &foo provided int is as wide as a pointer. */
3662 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3663 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3664 return initializer_constant_valid_p (src, endtype);
3666 /* Likewise conversions from int to pointers, but also allow
3667 conversions from 0. */
3668 if ((POINTER_TYPE_P (dest_type)
3669 || TREE_CODE (dest_type) == OFFSET_TYPE)
3670 && INTEGRAL_TYPE_P (src_type))
3672 if (integer_zerop (src))
3673 return null_pointer_node;
3674 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3675 return initializer_constant_valid_p (src, endtype);
3678 /* Allow conversions to struct or union types if the value
3680 if (TREE_CODE (dest_type) == RECORD_TYPE
3681 || TREE_CODE (dest_type) == UNION_TYPE)
3682 return initializer_constant_valid_p (src, endtype);
3687 if (! INTEGRAL_TYPE_P (endtype)
3688 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3690 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3692 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3694 /* If either term is absolute, use the other terms relocation. */
3695 if (valid0 == null_pointer_node)
3697 if (valid1 == null_pointer_node)
3703 if (! INTEGRAL_TYPE_P (endtype)
3704 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3706 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3708 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3710 /* Win if second argument is absolute. */
3711 if (valid1 == null_pointer_node)
3713 /* Win if both arguments have the same relocation.
3714 Then the value is absolute. */
3715 if (valid0 == valid1 && valid0 != 0)
3716 return null_pointer_node;
3718 /* Since GCC guarantees that string constants are unique in the
3719 generated code, a subtraction between two copies of the same
3720 constant string is absolute. */
3721 if (valid0 && TREE_CODE (valid0) == STRING_CST
3722 && valid1 && TREE_CODE (valid1) == STRING_CST
3723 && operand_equal_p (valid0, valid1, 1))
3724 return null_pointer_node;
3727 /* Support narrowing differences. */
3728 if (INTEGRAL_TYPE_P (endtype))
3732 op0 = TREE_OPERAND (value, 0);
3733 op1 = TREE_OPERAND (value, 1);
3735 /* Like STRIP_NOPS except allow the operand mode to widen.
3736 This works around a feature of fold that simplifies
3737 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3738 that the narrower operation is cheaper. */
3740 while (TREE_CODE (op0) == NOP_EXPR
3741 || TREE_CODE (op0) == CONVERT_EXPR
3742 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3744 tree inner = TREE_OPERAND (op0, 0);
3745 if (inner == error_mark_node
3746 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3747 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3748 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3753 while (TREE_CODE (op1) == NOP_EXPR
3754 || TREE_CODE (op1) == CONVERT_EXPR
3755 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3757 tree inner = TREE_OPERAND (op1, 0);
3758 if (inner == error_mark_node
3759 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3760 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3761 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3766 op0 = initializer_constant_valid_p (op0, endtype);
3767 op1 = initializer_constant_valid_p (op1, endtype);
3769 /* Both initializers must be known. */
3773 return null_pointer_node;
3775 /* Support differences between labels. */
3776 if (TREE_CODE (op0) == LABEL_DECL
3777 && TREE_CODE (op1) == LABEL_DECL)
3778 return null_pointer_node;
3780 if (TREE_CODE (op0) == STRING_CST
3781 && TREE_CODE (op1) == STRING_CST
3782 && operand_equal_p (op0, op1, 1))
3783 return null_pointer_node;
3795 /* Output assembler code for constant EXP to FILE, with no label.
3796 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3797 Assumes output_addressed_constants has been done on EXP already.
3799 Generate exactly SIZE bytes of assembler data, padding at the end
3800 with zeros if necessary. SIZE must always be specified.
3802 SIZE is important for structure constructors,
3803 since trailing members may have been omitted from the constructor.
3804 It is also important for initialization of arrays from string constants
3805 since the full length of the string constant might not be wanted.
3806 It is also needed for initialization of unions, where the initializer's
3807 type is just one member, and that may not be as long as the union.
3809 There a case in which we would fail to output exactly SIZE bytes:
3810 for a structure constructor that wants to produce more than SIZE bytes.
3811 But such constructors will never be generated for any possible input.
3813 ALIGN is the alignment of the data in bits. */
3816 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3818 enum tree_code code;
3819 unsigned HOST_WIDE_INT thissize;
3821 /* Some front-ends use constants other than the standard language-independent
3822 varieties, but which may still be output directly. Give the front-end a
3823 chance to convert EXP to a language-independent representation. */
3824 exp = lang_hooks.expand_constant (exp);
3826 if (size == 0 || flag_syntax_only)
3829 /* Eliminate any conversions since we'll be outputting the underlying
3831 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3832 || TREE_CODE (exp) == NON_LVALUE_EXPR
3833 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3834 exp = TREE_OPERAND (exp, 0);
3836 code = TREE_CODE (TREE_TYPE (exp));
3837 thissize = int_size_in_bytes (TREE_TYPE (exp));
3839 /* Allow a constructor with no elements for any data type.
3840 This means to fill the space with zeros. */
3841 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3843 assemble_zeros (size);
3847 if (TREE_CODE (exp) == FDESC_EXPR)
3849 #ifdef ASM_OUTPUT_FDESC
3850 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
3851 tree decl = TREE_OPERAND (exp, 0);
3852 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
3859 /* Now output the underlying data. If we've handling the padding, return.
3860 Otherwise, break and ensure SIZE is the size written. */
3868 case REFERENCE_TYPE:
3870 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3871 EXPAND_INITIALIZER),
3872 MIN (size, thissize), align, 0))
3873 error ("initializer for integer value is too complicated");
3877 if (TREE_CODE (exp) != REAL_CST)
3878 error ("initializer for floating value is not a floating constant");
3880 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
3884 output_constant (TREE_REALPART (exp), thissize / 2, align);
3885 output_constant (TREE_IMAGPART (exp), thissize / 2,
3886 min_align (align, BITS_PER_UNIT * (thissize / 2)));
3891 switch (TREE_CODE (exp))
3894 output_constructor (exp, size, align);
3897 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
3899 assemble_string (TREE_STRING_POINTER (exp), thissize);
3906 unsigned int nalign;
3907 enum machine_mode inner;
3909 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
3910 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
3912 elt_size = GET_MODE_SIZE (inner);
3914 link = TREE_VECTOR_CST_ELTS (exp);
3915 output_constant (TREE_VALUE (link), elt_size, align);
3916 while ((link = TREE_CHAIN (link)) != NULL)
3917 output_constant (TREE_VALUE (link), elt_size, nalign);
3927 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
3928 output_constructor (exp, size, align);
3938 if (size > thissize)
3939 assemble_zeros (size - thissize);
3943 /* Subroutine of output_constructor, used for computing the size of
3944 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3945 type with an unspecified upper bound. */
3947 static unsigned HOST_WIDE_INT
3948 array_size_for_constructor (tree val)
3952 /* This code used to attempt to handle string constants that are not
3953 arrays of single-bytes, but nothing else does, so there's no point in
3955 if (TREE_CODE (val) == STRING_CST)
3956 return TREE_STRING_LENGTH (val);
3958 max_index = NULL_TREE;
3959 for (i = CONSTRUCTOR_ELTS (val); i; i = TREE_CHAIN (i))
3961 tree index = TREE_PURPOSE (i);
3963 if (TREE_CODE (index) == RANGE_EXPR)
3964 index = TREE_OPERAND (index, 1);
3965 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
3969 if (max_index == NULL_TREE)
3972 /* Compute the total number of array elements. */
3973 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
3975 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
3976 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
3978 /* Multiply by the array element unit size to find number of bytes. */
3979 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
3981 return tree_low_cst (i, 1);
3984 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3985 Generate at least SIZE bytes, padding if necessary. */
3988 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
3991 tree type = TREE_TYPE (exp);
3992 tree link, field = 0;
3994 /* Number of bytes output or skipped so far.
3995 In other words, current position within the constructor. */
3996 HOST_WIDE_INT total_bytes = 0;
3997 /* Nonzero means BYTE contains part of a byte, to be output. */
3998 int byte_buffer_in_use = 0;
4001 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4003 if (TREE_CODE (type) == RECORD_TYPE)
4004 field = TYPE_FIELDS (type);
4006 if (TREE_CODE (type) == ARRAY_TYPE
4007 && TYPE_DOMAIN (type) != 0)
4008 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4010 /* As LINK goes through the elements of the constant,
4011 FIELD goes through the structure fields, if the constant is a structure.
4012 if the constant is a union, then we override this,
4013 by getting the field from the TREE_LIST element.
4014 But the constant could also be an array. Then FIELD is zero.
4016 There is always a maximum of one element in the chain LINK for unions
4017 (even if the initializer in a source program incorrectly contains
4019 for (link = CONSTRUCTOR_ELTS (exp);
4021 link = TREE_CHAIN (link),
4022 field = field ? TREE_CHAIN (field) : 0)
4024 tree val = TREE_VALUE (link);
4027 /* The element in a union constructor specifies the proper field
4029 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4030 || TREE_CODE (type) == QUAL_UNION_TYPE)
4031 && TREE_PURPOSE (link) != 0)
4032 field = TREE_PURPOSE (link);
4034 else if (TREE_CODE (type) == ARRAY_TYPE)
4035 index = TREE_PURPOSE (link);
4037 #ifdef ASM_COMMENT_START
4038 if (field && flag_verbose_asm)
4039 fprintf (asm_out_file, "%s %s:\n",
4042 ? IDENTIFIER_POINTER (DECL_NAME (field))
4046 /* Eliminate the marker that makes a cast not be an lvalue. */
4050 if (index && TREE_CODE (index) == RANGE_EXPR)
4052 unsigned HOST_WIDE_INT fieldsize
4053 = int_size_in_bytes (TREE_TYPE (type));
4054 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4055 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4056 HOST_WIDE_INT index;
4057 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4059 for (index = lo_index; index <= hi_index; index++)
4061 /* Output the element's initial value. */
4063 assemble_zeros (fieldsize);
4065 output_constant (val, fieldsize, align2);
4067 /* Count its size. */
4068 total_bytes += fieldsize;
4071 else if (field == 0 || !DECL_BIT_FIELD (field))
4073 /* An element that is not a bit-field. */
4075 unsigned HOST_WIDE_INT fieldsize;
4076 /* Since this structure is static,
4077 we know the positions are constant. */
4078 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4079 unsigned int align2;
4082 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4083 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4085 /* Output any buffered-up bit-fields preceding this element. */
4086 if (byte_buffer_in_use)
4088 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4090 byte_buffer_in_use = 0;
4093 /* Advance to offset of this element.
4094 Note no alignment needed in an array, since that is guaranteed
4095 if each element has the proper size. */
4096 if ((field != 0 || index != 0) && pos != total_bytes)
4098 assemble_zeros (pos - total_bytes);
4102 /* Find the alignment of this element. */
4103 align2 = min_align (align, BITS_PER_UNIT * pos);
4105 /* Determine size this element should occupy. */
4110 /* If this is an array with an unspecified upper bound,
4111 the initializer determines the size. */
4112 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4113 but we cannot do this until the deprecated support for
4114 initializing zero-length array members is removed. */
4115 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4116 && TYPE_DOMAIN (TREE_TYPE (field))
4117 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4119 fieldsize = array_size_for_constructor (val);
4120 /* Given a non-empty initialization, this field had
4122 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4124 else if (DECL_SIZE_UNIT (field))
4126 /* ??? This can't be right. If the decl size overflows
4127 a host integer we will silently emit no data. */
4128 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4129 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4133 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4135 /* Output the element's initial value. */
4137 assemble_zeros (fieldsize);
4139 output_constant (val, fieldsize, align2);
4141 /* Count its size. */
4142 total_bytes += fieldsize;
4144 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4145 error ("invalid initial value for member %qs",
4146 IDENTIFIER_POINTER (DECL_NAME (field)));
4149 /* Element that is a bit-field. */
4151 HOST_WIDE_INT next_offset = int_bit_position (field);
4152 HOST_WIDE_INT end_offset
4153 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4156 val = integer_zero_node;
4158 /* If this field does not start in this (or, next) byte,
4160 if (next_offset / BITS_PER_UNIT != total_bytes)
4162 /* Output remnant of any bit field in previous bytes. */
4163 if (byte_buffer_in_use)
4165 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4167 byte_buffer_in_use = 0;
4170 /* If still not at proper byte, advance to there. */
4171 if (next_offset / BITS_PER_UNIT != total_bytes)
4173 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4174 total_bytes = next_offset / BITS_PER_UNIT;
4178 if (! byte_buffer_in_use)
4181 /* We must split the element into pieces that fall within
4182 separate bytes, and combine each byte with previous or
4183 following bit-fields. */
4185 /* next_offset is the offset n fbits from the beginning of
4186 the structure to the next bit of this element to be processed.
4187 end_offset is the offset of the first bit past the end of
4189 while (next_offset < end_offset)
4193 HOST_WIDE_INT value;
4194 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4195 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4197 /* Advance from byte to byte
4198 within this element when necessary. */
4199 while (next_byte != total_bytes)
4201 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4206 /* Number of bits we can process at once
4207 (all part of the same byte). */
4208 this_time = MIN (end_offset - next_offset,
4209 BITS_PER_UNIT - next_bit);
4210 if (BYTES_BIG_ENDIAN)
4212 /* On big-endian machine, take the most significant bits
4213 first (of the bits that are significant)
4214 and put them into bytes from the most significant end. */
4215 shift = end_offset - next_offset - this_time;
4217 /* Don't try to take a bunch of bits that cross
4218 the word boundary in the INTEGER_CST. We can
4219 only select bits from the LOW or HIGH part
4221 if (shift < HOST_BITS_PER_WIDE_INT
4222 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4224 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4225 shift = HOST_BITS_PER_WIDE_INT;
4228 /* Now get the bits from the appropriate constant word. */
4229 if (shift < HOST_BITS_PER_WIDE_INT)
4230 value = TREE_INT_CST_LOW (val);
4233 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4234 value = TREE_INT_CST_HIGH (val);
4235 shift -= HOST_BITS_PER_WIDE_INT;
4238 /* Get the result. This works only when:
4239 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4240 byte |= (((value >> shift)
4241 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4242 << (BITS_PER_UNIT - this_time - next_bit));
4246 /* On little-endian machines,
4247 take first the least significant bits of the value
4248 and pack them starting at the least significant
4249 bits of the bytes. */
4250 shift = next_offset - int_bit_position (field);
4252 /* Don't try to take a bunch of bits that cross
4253 the word boundary in the INTEGER_CST. We can
4254 only select bits from the LOW or HIGH part
4256 if (shift < HOST_BITS_PER_WIDE_INT
4257 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4258 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4260 /* Now get the bits from the appropriate constant word. */
4261 if (shift < HOST_BITS_PER_WIDE_INT)
4262 value = TREE_INT_CST_LOW (val);
4265 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4266 value = TREE_INT_CST_HIGH (val);
4267 shift -= HOST_BITS_PER_WIDE_INT;
4270 /* Get the result. This works only when:
4271 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4272 byte |= (((value >> shift)
4273 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4277 next_offset += this_time;
4278 byte_buffer_in_use = 1;
4283 if (byte_buffer_in_use)
4285 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4289 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4290 assemble_zeros (size - total_bytes);
4293 /* This TREE_LIST contains any weak symbol declarations waiting
4295 static GTY(()) tree weak_decls;
4297 /* Mark DECL as weak. */
4300 mark_weak (tree decl)
4302 DECL_WEAK (decl) = 1;
4304 if (DECL_RTL_SET_P (decl)
4305 && MEM_P (DECL_RTL (decl))
4306 && XEXP (DECL_RTL (decl), 0)
4307 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4308 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4311 /* Merge weak status between NEWDECL and OLDDECL. */
4314 merge_weak (tree newdecl, tree olddecl)
4316 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4318 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4321 /* We put the NEWDECL on the weak_decls list at some point
4322 and OLDDECL as well. Keep just OLDDECL on the list. */
4323 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4324 if (TREE_VALUE (*pwd) == newdecl)
4326 *pwd = TREE_CHAIN (*pwd);
4333 if (DECL_WEAK (newdecl))
4337 /* NEWDECL is weak, but OLDDECL is not. */
4339 /* If we already output the OLDDECL, we're in trouble; we can't
4340 go back and make it weak. This error cannot caught in
4341 declare_weak because the NEWDECL and OLDDECL was not yet
4342 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4343 if (TREE_ASM_WRITTEN (olddecl))
4344 error ("%Jweak declaration of %qD must precede definition",
4347 /* If we've already generated rtl referencing OLDDECL, we may
4348 have done so in a way that will not function properly with
4350 else if (TREE_USED (olddecl)
4351 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4352 warning (0, "%Jweak declaration of %qD after first use results "
4353 "in unspecified behavior", newdecl, newdecl);
4357 /* We put the NEWDECL on the weak_decls list at some point.
4358 Replace it with the OLDDECL. */
4359 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4360 if (TREE_VALUE (wd) == newdecl)
4362 TREE_VALUE (wd) = olddecl;
4365 /* We may not find the entry on the list. If NEWDECL is a
4366 weak alias, then we will have already called
4367 globalize_decl to remove the entry; in that case, we do
4368 not need to do anything. */
4371 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4372 mark_weak (olddecl);
4375 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4376 weak. Just update NEWDECL to indicate that it's weak too. */
4377 mark_weak (newdecl);
4380 /* Declare DECL to be a weak symbol. */
4383 declare_weak (tree decl)
4385 if (! TREE_PUBLIC (decl))
4386 error ("%Jweak declaration of %qD must be public", decl, decl);
4387 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4388 error ("%Jweak declaration of %qD must precede definition", decl, decl);
4389 else if (SUPPORTS_WEAK)
4391 if (! DECL_WEAK (decl))
4392 weak_decls = tree_cons (NULL, decl, weak_decls);
4395 warning (0, "%Jweak declaration of %qD not supported", decl, decl);
4400 /* Emit any pending weak declarations. */
4407 for (t = weak_decls; t; t = TREE_CHAIN (t))
4409 tree decl = TREE_VALUE (t);
4410 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4411 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4414 if (! TREE_USED (decl))
4417 #ifdef ASM_WEAKEN_DECL
4418 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4420 #ifdef ASM_WEAKEN_LABEL
4421 ASM_WEAKEN_LABEL (asm_out_file, name);
4423 #ifdef ASM_OUTPUT_WEAK_ALIAS
4424 warning (0, "only weak aliases are supported in this configuration");
4432 /* Emit the assembly bits to indicate that DECL is globally visible. */
4435 globalize_decl (tree decl)
4437 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4439 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4440 if (DECL_WEAK (decl))
4444 #ifdef ASM_WEAKEN_DECL
4445 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4447 ASM_WEAKEN_LABEL (asm_out_file, name);
4450 /* Remove this function from the pending weak list so that
4451 we do not emit multiple .weak directives for it. */
4452 for (p = &weak_decls; (t = *p) ; )
4454 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4455 *p = TREE_CHAIN (t);
4457 p = &TREE_CHAIN (t);
4461 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4462 if (DECL_ONE_ONLY (decl))
4463 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4466 targetm.asm_out.globalize_label (asm_out_file, name);
4469 /* We have to be able to tell cgraph about the needed-ness of the target
4470 of an alias. This requires that the decl have been defined. Aliases
4471 that precede their definition have to be queued for later processing. */
4473 typedef struct alias_pair GTY(())
4479 /* Define gc'd vector type. */
4480 DEF_VEC_O(alias_pair);
4481 DEF_VEC_ALLOC_O(alias_pair,gc);
4483 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4485 /* Given an assembly name, find the decl it is associated with. At the
4486 same time, mark it needed for cgraph. */
4489 find_decl_and_mark_needed (tree decl, tree target)
4491 struct cgraph_node *fnode = NULL;
4492 struct cgraph_varpool_node *vnode = NULL;
4494 /* C++ thunk emitting code produces aliases late in the game.
4495 Avoid confusing cgraph code in that case. */
4496 if (!cgraph_global_info_ready)
4498 if (TREE_CODE (decl) == FUNCTION_DECL)
4500 fnode = cgraph_node_for_asm (target);
4502 vnode = cgraph_varpool_node_for_asm (target);
4506 vnode = cgraph_varpool_node_for_asm (target);
4508 fnode = cgraph_node_for_asm (target);
4514 cgraph_mark_needed_node (fnode);
4519 cgraph_varpool_mark_needed_node (vnode);
4526 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4527 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4528 tree node is DECL to have the value of the tree node TARGET. */
4531 do_assemble_alias (tree decl, tree target ATTRIBUTE_UNUSED)
4533 if (TREE_ASM_WRITTEN (decl))
4536 TREE_ASM_WRITTEN (decl) = 1;
4537 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4539 #ifdef ASM_OUTPUT_DEF
4540 /* Make name accessible from other files, if appropriate. */
4542 if (TREE_PUBLIC (decl))
4544 globalize_decl (decl);
4545 maybe_assemble_visibility (decl);
4548 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4549 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4551 ASM_OUTPUT_DEF (asm_out_file,
4552 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4553 IDENTIFIER_POINTER (target));
4555 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4560 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4561 # ifdef ASM_WEAKEN_DECL
4562 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4564 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4566 /* Remove this function from the pending weak list so that
4567 we do not emit multiple .weak directives for it. */
4568 for (p = &weak_decls; (t = *p) ; )
4569 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4570 *p = TREE_CHAIN (t);
4572 p = &TREE_CHAIN (t);
4577 /* First pass of completing pending aliases. Make sure that cgraph knows
4578 which symbols will be required. */
4581 finish_aliases_1 (void)
4586 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4590 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4591 if (target_decl == NULL)
4592 error ("%J%qD aliased to undefined symbol %qE",
4593 p->decl, p->decl, p->target);
4594 else if (DECL_EXTERNAL (target_decl))
4595 error ("%J%qD aliased to external symbol %qE",
4596 p->decl, p->decl, p->target);
4600 /* Second pass of completing pending aliases. Emit the actual assembly.
4601 This happens at the end of compilation and thus it is assured that the
4602 target symbol has been emitted. */
4605 finish_aliases_2 (void)
4610 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4611 do_assemble_alias (p->decl, p->target);
4613 VEC_truncate (alias_pair, alias_pairs, 0);
4616 /* Emit an assembler directive to make the symbol for DECL an alias to
4617 the symbol for TARGET. */
4620 assemble_alias (tree decl, tree target)
4624 #if !defined (ASM_OUTPUT_DEF)
4625 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4626 error ("%Jalias definitions not supported in this configuration", decl);
4629 if (!DECL_WEAK (decl))
4631 error ("%Jonly weak aliases are supported in this configuration", decl);
4637 /* We must force creation of DECL_RTL for debug info generation, even though
4638 we don't use it here. */
4639 make_decl_rtl (decl);
4640 TREE_USED (decl) = 1;
4642 /* A quirk of the initial implementation of aliases required that the user
4643 add "extern" to all of them. Which is silly, but now historical. Do
4644 note that the symbol is in fact locally defined. */
4645 DECL_EXTERNAL (decl) = 0;
4647 /* Allow aliases to aliases. */
4648 if (TREE_CODE (decl) == FUNCTION_DECL)
4649 cgraph_node (decl)->alias = true;
4651 cgraph_varpool_node (decl)->alias = true;
4653 /* If the target has already been emitted, we don't have to queue the
4654 alias. This saves a tad o memory. */
4655 target_decl = find_decl_and_mark_needed (decl, target);
4656 if (target_decl && TREE_ASM_WRITTEN (target_decl))
4657 do_assemble_alias (decl, target);
4660 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
4666 /* Emit an assembler directive to set symbol for DECL visibility to
4667 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4670 default_assemble_visibility (tree decl, int vis)
4672 static const char * const visibility_types[] = {
4673 NULL, "internal", "hidden", "protected"
4676 const char *name, *type;
4678 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4679 type = visibility_types[vis];
4681 #ifdef HAVE_GAS_HIDDEN
4682 fprintf (asm_out_file, "\t.%s\t", type);
4683 assemble_name (asm_out_file, name);
4684 fprintf (asm_out_file, "\n");
4686 warning (0, "visibility attribute not supported in this configuration; ignored");
4690 /* A helper function to call assemble_visibility when needed for a decl. */
4693 maybe_assemble_visibility (tree decl)
4695 enum symbol_visibility vis = DECL_VISIBILITY (decl);
4697 if (vis != VISIBILITY_DEFAULT)
4698 targetm.asm_out.visibility (decl, vis);
4701 /* Returns 1 if the target configuration supports defining public symbols
4702 so that one of them will be chosen at link time instead of generating a
4703 multiply-defined symbol error, whether through the use of weak symbols or
4704 a target-specific mechanism for having duplicates discarded. */
4707 supports_one_only (void)
4709 if (SUPPORTS_ONE_ONLY)
4711 return SUPPORTS_WEAK;
4714 /* Set up DECL as a public symbol that can be defined in multiple
4715 translation units without generating a linker error. */
4718 make_decl_one_only (tree decl)
4720 gcc_assert (TREE_CODE (decl) == VAR_DECL
4721 || TREE_CODE (decl) == FUNCTION_DECL);
4723 TREE_PUBLIC (decl) = 1;
4725 if (SUPPORTS_ONE_ONLY)
4727 #ifdef MAKE_DECL_ONE_ONLY
4728 MAKE_DECL_ONE_ONLY (decl);
4730 DECL_ONE_ONLY (decl) = 1;
4732 else if (TREE_CODE (decl) == VAR_DECL
4733 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4734 DECL_COMMON (decl) = 1;
4737 gcc_assert (SUPPORTS_WEAK);
4738 DECL_WEAK (decl) = 1;
4743 init_varasm_once (void)
4745 in_named_htab = htab_create_ggc (31, in_named_entry_hash,
4746 in_named_entry_eq, NULL);
4747 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
4748 const_desc_eq, NULL);
4750 const_alias_set = new_alias_set ();
4753 static enum tls_model
4754 decl_tls_model (tree decl)
4756 enum tls_model kind;
4757 tree attr = lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl));
4762 attr = TREE_VALUE (TREE_VALUE (attr));
4763 gcc_assert (TREE_CODE (attr) == STRING_CST);
4765 if (!strcmp (TREE_STRING_POINTER (attr), "local-exec"))
4766 kind = TLS_MODEL_LOCAL_EXEC;
4767 else if (!strcmp (TREE_STRING_POINTER (attr), "initial-exec"))
4768 kind = TLS_MODEL_INITIAL_EXEC;
4769 else if (!strcmp (TREE_STRING_POINTER (attr), "local-dynamic"))
4770 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
4771 else if (!strcmp (TREE_STRING_POINTER (attr), "global-dynamic"))
4772 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4778 is_local = targetm.binds_local_p (decl);
4782 kind = TLS_MODEL_LOCAL_EXEC;
4784 kind = TLS_MODEL_INITIAL_EXEC;
4786 /* Local dynamic is inefficient when we're not combining the
4787 parts of the address. */
4788 else if (optimize && is_local)
4789 kind = TLS_MODEL_LOCAL_DYNAMIC;
4791 kind = TLS_MODEL_GLOBAL_DYNAMIC;
4792 if (kind < flag_tls_default)
4793 kind = flag_tls_default;
4798 /* Select a set of attributes for section NAME based on the properties
4799 of DECL and whether or not RELOC indicates that DECL's initializer
4800 might contain runtime relocations.
4802 We make the section read-only and executable for a function decl,
4803 read-only for a const data decl, and writable for a non-const data decl. */
4806 default_section_type_flags (tree decl, const char *name, int reloc)
4808 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
4812 default_section_type_flags_1 (tree decl, const char *name, int reloc,
4817 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
4818 flags = SECTION_CODE;
4819 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
4821 else if (current_function_decl
4823 && cfun->unlikely_text_section_name
4824 && strcmp (name, cfun->unlikely_text_section_name) == 0)
4825 flags = SECTION_CODE;
4827 && (!current_function_decl || !cfun)
4828 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
4829 flags = SECTION_CODE;
4831 flags = SECTION_WRITE;
4833 if (decl && DECL_ONE_ONLY (decl))
4834 flags |= SECTION_LINKONCE;
4836 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
4837 flags |= SECTION_TLS | SECTION_WRITE;
4839 if (strcmp (name, ".bss") == 0
4840 || strncmp (name, ".bss.", 5) == 0
4841 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
4842 || strcmp (name, ".sbss") == 0
4843 || strncmp (name, ".sbss.", 6) == 0
4844 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
4845 flags |= SECTION_BSS;
4847 if (strcmp (name, ".tdata") == 0
4848 || strncmp (name, ".tdata.", 7) == 0
4849 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
4850 flags |= SECTION_TLS;
4852 if (strcmp (name, ".tbss") == 0
4853 || strncmp (name, ".tbss.", 6) == 0
4854 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
4855 flags |= SECTION_TLS | SECTION_BSS;
4857 /* These three sections have special ELF types. They are neither
4858 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4859 want to print a section type (@progbits or @nobits). If someone
4860 is silly enough to emit code or TLS variables to one of these
4861 sections, then don't handle them specially. */
4862 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
4863 && (strcmp (name, ".init_array") == 0
4864 || strcmp (name, ".fini_array") == 0
4865 || strcmp (name, ".preinit_array") == 0))
4866 flags |= SECTION_NOTYPE;
4871 /* Output assembly to switch to section NAME with attribute FLAGS.
4872 Four variants for common object file formats. */
4875 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
4876 unsigned int flags ATTRIBUTE_UNUSED,
4877 tree decl ATTRIBUTE_UNUSED)
4879 /* Some object formats don't support named sections at all. The
4880 front-end should already have flagged this as an error. */
4885 default_elf_asm_named_section (const char *name, unsigned int flags,
4886 tree decl ATTRIBUTE_UNUSED)
4888 char flagchars[10], *f = flagchars;
4890 /* If we have already declared this section, we can use an
4891 abbreviated form to switch back to it -- unless this section is
4892 part of a COMDAT groups, in which case GAS requires the full
4893 declaration every time. */
4894 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4895 && ! named_section_first_declaration (name))
4897 fprintf (asm_out_file, "\t.section\t%s\n", name);
4901 if (!(flags & SECTION_DEBUG))
4903 if (flags & SECTION_WRITE)
4905 if (flags & SECTION_CODE)
4907 if (flags & SECTION_SMALL)
4909 if (flags & SECTION_MERGE)
4911 if (flags & SECTION_STRINGS)
4913 if (flags & SECTION_TLS)
4915 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4919 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
4921 if (!(flags & SECTION_NOTYPE))
4926 if (flags & SECTION_BSS)
4932 #ifdef ASM_COMMENT_START
4933 /* On platforms that use "@" as the assembly comment character,
4935 if (strcmp (ASM_COMMENT_START, "@") == 0)
4938 fprintf (asm_out_file, format, type);
4940 if (flags & SECTION_ENTSIZE)
4941 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
4942 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4943 fprintf (asm_out_file, ",%s,comdat",
4944 lang_hooks.decls.comdat_group (decl));
4947 putc ('\n', asm_out_file);
4951 default_coff_asm_named_section (const char *name, unsigned int flags,
4952 tree decl ATTRIBUTE_UNUSED)
4954 char flagchars[8], *f = flagchars;
4956 if (flags & SECTION_WRITE)
4958 if (flags & SECTION_CODE)
4962 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
4966 default_pe_asm_named_section (const char *name, unsigned int flags,
4969 default_coff_asm_named_section (name, flags, decl);
4971 if (flags & SECTION_LINKONCE)
4973 /* Functions may have been compiled at various levels of
4974 optimization so we can't use `same_size' here.
4975 Instead, have the linker pick one. */
4976 fprintf (asm_out_file, "\t.linkonce %s\n",
4977 (flags & SECTION_CODE ? "discard" : "same_size"));
4981 /* The lame default section selector. */
4984 default_select_section (tree decl, int reloc,
4985 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
4987 bool readonly = false;
4991 if (decl_readonly_section (decl, reloc))
4994 else if (TREE_CODE (decl) == CONSTRUCTOR)
4996 if (! ((flag_pic && reloc)
4997 || !TREE_READONLY (decl)
4998 || TREE_SIDE_EFFECTS (decl)
4999 || !TREE_CONSTANT (decl)))
5002 else if (TREE_CODE (decl) == STRING_CST)
5004 else if (! (flag_pic && reloc))
5008 readonly_data_section ();
5013 /* A helper function for default_elf_select_section and
5014 default_elf_unique_section. Categorizes the DECL. */
5016 enum section_category
5021 SECCAT_RODATA_MERGE_STR,
5022 SECCAT_RODATA_MERGE_STR_INIT,
5023 SECCAT_RODATA_MERGE_CONST,
5028 /* To optimize loading of shared programs, define following subsections
5030 _REL Contains data that has relocations, so they get grouped
5031 together and dynamic linker will visit fewer pages in memory.
5032 _RO Contains data that is otherwise read-only. This is useful
5033 with prelinking as most relocations won't be dynamically
5034 linked and thus stay read only.
5035 _LOCAL Marks data containing relocations only to local objects.
5036 These relocations will get fully resolved by prelinking. */
5038 SECCAT_DATA_REL_LOCAL,
5040 SECCAT_DATA_REL_RO_LOCAL,
5050 static enum section_category
5051 categorize_decl_for_section (tree, int, int);
5053 static enum section_category
5054 categorize_decl_for_section (tree decl, int reloc, int shlib)
5056 enum section_category ret;
5058 if (TREE_CODE (decl) == FUNCTION_DECL)
5060 else if (TREE_CODE (decl) == STRING_CST)
5062 if (flag_mudflap) /* or !flag_merge_constants */
5063 return SECCAT_RODATA;
5065 return SECCAT_RODATA_MERGE_STR;
5067 else if (TREE_CODE (decl) == VAR_DECL)
5069 if (DECL_INITIAL (decl) == NULL
5070 || DECL_INITIAL (decl) == error_mark_node
5071 || (flag_zero_initialized_in_bss
5072 /* Leave constant zeroes in .rodata so they can be shared. */
5073 && !TREE_READONLY (decl)
5074 && initializer_zerop (DECL_INITIAL (decl))))
5076 else if (! TREE_READONLY (decl)
5077 || TREE_SIDE_EFFECTS (decl)
5078 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5080 if (shlib && (reloc & 2))
5081 ret = SECCAT_DATA_REL;
5082 else if (shlib && reloc)
5083 ret = SECCAT_DATA_REL_LOCAL;
5087 else if (shlib && (reloc & 2))
5088 ret = SECCAT_DATA_REL_RO;
5089 else if (shlib && reloc)
5090 ret = SECCAT_DATA_REL_RO_LOCAL;
5091 else if (reloc || flag_merge_constants < 2)
5092 /* C and C++ don't allow different variables to share the same
5093 location. -fmerge-all-constants allows even that (at the
5094 expense of not conforming). */
5095 ret = SECCAT_RODATA;
5096 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5097 ret = SECCAT_RODATA_MERGE_STR_INIT;
5099 ret = SECCAT_RODATA_MERGE_CONST;
5101 else if (TREE_CODE (decl) == CONSTRUCTOR)
5103 if ((shlib && reloc)
5104 || TREE_SIDE_EFFECTS (decl)
5105 || ! TREE_CONSTANT (decl))
5108 ret = SECCAT_RODATA;
5111 ret = SECCAT_RODATA;
5113 /* There are no read-only thread-local sections. */
5114 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
5116 /* Note that this would be *just* SECCAT_BSS, except that there's
5117 no concept of a read-only thread-local-data section. */
5118 if (ret == SECCAT_BSS
5119 || (flag_zero_initialized_in_bss
5120 && initializer_zerop (DECL_INITIAL (decl))))
5126 /* If the target uses small data sections, select it. */
5127 else if (targetm.in_small_data_p (decl))
5129 if (ret == SECCAT_BSS)
5131 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5132 ret = SECCAT_SRODATA;
5141 decl_readonly_section (tree decl, int reloc)
5143 return decl_readonly_section_1 (decl, reloc, flag_pic);
5147 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5149 switch (categorize_decl_for_section (decl, reloc, shlib))
5152 case SECCAT_RODATA_MERGE_STR:
5153 case SECCAT_RODATA_MERGE_STR_INIT:
5154 case SECCAT_RODATA_MERGE_CONST:
5155 case SECCAT_SRODATA:
5164 /* Select a section based on the above categorization. */
5167 default_elf_select_section (tree decl, int reloc,
5168 unsigned HOST_WIDE_INT align)
5170 default_elf_select_section_1 (decl, reloc, align, flag_pic);
5174 default_elf_select_section_1 (tree decl, int reloc,
5175 unsigned HOST_WIDE_INT align, int shlib)
5178 switch (categorize_decl_for_section (decl, reloc, shlib))
5181 /* We're not supposed to be called on FUNCTION_DECLs. */
5184 readonly_data_section ();
5186 case SECCAT_RODATA_MERGE_STR:
5187 mergeable_string_section (decl, align, 0);
5189 case SECCAT_RODATA_MERGE_STR_INIT:
5190 mergeable_string_section (DECL_INITIAL (decl), align, 0);
5192 case SECCAT_RODATA_MERGE_CONST:
5193 mergeable_constant_section (DECL_MODE (decl), align, 0);
5195 case SECCAT_SRODATA:
5201 case SECCAT_DATA_REL:
5202 sname = ".data.rel";
5204 case SECCAT_DATA_REL_LOCAL:
5205 sname = ".data.rel.local";
5207 case SECCAT_DATA_REL_RO:
5208 sname = ".data.rel.ro";
5210 case SECCAT_DATA_REL_RO_LOCAL:
5211 sname = ".data.rel.ro.local";
5220 #ifdef BSS_SECTION_ASM_OP
5239 named_section (decl, sname, reloc);
5242 /* Construct a unique section name based on the decl name and the
5243 categorization performed above. */
5246 default_unique_section (tree decl, int reloc)
5248 default_unique_section_1 (decl, reloc, flag_pic);
5252 default_unique_section_1 (tree decl, int reloc, int shlib)
5254 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5255 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5256 const char *prefix, *name;
5260 switch (categorize_decl_for_section (decl, reloc, shlib))
5263 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5266 case SECCAT_RODATA_MERGE_STR:
5267 case SECCAT_RODATA_MERGE_STR_INIT:
5268 case SECCAT_RODATA_MERGE_CONST:
5269 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5271 case SECCAT_SRODATA:
5272 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5275 case SECCAT_DATA_REL:
5276 case SECCAT_DATA_REL_LOCAL:
5277 case SECCAT_DATA_REL_RO:
5278 case SECCAT_DATA_REL_RO_LOCAL:
5279 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5282 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5285 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5288 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5291 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5294 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5299 plen = strlen (prefix);
5301 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5302 name = targetm.strip_name_encoding (name);
5303 nlen = strlen (name);
5305 string = alloca (nlen + plen + 1);
5306 memcpy (string, prefix, plen);
5307 memcpy (string + plen, name, nlen + 1);
5309 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5313 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5315 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5318 switch (GET_CODE (x))
5330 readonly_data_section ();
5334 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5335 unsigned HOST_WIDE_INT align)
5337 /* ??? Handle small data here somehow. */
5340 switch (GET_CODE (x))
5344 named_section (NULL_TREE, ".data.rel.ro", 3);
5348 named_section (NULL_TREE, ".data.rel.ro.local", 1);
5355 mergeable_constant_section (mode, align, 0);
5358 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5361 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5366 /* Careful not to prod global register variables. */
5369 symbol = XEXP (rtl, 0);
5370 if (GET_CODE (symbol) != SYMBOL_REF)
5374 if (TREE_CODE (decl) == FUNCTION_DECL)
5375 flags |= SYMBOL_FLAG_FUNCTION;
5376 if (targetm.binds_local_p (decl))
5377 flags |= SYMBOL_FLAG_LOCAL;
5378 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
5379 flags |= decl_tls_model (decl) << SYMBOL_FLAG_TLS_SHIFT;
5380 else if (targetm.in_small_data_p (decl))
5381 flags |= SYMBOL_FLAG_SMALL;
5382 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5383 being PUBLIC, the thing *must* be defined in this translation unit.
5384 Prevent this buglet from being propagated into rtl code as well. */
5385 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5386 flags |= SYMBOL_FLAG_EXTERNAL;
5388 SYMBOL_REF_FLAGS (symbol) = flags;
5391 /* By default, we do nothing for encode_section_info, so we need not
5392 do anything but discard the '*' marker. */
5395 default_strip_name_encoding (const char *str)
5397 return str + (*str == '*');
5400 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5401 wrt cross-module name binding. */
5404 default_binds_local_p (tree exp)
5406 return default_binds_local_p_1 (exp, flag_shlib);
5410 default_binds_local_p_1 (tree exp, int shlib)
5414 /* A non-decl is an entry in the constant pool. */
5417 /* Static variables are always local. */
5418 else if (! TREE_PUBLIC (exp))
5420 /* A variable is local if the user explicitly tells us so. */
5421 else if (DECL_VISIBILITY_SPECIFIED (exp) && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5423 /* Otherwise, variables defined outside this object may not be local. */
5424 else if (DECL_EXTERNAL (exp))
5426 /* Linkonce and weak data are never local. */
5427 else if (DECL_ONE_ONLY (exp) || DECL_WEAK (exp))
5429 /* If none of the above and visibility is not default, make local. */
5430 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5432 /* If PIC, then assume that any global name can be overridden by
5433 symbols resolved from other modules. */
5436 /* Uninitialized COMMON variable may be unified with symbols
5437 resolved from other modules. */
5438 else if (DECL_COMMON (exp)
5439 && (DECL_INITIAL (exp) == NULL
5440 || DECL_INITIAL (exp) == error_mark_node))
5442 /* Otherwise we're left with initialized (or non-common) global data
5443 which is of necessity defined locally. */
5450 /* Determine whether or not a pointer mode is valid. Assume defaults
5451 of ptr_mode or Pmode - can be overridden. */
5453 default_valid_pointer_mode (enum machine_mode mode)
5455 return (mode == ptr_mode || mode == Pmode);
5458 /* Default function to output code that will globalize a label. A
5459 target must define GLOBAL_ASM_OP or provide its own function to
5460 globalize a label. */
5461 #ifdef GLOBAL_ASM_OP
5463 default_globalize_label (FILE * stream, const char *name)
5465 fputs (GLOBAL_ASM_OP, stream);
5466 assemble_name (stream, name);
5467 putc ('\n', stream);
5469 #endif /* GLOBAL_ASM_OP */
5471 /* Default function to output a label for unwind information. The
5472 default is to do nothing. A target that needs nonlocal labels for
5473 unwind information must provide its own function to do this. */
5475 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5476 tree decl ATTRIBUTE_UNUSED,
5477 int for_eh ATTRIBUTE_UNUSED,
5478 int empty ATTRIBUTE_UNUSED)
5482 /* This is how to output an internal numbered label where PREFIX is
5483 the class of label and LABELNO is the number within the class. */
5486 default_internal_label (FILE *stream, const char *prefix,
5487 unsigned long labelno)
5489 char *const buf = alloca (40 + strlen (prefix));
5490 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5491 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5494 /* This is the default behavior at the beginning of a file. It's
5495 controlled by two other target-hook toggles. */
5497 default_file_start (void)
5499 if (targetm.file_start_app_off && !flag_verbose_asm)
5500 fputs (ASM_APP_OFF, asm_out_file);
5502 if (targetm.file_start_file_directive)
5503 output_file_directive (asm_out_file, main_input_filename);
5506 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5507 which emits a special section directive used to indicate whether or
5508 not this object file needs an executable stack. This is primarily
5509 a GNU extension to ELF but could be used on other targets. */
5511 int trampolines_created;
5514 file_end_indicate_exec_stack (void)
5516 unsigned int flags = SECTION_DEBUG;
5517 if (trampolines_created)
5518 flags |= SECTION_CODE;
5520 named_section_flags (".note.GNU-stack", flags);
5523 #include "gt-varasm.h"