1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 /* This file handles generation of all the assembler code
25 *except* the instructions of a function.
26 This includes declarations of variables and their initial values.
28 We also output the assembler code for constants stored in memory
29 and are responsible for combining constants with the same value. */
33 #include "coretypes.h"
40 #include "hard-reg-set.h"
48 #include "langhooks.h"
52 #include "tree-mudflap.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h" /* Needed for external data
59 declarations for e.g. AIX 4.x. */
62 /* The (assembler) name of the first globally-visible object output. */
63 extern GTY(()) const char *first_global_object_name;
64 extern GTY(()) const char *weak_global_object_name;
66 const char *first_global_object_name;
67 const char *weak_global_object_name;
70 struct constant_descriptor_rtx;
71 struct rtx_constant_pool;
73 struct varasm_status GTY(())
75 /* If we're using a per-function constant pool, this is it. */
76 struct rtx_constant_pool *pool;
78 /* Number of tree-constants deferred during the expansion of this
80 unsigned int deferred_constants;
83 #define n_deferred_constants (cfun->varasm->deferred_constants)
85 /* Number for making the label on the next
86 constant that is stored in memory. */
88 static GTY(()) int const_labelno;
90 /* Carry information from ASM_DECLARE_OBJECT_NAME
91 to ASM_FINISH_DECLARE_OBJECT. */
93 int size_directive_output;
95 /* The last decl for which assemble_variable was called,
96 if it did ASM_DECLARE_OBJECT_NAME.
97 If the last call to assemble_variable didn't do that,
100 tree last_assemble_variable_decl;
102 /* The following global variable indicates if the first basic block
103 in a function belongs to the cold partition or not. */
105 bool first_function_block_is_cold;
107 /* We give all constants their own alias set. Perhaps redundant with
108 MEM_READONLY_P, but pre-dates it. */
110 static HOST_WIDE_INT const_alias_set;
112 static const char *strip_reg_name (const char *);
113 static int contains_pointers_p (tree);
114 #ifdef ASM_OUTPUT_EXTERNAL
115 static bool incorporeal_function_p (tree);
117 static void decode_addr_const (tree, struct addr_const *);
118 static hashval_t const_desc_hash (const void *);
119 static int const_desc_eq (const void *, const void *);
120 static hashval_t const_hash_1 (const tree);
121 static int compare_constant (const tree, const tree);
122 static tree copy_constant (tree);
123 static void output_constant_def_contents (rtx);
124 static void output_addressed_constants (tree);
125 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
126 static unsigned min_align (unsigned, unsigned);
127 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
128 static void globalize_decl (tree);
129 static void maybe_assemble_visibility (tree);
130 #ifdef BSS_SECTION_ASM_OP
131 #ifdef ASM_OUTPUT_BSS
132 static void asm_output_bss (FILE *, tree, const char *,
133 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
135 #ifdef ASM_OUTPUT_ALIGNED_BSS
136 static void asm_output_aligned_bss (FILE *, tree, const char *,
137 unsigned HOST_WIDE_INT, int)
140 #endif /* BSS_SECTION_ASM_OP */
141 static void mark_weak (tree);
143 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
144 section *text_section;
145 section *data_section;
146 section *readonly_data_section;
147 section *sdata_section;
148 section *ctors_section;
149 section *dtors_section;
150 section *bss_section;
151 section *sbss_section;
153 /* Various forms of common section. All are guaranteed to be nonnull. */
154 section *tls_comm_section;
155 section *comm_section;
156 section *lcomm_section;
158 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
160 section *bss_noswitch_section;
162 /* The section that holds the main exception table, when known. The section
163 is set either by the target's init_sections hook or by the first call to
164 switch_to_exception_section. */
165 section *exception_section;
167 /* The section that holds the DWARF2 frame unwind information, when known.
168 The section is set either by the target's init_sections hook or by the
169 first call to switch_to_eh_frame_section. */
170 section *eh_frame_section;
172 /* asm_out_file's current section. This is NULL if no section has yet
173 been selected or if we lose track of what the current section is. */
176 /* True if code for the current function is currently being directed
177 at the cold section. */
178 bool in_cold_section_p;
180 /* A linked list of all the unnamed sections. */
181 static GTY(()) section *unnamed_sections;
183 /* Return a nonzero value if DECL has a section attribute. */
184 #ifndef IN_NAMED_SECTION
185 #define IN_NAMED_SECTION(DECL) \
186 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
187 && DECL_SECTION_NAME (DECL) != NULL_TREE)
190 /* Hash table of named sections. */
191 static GTY((param_is (section))) htab_t section_htab;
193 /* A table of object_blocks, indexed by section. */
194 static GTY((param_is (struct object_block))) htab_t object_block_htab;
196 /* The next number to use for internal anchor labels. */
197 static GTY(()) int anchor_labelno;
199 /* Helper routines for maintaining section_htab. */
202 section_entry_eq (const void *p1, const void *p2)
204 const section *old = p1;
205 const char *new = p2;
207 return strcmp (old->named.name, new) == 0;
211 section_entry_hash (const void *p)
213 const section *old = p;
214 return htab_hash_string (old->named.name);
217 /* Return a hash value for section SECT. */
220 hash_section (section *sect)
222 if (sect->common.flags & SECTION_NAMED)
223 return htab_hash_string (sect->named.name);
224 return sect->common.flags;
227 /* Helper routines for maintaining object_block_htab. */
230 object_block_entry_eq (const void *p1, const void *p2)
232 const struct object_block *old = p1;
233 const section *new = p2;
235 return old->sect == new;
239 object_block_entry_hash (const void *p)
241 const struct object_block *old = p;
242 return hash_section (old->sect);
245 /* Return a new unnamed section with the given fields. */
248 get_unnamed_section (unsigned int flags, void (*callback) (const void *),
253 sect = ggc_alloc (sizeof (struct unnamed_section));
254 sect->unnamed.common.flags = flags | SECTION_UNNAMED;
255 sect->unnamed.callback = callback;
256 sect->unnamed.data = data;
257 sect->unnamed.next = unnamed_sections;
259 unnamed_sections = sect;
263 /* Return a SECTION_NOSWITCH section with the given fields. */
266 get_noswitch_section (unsigned int flags, noswitch_section_callback callback)
270 sect = ggc_alloc (sizeof (struct unnamed_section));
271 sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
272 sect->noswitch.callback = callback;
277 /* Return the named section structure associated with NAME. Create
278 a new section with the given fields if no such structure exists. */
281 get_section (const char *name, unsigned int flags, tree decl)
283 section *sect, **slot;
286 htab_find_slot_with_hash (section_htab, name,
287 htab_hash_string (name), INSERT);
288 flags |= SECTION_NAMED;
291 sect = ggc_alloc (sizeof (struct named_section));
292 sect->named.common.flags = flags;
293 sect->named.name = ggc_strdup (name);
294 sect->named.decl = decl;
300 if ((sect->common.flags & ~SECTION_DECLARED) != flags
301 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
303 /* Sanity check user variables for flag changes. */
305 decl = sect->named.decl;
307 error ("%+D causes a section type conflict", decl);
313 /* Return true if the current compilation mode benefits from having
314 objects grouped into blocks. */
317 use_object_blocks_p (void)
319 return flag_section_anchors;
322 /* Return the object_block structure for section SECT. Create a new
323 structure if we haven't created one already. Return null if SECT
326 static struct object_block *
327 get_block_for_section (section *sect)
329 struct object_block *block;
335 slot = htab_find_slot_with_hash (object_block_htab, sect,
336 hash_section (sect), INSERT);
337 block = (struct object_block *) *slot;
340 block = (struct object_block *)
341 ggc_alloc_cleared (sizeof (struct object_block));
348 /* Create a symbol with label LABEL and place it at byte offset
349 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
350 is not yet known. LABEL must be a garbage-collected string. */
353 create_block_symbol (const char *label, struct object_block *block,
354 HOST_WIDE_INT offset)
359 /* Create the extended SYMBOL_REF. */
360 size = RTX_HDR_SIZE + sizeof (struct block_symbol);
361 symbol = ggc_alloc_zone (size, &rtl_zone);
363 /* Initialize the normal SYMBOL_REF fields. */
364 memset (symbol, 0, size);
365 PUT_CODE (symbol, SYMBOL_REF);
366 PUT_MODE (symbol, Pmode);
367 XSTR (symbol, 0) = label;
368 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
370 /* Initialize the block_symbol stuff. */
371 SYMBOL_REF_BLOCK (symbol) = block;
372 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
378 initialize_cold_section_name (void)
380 const char *stripped_name;
384 gcc_assert (cfun && current_function_decl);
385 if (cfun->unlikely_text_section_name)
388 dsn = DECL_SECTION_NAME (current_function_decl);
389 if (flag_function_sections && dsn)
391 name = alloca (TREE_STRING_LENGTH (dsn) + 1);
392 memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
394 stripped_name = targetm.strip_name_encoding (name);
396 buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
397 cfun->unlikely_text_section_name = ggc_strdup (buffer);
400 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
403 /* Tell assembler to switch to unlikely-to-be-executed text section. */
406 unlikely_text_section (void)
410 if (!cfun->unlikely_text_section_name)
411 initialize_cold_section_name ();
413 return get_named_section (NULL, cfun->unlikely_text_section_name, 0);
416 return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
419 /* When called within a function context, return true if the function
420 has been assigned a cold text section and if SECT is that section.
421 When called outside a function context, return true if SECT is the
422 default cold section. */
425 unlikely_text_section_p (section *sect)
430 name = cfun->unlikely_text_section_name;
432 name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
436 && SECTION_STYLE (sect) == SECTION_NAMED
437 && strcmp (name, sect->named.name) == 0);
440 /* Return a section with a particular name and with whatever SECTION_*
441 flags section_type_flags deems appropriate. The name of the section
442 is taken from NAME if nonnull, otherwise it is taken from DECL's
443 DECL_SECTION_NAME. DECL is the decl associated with the section
444 (see the section comment for details) and RELOC is as for
445 section_type_flags. */
448 get_named_section (tree decl, const char *name, int reloc)
452 gcc_assert (!decl || DECL_P (decl));
454 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
456 flags = targetm.section_type_flags (decl, name, reloc);
458 return get_section (name, flags, decl);
461 /* If required, set DECL_SECTION_NAME to a unique name. */
464 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
465 int flag_function_or_data_sections)
467 if (DECL_SECTION_NAME (decl) == NULL_TREE
468 && targetm.have_named_sections
469 && (flag_function_or_data_sections
470 || DECL_ONE_ONLY (decl)))
471 targetm.asm_out.unique_section (decl, reloc);
474 #ifdef BSS_SECTION_ASM_OP
476 #ifdef ASM_OUTPUT_BSS
478 /* Utility function for ASM_OUTPUT_BSS for targets to use if
479 they don't support alignments in .bss.
480 ??? It is believed that this function will work in most cases so such
481 support is localized here. */
484 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
486 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
487 unsigned HOST_WIDE_INT rounded)
489 targetm.asm_out.globalize_label (file, name);
490 switch_to_section (bss_section);
491 #ifdef ASM_DECLARE_OBJECT_NAME
492 last_assemble_variable_decl = decl;
493 ASM_DECLARE_OBJECT_NAME (file, name, decl);
495 /* Standard thing is just output label for the object. */
496 ASM_OUTPUT_LABEL (file, name);
497 #endif /* ASM_DECLARE_OBJECT_NAME */
498 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
503 #ifdef ASM_OUTPUT_ALIGNED_BSS
505 /* Utility function for targets to use in implementing
506 ASM_OUTPUT_ALIGNED_BSS.
507 ??? It is believed that this function will work in most cases so such
508 support is localized here. */
511 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
512 const char *name, unsigned HOST_WIDE_INT size,
515 switch_to_section (bss_section);
516 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
517 #ifdef ASM_DECLARE_OBJECT_NAME
518 last_assemble_variable_decl = decl;
519 ASM_DECLARE_OBJECT_NAME (file, name, decl);
521 /* Standard thing is just output label for the object. */
522 ASM_OUTPUT_LABEL (file, name);
523 #endif /* ASM_DECLARE_OBJECT_NAME */
524 ASM_OUTPUT_SKIP (file, size ? size : 1);
529 #endif /* BSS_SECTION_ASM_OP */
531 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
532 /* Return the hot section for function DECL. Return text_section for
536 hot_function_section (tree decl)
538 if (decl != NULL_TREE
539 && DECL_SECTION_NAME (decl) != NULL_TREE
540 && targetm.have_named_sections)
541 return get_named_section (decl, NULL, 0);
547 /* Return the section for function DECL.
549 If DECL is NULL_TREE, return the text section. We can be passed
550 NULL_TREE under some circumstances by dbxout.c at least. */
553 function_section (tree decl)
557 if (first_function_block_is_cold)
560 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
561 if (decl != NULL_TREE
562 && DECL_SECTION_NAME (decl) != NULL_TREE)
563 return reloc ? unlikely_text_section ()
564 : get_named_section (decl, NULL, 0);
566 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
568 return reloc ? unlikely_text_section () : hot_function_section (decl);
573 current_function_section (void)
575 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
576 if (current_function_decl != NULL_TREE
577 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
578 return in_cold_section_p ? unlikely_text_section ()
579 : get_named_section (current_function_decl,
582 return targetm.asm_out.select_section (current_function_decl,
584 DECL_ALIGN (current_function_decl));
586 return (in_cold_section_p
587 ? unlikely_text_section ()
588 : hot_function_section (current_function_decl));
592 /* Return the read-only data section associated with function DECL. */
595 default_function_rodata_section (tree decl)
597 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
599 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
601 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
603 size_t len = strlen (name) + 3;
604 char* rname = alloca (len);
606 strcpy (rname, ".rodata");
607 strcat (rname, name + 5);
608 return get_section (rname, SECTION_LINKONCE, decl);
610 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
611 else if (DECL_ONE_ONLY (decl)
612 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
614 size_t len = strlen (name) + 1;
615 char *rname = alloca (len);
617 memcpy (rname, name, len);
619 return get_section (rname, SECTION_LINKONCE, decl);
621 /* For .text.foo we want to use .rodata.foo. */
622 else if (flag_function_sections && flag_data_sections
623 && strncmp (name, ".text.", 6) == 0)
625 size_t len = strlen (name) + 1;
626 char *rname = alloca (len + 2);
628 memcpy (rname, ".rodata", 7);
629 memcpy (rname + 7, name + 5, len - 5);
630 return get_section (rname, 0, decl);
634 return readonly_data_section;
637 /* Return the read-only data section associated with function DECL
638 for targets where that section should be always the single
639 readonly data section. */
642 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
644 return readonly_data_section;
647 /* Return the section to use for string merging. */
650 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
651 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
652 unsigned int flags ATTRIBUTE_UNUSED)
654 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
655 && TREE_CODE (decl) == STRING_CST
656 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
658 && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
660 enum machine_mode mode;
661 unsigned int modesize;
666 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
667 modesize = GET_MODE_BITSIZE (mode);
668 if (modesize >= 8 && modesize <= 256
669 && (modesize & (modesize - 1)) == 0)
671 if (align < modesize)
674 str = TREE_STRING_POINTER (decl);
675 len = TREE_STRING_LENGTH (decl);
676 unit = GET_MODE_SIZE (mode);
678 /* Check for embedded NUL characters. */
679 for (i = 0; i < len; i += unit)
681 for (j = 0; j < unit; j++)
682 if (str[i + j] != '\0')
689 sprintf (name, ".rodata.str%d.%d", modesize / 8,
691 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
692 return get_section (name, flags, NULL);
697 return readonly_data_section;
700 /* Return the section to use for constant merging. */
703 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
704 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
705 unsigned int flags ATTRIBUTE_UNUSED)
707 unsigned int modesize = GET_MODE_BITSIZE (mode);
709 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
715 && (align & (align - 1)) == 0)
719 sprintf (name, ".rodata.cst%d", (int) (align / 8));
720 flags |= (align / 8) | SECTION_MERGE;
721 return get_section (name, flags, NULL);
723 return readonly_data_section;
726 /* Given NAME, a putative register name, discard any customary prefixes. */
729 strip_reg_name (const char *name)
731 #ifdef REGISTER_PREFIX
732 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
733 name += strlen (REGISTER_PREFIX);
735 if (name[0] == '%' || name[0] == '#')
740 /* The user has asked for a DECL to have a particular name. Set (or
741 change) it in such a way that we don't prefix an underscore to
744 set_user_assembler_name (tree decl, const char *name)
746 char *starred = alloca (strlen (name) + 2);
748 strcpy (starred + 1, name);
749 change_decl_assembler_name (decl, get_identifier (starred));
750 SET_DECL_RTL (decl, NULL_RTX);
753 /* Decode an `asm' spec for a declaration as a register name.
754 Return the register number, or -1 if nothing specified,
755 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
756 or -3 if ASMSPEC is `cc' and is not recognized,
757 or -4 if ASMSPEC is `memory' and is not recognized.
758 Accept an exact spelling or a decimal number.
759 Prefixes such as % are optional. */
762 decode_reg_name (const char *asmspec)
768 /* Get rid of confusing prefixes. */
769 asmspec = strip_reg_name (asmspec);
771 /* Allow a decimal number as a "register name". */
772 for (i = strlen (asmspec) - 1; i >= 0; i--)
773 if (! ISDIGIT (asmspec[i]))
775 if (asmspec[0] != 0 && i < 0)
778 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
784 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
786 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
789 #ifdef ADDITIONAL_REGISTER_NAMES
791 static const struct { const char *const name; const int number; } table[]
792 = ADDITIONAL_REGISTER_NAMES;
794 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
796 && ! strcmp (asmspec, table[i].name))
797 return table[i].number;
799 #endif /* ADDITIONAL_REGISTER_NAMES */
801 if (!strcmp (asmspec, "memory"))
804 if (!strcmp (asmspec, "cc"))
813 /* Return true if DECL's initializer is suitable for a BSS section. */
816 bss_initializer_p (tree decl)
818 return (DECL_INITIAL (decl) == NULL
819 || DECL_INITIAL (decl) == error_mark_node
820 || (flag_zero_initialized_in_bss
821 /* Leave constant zeroes in .rodata so they
823 && !TREE_READONLY (decl)
824 && initializer_zerop (DECL_INITIAL (decl))));
827 /* Return the section into which the given VAR_DECL or CONST_DECL
828 should be placed. PREFER_NOSWITCH_P is true if a noswitch
829 section should be used wherever possible. */
832 get_variable_section (tree decl, bool prefer_noswitch_p)
836 /* If the decl has been given an explicit section name, then it
837 isn't common, and shouldn't be handled as such. */
838 if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
840 if (DECL_THREAD_LOCAL_P (decl))
841 return tls_comm_section;
842 if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
846 if (DECL_INITIAL (decl) == error_mark_node)
847 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
848 else if (DECL_INITIAL (decl))
849 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
853 resolve_unique_section (decl, reloc, flag_data_sections);
854 if (IN_NAMED_SECTION (decl))
855 return get_named_section (decl, NULL, reloc);
857 if (!DECL_THREAD_LOCAL_P (decl)
858 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
859 && bss_initializer_p (decl))
861 if (!TREE_PUBLIC (decl))
862 return lcomm_section;
863 if (bss_noswitch_section)
864 return bss_noswitch_section;
867 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
870 /* Return the block into which object_block DECL should be placed. */
872 static struct object_block *
873 get_block_for_decl (tree decl)
877 if (TREE_CODE (decl) == VAR_DECL)
879 /* The object must be defined in this translation unit. */
880 if (DECL_EXTERNAL (decl))
883 /* There's no point using object blocks for something that is
884 isolated by definition. */
885 if (DECL_ONE_ONLY (decl))
889 /* We can only calculate block offsets if the decl has a known
891 if (DECL_SIZE_UNIT (decl) == NULL)
893 if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
896 /* Find out which section should contain DECL. We cannot put it into
897 an object block if it requires a standalone definition. */
898 sect = get_variable_section (decl, true);
899 if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
902 return get_block_for_section (sect);
905 /* Make sure block symbol SYMBOL is in block BLOCK. */
908 change_symbol_block (rtx symbol, struct object_block *block)
910 if (block != SYMBOL_REF_BLOCK (symbol))
912 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
913 SYMBOL_REF_BLOCK (symbol) = block;
917 /* Return true if it is possible to put DECL in an object_block. */
920 use_blocks_for_decl_p (tree decl)
922 /* Only data DECLs can be placed into object blocks. */
923 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
926 /* Detect decls created by dw2_force_const_mem. Such decls are
927 special because DECL_INITIAL doesn't specify the decl's true value.
928 dw2_output_indirect_constants will instead call assemble_variable
929 with dont_output_data set to 1 and then print the contents itself. */
930 if (DECL_INITIAL (decl) == decl)
936 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
937 have static storage duration. In other words, it should not be an
938 automatic variable, including PARM_DECLs.
940 There is, however, one exception: this function handles variables
941 explicitly placed in a particular register by the user.
943 This is never called for PARM_DECL nodes. */
946 make_decl_rtl (tree decl)
948 const char *name = 0;
952 /* Check that we are not being given an automatic variable. */
953 gcc_assert (TREE_CODE (decl) != PARM_DECL
954 && TREE_CODE (decl) != RESULT_DECL);
956 /* A weak alias has TREE_PUBLIC set but not the other bits. */
957 gcc_assert (TREE_CODE (decl) != VAR_DECL
958 || TREE_STATIC (decl)
959 || TREE_PUBLIC (decl)
960 || DECL_EXTERNAL (decl)
961 || DECL_REGISTER (decl));
963 /* And that we were not given a type or a label. */
964 gcc_assert (TREE_CODE (decl) != TYPE_DECL
965 && TREE_CODE (decl) != LABEL_DECL);
967 /* For a duplicate declaration, we can be called twice on the
968 same DECL node. Don't discard the RTL already made. */
969 if (DECL_RTL_SET_P (decl))
971 /* If the old RTL had the wrong mode, fix the mode. */
973 if (GET_MODE (x) != DECL_MODE (decl))
974 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
976 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
979 /* ??? Another way to do this would be to maintain a hashed
980 table of such critters. Instead of adding stuff to a DECL
981 to give certain attributes to it, we could use an external
982 hash map from DECL to set of attributes. */
984 /* Let the target reassign the RTL if it wants.
985 This is necessary, for example, when one machine specific
986 decl attribute overrides another. */
987 targetm.encode_section_info (decl, DECL_RTL (decl), false);
989 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
990 on the new decl information. */
992 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
993 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
994 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
996 /* Make this function static known to the mudflap runtime. */
997 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
998 mudflap_enqueue_decl (decl);
1003 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1005 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1006 && DECL_REGISTER (decl))
1008 error ("register name not specified for %q+D", decl);
1010 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1012 const char *asmspec = name+1;
1013 reg_number = decode_reg_name (asmspec);
1014 /* First detect errors in declaring global registers. */
1015 if (reg_number == -1)
1016 error ("register name not specified for %q+D", decl);
1017 else if (reg_number < 0)
1018 error ("invalid register name for %q+D", decl);
1019 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1020 error ("data type of %q+D isn%'t suitable for a register",
1022 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1023 error ("register specified for %q+D isn%'t suitable for data type",
1025 /* Now handle properly declared static register variables. */
1030 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1032 DECL_INITIAL (decl) = 0;
1033 error ("global register variable has initial value");
1035 if (TREE_THIS_VOLATILE (decl))
1036 warning (OPT_Wvolatile_register_var,
1037 "optimization may eliminate reads and/or "
1038 "writes to register variables");
1040 /* If the user specified one of the eliminables registers here,
1041 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1042 confused with that register and be eliminated. This usage is
1043 somewhat suspect... */
1045 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1046 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1047 REG_USERVAR_P (DECL_RTL (decl)) = 1;
1049 if (TREE_STATIC (decl))
1051 /* Make this register global, so not usable for anything
1053 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1054 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1055 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1057 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1059 globalize_reg (reg_number + --nregs);
1062 /* As a register variable, it has no section. */
1066 /* Now handle ordinary static variables and functions (in memory).
1067 Also handle vars declared register invalidly. */
1068 else if (name[0] == '*')
1070 #ifdef REGISTER_PREFIX
1071 if (strlen (REGISTER_PREFIX) != 0)
1073 reg_number = decode_reg_name (name);
1074 if (reg_number >= 0 || reg_number == -3)
1075 error ("register name given for non-register variable %q+D", decl);
1080 /* Specifying a section attribute on a variable forces it into a
1081 non-.bss section, and thus it cannot be common. */
1082 if (TREE_CODE (decl) == VAR_DECL
1083 && DECL_SECTION_NAME (decl) != NULL_TREE
1084 && DECL_INITIAL (decl) == NULL_TREE
1085 && DECL_COMMON (decl))
1086 DECL_COMMON (decl) = 0;
1088 /* Variables can't be both common and weak. */
1089 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1090 DECL_COMMON (decl) = 0;
1092 if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1093 x = create_block_symbol (name, get_block_for_decl (decl), -1);
1095 x = gen_rtx_SYMBOL_REF (Pmode, name);
1096 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1097 SET_SYMBOL_REF_DECL (x, decl);
1099 x = gen_rtx_MEM (DECL_MODE (decl), x);
1100 if (TREE_CODE (decl) != FUNCTION_DECL)
1101 set_mem_attributes (x, decl, 1);
1102 SET_DECL_RTL (decl, x);
1104 /* Optionally set flags or add text to the name to record information
1105 such as that it is a function name.
1106 If the name is changed, the macro ASM_OUTPUT_LABELREF
1107 will have to know how to strip this information. */
1108 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1110 /* Make this function static known to the mudflap runtime. */
1111 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1112 mudflap_enqueue_decl (decl);
1115 /* Make the rtl for variable VAR be volatile.
1116 Use this only for static variables. */
1119 make_var_volatile (tree var)
1121 gcc_assert (MEM_P (DECL_RTL (var)));
1123 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1126 /* Output a string of literal assembler code
1127 for an `asm' keyword used between functions. */
1130 assemble_asm (tree string)
1134 if (TREE_CODE (string) == ADDR_EXPR)
1135 string = TREE_OPERAND (string, 0);
1137 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1140 /* Record an element in the table of global destructors. SYMBOL is
1141 a SYMBOL_REF of the function to be called; PRIORITY is a number
1142 between 0 and MAX_INIT_PRIORITY. */
1145 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1146 int priority ATTRIBUTE_UNUSED)
1148 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1149 /* Tell GNU LD that this is part of the static destructor set.
1150 This will work for any system that uses stabs, most usefully
1152 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1153 dbxout_stab_value_label (XSTR (symbol, 0));
1155 sorry ("global destructors not supported on this target");
1160 default_named_section_asm_out_destructor (rtx symbol, int priority)
1162 const char *section = ".dtors";
1165 /* ??? This only works reliably with the GNU linker. */
1166 if (priority != DEFAULT_INIT_PRIORITY)
1168 sprintf (buf, ".dtors.%.5u",
1169 /* Invert the numbering so the linker puts us in the proper
1170 order; constructors are run from right to left, and the
1171 linker sorts in increasing order. */
1172 MAX_INIT_PRIORITY - priority);
1176 switch_to_section (get_section (section, SECTION_WRITE, NULL));
1177 assemble_align (POINTER_SIZE);
1178 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1181 #ifdef DTORS_SECTION_ASM_OP
1183 default_dtor_section_asm_out_destructor (rtx symbol,
1184 int priority ATTRIBUTE_UNUSED)
1186 switch_to_section (dtors_section);
1187 assemble_align (POINTER_SIZE);
1188 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1192 /* Likewise for global constructors. */
1195 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1196 int priority ATTRIBUTE_UNUSED)
1198 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1199 /* Tell GNU LD that this is part of the static destructor set.
1200 This will work for any system that uses stabs, most usefully
1202 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1203 dbxout_stab_value_label (XSTR (symbol, 0));
1205 sorry ("global constructors not supported on this target");
1210 default_named_section_asm_out_constructor (rtx symbol, int priority)
1212 const char *section = ".ctors";
1215 /* ??? This only works reliably with the GNU linker. */
1216 if (priority != DEFAULT_INIT_PRIORITY)
1218 sprintf (buf, ".ctors.%.5u",
1219 /* Invert the numbering so the linker puts us in the proper
1220 order; constructors are run from right to left, and the
1221 linker sorts in increasing order. */
1222 MAX_INIT_PRIORITY - priority);
1226 switch_to_section (get_section (section, SECTION_WRITE, NULL));
1227 assemble_align (POINTER_SIZE);
1228 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1231 #ifdef CTORS_SECTION_ASM_OP
1233 default_ctor_section_asm_out_constructor (rtx symbol,
1234 int priority ATTRIBUTE_UNUSED)
1236 switch_to_section (ctors_section);
1237 assemble_align (POINTER_SIZE);
1238 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1242 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1243 a nonzero value if the constant pool should be output before the
1244 start of the function, or a zero value if the pool should output
1245 after the end of the function. The default is to put it before the
1248 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1249 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1252 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1253 to be output to assembler.
1254 Set first_global_object_name and weak_global_object_name as appropriate. */
1257 notice_global_symbol (tree decl)
1259 const char **type = &first_global_object_name;
1261 if (first_global_object_name
1262 || !TREE_PUBLIC (decl)
1263 || DECL_EXTERNAL (decl)
1264 || !DECL_NAME (decl)
1265 || (TREE_CODE (decl) != FUNCTION_DECL
1266 && (TREE_CODE (decl) != VAR_DECL
1267 || (DECL_COMMON (decl)
1268 && (DECL_INITIAL (decl) == 0
1269 || DECL_INITIAL (decl) == error_mark_node))))
1270 || !MEM_P (DECL_RTL (decl)))
1273 /* We win when global object is found, but it is useful to know about weak
1274 symbol as well so we can produce nicer unique names. */
1275 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1276 type = &weak_global_object_name;
1282 rtx decl_rtl = DECL_RTL (decl);
1284 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1285 name = ggc_strdup (p);
1291 /* Output assembler code for the constant pool of a function and associated
1292 with defining the name of the function. DECL describes the function.
1293 NAME is the function's name. For the constant pool, we use the current
1294 constant pool data. */
1297 assemble_start_function (tree decl, const char *fnname)
1300 char tmp_label[100];
1301 bool hot_label_written = false;
1303 cfun->unlikely_text_section_name = NULL;
1305 first_function_block_is_cold = false;
1306 if (flag_reorder_blocks_and_partition)
1308 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1309 cfun->hot_section_label = ggc_strdup (tmp_label);
1310 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1311 cfun->cold_section_label = ggc_strdup (tmp_label);
1312 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1313 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1314 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1315 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1320 cfun->hot_section_label = NULL;
1321 cfun->cold_section_label = NULL;
1322 cfun->hot_section_end_label = NULL;
1323 cfun->cold_section_end_label = NULL;
1326 /* The following code does not need preprocessing in the assembler. */
1330 if (CONSTANT_POOL_BEFORE_FUNCTION)
1331 output_constant_pool (fnname, decl);
1333 resolve_unique_section (decl, 0, flag_function_sections);
1335 /* Make sure the not and cold text (code) sections are properly
1336 aligned. This is necessary here in the case where the function
1337 has both hot and cold sections, because we don't want to re-set
1338 the alignment when the section switch happens mid-function. */
1340 if (flag_reorder_blocks_and_partition)
1342 switch_to_section (unlikely_text_section ());
1343 assemble_align (FUNCTION_BOUNDARY);
1344 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1346 /* When the function starts with a cold section, we need to explicitly
1347 align the hot section and write out the hot section label.
1348 But if the current function is a thunk, we do not have a CFG. */
1349 if (!current_function_is_thunk
1350 && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1352 switch_to_section (text_section);
1353 assemble_align (FUNCTION_BOUNDARY);
1354 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1355 hot_label_written = true;
1356 first_function_block_is_cold = true;
1359 else if (DECL_SECTION_NAME (decl))
1361 /* Calls to function_section rely on first_function_block_is_cold
1362 being accurate. The first block may be cold even if we aren't
1363 doing partitioning, if the entire function was decided by
1364 choose_function_section (predict.c) to be cold. */
1366 initialize_cold_section_name ();
1368 if (cfun->unlikely_text_section_name
1369 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1370 cfun->unlikely_text_section_name) == 0)
1371 first_function_block_is_cold = true;
1374 in_cold_section_p = first_function_block_is_cold;
1376 /* Switch to the correct text section for the start of the function. */
1378 switch_to_section (function_section (decl));
1379 if (flag_reorder_blocks_and_partition
1380 && !hot_label_written)
1381 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1383 /* Tell assembler to move to target machine's alignment for functions. */
1384 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1385 if (align < force_align_functions_log)
1386 align = force_align_functions_log;
1389 ASM_OUTPUT_ALIGN (asm_out_file, align);
1392 /* Handle a user-specified function alignment.
1393 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1394 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1395 if (align_functions_log > align
1396 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1398 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1399 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1400 align_functions_log, align_functions - 1);
1402 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1406 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1407 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1410 (*debug_hooks->begin_function) (decl);
1412 /* Make function name accessible from other files, if appropriate. */
1414 if (TREE_PUBLIC (decl))
1416 notice_global_symbol (decl);
1418 globalize_decl (decl);
1420 maybe_assemble_visibility (decl);
1423 if (DECL_PRESERVE_P (decl))
1424 targetm.asm_out.mark_decl_preserved (fnname);
1426 /* Do any machine/system dependent processing of the function name. */
1427 #ifdef ASM_DECLARE_FUNCTION_NAME
1428 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1430 /* Standard thing is just output label for the function. */
1431 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1432 #endif /* ASM_DECLARE_FUNCTION_NAME */
1435 /* Output assembler code associated with defining the size of the
1436 function. DECL describes the function. NAME is the function's name. */
1439 assemble_end_function (tree decl, const char *fnname)
1441 #ifdef ASM_DECLARE_FUNCTION_SIZE
1442 /* We could have switched section in the middle of the function. */
1443 if (flag_reorder_blocks_and_partition)
1444 switch_to_section (function_section (decl));
1445 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1447 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1449 output_constant_pool (fnname, decl);
1450 switch_to_section (function_section (decl)); /* need to switch back */
1452 /* Output labels for end of hot/cold text sections (to be used by
1454 if (flag_reorder_blocks_and_partition)
1456 section *save_text_section;
1458 save_text_section = in_section;
1459 switch_to_section (unlikely_text_section ());
1460 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1461 if (first_function_block_is_cold)
1462 switch_to_section (text_section);
1464 switch_to_section (function_section (decl));
1465 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1466 switch_to_section (save_text_section);
1470 /* Assemble code to leave SIZE bytes of zeros. */
1473 assemble_zeros (unsigned HOST_WIDE_INT size)
1475 /* Do no output if -fsyntax-only. */
1476 if (flag_syntax_only)
1479 #ifdef ASM_NO_SKIP_IN_TEXT
1480 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1481 so we must output 0s explicitly in the text section. */
1482 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1484 unsigned HOST_WIDE_INT i;
1485 for (i = 0; i < size; i++)
1486 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1491 ASM_OUTPUT_SKIP (asm_out_file, size);
1494 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1497 assemble_align (int align)
1499 if (align > BITS_PER_UNIT)
1501 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1505 /* Assemble a string constant with the specified C string as contents. */
1508 assemble_string (const char *p, int size)
1513 /* If the string is very long, split it up. */
1517 int thissize = size - pos;
1518 if (thissize > maximum)
1521 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1529 /* A noswitch_section_callback for lcomm_section. */
1532 emit_local (tree decl ATTRIBUTE_UNUSED,
1533 const char *name ATTRIBUTE_UNUSED,
1534 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1535 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1537 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1538 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1539 size, DECL_ALIGN (decl));
1541 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1542 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1545 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1550 /* A noswitch_section_callback for bss_noswitch_section. */
1552 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1554 emit_bss (tree decl ATTRIBUTE_UNUSED,
1555 const char *name ATTRIBUTE_UNUSED,
1556 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1557 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1559 #if defined ASM_OUTPUT_ALIGNED_BSS
1560 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1563 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1569 /* A noswitch_section_callback for comm_section. */
1572 emit_common (tree decl ATTRIBUTE_UNUSED,
1573 const char *name ATTRIBUTE_UNUSED,
1574 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1575 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1577 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1578 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1579 size, DECL_ALIGN (decl));
1581 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1582 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1585 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1590 /* A noswitch_section_callback for tls_comm_section. */
1593 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1594 const char *name ATTRIBUTE_UNUSED,
1595 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1596 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1598 #ifdef ASM_OUTPUT_TLS_COMMON
1599 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1602 sorry ("thread-local COMMON data not implemented");
1607 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1608 NAME is the name of DECL's SYMBOL_REF. */
1611 assemble_noswitch_variable (tree decl, const char *name, section *sect)
1613 unsigned HOST_WIDE_INT size, rounded;
1615 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1618 /* Don't allocate zero bytes of common,
1619 since that means "undefined external" in the linker. */
1623 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1624 so that each uninitialized object starts on such a boundary. */
1625 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1626 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1627 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1629 if (!sect->noswitch.callback (decl, name, size, rounded)
1630 && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1631 warning (0, "requested alignment for %q+D is greater than "
1632 "implemented alignment of %wu", decl, rounded);
1635 /* A subroutine of assemble_variable. Output the label and contents of
1636 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
1637 is as for assemble_variable. */
1640 assemble_variable_contents (tree decl, const char *name,
1641 bool dont_output_data)
1643 /* Do any machine/system dependent processing of the object. */
1644 #ifdef ASM_DECLARE_OBJECT_NAME
1645 last_assemble_variable_decl = decl;
1646 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1648 /* Standard thing is just output label for the object. */
1649 ASM_OUTPUT_LABEL (asm_out_file, name);
1650 #endif /* ASM_DECLARE_OBJECT_NAME */
1652 if (!dont_output_data)
1654 if (DECL_INITIAL (decl)
1655 && DECL_INITIAL (decl) != error_mark_node
1656 && !initializer_zerop (DECL_INITIAL (decl)))
1657 /* Output the actual data. */
1658 output_constant (DECL_INITIAL (decl),
1659 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1662 /* Leave space for it. */
1663 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1667 /* Assemble everything that is needed for a variable or function declaration.
1668 Not used for automatic variables, and not used for function definitions.
1669 Should not be called for variables of incomplete structure type.
1671 TOP_LEVEL is nonzero if this variable has file scope.
1672 AT_END is nonzero if this is the special handling, at end of compilation,
1673 to define things that have had only tentative definitions.
1674 DONT_OUTPUT_DATA if nonzero means don't actually output the
1675 initial value (that will be done by the caller). */
1678 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1679 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1683 rtx decl_rtl, symbol;
1686 if (lang_hooks.decls.prepare_assemble_variable)
1687 lang_hooks.decls.prepare_assemble_variable (decl);
1689 last_assemble_variable_decl = 0;
1691 /* Normally no need to say anything here for external references,
1692 since assemble_external is called by the language-specific code
1693 when a declaration is first seen. */
1695 if (DECL_EXTERNAL (decl))
1698 /* Output no assembler code for a function declaration.
1699 Only definitions of functions output anything. */
1701 if (TREE_CODE (decl) == FUNCTION_DECL)
1704 /* Do nothing for global register variables. */
1705 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1707 TREE_ASM_WRITTEN (decl) = 1;
1711 /* If type was incomplete when the variable was declared,
1712 see if it is complete now. */
1714 if (DECL_SIZE (decl) == 0)
1715 layout_decl (decl, 0);
1717 /* Still incomplete => don't allocate it; treat the tentative defn
1718 (which is what it must have been) as an `extern' reference. */
1720 if (!dont_output_data && DECL_SIZE (decl) == 0)
1722 error ("storage size of %q+D isn%'t known", decl);
1723 TREE_ASM_WRITTEN (decl) = 1;
1727 /* The first declaration of a variable that comes through this function
1728 decides whether it is global (in C, has external linkage)
1729 or local (in C, has internal linkage). So do nothing more
1730 if this function has already run. */
1732 if (TREE_ASM_WRITTEN (decl))
1735 /* Make sure targetm.encode_section_info is invoked before we set
1737 decl_rtl = DECL_RTL (decl);
1739 TREE_ASM_WRITTEN (decl) = 1;
1741 /* Do no output if -fsyntax-only. */
1742 if (flag_syntax_only)
1747 if (! dont_output_data
1748 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1750 error ("size of variable %q+D is too large", decl);
1754 gcc_assert (MEM_P (decl_rtl));
1755 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
1756 symbol = XEXP (decl_rtl, 0);
1757 name = XSTR (symbol, 0);
1758 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1759 notice_global_symbol (decl);
1761 /* Compute the alignment of this data. */
1763 align = DECL_ALIGN (decl);
1765 /* In the case for initialing an array whose length isn't specified,
1766 where we have not yet been able to do the layout,
1767 figure out the proper alignment now. */
1768 if (dont_output_data && DECL_SIZE (decl) == 0
1769 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1770 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1772 /* Some object file formats have a maximum alignment which they support.
1773 In particular, a.out format supports a maximum alignment of 4. */
1774 if (align > MAX_OFILE_ALIGNMENT)
1776 warning (0, "alignment of %q+D is greater than maximum object "
1777 "file alignment. Using %d", decl,
1778 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1779 align = MAX_OFILE_ALIGNMENT;
1782 /* On some machines, it is good to increase alignment sometimes. */
1783 if (! DECL_USER_ALIGN (decl))
1785 #ifdef DATA_ALIGNMENT
1786 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1788 #ifdef CONSTANT_ALIGNMENT
1789 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1790 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1794 /* Reset the alignment in case we have made it tighter, so we can benefit
1795 from it in get_pointer_alignment. */
1796 DECL_ALIGN (decl) = align;
1797 set_mem_align (decl_rtl, align);
1799 if (TREE_PUBLIC (decl))
1800 maybe_assemble_visibility (decl);
1802 if (DECL_PRESERVE_P (decl))
1803 targetm.asm_out.mark_decl_preserved (name);
1805 /* First make the assembler name(s) global if appropriate. */
1806 sect = get_variable_section (decl, false);
1807 if (TREE_PUBLIC (decl)
1809 && (sect->common.flags & SECTION_COMMON) == 0)
1810 globalize_decl (decl);
1812 /* Output any data that we will need to use the address of. */
1813 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1814 output_addressed_constants (DECL_INITIAL (decl));
1816 /* dbxout.c needs to know this. */
1817 if (in_section && (in_section->common.flags & SECTION_CODE) != 0)
1818 DECL_IN_TEXT_SECTION (decl) = 1;
1820 /* If the decl is part of an object_block, make sure that the decl
1821 has been positioned within its block, but do not write out its
1822 definition yet. output_object_blocks will do that later. */
1823 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
1825 gcc_assert (!dont_output_data);
1826 place_block_symbol (symbol);
1828 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1829 assemble_noswitch_variable (decl, name, sect);
1832 switch_to_section (sect);
1833 if (align > BITS_PER_UNIT)
1834 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1835 assemble_variable_contents (decl, name, dont_output_data);
1839 /* Return 1 if type TYPE contains any pointers. */
1842 contains_pointers_p (tree type)
1844 switch (TREE_CODE (type))
1847 case REFERENCE_TYPE:
1848 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1849 so I'll play safe and return 1. */
1855 case QUAL_UNION_TYPE:
1858 /* For a type that has fields, see if the fields have pointers. */
1859 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1860 if (TREE_CODE (fields) == FIELD_DECL
1861 && contains_pointers_p (TREE_TYPE (fields)))
1867 /* An array type contains pointers if its element type does. */
1868 return contains_pointers_p (TREE_TYPE (type));
1875 /* In unit-at-a-time mode, we delay assemble_external processing until
1876 the compilation unit is finalized. This is the best we can do for
1877 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1878 it all the way to final. See PR 17982 for further discussion. */
1879 static GTY(()) tree pending_assemble_externals;
1881 #ifdef ASM_OUTPUT_EXTERNAL
1882 /* True if DECL is a function decl for which no out-of-line copy exists.
1883 It is assumed that DECL's assembler name has been set. */
1886 incorporeal_function_p (tree decl)
1888 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1892 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1893 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1896 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1897 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1903 /* Actually do the tests to determine if this is necessary, and invoke
1904 ASM_OUTPUT_EXTERNAL. */
1906 assemble_external_real (tree decl)
1908 rtx rtl = DECL_RTL (decl);
1910 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1911 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1912 && !incorporeal_function_p (decl))
1914 /* Some systems do require some output. */
1915 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1916 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1922 process_pending_assemble_externals (void)
1924 #ifdef ASM_OUTPUT_EXTERNAL
1926 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1927 assemble_external_real (TREE_VALUE (list));
1929 pending_assemble_externals = 0;
1933 /* Output something to declare an external symbol to the assembler.
1934 (Most assemblers don't need this, so we normally output nothing.)
1935 Do nothing if DECL is not external. */
1938 assemble_external (tree decl ATTRIBUTE_UNUSED)
1940 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1941 main body of this code is only rarely exercised. To provide some
1942 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1943 open. If it's not, we should not be calling this function. */
1944 gcc_assert (asm_out_file);
1946 #ifdef ASM_OUTPUT_EXTERNAL
1947 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1950 if (flag_unit_at_a_time)
1951 pending_assemble_externals = tree_cons (0, decl,
1952 pending_assemble_externals);
1954 assemble_external_real (decl);
1958 /* Similar, for calling a library function FUN. */
1961 assemble_external_libcall (rtx fun)
1963 /* Declare library function name external when first used, if nec. */
1964 if (! SYMBOL_REF_USED (fun))
1966 SYMBOL_REF_USED (fun) = 1;
1967 targetm.asm_out.external_libcall (fun);
1971 /* Assemble a label named NAME. */
1974 assemble_label (const char *name)
1976 ASM_OUTPUT_LABEL (asm_out_file, name);
1979 /* Set the symbol_referenced flag for ID. */
1981 mark_referenced (tree id)
1983 TREE_SYMBOL_REFERENCED (id) = 1;
1986 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1988 mark_decl_referenced (tree decl)
1990 if (TREE_CODE (decl) == FUNCTION_DECL)
1992 /* Extern inline functions don't become needed when referenced.
1993 If we know a method will be emitted in other TU and no new
1994 functions can be marked reachable, just use the external
1996 struct cgraph_node *node = cgraph_node (decl);
1997 if (!DECL_EXTERNAL (decl)
1998 && (!node->local.vtable_method || !cgraph_global_info_ready
1999 || !node->local.finalized))
2000 cgraph_mark_needed_node (node);
2002 else if (TREE_CODE (decl) == VAR_DECL)
2004 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
2005 cgraph_varpool_mark_needed_node (node);
2006 /* C++ frontend use mark_decl_references to force COMDAT variables
2007 to be output that might appear dead otherwise. */
2008 node->force_output = true;
2010 /* else do nothing - we can get various sorts of CST nodes here,
2011 which do not need to be marked. */
2015 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2016 until we find an identifier that is not itself a transparent alias.
2017 Modify the alias passed to it by reference (and all aliases on the
2018 way to the ultimate target), such that they do not have to be
2019 followed again, and return the ultimate target of the alias
2023 ultimate_transparent_alias_target (tree *alias)
2025 tree target = *alias;
2027 if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2029 gcc_assert (TREE_CHAIN (target));
2030 target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2031 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2032 && ! TREE_CHAIN (target));
2039 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2040 starts with a *, the rest of NAME is output verbatim. Otherwise
2041 NAME is transformed in a target-specific way (usually by the
2042 addition of an underscore). */
2045 assemble_name_raw (FILE *file, const char *name)
2048 fputs (&name[1], file);
2050 ASM_OUTPUT_LABELREF (file, name);
2053 /* Like assemble_name_raw, but should be used when NAME might refer to
2054 an entity that is also represented as a tree (like a function or
2055 variable). If NAME does refer to such an entity, that entity will
2056 be marked as referenced. */
2059 assemble_name (FILE *file, const char *name)
2061 const char *real_name;
2064 real_name = targetm.strip_name_encoding (name);
2066 id = maybe_get_identifier (real_name);
2071 mark_referenced (id);
2072 ultimate_transparent_alias_target (&id);
2074 name = IDENTIFIER_POINTER (id);
2075 gcc_assert (! TREE_CHAIN (id));
2078 assemble_name_raw (file, name);
2081 /* Allocate SIZE bytes writable static space with a gensym name
2082 and return an RTX to refer to its address. */
2085 assemble_static_space (unsigned HOST_WIDE_INT size)
2088 const char *namestring;
2091 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2093 namestring = ggc_strdup (name);
2095 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2096 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2098 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2099 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2102 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2103 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2106 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2107 so that each uninitialized object starts on such a boundary. */
2108 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2109 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2110 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2111 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2112 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2113 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2120 /* Assemble the static constant template for function entry trampolines.
2121 This is done at most once per compilation.
2122 Returns an RTX for the address of the template. */
2124 static GTY(()) rtx initial_trampoline;
2126 #ifdef TRAMPOLINE_TEMPLATE
2128 assemble_trampoline_template (void)
2135 if (initial_trampoline)
2136 return initial_trampoline;
2138 /* By default, put trampoline templates in read-only data section. */
2140 #ifdef TRAMPOLINE_SECTION
2141 switch_to_section (TRAMPOLINE_SECTION);
2143 switch_to_section (readonly_data_section);
2146 /* Write the assembler code to define one. */
2147 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2150 ASM_OUTPUT_ALIGN (asm_out_file, align);
2153 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2154 TRAMPOLINE_TEMPLATE (asm_out_file);
2156 /* Record the rtl to refer to it. */
2157 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2158 name = ggc_strdup (label);
2159 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2160 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2162 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2163 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2165 return initial_trampoline;
2169 /* A and B are either alignments or offsets. Return the minimum alignment
2170 that may be assumed after adding the two together. */
2172 static inline unsigned
2173 min_align (unsigned int a, unsigned int b)
2175 return (a | b) & -(a | b);
2178 /* Return the assembler directive for creating a given kind of integer
2179 object. SIZE is the number of bytes in the object and ALIGNED_P
2180 indicates whether it is known to be aligned. Return NULL if the
2181 assembly dialect has no such directive.
2183 The returned string should be printed at the start of a new line and
2184 be followed immediately by the object's initial value. */
2187 integer_asm_op (int size, int aligned_p)
2189 struct asm_int_op *ops;
2192 ops = &targetm.asm_out.aligned_op;
2194 ops = &targetm.asm_out.unaligned_op;
2199 return targetm.asm_out.byte_op;
2213 /* Use directive OP to assemble an integer object X. Print OP at the
2214 start of the line, followed immediately by the value of X. */
2217 assemble_integer_with_op (const char *op, rtx x)
2219 fputs (op, asm_out_file);
2220 output_addr_const (asm_out_file, x);
2221 fputc ('\n', asm_out_file);
2224 /* The default implementation of the asm_out.integer target hook. */
2227 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2228 unsigned int size ATTRIBUTE_UNUSED,
2229 int aligned_p ATTRIBUTE_UNUSED)
2231 const char *op = integer_asm_op (size, aligned_p);
2232 /* Avoid GAS bugs for large values. Specifically negative values whose
2233 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2234 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2236 return op && (assemble_integer_with_op (op, x), true);
2239 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2240 the alignment of the integer in bits. Return 1 if we were able to output
2241 the constant, otherwise 0. We must be able to output the constant,
2242 if FORCE is nonzero. */
2245 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2249 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2251 /* See if the target hook can handle this kind of object. */
2252 if (targetm.asm_out.integer (x, size, aligned_p))
2255 /* If the object is a multi-byte one, try splitting it up. Split
2256 it into words it if is multi-word, otherwise split it into bytes. */
2259 enum machine_mode omode, imode;
2260 unsigned int subalign;
2261 unsigned int subsize, i;
2263 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2264 subalign = MIN (align, subsize * BITS_PER_UNIT);
2265 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2266 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2268 for (i = 0; i < size; i += subsize)
2270 rtx partial = simplify_subreg (omode, x, imode, i);
2271 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2277 /* If we've printed some of it, but not all of it, there's no going
2282 gcc_assert (!force);
2288 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2290 long data[4] = {0, 0, 0, 0};
2292 int bitsize, nelts, nunits, units_per;
2294 /* This is hairy. We have a quantity of known size. real_to_target
2295 will put it into an array of *host* longs, 32 bits per element
2296 (even if long is more than 32 bits). We need to determine the
2297 number of array elements that are occupied (nelts) and the number
2298 of *target* min-addressable units that will be occupied in the
2299 object file (nunits). We cannot assume that 32 divides the
2300 mode's bitsize (size * BITS_PER_UNIT) evenly.
2302 size * BITS_PER_UNIT is used here to make sure that padding bits
2303 (which might appear at either end of the value; real_to_target
2304 will include the padding bits in its output array) are included. */
2306 nunits = GET_MODE_SIZE (mode);
2307 bitsize = nunits * BITS_PER_UNIT;
2308 nelts = CEIL (bitsize, 32);
2309 units_per = 32 / BITS_PER_UNIT;
2311 real_to_target (data, &d, mode);
2313 /* Put out the first word with the specified alignment. */
2314 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2315 nunits -= units_per;
2317 /* Subsequent words need only 32-bit alignment. */
2318 align = min_align (align, 32);
2320 for (i = 1; i < nelts; i++)
2322 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2323 nunits -= units_per;
2327 /* Given an expression EXP with a constant value,
2328 reduce it to the sum of an assembler symbol and an integer.
2329 Store them both in the structure *VALUE.
2330 EXP must be reducible. */
2332 struct addr_const GTY(())
2335 HOST_WIDE_INT offset;
2339 decode_addr_const (tree exp, struct addr_const *value)
2341 tree target = TREE_OPERAND (exp, 0);
2347 if (TREE_CODE (target) == COMPONENT_REF
2348 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2351 offset += int_byte_position (TREE_OPERAND (target, 1));
2352 target = TREE_OPERAND (target, 0);
2354 else if (TREE_CODE (target) == ARRAY_REF
2355 || TREE_CODE (target) == ARRAY_RANGE_REF)
2357 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2358 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2359 target = TREE_OPERAND (target, 0);
2365 switch (TREE_CODE (target))
2369 x = DECL_RTL (target);
2373 x = gen_rtx_MEM (FUNCTION_MODE,
2374 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2382 x = output_constant_def (target, 1);
2389 gcc_assert (MEM_P (x));
2393 value->offset = offset;
2396 /* Uniquize all constants that appear in memory.
2397 Each constant in memory thus far output is recorded
2398 in `const_desc_table'. */
2400 struct constant_descriptor_tree GTY(())
2402 /* A MEM for the constant. */
2405 /* The value of the constant. */
2408 /* Hash of value. Computing the hash from value each time
2409 hashfn is called can't work properly, as that means recursive
2410 use of the hash table during hash table expansion. */
2414 static GTY((param_is (struct constant_descriptor_tree)))
2415 htab_t const_desc_htab;
2417 static struct constant_descriptor_tree * build_constant_desc (tree);
2418 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2420 /* Compute a hash code for a constant expression. */
2423 const_desc_hash (const void *ptr)
2425 return ((struct constant_descriptor_tree *)ptr)->hash;
2429 const_hash_1 (const tree exp)
2434 enum tree_code code = TREE_CODE (exp);
2436 /* Either set P and LEN to the address and len of something to hash and
2437 exit the switch or return a value. */
2442 p = (char *) &TREE_INT_CST (exp);
2443 len = sizeof TREE_INT_CST (exp);
2447 return real_hash (TREE_REAL_CST_PTR (exp));
2450 p = TREE_STRING_POINTER (exp);
2451 len = TREE_STRING_LENGTH (exp);
2455 return (const_hash_1 (TREE_REALPART (exp)) * 5
2456 + const_hash_1 (TREE_IMAGPART (exp)));
2460 unsigned HOST_WIDE_INT idx;
2463 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2465 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2467 hi = hi * 603 + const_hash_1 (value);
2475 struct addr_const value;
2477 decode_addr_const (exp, &value);
2478 switch (GET_CODE (value.base))
2481 /* Don't hash the address of the SYMBOL_REF;
2482 only use the offset and the symbol name. */
2484 p = XSTR (value.base, 0);
2485 for (i = 0; p[i] != 0; i++)
2486 hi = ((hi * 613) + (unsigned) (p[i]));
2490 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2501 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2502 + const_hash_1 (TREE_OPERAND (exp, 1)));
2506 case NON_LVALUE_EXPR:
2507 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2510 /* A language specific constant. Just hash the code. */
2514 /* Compute hashing function. */
2516 for (i = 0; i < len; i++)
2517 hi = ((hi * 613) + (unsigned) (p[i]));
2522 /* Wrapper of compare_constant, for the htab interface. */
2524 const_desc_eq (const void *p1, const void *p2)
2526 const struct constant_descriptor_tree *c1 = p1;
2527 const struct constant_descriptor_tree *c2 = p2;
2528 if (c1->hash != c2->hash)
2530 return compare_constant (c1->value, c2->value);
2533 /* Compare t1 and t2, and return 1 only if they are known to result in
2534 the same bit pattern on output. */
2537 compare_constant (const tree t1, const tree t2)
2539 enum tree_code typecode;
2541 if (t1 == NULL_TREE)
2542 return t2 == NULL_TREE;
2543 if (t2 == NULL_TREE)
2546 if (TREE_CODE (t1) != TREE_CODE (t2))
2549 switch (TREE_CODE (t1))
2552 /* Integer constants are the same only if the same width of type. */
2553 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2555 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2557 return tree_int_cst_equal (t1, t2);
2560 /* Real constants are the same only if the same width of type. */
2561 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2564 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2567 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2570 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2571 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2572 TREE_STRING_LENGTH (t1)));
2575 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2576 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2580 VEC(constructor_elt, gc) *v1, *v2;
2581 unsigned HOST_WIDE_INT idx;
2583 typecode = TREE_CODE (TREE_TYPE (t1));
2584 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2587 if (typecode == ARRAY_TYPE)
2589 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2590 /* For arrays, check that the sizes all match. */
2591 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2593 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2598 /* For record and union constructors, require exact type
2600 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2604 v1 = CONSTRUCTOR_ELTS (t1);
2605 v2 = CONSTRUCTOR_ELTS (t2);
2606 if (VEC_length (constructor_elt, v1)
2607 != VEC_length (constructor_elt, v2))
2610 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2612 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2613 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2615 /* Check that each value is the same... */
2616 if (!compare_constant (c1->value, c2->value))
2618 /* ... and that they apply to the same fields! */
2619 if (typecode == ARRAY_TYPE)
2621 if (!compare_constant (c1->index, c2->index))
2626 if (c1->index != c2->index)
2637 struct addr_const value1, value2;
2639 decode_addr_const (t1, &value1);
2640 decode_addr_const (t2, &value2);
2641 return (value1.offset == value2.offset
2642 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2648 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2649 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2653 case NON_LVALUE_EXPR:
2654 case VIEW_CONVERT_EXPR:
2655 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2660 nt1 = lang_hooks.expand_constant (t1);
2661 nt2 = lang_hooks.expand_constant (t2);
2662 if (nt1 != t1 || nt2 != t2)
2663 return compare_constant (nt1, nt2);
2672 /* Make a copy of the whole tree structure for a constant. This
2673 handles the same types of nodes that compare_constant handles. */
2676 copy_constant (tree exp)
2678 switch (TREE_CODE (exp))
2681 /* For ADDR_EXPR, we do not want to copy the decl whose address
2682 is requested. We do want to copy constants though. */
2683 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2684 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2685 copy_constant (TREE_OPERAND (exp, 0)));
2687 return copy_node (exp);
2692 return copy_node (exp);
2695 return build_complex (TREE_TYPE (exp),
2696 copy_constant (TREE_REALPART (exp)),
2697 copy_constant (TREE_IMAGPART (exp)));
2701 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2702 copy_constant (TREE_OPERAND (exp, 0)),
2703 copy_constant (TREE_OPERAND (exp, 1)));
2707 case NON_LVALUE_EXPR:
2708 case VIEW_CONVERT_EXPR:
2709 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2710 copy_constant (TREE_OPERAND (exp, 0)));
2714 tree copy = copy_node (exp);
2715 VEC(constructor_elt, gc) *v;
2716 unsigned HOST_WIDE_INT idx;
2717 tree purpose, value;
2719 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
2720 CONSTRUCTOR_ELTS (exp)));
2721 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
2723 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
2724 ce->index = purpose;
2725 ce->value = copy_constant (value);
2727 CONSTRUCTOR_ELTS (copy) = v;
2733 tree t = lang_hooks.expand_constant (exp);
2735 gcc_assert (t == exp);
2736 return copy_constant (t);
2741 /* Return the alignment of constant EXP in bits. */
2744 get_constant_alignment (tree exp)
2748 align = TYPE_ALIGN (TREE_TYPE (exp));
2749 #ifdef CONSTANT_ALIGNMENT
2750 align = CONSTANT_ALIGNMENT (exp, align);
2755 /* Return the section into which constant EXP should be placed. */
2758 get_constant_section (tree exp)
2760 if (IN_NAMED_SECTION (exp))
2761 return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
2763 return targetm.asm_out.select_section (exp,
2764 compute_reloc_for_constant (exp),
2765 get_constant_alignment (exp));
2768 /* Return the size of constant EXP in bytes. */
2770 static HOST_WIDE_INT
2771 get_constant_size (tree exp)
2775 size = int_size_in_bytes (TREE_TYPE (exp));
2776 if (TREE_CODE (exp) == STRING_CST)
2777 size = MAX (TREE_STRING_LENGTH (exp), size);
2781 /* Subroutine of output_constant_def:
2782 No constant equal to EXP is known to have been output.
2783 Make a constant descriptor to enter EXP in the hash table.
2784 Assign the label number and construct RTL to refer to the
2785 constant's location in memory.
2786 Caller is responsible for updating the hash table. */
2788 static struct constant_descriptor_tree *
2789 build_constant_desc (tree exp)
2795 struct constant_descriptor_tree *desc;
2797 desc = ggc_alloc (sizeof (*desc));
2798 desc->value = copy_constant (exp);
2800 /* Propagate marked-ness to copied constant. */
2801 if (flag_mudflap && mf_marked_p (exp))
2802 mf_mark (desc->value);
2804 /* Create a string containing the label name, in LABEL. */
2805 labelno = const_labelno++;
2806 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2808 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2809 if (use_object_blocks_p ())
2811 section *sect = get_constant_section (exp);
2812 symbol = create_block_symbol (ggc_strdup (label),
2813 get_block_for_section (sect), -1);
2816 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2817 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
2818 SET_SYMBOL_REF_DECL (symbol, desc->value);
2819 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2821 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2822 set_mem_attributes (rtl, exp, 1);
2823 set_mem_alias_set (rtl, 0);
2824 set_mem_alias_set (rtl, const_alias_set);
2826 /* Set flags or add text to the name to record information, such as
2827 that it is a local symbol. If the name is changed, the macro
2828 ASM_OUTPUT_LABELREF will have to know how to strip this
2829 information. This call might invalidate our local variable
2830 SYMBOL; we can't use it afterward. */
2832 targetm.encode_section_info (exp, rtl, true);
2839 /* Return an rtx representing a reference to constant data in memory
2840 for the constant expression EXP.
2842 If assembler code for such a constant has already been output,
2843 return an rtx to refer to it.
2844 Otherwise, output such a constant in memory
2845 and generate an rtx for it.
2847 If DEFER is nonzero, this constant can be deferred and output only
2848 if referenced in the function after all optimizations.
2850 `const_desc_table' records which constants already have label strings. */
2853 output_constant_def (tree exp, int defer)
2855 struct constant_descriptor_tree *desc;
2856 struct constant_descriptor_tree key;
2859 /* Look up EXP in the table of constant descriptors. If we didn't find
2860 it, create a new one. */
2862 key.hash = const_hash_1 (exp);
2863 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
2868 desc = build_constant_desc (exp);
2869 desc->hash = key.hash;
2873 maybe_output_constant_def_contents (desc, defer);
2877 /* Subroutine of output_constant_def: Decide whether or not we need to
2878 output the constant DESC now, and if so, do it. */
2880 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2883 rtx symbol = XEXP (desc->rtl, 0);
2884 tree exp = desc->value;
2886 if (flag_syntax_only)
2889 if (TREE_ASM_WRITTEN (exp))
2890 /* Already output; don't do it again. */
2893 /* We can always defer constants as long as the context allows
2897 /* Increment n_deferred_constants if it exists. It needs to be at
2898 least as large as the number of constants actually referred to
2899 by the function. If it's too small we'll stop looking too early
2900 and fail to emit constants; if it's too large we'll only look
2901 through the entire function when we could have stopped earlier. */
2903 n_deferred_constants++;
2907 output_constant_def_contents (symbol);
2910 /* Subroutine of output_constant_def_contents. Output the definition
2911 of constant EXP, which is pointed to by label LABEL. ALIGN is the
2912 constant's alignment in bits. */
2915 assemble_constant_contents (tree exp, const char *label, unsigned int align)
2919 size = get_constant_size (exp);
2921 /* Do any machine/system dependent processing of the constant. */
2922 #ifdef ASM_DECLARE_CONSTANT_NAME
2923 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2925 /* Standard thing is just output label for the constant. */
2926 ASM_OUTPUT_LABEL (asm_out_file, label);
2927 #endif /* ASM_DECLARE_CONSTANT_NAME */
2929 /* Output the value of EXP. */
2930 output_constant (exp, size, align);
2933 /* We must output the constant data referred to by SYMBOL; do so. */
2936 output_constant_def_contents (rtx symbol)
2938 tree exp = SYMBOL_REF_DECL (symbol);
2941 /* Make sure any other constants whose addresses appear in EXP
2942 are assigned label numbers. */
2943 output_addressed_constants (exp);
2945 /* We are no longer deferring this constant. */
2946 TREE_ASM_WRITTEN (exp) = 1;
2948 /* If the constant is part of an object block, make sure that the
2949 decl has been positioned within its block, but do not write out
2950 its definition yet. output_object_blocks will do that later. */
2951 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2952 place_block_symbol (symbol);
2955 switch_to_section (get_constant_section (exp));
2956 align = get_constant_alignment (exp);
2957 if (align > BITS_PER_UNIT)
2958 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2959 assemble_constant_contents (exp, XSTR (symbol, 0), align);
2962 mudflap_enqueue_constant (exp);
2965 /* Look up EXP in the table of constant descriptors. Return the rtl
2966 if it has been emitted, else null. */
2969 lookup_constant_def (tree exp)
2971 struct constant_descriptor_tree *desc;
2972 struct constant_descriptor_tree key;
2975 key.hash = const_hash_1 (exp);
2976 desc = htab_find_with_hash (const_desc_htab, &key, key.hash);
2978 return (desc ? desc->rtl : NULL_RTX);
2981 /* Used in the hash tables to avoid outputting the same constant
2982 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2983 are output once per function, not once per file. */
2984 /* ??? Only a few targets need per-function constant pools. Most
2985 can use one per-file pool. Should add a targetm bit to tell the
2988 struct rtx_constant_pool GTY(())
2990 /* Pointers to first and last constant in pool, as ordered by offset. */
2991 struct constant_descriptor_rtx *first;
2992 struct constant_descriptor_rtx *last;
2994 /* Hash facility for making memory-constants from constant rtl-expressions.
2995 It is used on RISC machines where immediate integer arguments and
2996 constant addresses are restricted so that such constants must be stored
2998 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3000 /* Current offset in constant pool (does not include any
3001 machine-specific header). */
3002 HOST_WIDE_INT offset;
3005 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
3007 struct constant_descriptor_rtx *next;
3011 HOST_WIDE_INT offset;
3013 enum machine_mode mode;
3019 /* Hash and compare functions for const_rtx_htab. */
3022 const_desc_rtx_hash (const void *ptr)
3024 const struct constant_descriptor_rtx *desc = ptr;
3029 const_desc_rtx_eq (const void *a, const void *b)
3031 const struct constant_descriptor_rtx *x = a;
3032 const struct constant_descriptor_rtx *y = b;
3034 if (x->mode != y->mode)
3036 return rtx_equal_p (x->constant, y->constant);
3039 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
3042 const_rtx_hash_1 (rtx *xp, void *data)
3044 unsigned HOST_WIDE_INT hwi;
3045 enum machine_mode mode;
3051 code = GET_CODE (x);
3052 mode = GET_MODE (x);
3053 h = (hashval_t) code * 1048573 + mode;
3061 const int shift = sizeof (hashval_t) * CHAR_BIT;
3062 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3065 h ^= (hashval_t) hwi;
3066 for (i = 1; i < n; ++i)
3069 h ^= (hashval_t) hwi;
3075 if (mode == VOIDmode)
3077 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3081 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3087 for (i = XVECLEN (x, 0); i-- > 0; )
3088 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3093 h ^= htab_hash_string (XSTR (x, 0));
3097 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3101 case UNSPEC_VOLATILE:
3102 h = h * 251 + XINT (x, 1);
3110 *hp = *hp * 509 + h;
3114 /* Compute a hash value for X, which should be a constant. */
3117 const_rtx_hash (rtx x)
3120 for_each_rtx (&x, const_rtx_hash_1, &h);
3125 /* Initialize constant pool hashing for a new function. */
3128 init_varasm_status (struct function *f)
3130 struct varasm_status *p;
3131 struct rtx_constant_pool *pool;
3133 p = ggc_alloc (sizeof (struct varasm_status));
3136 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3138 p->deferred_constants = 0;
3140 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3141 const_desc_rtx_eq, NULL);
3142 pool->first = pool->last = NULL;
3146 /* Given a MINUS expression, simplify it if both sides
3147 include the same symbol. */
3150 simplify_subtraction (rtx x)
3152 rtx r = simplify_rtx (x);
3156 /* Given a constant rtx X, make (or find) a memory constant for its value
3157 and return a MEM rtx to refer to it in memory. */
3160 force_const_mem (enum machine_mode mode, rtx x)
3162 struct constant_descriptor_rtx *desc, tmp;
3163 struct rtx_constant_pool *pool = cfun->varasm->pool;
3170 /* If we're not allowed to drop X into the constant pool, don't. */
3171 if (targetm.cannot_force_const_mem (x))
3174 /* Lookup the value in the hashtable. */
3177 hash = const_rtx_hash (x);
3178 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3181 /* If the constant was already present, return its memory. */
3183 return copy_rtx (desc->mem);
3185 /* Otherwise, create a new descriptor. */
3186 desc = ggc_alloc (sizeof (*desc));
3189 /* Align the location counter as required by EXP's data type. */
3190 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3191 #ifdef CONSTANT_ALIGNMENT
3193 tree type = lang_hooks.types.type_for_mode (mode, 0);
3194 if (type != NULL_TREE)
3195 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3199 pool->offset += (align / BITS_PER_UNIT) - 1;
3200 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3203 desc->constant = tmp.constant;
3204 desc->offset = pool->offset;
3207 desc->align = align;
3208 desc->labelno = const_labelno;
3211 pool->offset += GET_MODE_SIZE (mode);
3213 pool->last->next = desc;
3215 pool->first = pool->last = desc;
3218 /* Create a string containing the label name, in LABEL. */
3219 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3222 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3223 the constants pool. */
3224 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3226 section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3227 symbol = create_block_symbol (ggc_strdup (label),
3228 get_block_for_section (sect), -1);
3231 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3233 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3234 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3235 SET_SYMBOL_REF_CONSTANT (symbol, desc);
3236 current_function_uses_const_pool = 1;
3238 /* Construct the MEM. */
3239 desc->mem = def = gen_const_mem (mode, symbol);
3240 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3241 set_mem_align (def, align);
3243 /* If we're dropping a label to the constant pool, make sure we
3245 if (GET_CODE (x) == LABEL_REF)
3246 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3248 return copy_rtx (def);
3251 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3254 get_pool_constant (rtx addr)
3256 return SYMBOL_REF_CONSTANT (addr)->constant;
3259 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3260 and whether it has been output or not. */
3263 get_pool_constant_mark (rtx addr, bool *pmarked)
3265 struct constant_descriptor_rtx *desc;
3267 desc = SYMBOL_REF_CONSTANT (addr);
3268 *pmarked = (desc->mark != 0);
3269 return desc->constant;
3272 /* Similar, return the mode. */
3275 get_pool_mode (rtx addr)
3277 return SYMBOL_REF_CONSTANT (addr)->mode;
3280 /* Return the size of the constant pool. */
3283 get_pool_size (void)
3285 return cfun->varasm->pool->offset;
3288 /* Worker function for output_constant_pool_1. Emit assembly for X
3289 in MODE with known alignment ALIGN. */
3292 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3294 switch (GET_MODE_CLASS (mode))
3297 case MODE_DECIMAL_FLOAT:
3301 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3302 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3303 assemble_real (r, mode, align);
3308 case MODE_PARTIAL_INT:
3309 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3312 case MODE_VECTOR_FLOAT:
3313 case MODE_VECTOR_INT:
3316 enum machine_mode submode = GET_MODE_INNER (mode);
3317 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3319 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3320 units = CONST_VECTOR_NUNITS (x);
3322 for (i = 0; i < units; i++)
3324 rtx elt = CONST_VECTOR_ELT (x, i);
3325 output_constant_pool_2 (submode, elt, i ? subalign : align);
3335 /* Worker function for output_constant_pool. Emit constant DESC,
3336 giving it ALIGN bits of alignment. */
3339 output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3346 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3347 whose CODE_LABEL has been deleted. This can occur if a jump table
3348 is eliminated by optimization. If so, write a constant of zero
3349 instead. Note that this can also happen by turning the
3350 CODE_LABEL into a NOTE. */
3351 /* ??? This seems completely and utterly wrong. Certainly it's
3352 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3353 functioning even with INSN_DELETED_P and friends. */
3356 switch (GET_CODE (x))
3359 if (GET_CODE (XEXP (x, 0)) != PLUS
3360 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3362 tmp = XEXP (XEXP (x, 0), 0);
3367 gcc_assert (!INSN_DELETED_P (tmp));
3368 gcc_assert (!NOTE_P (tmp)
3369 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3376 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3377 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3378 align, desc->labelno, done);
3381 assemble_align (align);
3383 /* Output the label. */
3384 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3386 /* Output the data. */
3387 output_constant_pool_2 (desc->mode, x, align);
3389 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3390 sections have proper size. */
3391 if (align > GET_MODE_BITSIZE (desc->mode)
3393 && (in_section->common.flags & SECTION_MERGE))
3394 assemble_align (align);
3396 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3402 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3403 to as used. Emit referenced deferred strings. This function can
3404 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3407 mark_constant (rtx *current_rtx, void *data)
3409 struct rtx_constant_pool *pool = data;
3410 rtx x = *current_rtx;
3412 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3415 if (CONSTANT_POOL_ADDRESS_P (x))
3417 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
3418 if (desc->mark == 0)
3421 for_each_rtx (&desc->constant, mark_constant, pool);
3424 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3426 tree exp = SYMBOL_REF_DECL (x);
3427 if (!TREE_ASM_WRITTEN (exp))
3429 n_deferred_constants--;
3430 output_constant_def_contents (x);
3437 /* Look through appropriate parts of INSN, marking all entries in the
3438 constant pool which are actually being used. Entries that are only
3439 referenced by other constants are also marked as used. Emit
3440 deferred strings that are used. */
3443 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3448 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3449 insns, not any notes that may be attached. We don't want to mark
3450 a constant just because it happens to appear in a REG_EQUIV note. */
3451 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3453 rtx seq = PATTERN (insn);
3454 int i, n = XVECLEN (seq, 0);
3455 for (i = 0; i < n; ++i)
3457 rtx subinsn = XVECEXP (seq, 0, i);
3458 if (INSN_P (subinsn))
3459 for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3463 for_each_rtx (&PATTERN (insn), mark_constant, pool);
3466 /* Look through the instructions for this function, and mark all the
3467 entries in POOL which are actually being used. Emit deferred constants
3468 which have indeed been used. */
3471 mark_constant_pool (struct rtx_constant_pool *pool)
3475 if (pool->first == 0 && n_deferred_constants == 0)
3478 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3479 mark_constants (pool, insn);
3481 for (link = current_function_epilogue_delay_list;
3483 link = XEXP (link, 1))
3484 mark_constants (pool, XEXP (link, 0));
3487 /* Write all the constants in the constant pool. */
3490 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3491 tree fndecl ATTRIBUTE_UNUSED)
3493 struct rtx_constant_pool *pool = cfun->varasm->pool;
3494 struct constant_descriptor_rtx *desc;
3496 /* It is possible for gcc to call force_const_mem and then to later
3497 discard the instructions which refer to the constant. In such a
3498 case we do not need to output the constant. */
3499 mark_constant_pool (pool);
3501 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3502 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3505 for (desc = pool->first; desc ; desc = desc->next)
3508 /* If the constant is part of an object_block, make sure that
3509 the constant has been positioned within its block, but do not
3510 write out its definition yet. output_object_blocks will do
3512 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
3513 && SYMBOL_REF_BLOCK (desc->sym))
3514 place_block_symbol (desc->sym);
3517 switch_to_section (targetm.asm_out.select_rtx_section
3518 (desc->mode, desc->constant, desc->align));
3519 output_constant_pool_1 (desc, desc->align);
3523 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3524 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3528 /* Determine what kind of relocations EXP may need. */
3531 compute_reloc_for_constant (tree exp)
3533 int reloc = 0, reloc2;
3536 /* Give the front-end a chance to convert VALUE to something that
3537 looks more like a constant to the back-end. */
3538 exp = lang_hooks.expand_constant (exp);
3540 switch (TREE_CODE (exp))
3544 /* Go inside any operations that get_inner_reference can handle and see
3545 if what's inside is a constant: no need to do anything here for
3546 addresses of variables or functions. */
3547 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3548 tem = TREE_OPERAND (tem, 0))
3551 if (TREE_PUBLIC (tem))
3558 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3559 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3563 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3564 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3565 /* The difference of two local labels is computable at link time. */
3566 if (reloc == 1 && reloc2 == 1)
3574 case NON_LVALUE_EXPR:
3575 case VIEW_CONVERT_EXPR:
3576 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3581 unsigned HOST_WIDE_INT idx;
3582 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3584 reloc |= compute_reloc_for_constant (tem);
3594 /* Find all the constants whose addresses are referenced inside of EXP,
3595 and make sure assembler code with a label has been output for each one.
3596 Indicate whether an ADDR_EXPR has been encountered. */
3599 output_addressed_constants (tree exp)
3603 /* Give the front-end a chance to convert VALUE to something that
3604 looks more like a constant to the back-end. */
3605 exp = lang_hooks.expand_constant (exp);
3607 switch (TREE_CODE (exp))
3611 /* Go inside any operations that get_inner_reference can handle and see
3612 if what's inside is a constant: no need to do anything here for
3613 addresses of variables or functions. */
3614 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3615 tem = TREE_OPERAND (tem, 0))
3618 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3619 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3620 tem = DECL_INITIAL (tem);
3622 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3623 output_constant_def (tem, 0);
3628 output_addressed_constants (TREE_OPERAND (exp, 1));
3633 case NON_LVALUE_EXPR:
3634 case VIEW_CONVERT_EXPR:
3635 output_addressed_constants (TREE_OPERAND (exp, 0));
3640 unsigned HOST_WIDE_INT idx;
3641 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3643 output_addressed_constants (tem);
3652 /* Return nonzero if VALUE is a valid constant-valued expression
3653 for use in initializing a static variable; one that can be an
3654 element of a "constant" initializer.
3656 Return null_pointer_node if the value is absolute;
3657 if it is relocatable, return the variable that determines the relocation.
3658 We assume that VALUE has been folded as much as possible;
3659 therefore, we do not need to check for such things as
3660 arithmetic-combinations of integers. */
3663 initializer_constant_valid_p (tree value, tree endtype)
3665 /* Give the front-end a chance to convert VALUE to something that
3666 looks more like a constant to the back-end. */
3667 value = lang_hooks.expand_constant (value);
3669 switch (TREE_CODE (value))
3672 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3673 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3674 && TREE_CONSTANT (value)
3675 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value)))
3677 unsigned HOST_WIDE_INT idx;
3679 bool absolute = true;
3681 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
3684 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
3687 if (reloc != null_pointer_node)
3690 /* For a non-absolute relocation, there is no single
3691 variable that can be "the variable that determines the
3693 return absolute ? null_pointer_node : error_mark_node;
3696 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3703 return null_pointer_node;
3707 value = staticp (TREE_OPERAND (value, 0));
3710 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3711 be a constant, this is old-skool offsetof-like nonsense. */
3712 if (TREE_CODE (value) == INDIRECT_REF
3713 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3714 return null_pointer_node;
3715 /* Taking the address of a nested function involves a trampoline. */
3716 if (TREE_CODE (value) == FUNCTION_DECL
3717 && ((decl_function_context (value)
3718 && !DECL_NO_STATIC_CHAIN (value))
3719 || DECL_DLLIMPORT_P (value)))
3721 /* "&{...}" requires a temporary to hold the constructed
3723 if (TREE_CODE (value) == CONSTRUCTOR)
3728 case VIEW_CONVERT_EXPR:
3729 case NON_LVALUE_EXPR:
3730 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3739 src = TREE_OPERAND (value, 0);
3740 src_type = TREE_TYPE (src);
3741 dest_type = TREE_TYPE (value);
3743 /* Allow conversions between pointer types, floating-point
3744 types, and offset types. */
3745 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3746 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3747 || (TREE_CODE (dest_type) == OFFSET_TYPE
3748 && TREE_CODE (src_type) == OFFSET_TYPE))
3749 return initializer_constant_valid_p (src, endtype);
3751 /* Allow length-preserving conversions between integer types. */
3752 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3753 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3754 return initializer_constant_valid_p (src, endtype);
3756 /* Allow conversions between other integer types only if
3758 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3760 tree inner = initializer_constant_valid_p (src, endtype);
3761 if (inner == null_pointer_node)
3762 return null_pointer_node;
3766 /* Allow (int) &foo provided int is as wide as a pointer. */
3767 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3768 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3769 return initializer_constant_valid_p (src, endtype);
3771 /* Likewise conversions from int to pointers, but also allow
3772 conversions from 0. */
3773 if ((POINTER_TYPE_P (dest_type)
3774 || TREE_CODE (dest_type) == OFFSET_TYPE)
3775 && INTEGRAL_TYPE_P (src_type))
3777 if (TREE_CODE (src) == INTEGER_CST
3778 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
3779 return null_pointer_node;
3780 if (integer_zerop (src))
3781 return null_pointer_node;
3782 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3783 return initializer_constant_valid_p (src, endtype);
3786 /* Allow conversions to struct or union types if the value
3788 if (TREE_CODE (dest_type) == RECORD_TYPE
3789 || TREE_CODE (dest_type) == UNION_TYPE)
3790 return initializer_constant_valid_p (src, endtype);
3795 if (! INTEGRAL_TYPE_P (endtype)
3796 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3798 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3800 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3802 /* If either term is absolute, use the other terms relocation. */
3803 if (valid0 == null_pointer_node)
3805 if (valid1 == null_pointer_node)
3811 if (! INTEGRAL_TYPE_P (endtype)
3812 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3814 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3816 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3818 /* Win if second argument is absolute. */
3819 if (valid1 == null_pointer_node)
3821 /* Win if both arguments have the same relocation.
3822 Then the value is absolute. */
3823 if (valid0 == valid1 && valid0 != 0)
3824 return null_pointer_node;
3826 /* Since GCC guarantees that string constants are unique in the
3827 generated code, a subtraction between two copies of the same
3828 constant string is absolute. */
3829 if (valid0 && TREE_CODE (valid0) == STRING_CST
3830 && valid1 && TREE_CODE (valid1) == STRING_CST
3831 && operand_equal_p (valid0, valid1, 1))
3832 return null_pointer_node;
3835 /* Support narrowing differences. */
3836 if (INTEGRAL_TYPE_P (endtype))
3840 op0 = TREE_OPERAND (value, 0);
3841 op1 = TREE_OPERAND (value, 1);
3843 /* Like STRIP_NOPS except allow the operand mode to widen.
3844 This works around a feature of fold that simplifies
3845 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3846 that the narrower operation is cheaper. */
3848 while (TREE_CODE (op0) == NOP_EXPR
3849 || TREE_CODE (op0) == CONVERT_EXPR
3850 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3852 tree inner = TREE_OPERAND (op0, 0);
3853 if (inner == error_mark_node
3854 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3855 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3856 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3861 while (TREE_CODE (op1) == NOP_EXPR
3862 || TREE_CODE (op1) == CONVERT_EXPR
3863 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3865 tree inner = TREE_OPERAND (op1, 0);
3866 if (inner == error_mark_node
3867 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3868 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3869 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3874 op0 = initializer_constant_valid_p (op0, endtype);
3875 op1 = initializer_constant_valid_p (op1, endtype);
3877 /* Both initializers must be known. */
3881 return null_pointer_node;
3883 /* Support differences between labels. */
3884 if (TREE_CODE (op0) == LABEL_DECL
3885 && TREE_CODE (op1) == LABEL_DECL)
3886 return null_pointer_node;
3888 if (TREE_CODE (op0) == STRING_CST
3889 && TREE_CODE (op1) == STRING_CST
3890 && operand_equal_p (op0, op1, 1))
3891 return null_pointer_node;
3903 /* Output assembler code for constant EXP to FILE, with no label.
3904 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3905 Assumes output_addressed_constants has been done on EXP already.
3907 Generate exactly SIZE bytes of assembler data, padding at the end
3908 with zeros if necessary. SIZE must always be specified.
3910 SIZE is important for structure constructors,
3911 since trailing members may have been omitted from the constructor.
3912 It is also important for initialization of arrays from string constants
3913 since the full length of the string constant might not be wanted.
3914 It is also needed for initialization of unions, where the initializer's
3915 type is just one member, and that may not be as long as the union.
3917 There a case in which we would fail to output exactly SIZE bytes:
3918 for a structure constructor that wants to produce more than SIZE bytes.
3919 But such constructors will never be generated for any possible input.
3921 ALIGN is the alignment of the data in bits. */
3924 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3926 enum tree_code code;
3927 unsigned HOST_WIDE_INT thissize;
3929 /* Some front-ends use constants other than the standard language-independent
3930 varieties, but which may still be output directly. Give the front-end a
3931 chance to convert EXP to a language-independent representation. */
3932 exp = lang_hooks.expand_constant (exp);
3934 if (size == 0 || flag_syntax_only)
3937 /* See if we're trying to initialize a pointer in a non-default mode
3938 to the address of some declaration somewhere. If the target says
3939 the mode is valid for pointers, assume the target has a way of
3941 if (TREE_CODE (exp) == NOP_EXPR
3942 && POINTER_TYPE_P (TREE_TYPE (exp))
3943 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3945 tree saved_type = TREE_TYPE (exp);
3947 /* Peel off any intermediate conversions-to-pointer for valid
3949 while (TREE_CODE (exp) == NOP_EXPR
3950 && POINTER_TYPE_P (TREE_TYPE (exp))
3951 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3952 exp = TREE_OPERAND (exp, 0);
3954 /* If what we're left with is the address of something, we can
3955 convert the address to the final type and output it that
3957 if (TREE_CODE (exp) == ADDR_EXPR)
3958 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
3959 /* Likewise for constant ints. */
3960 else if (TREE_CODE (exp) == INTEGER_CST)
3961 exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
3962 TREE_INT_CST_HIGH (exp));
3966 /* Eliminate any conversions since we'll be outputting the underlying
3968 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3969 || TREE_CODE (exp) == NON_LVALUE_EXPR
3970 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3972 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp));
3973 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)));
3975 /* Make sure eliminating the conversion is really a no-op, except with
3976 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
3977 union types to allow for Ada unchecked unions. */
3978 if (type_size > op_size
3979 && TREE_CODE (exp) != VIEW_CONVERT_EXPR
3980 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE)
3981 internal_error ("no-op convert from %wd to %wd bytes in initializer",
3982 op_size, type_size);
3984 exp = TREE_OPERAND (exp, 0);
3987 code = TREE_CODE (TREE_TYPE (exp));
3988 thissize = int_size_in_bytes (TREE_TYPE (exp));
3990 /* Allow a constructor with no elements for any data type.
3991 This means to fill the space with zeros. */
3992 if (TREE_CODE (exp) == CONSTRUCTOR
3993 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
3995 assemble_zeros (size);
3999 if (TREE_CODE (exp) == FDESC_EXPR)
4001 #ifdef ASM_OUTPUT_FDESC
4002 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4003 tree decl = TREE_OPERAND (exp, 0);
4004 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4011 /* Now output the underlying data. If we've handling the padding, return.
4012 Otherwise, break and ensure SIZE is the size written. */
4019 case REFERENCE_TYPE:
4021 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4022 EXPAND_INITIALIZER),
4023 MIN (size, thissize), align, 0))
4024 error ("initializer for integer value is too complicated");
4028 if (TREE_CODE (exp) != REAL_CST)
4029 error ("initializer for floating value is not a floating constant");
4031 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
4035 output_constant (TREE_REALPART (exp), thissize / 2, align);
4036 output_constant (TREE_IMAGPART (exp), thissize / 2,
4037 min_align (align, BITS_PER_UNIT * (thissize / 2)));
4042 switch (TREE_CODE (exp))
4045 output_constructor (exp, size, align);
4048 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
4050 assemble_string (TREE_STRING_POINTER (exp), thissize);
4057 unsigned int nalign;
4058 enum machine_mode inner;
4060 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
4061 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
4063 elt_size = GET_MODE_SIZE (inner);
4065 link = TREE_VECTOR_CST_ELTS (exp);
4066 output_constant (TREE_VALUE (link), elt_size, align);
4067 while ((link = TREE_CHAIN (link)) != NULL)
4068 output_constant (TREE_VALUE (link), elt_size, nalign);
4078 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
4079 output_constructor (exp, size, align);
4089 if (size > thissize)
4090 assemble_zeros (size - thissize);
4094 /* Subroutine of output_constructor, used for computing the size of
4095 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4096 type with an unspecified upper bound. */
4098 static unsigned HOST_WIDE_INT
4099 array_size_for_constructor (tree val)
4102 unsigned HOST_WIDE_INT cnt;
4105 /* This code used to attempt to handle string constants that are not
4106 arrays of single-bytes, but nothing else does, so there's no point in
4108 if (TREE_CODE (val) == STRING_CST)
4109 return TREE_STRING_LENGTH (val);
4111 max_index = NULL_TREE;
4112 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
4114 if (TREE_CODE (index) == RANGE_EXPR)
4115 index = TREE_OPERAND (index, 1);
4116 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4120 if (max_index == NULL_TREE)
4123 /* Compute the total number of array elements. */
4124 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4126 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4127 i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
4129 /* Multiply by the array element unit size to find number of bytes. */
4130 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4132 return tree_low_cst (i, 1);
4135 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4136 Generate at least SIZE bytes, padding if necessary. */
4139 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4142 tree type = TREE_TYPE (exp);
4145 /* Number of bytes output or skipped so far.
4146 In other words, current position within the constructor. */
4147 HOST_WIDE_INT total_bytes = 0;
4148 /* Nonzero means BYTE contains part of a byte, to be output. */
4149 int byte_buffer_in_use = 0;
4151 unsigned HOST_WIDE_INT cnt;
4152 constructor_elt *ce;
4154 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4156 if (TREE_CODE (type) == RECORD_TYPE)
4157 field = TYPE_FIELDS (type);
4159 if (TREE_CODE (type) == ARRAY_TYPE
4160 && TYPE_DOMAIN (type) != 0)
4161 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4163 /* As LINK goes through the elements of the constant,
4164 FIELD goes through the structure fields, if the constant is a structure.
4165 if the constant is a union, then we override this,
4166 by getting the field from the TREE_LIST element.
4167 But the constant could also be an array. Then FIELD is zero.
4169 There is always a maximum of one element in the chain LINK for unions
4170 (even if the initializer in a source program incorrectly contains
4173 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4174 cnt++, field = field ? TREE_CHAIN (field) : 0)
4176 tree val = ce->value;
4179 /* The element in a union constructor specifies the proper field
4181 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4182 || TREE_CODE (type) == QUAL_UNION_TYPE)
4186 else if (TREE_CODE (type) == ARRAY_TYPE)
4189 #ifdef ASM_COMMENT_START
4190 if (field && flag_verbose_asm)
4191 fprintf (asm_out_file, "%s %s:\n",
4194 ? IDENTIFIER_POINTER (DECL_NAME (field))
4198 /* Eliminate the marker that makes a cast not be an lvalue. */
4202 if (index && TREE_CODE (index) == RANGE_EXPR)
4204 unsigned HOST_WIDE_INT fieldsize
4205 = int_size_in_bytes (TREE_TYPE (type));
4206 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4207 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4208 HOST_WIDE_INT index;
4209 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4211 for (index = lo_index; index <= hi_index; index++)
4213 /* Output the element's initial value. */
4215 assemble_zeros (fieldsize);
4217 output_constant (val, fieldsize, align2);
4219 /* Count its size. */
4220 total_bytes += fieldsize;
4223 else if (field == 0 || !DECL_BIT_FIELD (field))
4225 /* An element that is not a bit-field. */
4227 unsigned HOST_WIDE_INT fieldsize;
4228 /* Since this structure is static,
4229 we know the positions are constant. */
4230 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4231 unsigned int align2;
4234 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4235 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4237 /* Output any buffered-up bit-fields preceding this element. */
4238 if (byte_buffer_in_use)
4240 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4242 byte_buffer_in_use = 0;
4245 /* Advance to offset of this element.
4246 Note no alignment needed in an array, since that is guaranteed
4247 if each element has the proper size. */
4248 if ((field != 0 || index != 0) && pos != total_bytes)
4250 gcc_assert (pos >= total_bytes);
4251 assemble_zeros (pos - total_bytes);
4255 /* Find the alignment of this element. */
4256 align2 = min_align (align, BITS_PER_UNIT * pos);
4258 /* Determine size this element should occupy. */
4263 /* If this is an array with an unspecified upper bound,
4264 the initializer determines the size. */
4265 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4266 but we cannot do this until the deprecated support for
4267 initializing zero-length array members is removed. */
4268 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4269 && TYPE_DOMAIN (TREE_TYPE (field))
4270 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4272 fieldsize = array_size_for_constructor (val);
4273 /* Given a non-empty initialization, this field had
4275 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4277 else if (DECL_SIZE_UNIT (field))
4279 /* ??? This can't be right. If the decl size overflows
4280 a host integer we will silently emit no data. */
4281 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4282 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4286 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4288 /* Output the element's initial value. */
4290 assemble_zeros (fieldsize);
4292 output_constant (val, fieldsize, align2);
4294 /* Count its size. */
4295 total_bytes += fieldsize;
4297 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4298 error ("invalid initial value for member %qs",
4299 IDENTIFIER_POINTER (DECL_NAME (field)));
4302 /* Element that is a bit-field. */
4304 HOST_WIDE_INT next_offset = int_bit_position (field);
4305 HOST_WIDE_INT end_offset
4306 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4309 val = integer_zero_node;
4311 /* If this field does not start in this (or, next) byte,
4313 if (next_offset / BITS_PER_UNIT != total_bytes)
4315 /* Output remnant of any bit field in previous bytes. */
4316 if (byte_buffer_in_use)
4318 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4320 byte_buffer_in_use = 0;
4323 /* If still not at proper byte, advance to there. */
4324 if (next_offset / BITS_PER_UNIT != total_bytes)
4326 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4327 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4328 total_bytes = next_offset / BITS_PER_UNIT;
4332 if (! byte_buffer_in_use)
4335 /* We must split the element into pieces that fall within
4336 separate bytes, and combine each byte with previous or
4337 following bit-fields. */
4339 /* next_offset is the offset n fbits from the beginning of
4340 the structure to the next bit of this element to be processed.
4341 end_offset is the offset of the first bit past the end of
4343 while (next_offset < end_offset)
4347 HOST_WIDE_INT value;
4348 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4349 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4351 /* Advance from byte to byte
4352 within this element when necessary. */
4353 while (next_byte != total_bytes)
4355 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4360 /* Number of bits we can process at once
4361 (all part of the same byte). */
4362 this_time = MIN (end_offset - next_offset,
4363 BITS_PER_UNIT - next_bit);
4364 if (BYTES_BIG_ENDIAN)
4366 /* On big-endian machine, take the most significant bits
4367 first (of the bits that are significant)
4368 and put them into bytes from the most significant end. */
4369 shift = end_offset - next_offset - this_time;
4371 /* Don't try to take a bunch of bits that cross
4372 the word boundary in the INTEGER_CST. We can
4373 only select bits from the LOW or HIGH part
4375 if (shift < HOST_BITS_PER_WIDE_INT
4376 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4378 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4379 shift = HOST_BITS_PER_WIDE_INT;
4382 /* Now get the bits from the appropriate constant word. */
4383 if (shift < HOST_BITS_PER_WIDE_INT)
4384 value = TREE_INT_CST_LOW (val);
4387 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4388 value = TREE_INT_CST_HIGH (val);
4389 shift -= HOST_BITS_PER_WIDE_INT;
4392 /* Get the result. This works only when:
4393 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4394 byte |= (((value >> shift)
4395 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4396 << (BITS_PER_UNIT - this_time - next_bit));
4400 /* On little-endian machines,
4401 take first the least significant bits of the value
4402 and pack them starting at the least significant
4403 bits of the bytes. */
4404 shift = next_offset - int_bit_position (field);
4406 /* Don't try to take a bunch of bits that cross
4407 the word boundary in the INTEGER_CST. We can
4408 only select bits from the LOW or HIGH part
4410 if (shift < HOST_BITS_PER_WIDE_INT
4411 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4412 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4414 /* Now get the bits from the appropriate constant word. */
4415 if (shift < HOST_BITS_PER_WIDE_INT)
4416 value = TREE_INT_CST_LOW (val);
4419 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4420 value = TREE_INT_CST_HIGH (val);
4421 shift -= HOST_BITS_PER_WIDE_INT;
4424 /* Get the result. This works only when:
4425 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4426 byte |= (((value >> shift)
4427 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4431 next_offset += this_time;
4432 byte_buffer_in_use = 1;
4437 if (byte_buffer_in_use)
4439 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4443 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4444 assemble_zeros (size - total_bytes);
4447 /* This TREE_LIST contains any weak symbol declarations waiting
4449 static GTY(()) tree weak_decls;
4451 /* Mark DECL as weak. */
4454 mark_weak (tree decl)
4456 DECL_WEAK (decl) = 1;
4458 if (DECL_RTL_SET_P (decl)
4459 && MEM_P (DECL_RTL (decl))
4460 && XEXP (DECL_RTL (decl), 0)
4461 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4462 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4465 /* Merge weak status between NEWDECL and OLDDECL. */
4468 merge_weak (tree newdecl, tree olddecl)
4470 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4472 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4475 /* We put the NEWDECL on the weak_decls list at some point
4476 and OLDDECL as well. Keep just OLDDECL on the list. */
4477 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4478 if (TREE_VALUE (*pwd) == newdecl)
4480 *pwd = TREE_CHAIN (*pwd);
4487 if (DECL_WEAK (newdecl))
4491 /* NEWDECL is weak, but OLDDECL is not. */
4493 /* If we already output the OLDDECL, we're in trouble; we can't
4494 go back and make it weak. This error cannot caught in
4495 declare_weak because the NEWDECL and OLDDECL was not yet
4496 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4497 if (TREE_ASM_WRITTEN (olddecl))
4498 error ("weak declaration of %q+D must precede definition",
4501 /* If we've already generated rtl referencing OLDDECL, we may
4502 have done so in a way that will not function properly with
4504 else if (TREE_USED (olddecl)
4505 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4506 warning (0, "weak declaration of %q+D after first use results "
4507 "in unspecified behavior", newdecl);
4511 /* We put the NEWDECL on the weak_decls list at some point.
4512 Replace it with the OLDDECL. */
4513 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4514 if (TREE_VALUE (wd) == newdecl)
4516 TREE_VALUE (wd) = olddecl;
4519 /* We may not find the entry on the list. If NEWDECL is a
4520 weak alias, then we will have already called
4521 globalize_decl to remove the entry; in that case, we do
4522 not need to do anything. */
4525 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4526 mark_weak (olddecl);
4529 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4530 weak. Just update NEWDECL to indicate that it's weak too. */
4531 mark_weak (newdecl);
4534 /* Declare DECL to be a weak symbol. */
4537 declare_weak (tree decl)
4539 if (! TREE_PUBLIC (decl))
4540 error ("weak declaration of %q+D must be public", decl);
4541 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4542 error ("weak declaration of %q+D must precede definition", decl);
4543 else if (SUPPORTS_WEAK)
4545 if (! DECL_WEAK (decl))
4546 weak_decls = tree_cons (NULL, decl, weak_decls);
4549 warning (0, "weak declaration of %q+D not supported", decl);
4555 weak_finish_1 (tree decl)
4557 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4558 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4561 if (! TREE_USED (decl))
4564 #ifdef ASM_WEAKEN_DECL
4565 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4567 #ifdef ASM_WEAKEN_LABEL
4568 ASM_WEAKEN_LABEL (asm_out_file, name);
4570 #ifdef ASM_OUTPUT_WEAK_ALIAS
4572 static bool warn_once = 0;
4575 warning (0, "only weak aliases are supported in this configuration");
4585 /* This TREE_LIST contains weakref targets. */
4587 static GTY(()) tree weakref_targets;
4589 /* Forward declaration. */
4590 static tree find_decl_and_mark_needed (tree decl, tree target);
4592 /* Emit any pending weak declarations. */
4599 for (t = weakref_targets; t; t = TREE_CHAIN (t))
4601 tree alias_decl = TREE_PURPOSE (t);
4602 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t));
4604 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl)))
4605 /* Remove alias_decl from the weak list, but leave entries for
4606 the target alone. */
4608 #ifndef ASM_OUTPUT_WEAKREF
4609 else if (! TREE_SYMBOL_REFERENCED (target))
4611 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
4612 defined, otherwise we and weak_finish_1 would use a
4613 different macros. */
4614 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
4615 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target));
4617 tree decl = find_decl_and_mark_needed (alias_decl, target);
4621 decl = build_decl (TREE_CODE (alias_decl), target,
4622 TREE_TYPE (alias_decl));
4624 DECL_EXTERNAL (decl) = 1;
4625 TREE_PUBLIC (decl) = 1;
4626 DECL_ARTIFICIAL (decl) = 1;
4627 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl);
4628 TREE_USED (decl) = 1;
4631 weak_finish_1 (decl);
4640 /* Remove the alias and the target from the pending weak list
4641 so that we do not emit any .weak directives for the former,
4642 nor multiple .weak directives for the latter. */
4643 for (p = &weak_decls; (t2 = *p) ; )
4645 if (TREE_VALUE (t2) == alias_decl
4646 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2)))
4647 *p = TREE_CHAIN (t2);
4649 p = &TREE_CHAIN (t2);
4652 /* Remove other weakrefs to the same target, to speed things up. */
4653 for (p = &TREE_CHAIN (t); (t2 = *p) ; )
4655 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2)))
4656 *p = TREE_CHAIN (t2);
4658 p = &TREE_CHAIN (t2);
4663 for (t = weak_decls; t; t = TREE_CHAIN (t))
4665 tree decl = TREE_VALUE (t);
4667 weak_finish_1 (decl);
4671 /* Emit the assembly bits to indicate that DECL is globally visible. */
4674 globalize_decl (tree decl)
4676 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4678 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4679 if (DECL_WEAK (decl))
4683 #ifdef ASM_WEAKEN_DECL
4684 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4686 ASM_WEAKEN_LABEL (asm_out_file, name);
4689 /* Remove this function from the pending weak list so that
4690 we do not emit multiple .weak directives for it. */
4691 for (p = &weak_decls; (t = *p) ; )
4693 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4694 *p = TREE_CHAIN (t);
4696 p = &TREE_CHAIN (t);
4699 /* Remove weakrefs to the same target from the pending weakref
4700 list, for the same reason. */
4701 for (p = &weakref_targets; (t = *p) ; )
4703 if (DECL_ASSEMBLER_NAME (decl)
4704 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4705 *p = TREE_CHAIN (t);
4707 p = &TREE_CHAIN (t);
4712 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4713 if (DECL_ONE_ONLY (decl))
4714 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4717 targetm.asm_out.globalize_label (asm_out_file, name);
4720 /* We have to be able to tell cgraph about the needed-ness of the target
4721 of an alias. This requires that the decl have been defined. Aliases
4722 that precede their definition have to be queued for later processing. */
4724 typedef struct alias_pair GTY(())
4730 /* Define gc'd vector type. */
4731 DEF_VEC_O(alias_pair);
4732 DEF_VEC_ALLOC_O(alias_pair,gc);
4734 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4736 /* Given an assembly name, find the decl it is associated with. At the
4737 same time, mark it needed for cgraph. */
4740 find_decl_and_mark_needed (tree decl, tree target)
4742 struct cgraph_node *fnode = NULL;
4743 struct cgraph_varpool_node *vnode = NULL;
4745 if (TREE_CODE (decl) == FUNCTION_DECL)
4747 fnode = cgraph_node_for_asm (target);
4749 vnode = cgraph_varpool_node_for_asm (target);
4753 vnode = cgraph_varpool_node_for_asm (target);
4755 fnode = cgraph_node_for_asm (target);
4760 /* We can't mark function nodes as used after cgraph global info
4761 is finished. This wouldn't generally be necessary, but C++
4762 virtual table thunks are introduced late in the game and
4763 might seem like they need marking, although in fact they
4765 if (! cgraph_global_info_ready)
4766 cgraph_mark_needed_node (fnode);
4771 cgraph_varpool_mark_needed_node (vnode);
4778 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4779 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4780 tree node is DECL to have the value of the tree node TARGET. */
4783 do_assemble_alias (tree decl, tree target)
4785 if (TREE_ASM_WRITTEN (decl))
4788 TREE_ASM_WRITTEN (decl) = 1;
4789 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4791 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4793 ultimate_transparent_alias_target (&target);
4795 if (!TREE_SYMBOL_REFERENCED (target))
4796 weakref_targets = tree_cons (decl, target, weakref_targets);
4798 #ifdef ASM_OUTPUT_WEAKREF
4799 ASM_OUTPUT_WEAKREF (asm_out_file, decl,
4800 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4801 IDENTIFIER_POINTER (target));
4805 error ("%Jweakref is not supported in this configuration", decl);
4812 #ifdef ASM_OUTPUT_DEF
4813 /* Make name accessible from other files, if appropriate. */
4815 if (TREE_PUBLIC (decl))
4817 globalize_decl (decl);
4818 maybe_assemble_visibility (decl);
4821 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4822 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4824 ASM_OUTPUT_DEF (asm_out_file,
4825 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4826 IDENTIFIER_POINTER (target));
4828 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4833 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4834 # ifdef ASM_WEAKEN_DECL
4835 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4837 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4839 /* Remove this function from the pending weak list so that
4840 we do not emit multiple .weak directives for it. */
4841 for (p = &weak_decls; (t = *p) ; )
4842 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4843 *p = TREE_CHAIN (t);
4845 p = &TREE_CHAIN (t);
4847 /* Remove weakrefs to the same target from the pending weakref
4848 list, for the same reason. */
4849 for (p = &weakref_targets; (t = *p) ; )
4851 if (DECL_ASSEMBLER_NAME (decl)
4852 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4853 *p = TREE_CHAIN (t);
4855 p = &TREE_CHAIN (t);
4861 /* First pass of completing pending aliases. Make sure that cgraph knows
4862 which symbols will be required. */
4865 finish_aliases_1 (void)
4870 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4874 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4875 if (target_decl == NULL)
4877 if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4878 error ("%q+D aliased to undefined symbol %qs",
4879 p->decl, IDENTIFIER_POINTER (p->target));
4881 else if (DECL_EXTERNAL (target_decl)
4882 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4883 error ("%q+D aliased to external symbol %qs",
4884 p->decl, IDENTIFIER_POINTER (p->target));
4888 /* Second pass of completing pending aliases. Emit the actual assembly.
4889 This happens at the end of compilation and thus it is assured that the
4890 target symbol has been emitted. */
4893 finish_aliases_2 (void)
4898 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4899 do_assemble_alias (p->decl, p->target);
4901 VEC_truncate (alias_pair, alias_pairs, 0);
4904 /* Emit an assembler directive to make the symbol for DECL an alias to
4905 the symbol for TARGET. */
4908 assemble_alias (tree decl, tree target)
4911 bool is_weakref = false;
4913 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4915 tree alias = DECL_ASSEMBLER_NAME (decl);
4919 ultimate_transparent_alias_target (&target);
4921 if (alias == target)
4922 error ("weakref %q+D ultimately targets itself", decl);
4925 #ifndef ASM_OUTPUT_WEAKREF
4926 IDENTIFIER_TRANSPARENT_ALIAS (alias) = 1;
4927 TREE_CHAIN (alias) = target;
4930 if (TREE_PUBLIC (decl))
4931 error ("weakref %q+D must have static linkage", decl);
4935 #if !defined (ASM_OUTPUT_DEF)
4936 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4937 error ("%Jalias definitions not supported in this configuration", decl);
4940 if (!DECL_WEAK (decl))
4942 error ("%Jonly weak aliases are supported in this configuration", decl);
4949 /* We must force creation of DECL_RTL for debug info generation, even though
4950 we don't use it here. */
4951 make_decl_rtl (decl);
4952 TREE_USED (decl) = 1;
4954 /* A quirk of the initial implementation of aliases required that the user
4955 add "extern" to all of them. Which is silly, but now historical. Do
4956 note that the symbol is in fact locally defined. */
4958 DECL_EXTERNAL (decl) = 0;
4960 /* Allow aliases to aliases. */
4961 if (TREE_CODE (decl) == FUNCTION_DECL)
4962 cgraph_node (decl)->alias = true;
4964 cgraph_varpool_node (decl)->alias = true;
4966 /* If the target has already been emitted, we don't have to queue the
4967 alias. This saves a tad o memory. */
4968 target_decl = find_decl_and_mark_needed (decl, target);
4969 if (target_decl && TREE_ASM_WRITTEN (target_decl))
4970 do_assemble_alias (decl, target);
4973 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
4979 /* Emit an assembler directive to set symbol for DECL visibility to
4980 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4983 default_assemble_visibility (tree decl, int vis)
4985 static const char * const visibility_types[] = {
4986 NULL, "internal", "hidden", "protected"
4989 const char *name, *type;
4991 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4992 type = visibility_types[vis];
4994 #ifdef HAVE_GAS_HIDDEN
4995 fprintf (asm_out_file, "\t.%s\t", type);
4996 assemble_name (asm_out_file, name);
4997 fprintf (asm_out_file, "\n");
4999 warning (OPT_Wattributes, "visibility attribute not supported "
5000 "in this configuration; ignored");
5004 /* A helper function to call assemble_visibility when needed for a decl. */
5007 maybe_assemble_visibility (tree decl)
5009 enum symbol_visibility vis = DECL_VISIBILITY (decl);
5011 if (vis != VISIBILITY_DEFAULT)
5012 targetm.asm_out.visibility (decl, vis);
5015 /* Returns 1 if the target configuration supports defining public symbols
5016 so that one of them will be chosen at link time instead of generating a
5017 multiply-defined symbol error, whether through the use of weak symbols or
5018 a target-specific mechanism for having duplicates discarded. */
5021 supports_one_only (void)
5023 if (SUPPORTS_ONE_ONLY)
5025 return SUPPORTS_WEAK;
5028 /* Set up DECL as a public symbol that can be defined in multiple
5029 translation units without generating a linker error. */
5032 make_decl_one_only (tree decl)
5034 gcc_assert (TREE_CODE (decl) == VAR_DECL
5035 || TREE_CODE (decl) == FUNCTION_DECL);
5037 TREE_PUBLIC (decl) = 1;
5039 if (SUPPORTS_ONE_ONLY)
5041 #ifdef MAKE_DECL_ONE_ONLY
5042 MAKE_DECL_ONE_ONLY (decl);
5044 DECL_ONE_ONLY (decl) = 1;
5046 else if (TREE_CODE (decl) == VAR_DECL
5047 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5048 DECL_COMMON (decl) = 1;
5051 gcc_assert (SUPPORTS_WEAK);
5052 DECL_WEAK (decl) = 1;
5057 init_varasm_once (void)
5059 section_htab = htab_create_ggc (31, section_entry_hash,
5060 section_entry_eq, NULL);
5061 object_block_htab = htab_create_ggc (31, object_block_entry_hash,
5062 object_block_entry_eq, NULL);
5063 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
5064 const_desc_eq, NULL);
5066 const_alias_set = new_alias_set ();
5068 #ifdef TEXT_SECTION_ASM_OP
5069 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op,
5070 TEXT_SECTION_ASM_OP);
5073 #ifdef DATA_SECTION_ASM_OP
5074 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5075 DATA_SECTION_ASM_OP);
5078 #ifdef SDATA_SECTION_ASM_OP
5079 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5080 SDATA_SECTION_ASM_OP);
5083 #ifdef READONLY_DATA_SECTION_ASM_OP
5084 readonly_data_section = get_unnamed_section (0, output_section_asm_op,
5085 READONLY_DATA_SECTION_ASM_OP);
5088 #ifdef CTORS_SECTION_ASM_OP
5089 ctors_section = get_unnamed_section (0, output_section_asm_op,
5090 CTORS_SECTION_ASM_OP);
5093 #ifdef DTORS_SECTION_ASM_OP
5094 dtors_section = get_unnamed_section (0, output_section_asm_op,
5095 DTORS_SECTION_ASM_OP);
5098 #ifdef BSS_SECTION_ASM_OP
5099 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5100 output_section_asm_op,
5101 BSS_SECTION_ASM_OP);
5104 #ifdef SBSS_SECTION_ASM_OP
5105 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5106 output_section_asm_op,
5107 SBSS_SECTION_ASM_OP);
5110 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5111 | SECTION_COMMON, emit_tls_common);
5112 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5113 | SECTION_COMMON, emit_local);
5114 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5115 | SECTION_COMMON, emit_common);
5117 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
5118 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS,
5122 targetm.asm_out.init_sections ();
5124 if (readonly_data_section == NULL)
5125 readonly_data_section = text_section;
5129 decl_default_tls_model (tree decl)
5131 enum tls_model kind;
5134 is_local = targetm.binds_local_p (decl);
5138 kind = TLS_MODEL_LOCAL_EXEC;
5140 kind = TLS_MODEL_INITIAL_EXEC;
5143 /* Local dynamic is inefficient when we're not combining the
5144 parts of the address. */
5145 else if (optimize && is_local)
5146 kind = TLS_MODEL_LOCAL_DYNAMIC;
5148 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5149 if (kind < flag_tls_default)
5150 kind = flag_tls_default;
5155 /* Select a set of attributes for section NAME based on the properties
5156 of DECL and whether or not RELOC indicates that DECL's initializer
5157 might contain runtime relocations.
5159 We make the section read-only and executable for a function decl,
5160 read-only for a const data decl, and writable for a non-const data decl. */
5163 default_section_type_flags (tree decl, const char *name, int reloc)
5165 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
5169 default_section_type_flags_1 (tree decl, const char *name, int reloc,
5174 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5175 flags = SECTION_CODE;
5176 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
5178 else if (current_function_decl
5180 && cfun->unlikely_text_section_name
5181 && strcmp (name, cfun->unlikely_text_section_name) == 0)
5182 flags = SECTION_CODE;
5184 && (!current_function_decl || !cfun)
5185 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5186 flags = SECTION_CODE;
5188 flags = SECTION_WRITE;
5190 if (decl && DECL_ONE_ONLY (decl))
5191 flags |= SECTION_LINKONCE;
5193 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5194 flags |= SECTION_TLS | SECTION_WRITE;
5196 if (strcmp (name, ".bss") == 0
5197 || strncmp (name, ".bss.", 5) == 0
5198 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5199 || strcmp (name, ".sbss") == 0
5200 || strncmp (name, ".sbss.", 6) == 0
5201 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5202 flags |= SECTION_BSS;
5204 if (strcmp (name, ".tdata") == 0
5205 || strncmp (name, ".tdata.", 7) == 0
5206 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
5207 flags |= SECTION_TLS;
5209 if (strcmp (name, ".tbss") == 0
5210 || strncmp (name, ".tbss.", 6) == 0
5211 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
5212 flags |= SECTION_TLS | SECTION_BSS;
5214 /* These three sections have special ELF types. They are neither
5215 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
5216 want to print a section type (@progbits or @nobits). If someone
5217 is silly enough to emit code or TLS variables to one of these
5218 sections, then don't handle them specially. */
5219 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
5220 && (strcmp (name, ".init_array") == 0
5221 || strcmp (name, ".fini_array") == 0
5222 || strcmp (name, ".preinit_array") == 0))
5223 flags |= SECTION_NOTYPE;
5228 /* Return true if the target supports some form of global BSS,
5229 either through bss_noswitch_section, or by selecting a BSS
5230 section in TARGET_ASM_SELECT_SECTION. */
5233 have_global_bss_p (void)
5235 return bss_noswitch_section || targetm.have_switchable_bss_sections;
5238 /* Output assembly to switch to section NAME with attribute FLAGS.
5239 Four variants for common object file formats. */
5242 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
5243 unsigned int flags ATTRIBUTE_UNUSED,
5244 tree decl ATTRIBUTE_UNUSED)
5246 /* Some object formats don't support named sections at all. The
5247 front-end should already have flagged this as an error. */
5252 default_elf_asm_named_section (const char *name, unsigned int flags,
5253 tree decl ATTRIBUTE_UNUSED)
5255 char flagchars[10], *f = flagchars;
5257 /* If we have already declared this section, we can use an
5258 abbreviated form to switch back to it -- unless this section is
5259 part of a COMDAT groups, in which case GAS requires the full
5260 declaration every time. */
5261 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5262 && (flags & SECTION_DECLARED))
5264 fprintf (asm_out_file, "\t.section\t%s\n", name);
5268 if (!(flags & SECTION_DEBUG))
5270 if (flags & SECTION_WRITE)
5272 if (flags & SECTION_CODE)
5274 if (flags & SECTION_SMALL)
5276 if (flags & SECTION_MERGE)
5278 if (flags & SECTION_STRINGS)
5280 if (flags & SECTION_TLS)
5282 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5286 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
5288 if (!(flags & SECTION_NOTYPE))
5293 if (flags & SECTION_BSS)
5299 #ifdef ASM_COMMENT_START
5300 /* On platforms that use "@" as the assembly comment character,
5302 if (strcmp (ASM_COMMENT_START, "@") == 0)
5305 fprintf (asm_out_file, format, type);
5307 if (flags & SECTION_ENTSIZE)
5308 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
5309 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5310 fprintf (asm_out_file, ",%s,comdat",
5311 lang_hooks.decls.comdat_group (decl));
5314 putc ('\n', asm_out_file);
5318 default_coff_asm_named_section (const char *name, unsigned int flags,
5319 tree decl ATTRIBUTE_UNUSED)
5321 char flagchars[8], *f = flagchars;
5323 if (flags & SECTION_WRITE)
5325 if (flags & SECTION_CODE)
5329 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5333 default_pe_asm_named_section (const char *name, unsigned int flags,
5336 default_coff_asm_named_section (name, flags, decl);
5338 if (flags & SECTION_LINKONCE)
5340 /* Functions may have been compiled at various levels of
5341 optimization so we can't use `same_size' here.
5342 Instead, have the linker pick one. */
5343 fprintf (asm_out_file, "\t.linkonce %s\n",
5344 (flags & SECTION_CODE ? "discard" : "same_size"));
5348 /* The lame default section selector. */
5351 default_select_section (tree decl, int reloc,
5352 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5356 if (decl_readonly_section (decl, reloc))
5357 return readonly_data_section;
5359 else if (TREE_CODE (decl) == CONSTRUCTOR)
5361 if (! ((flag_pic && reloc)
5362 || !TREE_READONLY (decl)
5363 || TREE_SIDE_EFFECTS (decl)
5364 || !TREE_CONSTANT (decl)))
5365 return readonly_data_section;
5367 else if (TREE_CODE (decl) == STRING_CST)
5368 return readonly_data_section;
5369 else if (! (flag_pic && reloc))
5370 return readonly_data_section;
5372 return data_section;
5375 enum section_category
5376 categorize_decl_for_section (tree decl, int reloc, int shlib)
5378 enum section_category ret;
5380 if (TREE_CODE (decl) == FUNCTION_DECL)
5382 else if (TREE_CODE (decl) == STRING_CST)
5384 if (flag_mudflap) /* or !flag_merge_constants */
5385 return SECCAT_RODATA;
5387 return SECCAT_RODATA_MERGE_STR;
5389 else if (TREE_CODE (decl) == VAR_DECL)
5391 if (bss_initializer_p (decl))
5393 else if (! TREE_READONLY (decl)
5394 || TREE_SIDE_EFFECTS (decl)
5395 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5397 if (shlib && (reloc & 2))
5398 ret = SECCAT_DATA_REL;
5399 else if (shlib && reloc)
5400 ret = SECCAT_DATA_REL_LOCAL;
5404 else if (shlib && (reloc & 2))
5405 ret = SECCAT_DATA_REL_RO;
5406 else if (shlib && reloc)
5407 ret = SECCAT_DATA_REL_RO_LOCAL;
5408 else if (reloc || flag_merge_constants < 2)
5409 /* C and C++ don't allow different variables to share the same
5410 location. -fmerge-all-constants allows even that (at the
5411 expense of not conforming). */
5412 ret = SECCAT_RODATA;
5413 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5414 ret = SECCAT_RODATA_MERGE_STR_INIT;
5416 ret = SECCAT_RODATA_MERGE_CONST;
5418 else if (TREE_CODE (decl) == CONSTRUCTOR)
5420 if ((shlib && reloc)
5421 || TREE_SIDE_EFFECTS (decl)
5422 || ! TREE_CONSTANT (decl))
5425 ret = SECCAT_RODATA;
5428 ret = SECCAT_RODATA;
5430 /* There are no read-only thread-local sections. */
5431 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5433 /* Note that this would be *just* SECCAT_BSS, except that there's
5434 no concept of a read-only thread-local-data section. */
5435 if (ret == SECCAT_BSS
5436 || (flag_zero_initialized_in_bss
5437 && initializer_zerop (DECL_INITIAL (decl))))
5443 /* If the target uses small data sections, select it. */
5444 else if (targetm.in_small_data_p (decl))
5446 if (ret == SECCAT_BSS)
5448 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5449 ret = SECCAT_SRODATA;
5458 decl_readonly_section (tree decl, int reloc)
5460 return decl_readonly_section_1 (decl, reloc, flag_pic);
5464 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5466 switch (categorize_decl_for_section (decl, reloc, shlib))
5469 case SECCAT_RODATA_MERGE_STR:
5470 case SECCAT_RODATA_MERGE_STR_INIT:
5471 case SECCAT_RODATA_MERGE_CONST:
5472 case SECCAT_SRODATA:
5481 /* Select a section based on the above categorization. */
5484 default_elf_select_section (tree decl, int reloc,
5485 unsigned HOST_WIDE_INT align)
5487 return default_elf_select_section_1 (decl, reloc, align, flag_pic);
5491 default_elf_select_section_1 (tree decl, int reloc,
5492 unsigned HOST_WIDE_INT align, int shlib)
5495 switch (categorize_decl_for_section (decl, reloc, shlib))
5498 /* We're not supposed to be called on FUNCTION_DECLs. */
5501 return readonly_data_section;
5502 case SECCAT_RODATA_MERGE_STR:
5503 return mergeable_string_section (decl, align, 0);
5504 case SECCAT_RODATA_MERGE_STR_INIT:
5505 return mergeable_string_section (DECL_INITIAL (decl), align, 0);
5506 case SECCAT_RODATA_MERGE_CONST:
5507 return mergeable_constant_section (DECL_MODE (decl), align, 0);
5508 case SECCAT_SRODATA:
5512 return data_section;
5513 case SECCAT_DATA_REL:
5514 sname = ".data.rel";
5516 case SECCAT_DATA_REL_LOCAL:
5517 sname = ".data.rel.local";
5519 case SECCAT_DATA_REL_RO:
5520 sname = ".data.rel.ro";
5522 case SECCAT_DATA_REL_RO_LOCAL:
5523 sname = ".data.rel.ro.local";
5548 return get_named_section (decl, sname, reloc);
5551 /* Construct a unique section name based on the decl name and the
5552 categorization performed above. */
5555 default_unique_section (tree decl, int reloc)
5557 default_unique_section_1 (decl, reloc, flag_pic);
5561 default_unique_section_1 (tree decl, int reloc, int shlib)
5563 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5564 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5565 const char *prefix, *name;
5569 switch (categorize_decl_for_section (decl, reloc, shlib))
5572 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5575 case SECCAT_RODATA_MERGE_STR:
5576 case SECCAT_RODATA_MERGE_STR_INIT:
5577 case SECCAT_RODATA_MERGE_CONST:
5578 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5580 case SECCAT_SRODATA:
5581 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5584 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5586 case SECCAT_DATA_REL:
5587 prefix = one_only ? ".gnu.linkonce.d.rel." : ".data.rel.";
5589 case SECCAT_DATA_REL_LOCAL:
5590 prefix = one_only ? ".gnu.linkonce.d.rel.local." : ".data.rel.local.";
5592 case SECCAT_DATA_REL_RO:
5593 prefix = one_only ? ".gnu.linkonce.d.rel.ro." : ".data.rel.ro.";
5595 case SECCAT_DATA_REL_RO_LOCAL:
5596 prefix = one_only ? ".gnu.linkonce.d.rel.ro.local."
5597 : ".data.rel.ro.local.";
5600 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5603 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5606 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5609 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5612 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5617 plen = strlen (prefix);
5619 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5620 name = targetm.strip_name_encoding (name);
5621 nlen = strlen (name);
5623 string = alloca (nlen + plen + 1);
5624 memcpy (string, prefix, plen);
5625 memcpy (string + plen, name, nlen + 1);
5627 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5631 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5633 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5636 switch (GET_CODE (x))
5641 return data_section;
5647 return readonly_data_section;
5651 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5652 unsigned HOST_WIDE_INT align)
5654 /* ??? Handle small data here somehow. */
5657 switch (GET_CODE (x))
5661 return get_named_section (NULL, ".data.rel.ro", 3);
5664 return get_named_section (NULL, ".data.rel.ro.local", 1);
5670 return mergeable_constant_section (mode, align, 0);
5673 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5676 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5681 /* Careful not to prod global register variables. */
5684 symbol = XEXP (rtl, 0);
5685 if (GET_CODE (symbol) != SYMBOL_REF)
5688 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO;
5689 if (TREE_CODE (decl) == FUNCTION_DECL)
5690 flags |= SYMBOL_FLAG_FUNCTION;
5691 if (targetm.binds_local_p (decl))
5692 flags |= SYMBOL_FLAG_LOCAL;
5693 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5694 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
5695 else if (targetm.in_small_data_p (decl))
5696 flags |= SYMBOL_FLAG_SMALL;
5697 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5698 being PUBLIC, the thing *must* be defined in this translation unit.
5699 Prevent this buglet from being propagated into rtl code as well. */
5700 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5701 flags |= SYMBOL_FLAG_EXTERNAL;
5703 SYMBOL_REF_FLAGS (symbol) = flags;
5706 /* By default, we do nothing for encode_section_info, so we need not
5707 do anything but discard the '*' marker. */
5710 default_strip_name_encoding (const char *str)
5712 return str + (*str == '*');
5715 #ifdef ASM_OUTPUT_DEF
5716 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
5717 anchor relative to ".", the current section position. */
5720 default_asm_output_anchor (rtx symbol)
5724 sprintf (buffer, ". + " HOST_WIDE_INT_PRINT_DEC,
5725 SYMBOL_REF_BLOCK_OFFSET (symbol));
5726 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer);
5730 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
5733 default_use_anchors_for_symbol_p (rtx symbol)
5738 /* Don't use anchors for mergeable sections. The linker might move
5739 the objects around. */
5740 sect = SYMBOL_REF_BLOCK (symbol)->sect;
5741 if (sect->common.flags & SECTION_MERGE)
5744 /* Don't use anchors for small data sections. The small data register
5745 acts as an anchor for such sections. */
5746 if (sect->common.flags & SECTION_SMALL)
5749 decl = SYMBOL_REF_DECL (symbol);
5750 if (decl && DECL_P (decl))
5752 /* Don't use section anchors for decls that might be defined by
5754 if (!targetm.binds_local_p (decl))
5757 /* Don't use section anchors for decls that will be placed in a
5758 small data section. */
5759 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
5760 one above. The problem is that we only use SECTION_SMALL for
5761 sections that should be marked as small in the section directive. */
5762 if (targetm.in_small_data_p (decl))
5768 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5769 wrt cross-module name binding. */
5772 default_binds_local_p (tree exp)
5774 return default_binds_local_p_1 (exp, flag_shlib);
5778 default_binds_local_p_1 (tree exp, int shlib)
5782 /* A non-decl is an entry in the constant pool. */
5785 /* Weakrefs may not bind locally, even though the weakref itself is
5786 always static and therefore local. */
5787 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
5789 /* Static variables are always local. */
5790 else if (! TREE_PUBLIC (exp))
5792 /* A variable is local if the user has said explicitly that it will
5794 else if (DECL_VISIBILITY_SPECIFIED (exp)
5795 && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5797 /* Variables defined outside this object might not be local. */
5798 else if (DECL_EXTERNAL (exp))
5800 /* If defined in this object and visibility is not default, must be
5802 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5804 /* Default visibility weak data can be overridden by a strong symbol
5805 in another module and so are not local. */
5806 else if (DECL_WEAK (exp))
5808 /* If PIC, then assume that any global name can be overridden by
5809 symbols resolved from other modules. */
5812 /* Uninitialized COMMON variable may be unified with symbols
5813 resolved from other modules. */
5814 else if (DECL_COMMON (exp)
5815 && (DECL_INITIAL (exp) == NULL
5816 || DECL_INITIAL (exp) == error_mark_node))
5818 /* Otherwise we're left with initialized (or non-common) global data
5819 which is of necessity defined locally. */
5826 /* Determine whether or not a pointer mode is valid. Assume defaults
5827 of ptr_mode or Pmode - can be overridden. */
5829 default_valid_pointer_mode (enum machine_mode mode)
5831 return (mode == ptr_mode || mode == Pmode);
5834 /* Default function to output code that will globalize a label. A
5835 target must define GLOBAL_ASM_OP or provide its own function to
5836 globalize a label. */
5837 #ifdef GLOBAL_ASM_OP
5839 default_globalize_label (FILE * stream, const char *name)
5841 fputs (GLOBAL_ASM_OP, stream);
5842 assemble_name (stream, name);
5843 putc ('\n', stream);
5845 #endif /* GLOBAL_ASM_OP */
5847 /* Default function to output a label for unwind information. The
5848 default is to do nothing. A target that needs nonlocal labels for
5849 unwind information must provide its own function to do this. */
5851 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5852 tree decl ATTRIBUTE_UNUSED,
5853 int for_eh ATTRIBUTE_UNUSED,
5854 int empty ATTRIBUTE_UNUSED)
5858 /* Default function to output a label to divide up the exception table.
5859 The default is to do nothing. A target that needs/wants to divide
5860 up the table must provide it's own function to do this. */
5862 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED)
5866 /* This is how to output an internal numbered label where PREFIX is
5867 the class of label and LABELNO is the number within the class. */
5870 default_internal_label (FILE *stream, const char *prefix,
5871 unsigned long labelno)
5873 char *const buf = alloca (40 + strlen (prefix));
5874 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5875 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5878 /* This is the default behavior at the beginning of a file. It's
5879 controlled by two other target-hook toggles. */
5881 default_file_start (void)
5883 if (targetm.file_start_app_off && !flag_verbose_asm)
5884 fputs (ASM_APP_OFF, asm_out_file);
5886 if (targetm.file_start_file_directive)
5887 output_file_directive (asm_out_file, main_input_filename);
5890 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5891 which emits a special section directive used to indicate whether or
5892 not this object file needs an executable stack. This is primarily
5893 a GNU extension to ELF but could be used on other targets. */
5895 int trampolines_created;
5898 file_end_indicate_exec_stack (void)
5900 unsigned int flags = SECTION_DEBUG;
5901 if (trampolines_created)
5902 flags |= SECTION_CODE;
5904 switch_to_section (get_section (".note.GNU-stack", flags, NULL));
5907 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
5908 a get_unnamed_section callback. */
5911 output_section_asm_op (const void *directive)
5913 fprintf (asm_out_file, "%s\n", (const char *) directive);
5916 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
5917 the current section is NEW_SECTION. */
5920 switch_to_section (section *new_section)
5922 if (in_section == new_section)
5925 if (new_section->common.flags & SECTION_FORGET)
5928 in_section = new_section;
5930 switch (SECTION_STYLE (new_section))
5934 && !cfun->unlikely_text_section_name
5935 && strcmp (new_section->named.name,
5936 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5937 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
5939 targetm.asm_out.named_section (new_section->named.name,
5940 new_section->named.common.flags,
5941 new_section->named.decl);
5944 case SECTION_UNNAMED:
5945 new_section->unnamed.callback (new_section->unnamed.data);
5948 case SECTION_NOSWITCH:
5953 new_section->common.flags |= SECTION_DECLARED;
5956 /* If block symbol SYMBOL has not yet been assigned an offset, place
5957 it at the end of its block. */
5960 place_block_symbol (rtx symbol)
5962 unsigned HOST_WIDE_INT size, mask, offset;
5963 struct constant_descriptor_rtx *desc;
5964 unsigned int alignment;
5965 struct object_block *block;
5968 gcc_assert (SYMBOL_REF_BLOCK (symbol));
5969 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0)
5972 /* Work out the symbol's size and alignment. */
5973 if (CONSTANT_POOL_ADDRESS_P (symbol))
5975 desc = SYMBOL_REF_CONSTANT (symbol);
5976 alignment = desc->align;
5977 size = GET_MODE_SIZE (desc->mode);
5979 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
5981 decl = SYMBOL_REF_DECL (symbol);
5982 alignment = get_constant_alignment (decl);
5983 size = get_constant_size (decl);
5987 decl = SYMBOL_REF_DECL (symbol);
5988 alignment = DECL_ALIGN (decl);
5989 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
5992 /* Calculate the object's offset from the start of the block. */
5993 block = SYMBOL_REF_BLOCK (symbol);
5994 mask = alignment / BITS_PER_UNIT - 1;
5995 offset = (block->size + mask) & ~mask;
5996 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
5998 /* Record the block's new alignment and size. */
5999 block->alignment = MAX (block->alignment, alignment);
6000 block->size = offset + size;
6002 VEC_safe_push (rtx, gc, block->objects, symbol);
6005 /* Return the anchor that should be used to address byte offset OFFSET
6006 from the first object in BLOCK. MODEL is the TLS model used
6010 get_section_anchor (struct object_block *block, HOST_WIDE_INT offset,
6011 enum tls_model model)
6014 unsigned int begin, middle, end;
6015 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta;
6018 /* Work out the anchor's offset. Use an offset of 0 for the first
6019 anchor so that we don't pessimize the case where we take the address
6020 of a variable at the beginning of the block. This is particularly
6021 useful when a block has only one variable assigned to it.
6023 We try to place anchors RANGE bytes apart, so there can then be
6024 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
6025 a ptr_mode offset. With some target settings, the lowest such
6026 anchor might be out of range for the lowest ptr_mode offset;
6027 likewise the highest anchor for the highest offset. Use anchors
6028 at the extreme ends of the ptr_mode range in such cases.
6030 All arithmetic uses unsigned integers in order to avoid
6032 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset;
6033 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset;
6034 range = max_offset - min_offset + 1;
6039 bias = 1 << (GET_MODE_BITSIZE (ptr_mode) - 1);
6042 delta = -(unsigned HOST_WIDE_INT) offset + max_offset;
6043 delta -= delta % range;
6046 offset = (HOST_WIDE_INT) (-delta);
6050 delta = (unsigned HOST_WIDE_INT) offset - min_offset;
6051 delta -= delta % range;
6052 if (delta > bias - 1)
6054 offset = (HOST_WIDE_INT) delta;
6058 /* Do a binary search to see if there's already an anchor we can use.
6059 Set BEGIN to the new anchor's index if not. */
6061 end = VEC_length (rtx, block->anchors);
6062 while (begin != end)
6064 middle = (end + begin) / 2;
6065 anchor = VEC_index (rtx, block->anchors, middle);
6066 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset)
6068 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset)
6070 else if (SYMBOL_REF_TLS_MODEL (anchor) > model)
6072 else if (SYMBOL_REF_TLS_MODEL (anchor) < model)
6078 /* Create a new anchor with a unique label. */
6079 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++);
6080 anchor = create_block_symbol (ggc_strdup (label), block, offset);
6081 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR;
6082 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT;
6084 /* Insert it at index BEGIN. */
6085 VEC_safe_insert (rtx, gc, block->anchors, begin, anchor);
6089 /* Output the objects in BLOCK. */
6092 output_object_block (struct object_block *block)
6094 struct constant_descriptor_rtx *desc;
6096 HOST_WIDE_INT offset;
6100 if (block->objects == NULL)
6103 /* Switch to the section and make sure that the first byte is
6104 suitably aligned. */
6105 switch_to_section (block->sect);
6106 assemble_align (block->alignment);
6108 /* Define the values of all anchors relative to the current section
6110 for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++)
6111 targetm.asm_out.output_anchor (symbol);
6113 /* Output the objects themselves. */
6115 for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++)
6117 /* Move to the object's offset, padding with zeros if necessary. */
6118 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset);
6119 offset = SYMBOL_REF_BLOCK_OFFSET (symbol);
6120 if (CONSTANT_POOL_ADDRESS_P (symbol))
6122 desc = SYMBOL_REF_CONSTANT (symbol);
6123 output_constant_pool_1 (desc, 1);
6124 offset += GET_MODE_SIZE (desc->mode);
6126 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6128 decl = SYMBOL_REF_DECL (symbol);
6129 assemble_constant_contents (decl, XSTR (symbol, 0),
6130 get_constant_alignment (decl));
6131 offset += get_constant_size (decl);
6135 decl = SYMBOL_REF_DECL (symbol);
6136 assemble_variable_contents (decl, XSTR (symbol, 0), false);
6137 offset += tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6142 /* A htab_traverse callback used to call output_object_block for
6143 each member of object_block_htab. */
6146 output_object_block_htab (void **slot, void *data ATTRIBUTE_UNUSED)
6148 output_object_block ((struct object_block *) (*slot));
6152 /* Output the definitions of all object_blocks. */
6155 output_object_blocks (void)
6157 htab_traverse (object_block_htab, output_object_block_htab, NULL);
6160 #include "gt-varasm.h"