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) || DECL_EXTERNAL (decl)
1263 || !DECL_NAME (decl)
1264 || (TREE_CODE (decl) != FUNCTION_DECL
1265 && (TREE_CODE (decl) != VAR_DECL
1266 || (DECL_COMMON (decl)
1267 && (DECL_INITIAL (decl) == 0
1268 || DECL_INITIAL (decl) == error_mark_node))))
1269 || !MEM_P (DECL_RTL (decl)))
1272 /* We win when global object is found, but it is useful to know about weak
1273 symbol as well so we can produce nicer unique names. */
1274 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1275 type = &weak_global_object_name;
1281 rtx decl_rtl = DECL_RTL (decl);
1283 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1284 name = ggc_strdup (p);
1290 /* Output assembler code for the constant pool of a function and associated
1291 with defining the name of the function. DECL describes the function.
1292 NAME is the function's name. For the constant pool, we use the current
1293 constant pool data. */
1296 assemble_start_function (tree decl, const char *fnname)
1299 char tmp_label[100];
1300 bool hot_label_written = false;
1302 cfun->unlikely_text_section_name = NULL;
1304 first_function_block_is_cold = false;
1305 if (flag_reorder_blocks_and_partition)
1307 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1308 cfun->hot_section_label = ggc_strdup (tmp_label);
1309 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1310 cfun->cold_section_label = ggc_strdup (tmp_label);
1311 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1312 cfun->hot_section_end_label = ggc_strdup (tmp_label);
1313 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1314 cfun->cold_section_end_label = ggc_strdup (tmp_label);
1319 cfun->hot_section_label = NULL;
1320 cfun->cold_section_label = NULL;
1321 cfun->hot_section_end_label = NULL;
1322 cfun->cold_section_end_label = NULL;
1325 /* The following code does not need preprocessing in the assembler. */
1329 if (CONSTANT_POOL_BEFORE_FUNCTION)
1330 output_constant_pool (fnname, decl);
1332 resolve_unique_section (decl, 0, flag_function_sections);
1334 /* Make sure the not and cold text (code) sections are properly
1335 aligned. This is necessary here in the case where the function
1336 has both hot and cold sections, because we don't want to re-set
1337 the alignment when the section switch happens mid-function. */
1339 if (flag_reorder_blocks_and_partition)
1341 switch_to_section (unlikely_text_section ());
1342 assemble_align (FUNCTION_BOUNDARY);
1343 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1345 /* When the function starts with a cold section, we need to explicitly
1346 align the hot section and write out the hot section label.
1347 But if the current function is a thunk, we do not have a CFG. */
1348 if (!current_function_is_thunk
1349 && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1351 switch_to_section (text_section);
1352 assemble_align (FUNCTION_BOUNDARY);
1353 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1354 hot_label_written = true;
1355 first_function_block_is_cold = true;
1358 else if (DECL_SECTION_NAME (decl))
1360 /* Calls to function_section rely on first_function_block_is_cold
1361 being accurate. The first block may be cold even if we aren't
1362 doing partitioning, if the entire function was decided by
1363 choose_function_section (predict.c) to be cold. */
1365 initialize_cold_section_name ();
1367 if (cfun->unlikely_text_section_name
1368 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1369 cfun->unlikely_text_section_name) == 0)
1370 first_function_block_is_cold = true;
1373 in_cold_section_p = first_function_block_is_cold;
1375 /* Switch to the correct text section for the start of the function. */
1377 switch_to_section (function_section (decl));
1378 if (flag_reorder_blocks_and_partition
1379 && !hot_label_written)
1380 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1382 /* Tell assembler to move to target machine's alignment for functions. */
1383 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1384 if (align < force_align_functions_log)
1385 align = force_align_functions_log;
1388 ASM_OUTPUT_ALIGN (asm_out_file, align);
1391 /* Handle a user-specified function alignment.
1392 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1393 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1394 if (align_functions_log > align
1395 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1397 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1398 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1399 align_functions_log, align_functions - 1);
1401 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1405 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1406 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1409 (*debug_hooks->begin_function) (decl);
1411 /* Make function name accessible from other files, if appropriate. */
1413 if (TREE_PUBLIC (decl))
1415 notice_global_symbol (decl);
1417 globalize_decl (decl);
1419 maybe_assemble_visibility (decl);
1422 if (DECL_PRESERVE_P (decl))
1423 targetm.asm_out.mark_decl_preserved (fnname);
1425 /* Do any machine/system dependent processing of the function name. */
1426 #ifdef ASM_DECLARE_FUNCTION_NAME
1427 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1429 /* Standard thing is just output label for the function. */
1430 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1431 #endif /* ASM_DECLARE_FUNCTION_NAME */
1434 /* Output assembler code associated with defining the size of the
1435 function. DECL describes the function. NAME is the function's name. */
1438 assemble_end_function (tree decl, const char *fnname)
1440 #ifdef ASM_DECLARE_FUNCTION_SIZE
1441 /* We could have switched section in the middle of the function. */
1442 if (flag_reorder_blocks_and_partition)
1443 switch_to_section (function_section (decl));
1444 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1446 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1448 output_constant_pool (fnname, decl);
1449 switch_to_section (function_section (decl)); /* need to switch back */
1451 /* Output labels for end of hot/cold text sections (to be used by
1453 if (flag_reorder_blocks_and_partition)
1455 section *save_text_section;
1457 save_text_section = in_section;
1458 switch_to_section (unlikely_text_section ());
1459 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1460 if (first_function_block_is_cold)
1461 switch_to_section (text_section);
1463 switch_to_section (function_section (decl));
1464 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1465 switch_to_section (save_text_section);
1469 /* Assemble code to leave SIZE bytes of zeros. */
1472 assemble_zeros (unsigned HOST_WIDE_INT size)
1474 /* Do no output if -fsyntax-only. */
1475 if (flag_syntax_only)
1478 #ifdef ASM_NO_SKIP_IN_TEXT
1479 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1480 so we must output 0s explicitly in the text section. */
1481 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1483 unsigned HOST_WIDE_INT i;
1484 for (i = 0; i < size; i++)
1485 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1490 ASM_OUTPUT_SKIP (asm_out_file, size);
1493 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1496 assemble_align (int align)
1498 if (align > BITS_PER_UNIT)
1500 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1504 /* Assemble a string constant with the specified C string as contents. */
1507 assemble_string (const char *p, int size)
1512 /* If the string is very long, split it up. */
1516 int thissize = size - pos;
1517 if (thissize > maximum)
1520 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1528 /* A noswitch_section_callback for lcomm_section. */
1531 emit_local (tree decl ATTRIBUTE_UNUSED,
1532 const char *name ATTRIBUTE_UNUSED,
1533 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1534 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1536 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1537 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1538 size, DECL_ALIGN (decl));
1540 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1541 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1544 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1549 /* A noswitch_section_callback for bss_noswitch_section. */
1551 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1553 emit_bss (tree decl ATTRIBUTE_UNUSED,
1554 const char *name ATTRIBUTE_UNUSED,
1555 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1556 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1558 #if defined ASM_OUTPUT_ALIGNED_BSS
1559 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1562 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1568 /* A noswitch_section_callback for comm_section. */
1571 emit_common (tree decl ATTRIBUTE_UNUSED,
1572 const char *name ATTRIBUTE_UNUSED,
1573 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1574 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1576 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1577 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1578 size, DECL_ALIGN (decl));
1580 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1581 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1584 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1589 /* A noswitch_section_callback for tls_comm_section. */
1592 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1593 const char *name ATTRIBUTE_UNUSED,
1594 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1595 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1597 #ifdef ASM_OUTPUT_TLS_COMMON
1598 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1601 sorry ("thread-local COMMON data not implemented");
1606 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1607 NAME is the name of DECL's SYMBOL_REF. */
1610 assemble_noswitch_variable (tree decl, const char *name, section *sect)
1612 unsigned HOST_WIDE_INT size, rounded;
1614 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1617 /* Don't allocate zero bytes of common,
1618 since that means "undefined external" in the linker. */
1622 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1623 so that each uninitialized object starts on such a boundary. */
1624 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1625 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1626 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1628 if (!sect->noswitch.callback (decl, name, size, rounded)
1629 && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1630 warning (0, "requested alignment for %q+D is greater than "
1631 "implemented alignment of %wu", decl, rounded);
1634 /* A subroutine of assemble_variable. Output the label and contents of
1635 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
1636 is as for assemble_variable. */
1639 assemble_variable_contents (tree decl, const char *name,
1640 bool dont_output_data)
1642 /* Do any machine/system dependent processing of the object. */
1643 #ifdef ASM_DECLARE_OBJECT_NAME
1644 last_assemble_variable_decl = decl;
1645 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1647 /* Standard thing is just output label for the object. */
1648 ASM_OUTPUT_LABEL (asm_out_file, name);
1649 #endif /* ASM_DECLARE_OBJECT_NAME */
1651 if (!dont_output_data)
1653 if (DECL_INITIAL (decl)
1654 && DECL_INITIAL (decl) != error_mark_node
1655 && !initializer_zerop (DECL_INITIAL (decl)))
1656 /* Output the actual data. */
1657 output_constant (DECL_INITIAL (decl),
1658 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1661 /* Leave space for it. */
1662 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1666 /* Assemble everything that is needed for a variable or function declaration.
1667 Not used for automatic variables, and not used for function definitions.
1668 Should not be called for variables of incomplete structure type.
1670 TOP_LEVEL is nonzero if this variable has file scope.
1671 AT_END is nonzero if this is the special handling, at end of compilation,
1672 to define things that have had only tentative definitions.
1673 DONT_OUTPUT_DATA if nonzero means don't actually output the
1674 initial value (that will be done by the caller). */
1677 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1678 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1682 rtx decl_rtl, symbol;
1685 if (lang_hooks.decls.prepare_assemble_variable)
1686 lang_hooks.decls.prepare_assemble_variable (decl);
1688 last_assemble_variable_decl = 0;
1690 /* Normally no need to say anything here for external references,
1691 since assemble_external is called by the language-specific code
1692 when a declaration is first seen. */
1694 if (DECL_EXTERNAL (decl))
1697 /* Output no assembler code for a function declaration.
1698 Only definitions of functions output anything. */
1700 if (TREE_CODE (decl) == FUNCTION_DECL)
1703 /* Do nothing for global register variables. */
1704 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1706 TREE_ASM_WRITTEN (decl) = 1;
1710 /* If type was incomplete when the variable was declared,
1711 see if it is complete now. */
1713 if (DECL_SIZE (decl) == 0)
1714 layout_decl (decl, 0);
1716 /* Still incomplete => don't allocate it; treat the tentative defn
1717 (which is what it must have been) as an `extern' reference. */
1719 if (!dont_output_data && DECL_SIZE (decl) == 0)
1721 error ("storage size of %q+D isn%'t known", decl);
1722 TREE_ASM_WRITTEN (decl) = 1;
1726 /* The first declaration of a variable that comes through this function
1727 decides whether it is global (in C, has external linkage)
1728 or local (in C, has internal linkage). So do nothing more
1729 if this function has already run. */
1731 if (TREE_ASM_WRITTEN (decl))
1734 /* Make sure targetm.encode_section_info is invoked before we set
1736 decl_rtl = DECL_RTL (decl);
1738 TREE_ASM_WRITTEN (decl) = 1;
1740 /* Do no output if -fsyntax-only. */
1741 if (flag_syntax_only)
1746 if (! dont_output_data
1747 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1749 error ("size of variable %q+D is too large", decl);
1753 gcc_assert (MEM_P (decl_rtl));
1754 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
1755 symbol = XEXP (decl_rtl, 0);
1756 name = XSTR (symbol, 0);
1757 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1758 notice_global_symbol (decl);
1760 /* Compute the alignment of this data. */
1762 align = DECL_ALIGN (decl);
1764 /* In the case for initialing an array whose length isn't specified,
1765 where we have not yet been able to do the layout,
1766 figure out the proper alignment now. */
1767 if (dont_output_data && DECL_SIZE (decl) == 0
1768 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1769 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1771 /* Some object file formats have a maximum alignment which they support.
1772 In particular, a.out format supports a maximum alignment of 4. */
1773 if (align > MAX_OFILE_ALIGNMENT)
1775 warning (0, "alignment of %q+D is greater than maximum object "
1776 "file alignment. Using %d", decl,
1777 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1778 align = MAX_OFILE_ALIGNMENT;
1781 /* On some machines, it is good to increase alignment sometimes. */
1782 if (! DECL_USER_ALIGN (decl))
1784 #ifdef DATA_ALIGNMENT
1785 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1787 #ifdef CONSTANT_ALIGNMENT
1788 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1789 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1793 /* Reset the alignment in case we have made it tighter, so we can benefit
1794 from it in get_pointer_alignment. */
1795 DECL_ALIGN (decl) = align;
1796 set_mem_align (decl_rtl, align);
1798 if (TREE_PUBLIC (decl))
1799 maybe_assemble_visibility (decl);
1801 if (DECL_PRESERVE_P (decl))
1802 targetm.asm_out.mark_decl_preserved (name);
1804 /* First make the assembler name(s) global if appropriate. */
1805 sect = get_variable_section (decl, false);
1806 if (TREE_PUBLIC (decl)
1808 && (sect->common.flags & SECTION_COMMON) == 0)
1809 globalize_decl (decl);
1811 /* Output any data that we will need to use the address of. */
1812 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1813 output_addressed_constants (DECL_INITIAL (decl));
1815 /* dbxout.c needs to know this. */
1816 if (in_section && (in_section->common.flags & SECTION_CODE) != 0)
1817 DECL_IN_TEXT_SECTION (decl) = 1;
1819 /* If the decl is part of an object_block, make sure that the decl
1820 has been positioned within its block, but do not write out its
1821 definition yet. output_object_blocks will do that later. */
1822 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
1824 gcc_assert (!dont_output_data);
1825 place_block_symbol (symbol);
1827 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1828 assemble_noswitch_variable (decl, name, sect);
1831 switch_to_section (sect);
1832 if (align > BITS_PER_UNIT)
1833 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1834 assemble_variable_contents (decl, name, dont_output_data);
1838 /* Return 1 if type TYPE contains any pointers. */
1841 contains_pointers_p (tree type)
1843 switch (TREE_CODE (type))
1846 case REFERENCE_TYPE:
1847 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1848 so I'll play safe and return 1. */
1854 case QUAL_UNION_TYPE:
1857 /* For a type that has fields, see if the fields have pointers. */
1858 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1859 if (TREE_CODE (fields) == FIELD_DECL
1860 && contains_pointers_p (TREE_TYPE (fields)))
1866 /* An array type contains pointers if its element type does. */
1867 return contains_pointers_p (TREE_TYPE (type));
1874 /* In unit-at-a-time mode, we delay assemble_external processing until
1875 the compilation unit is finalized. This is the best we can do for
1876 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1877 it all the way to final. See PR 17982 for further discussion. */
1878 static GTY(()) tree pending_assemble_externals;
1880 #ifdef ASM_OUTPUT_EXTERNAL
1881 /* True if DECL is a function decl for which no out-of-line copy exists.
1882 It is assumed that DECL's assembler name has been set. */
1885 incorporeal_function_p (tree decl)
1887 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1891 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1892 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1895 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1896 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1902 /* Actually do the tests to determine if this is necessary, and invoke
1903 ASM_OUTPUT_EXTERNAL. */
1905 assemble_external_real (tree decl)
1907 rtx rtl = DECL_RTL (decl);
1909 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1910 && !SYMBOL_REF_USED (XEXP (rtl, 0))
1911 && !incorporeal_function_p (decl))
1913 /* Some systems do require some output. */
1914 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1915 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1921 process_pending_assemble_externals (void)
1923 #ifdef ASM_OUTPUT_EXTERNAL
1925 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1926 assemble_external_real (TREE_VALUE (list));
1928 pending_assemble_externals = 0;
1932 /* Output something to declare an external symbol to the assembler.
1933 (Most assemblers don't need this, so we normally output nothing.)
1934 Do nothing if DECL is not external. */
1937 assemble_external (tree decl ATTRIBUTE_UNUSED)
1939 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1940 main body of this code is only rarely exercised. To provide some
1941 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1942 open. If it's not, we should not be calling this function. */
1943 gcc_assert (asm_out_file);
1945 #ifdef ASM_OUTPUT_EXTERNAL
1946 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1949 if (flag_unit_at_a_time)
1950 pending_assemble_externals = tree_cons (0, decl,
1951 pending_assemble_externals);
1953 assemble_external_real (decl);
1957 /* Similar, for calling a library function FUN. */
1960 assemble_external_libcall (rtx fun)
1962 /* Declare library function name external when first used, if nec. */
1963 if (! SYMBOL_REF_USED (fun))
1965 SYMBOL_REF_USED (fun) = 1;
1966 targetm.asm_out.external_libcall (fun);
1970 /* Assemble a label named NAME. */
1973 assemble_label (const char *name)
1975 ASM_OUTPUT_LABEL (asm_out_file, name);
1978 /* Set the symbol_referenced flag for ID. */
1980 mark_referenced (tree id)
1982 TREE_SYMBOL_REFERENCED (id) = 1;
1985 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1987 mark_decl_referenced (tree decl)
1989 if (TREE_CODE (decl) == FUNCTION_DECL)
1991 /* Extern inline functions don't become needed when referenced.
1992 If we know a method will be emitted in other TU and no new
1993 functions can be marked reachable, just use the external
1995 struct cgraph_node *node = cgraph_node (decl);
1996 if (!DECL_EXTERNAL (decl)
1997 && (!node->local.vtable_method || !cgraph_global_info_ready
1998 || !node->local.finalized))
1999 cgraph_mark_needed_node (node);
2001 else if (TREE_CODE (decl) == VAR_DECL)
2003 struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
2004 cgraph_varpool_mark_needed_node (node);
2005 /* C++ frontend use mark_decl_references to force COMDAT variables
2006 to be output that might appear dead otherwise. */
2007 node->force_output = true;
2009 /* else do nothing - we can get various sorts of CST nodes here,
2010 which do not need to be marked. */
2014 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2015 until we find an identifier that is not itself a transparent alias.
2016 Modify the alias passed to it by reference (and all aliases on the
2017 way to the ultimate target), such that they do not have to be
2018 followed again, and return the ultimate target of the alias
2022 ultimate_transparent_alias_target (tree *alias)
2024 tree target = *alias;
2026 if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2028 gcc_assert (TREE_CHAIN (target));
2029 target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2030 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2031 && ! TREE_CHAIN (target));
2038 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2039 starts with a *, the rest of NAME is output verbatim. Otherwise
2040 NAME is transformed in a target-specific way (usually by the
2041 addition of an underscore). */
2044 assemble_name_raw (FILE *file, const char *name)
2047 fputs (&name[1], file);
2049 ASM_OUTPUT_LABELREF (file, name);
2052 /* Like assemble_name_raw, but should be used when NAME might refer to
2053 an entity that is also represented as a tree (like a function or
2054 variable). If NAME does refer to such an entity, that entity will
2055 be marked as referenced. */
2058 assemble_name (FILE *file, const char *name)
2060 const char *real_name;
2063 real_name = targetm.strip_name_encoding (name);
2065 id = maybe_get_identifier (real_name);
2070 mark_referenced (id);
2071 ultimate_transparent_alias_target (&id);
2073 name = IDENTIFIER_POINTER (id);
2074 gcc_assert (! TREE_CHAIN (id));
2077 assemble_name_raw (file, name);
2080 /* Allocate SIZE bytes writable static space with a gensym name
2081 and return an RTX to refer to its address. */
2084 assemble_static_space (unsigned HOST_WIDE_INT size)
2087 const char *namestring;
2090 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2092 namestring = ggc_strdup (name);
2094 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2095 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2097 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2098 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2101 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2102 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2105 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2106 so that each uninitialized object starts on such a boundary. */
2107 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2108 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2109 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2110 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2111 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2112 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2119 /* Assemble the static constant template for function entry trampolines.
2120 This is done at most once per compilation.
2121 Returns an RTX for the address of the template. */
2123 static GTY(()) rtx initial_trampoline;
2125 #ifdef TRAMPOLINE_TEMPLATE
2127 assemble_trampoline_template (void)
2134 if (initial_trampoline)
2135 return initial_trampoline;
2137 /* By default, put trampoline templates in read-only data section. */
2139 #ifdef TRAMPOLINE_SECTION
2140 switch_to_section (TRAMPOLINE_SECTION);
2142 switch_to_section (readonly_data_section);
2145 /* Write the assembler code to define one. */
2146 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2149 ASM_OUTPUT_ALIGN (asm_out_file, align);
2152 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2153 TRAMPOLINE_TEMPLATE (asm_out_file);
2155 /* Record the rtl to refer to it. */
2156 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2157 name = ggc_strdup (label);
2158 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2159 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2161 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2162 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2164 return initial_trampoline;
2168 /* A and B are either alignments or offsets. Return the minimum alignment
2169 that may be assumed after adding the two together. */
2171 static inline unsigned
2172 min_align (unsigned int a, unsigned int b)
2174 return (a | b) & -(a | b);
2177 /* Return the assembler directive for creating a given kind of integer
2178 object. SIZE is the number of bytes in the object and ALIGNED_P
2179 indicates whether it is known to be aligned. Return NULL if the
2180 assembly dialect has no such directive.
2182 The returned string should be printed at the start of a new line and
2183 be followed immediately by the object's initial value. */
2186 integer_asm_op (int size, int aligned_p)
2188 struct asm_int_op *ops;
2191 ops = &targetm.asm_out.aligned_op;
2193 ops = &targetm.asm_out.unaligned_op;
2198 return targetm.asm_out.byte_op;
2212 /* Use directive OP to assemble an integer object X. Print OP at the
2213 start of the line, followed immediately by the value of X. */
2216 assemble_integer_with_op (const char *op, rtx x)
2218 fputs (op, asm_out_file);
2219 output_addr_const (asm_out_file, x);
2220 fputc ('\n', asm_out_file);
2223 /* The default implementation of the asm_out.integer target hook. */
2226 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2227 unsigned int size ATTRIBUTE_UNUSED,
2228 int aligned_p ATTRIBUTE_UNUSED)
2230 const char *op = integer_asm_op (size, aligned_p);
2231 /* Avoid GAS bugs for large values. Specifically negative values whose
2232 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2233 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2235 return op && (assemble_integer_with_op (op, x), true);
2238 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2239 the alignment of the integer in bits. Return 1 if we were able to output
2240 the constant, otherwise 0. We must be able to output the constant,
2241 if FORCE is nonzero. */
2244 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2248 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2250 /* See if the target hook can handle this kind of object. */
2251 if (targetm.asm_out.integer (x, size, aligned_p))
2254 /* If the object is a multi-byte one, try splitting it up. Split
2255 it into words it if is multi-word, otherwise split it into bytes. */
2258 enum machine_mode omode, imode;
2259 unsigned int subalign;
2260 unsigned int subsize, i;
2262 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2263 subalign = MIN (align, subsize * BITS_PER_UNIT);
2264 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2265 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2267 for (i = 0; i < size; i += subsize)
2269 rtx partial = simplify_subreg (omode, x, imode, i);
2270 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2276 /* If we've printed some of it, but not all of it, there's no going
2281 gcc_assert (!force);
2287 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2289 long data[4] = {0, 0, 0, 0};
2291 int bitsize, nelts, nunits, units_per;
2293 /* This is hairy. We have a quantity of known size. real_to_target
2294 will put it into an array of *host* longs, 32 bits per element
2295 (even if long is more than 32 bits). We need to determine the
2296 number of array elements that are occupied (nelts) and the number
2297 of *target* min-addressable units that will be occupied in the
2298 object file (nunits). We cannot assume that 32 divides the
2299 mode's bitsize (size * BITS_PER_UNIT) evenly.
2301 size * BITS_PER_UNIT is used here to make sure that padding bits
2302 (which might appear at either end of the value; real_to_target
2303 will include the padding bits in its output array) are included. */
2305 nunits = GET_MODE_SIZE (mode);
2306 bitsize = nunits * BITS_PER_UNIT;
2307 nelts = CEIL (bitsize, 32);
2308 units_per = 32 / BITS_PER_UNIT;
2310 real_to_target (data, &d, mode);
2312 /* Put out the first word with the specified alignment. */
2313 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2314 nunits -= units_per;
2316 /* Subsequent words need only 32-bit alignment. */
2317 align = min_align (align, 32);
2319 for (i = 1; i < nelts; i++)
2321 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2322 nunits -= units_per;
2326 /* Given an expression EXP with a constant value,
2327 reduce it to the sum of an assembler symbol and an integer.
2328 Store them both in the structure *VALUE.
2329 EXP must be reducible. */
2331 struct addr_const GTY(())
2334 HOST_WIDE_INT offset;
2338 decode_addr_const (tree exp, struct addr_const *value)
2340 tree target = TREE_OPERAND (exp, 0);
2346 if (TREE_CODE (target) == COMPONENT_REF
2347 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2350 offset += int_byte_position (TREE_OPERAND (target, 1));
2351 target = TREE_OPERAND (target, 0);
2353 else if (TREE_CODE (target) == ARRAY_REF
2354 || TREE_CODE (target) == ARRAY_RANGE_REF)
2356 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2357 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2358 target = TREE_OPERAND (target, 0);
2364 switch (TREE_CODE (target))
2368 x = DECL_RTL (target);
2372 x = gen_rtx_MEM (FUNCTION_MODE,
2373 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2381 x = output_constant_def (target, 1);
2388 gcc_assert (MEM_P (x));
2392 value->offset = offset;
2395 /* Uniquize all constants that appear in memory.
2396 Each constant in memory thus far output is recorded
2397 in `const_desc_table'. */
2399 struct constant_descriptor_tree GTY(())
2401 /* A MEM for the constant. */
2404 /* The value of the constant. */
2407 /* Hash of value. Computing the hash from value each time
2408 hashfn is called can't work properly, as that means recursive
2409 use of the hash table during hash table expansion. */
2413 static GTY((param_is (struct constant_descriptor_tree)))
2414 htab_t const_desc_htab;
2416 static struct constant_descriptor_tree * build_constant_desc (tree);
2417 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2419 /* Compute a hash code for a constant expression. */
2422 const_desc_hash (const void *ptr)
2424 return ((struct constant_descriptor_tree *)ptr)->hash;
2428 const_hash_1 (const tree exp)
2433 enum tree_code code = TREE_CODE (exp);
2435 /* Either set P and LEN to the address and len of something to hash and
2436 exit the switch or return a value. */
2441 p = (char *) &TREE_INT_CST (exp);
2442 len = sizeof TREE_INT_CST (exp);
2446 return real_hash (TREE_REAL_CST_PTR (exp));
2449 p = TREE_STRING_POINTER (exp);
2450 len = TREE_STRING_LENGTH (exp);
2454 return (const_hash_1 (TREE_REALPART (exp)) * 5
2455 + const_hash_1 (TREE_IMAGPART (exp)));
2459 unsigned HOST_WIDE_INT idx;
2462 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2464 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2466 hi = hi * 603 + const_hash_1 (value);
2474 struct addr_const value;
2476 decode_addr_const (exp, &value);
2477 switch (GET_CODE (value.base))
2480 /* Don't hash the address of the SYMBOL_REF;
2481 only use the offset and the symbol name. */
2483 p = XSTR (value.base, 0);
2484 for (i = 0; p[i] != 0; i++)
2485 hi = ((hi * 613) + (unsigned) (p[i]));
2489 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2500 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2501 + const_hash_1 (TREE_OPERAND (exp, 1)));
2505 case NON_LVALUE_EXPR:
2506 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2509 /* A language specific constant. Just hash the code. */
2513 /* Compute hashing function. */
2515 for (i = 0; i < len; i++)
2516 hi = ((hi * 613) + (unsigned) (p[i]));
2521 /* Wrapper of compare_constant, for the htab interface. */
2523 const_desc_eq (const void *p1, const void *p2)
2525 const struct constant_descriptor_tree *c1 = p1;
2526 const struct constant_descriptor_tree *c2 = p2;
2527 if (c1->hash != c2->hash)
2529 return compare_constant (c1->value, c2->value);
2532 /* Compare t1 and t2, and return 1 only if they are known to result in
2533 the same bit pattern on output. */
2536 compare_constant (const tree t1, const tree t2)
2538 enum tree_code typecode;
2540 if (t1 == NULL_TREE)
2541 return t2 == NULL_TREE;
2542 if (t2 == NULL_TREE)
2545 if (TREE_CODE (t1) != TREE_CODE (t2))
2548 switch (TREE_CODE (t1))
2551 /* Integer constants are the same only if the same width of type. */
2552 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2554 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2556 return tree_int_cst_equal (t1, t2);
2559 /* Real constants are the same only if the same width of type. */
2560 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2563 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2566 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2569 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2570 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2571 TREE_STRING_LENGTH (t1)));
2574 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2575 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2579 VEC(constructor_elt, gc) *v1, *v2;
2580 unsigned HOST_WIDE_INT idx;
2582 typecode = TREE_CODE (TREE_TYPE (t1));
2583 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2586 if (typecode == ARRAY_TYPE)
2588 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2589 /* For arrays, check that the sizes all match. */
2590 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2592 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2597 /* For record and union constructors, require exact type
2599 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2603 v1 = CONSTRUCTOR_ELTS (t1);
2604 v2 = CONSTRUCTOR_ELTS (t2);
2605 if (VEC_length (constructor_elt, v1)
2606 != VEC_length (constructor_elt, v2))
2609 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2611 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2612 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2614 /* Check that each value is the same... */
2615 if (!compare_constant (c1->value, c2->value))
2617 /* ... and that they apply to the same fields! */
2618 if (typecode == ARRAY_TYPE)
2620 if (!compare_constant (c1->index, c2->index))
2625 if (c1->index != c2->index)
2636 struct addr_const value1, value2;
2638 decode_addr_const (t1, &value1);
2639 decode_addr_const (t2, &value2);
2640 return (value1.offset == value2.offset
2641 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2647 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2648 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2652 case NON_LVALUE_EXPR:
2653 case VIEW_CONVERT_EXPR:
2654 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2659 nt1 = lang_hooks.expand_constant (t1);
2660 nt2 = lang_hooks.expand_constant (t2);
2661 if (nt1 != t1 || nt2 != t2)
2662 return compare_constant (nt1, nt2);
2671 /* Make a copy of the whole tree structure for a constant. This
2672 handles the same types of nodes that compare_constant handles. */
2675 copy_constant (tree exp)
2677 switch (TREE_CODE (exp))
2680 /* For ADDR_EXPR, we do not want to copy the decl whose address
2681 is requested. We do want to copy constants though. */
2682 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2683 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2684 copy_constant (TREE_OPERAND (exp, 0)));
2686 return copy_node (exp);
2691 return copy_node (exp);
2694 return build_complex (TREE_TYPE (exp),
2695 copy_constant (TREE_REALPART (exp)),
2696 copy_constant (TREE_IMAGPART (exp)));
2700 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2701 copy_constant (TREE_OPERAND (exp, 0)),
2702 copy_constant (TREE_OPERAND (exp, 1)));
2706 case NON_LVALUE_EXPR:
2707 case VIEW_CONVERT_EXPR:
2708 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2709 copy_constant (TREE_OPERAND (exp, 0)));
2713 tree copy = copy_node (exp);
2714 VEC(constructor_elt, gc) *v;
2715 unsigned HOST_WIDE_INT idx;
2716 tree purpose, value;
2718 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
2719 CONSTRUCTOR_ELTS (exp)));
2720 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
2722 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
2723 ce->index = purpose;
2724 ce->value = copy_constant (value);
2726 CONSTRUCTOR_ELTS (copy) = v;
2732 tree t = lang_hooks.expand_constant (exp);
2734 gcc_assert (t == exp);
2735 return copy_constant (t);
2740 /* Return the alignment of constant EXP in bits. */
2743 get_constant_alignment (tree exp)
2747 align = TYPE_ALIGN (TREE_TYPE (exp));
2748 #ifdef CONSTANT_ALIGNMENT
2749 align = CONSTANT_ALIGNMENT (exp, align);
2754 /* Return the section into which constant EXP should be placed. */
2757 get_constant_section (tree exp)
2759 if (IN_NAMED_SECTION (exp))
2760 return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
2762 return targetm.asm_out.select_section (exp,
2763 compute_reloc_for_constant (exp),
2764 get_constant_alignment (exp));
2767 /* Return the size of constant EXP in bytes. */
2769 static HOST_WIDE_INT
2770 get_constant_size (tree exp)
2774 size = int_size_in_bytes (TREE_TYPE (exp));
2775 if (TREE_CODE (exp) == STRING_CST)
2776 size = MAX (TREE_STRING_LENGTH (exp), size);
2780 /* Subroutine of output_constant_def:
2781 No constant equal to EXP is known to have been output.
2782 Make a constant descriptor to enter EXP in the hash table.
2783 Assign the label number and construct RTL to refer to the
2784 constant's location in memory.
2785 Caller is responsible for updating the hash table. */
2787 static struct constant_descriptor_tree *
2788 build_constant_desc (tree exp)
2794 struct constant_descriptor_tree *desc;
2796 desc = ggc_alloc (sizeof (*desc));
2797 desc->value = copy_constant (exp);
2799 /* Propagate marked-ness to copied constant. */
2800 if (flag_mudflap && mf_marked_p (exp))
2801 mf_mark (desc->value);
2803 /* Create a string containing the label name, in LABEL. */
2804 labelno = const_labelno++;
2805 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2807 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2808 if (use_object_blocks_p ())
2810 section *sect = get_constant_section (exp);
2811 symbol = create_block_symbol (ggc_strdup (label),
2812 get_block_for_section (sect), -1);
2815 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2816 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
2817 SET_SYMBOL_REF_DECL (symbol, desc->value);
2818 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2820 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2821 set_mem_attributes (rtl, exp, 1);
2822 set_mem_alias_set (rtl, 0);
2823 set_mem_alias_set (rtl, const_alias_set);
2825 /* Set flags or add text to the name to record information, such as
2826 that it is a local symbol. If the name is changed, the macro
2827 ASM_OUTPUT_LABELREF will have to know how to strip this
2828 information. This call might invalidate our local variable
2829 SYMBOL; we can't use it afterward. */
2831 targetm.encode_section_info (exp, rtl, true);
2838 /* Return an rtx representing a reference to constant data in memory
2839 for the constant expression EXP.
2841 If assembler code for such a constant has already been output,
2842 return an rtx to refer to it.
2843 Otherwise, output such a constant in memory
2844 and generate an rtx for it.
2846 If DEFER is nonzero, this constant can be deferred and output only
2847 if referenced in the function after all optimizations.
2849 `const_desc_table' records which constants already have label strings. */
2852 output_constant_def (tree exp, int defer)
2854 struct constant_descriptor_tree *desc;
2855 struct constant_descriptor_tree key;
2858 /* Look up EXP in the table of constant descriptors. If we didn't find
2859 it, create a new one. */
2861 key.hash = const_hash_1 (exp);
2862 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
2867 desc = build_constant_desc (exp);
2868 desc->hash = key.hash;
2872 maybe_output_constant_def_contents (desc, defer);
2876 /* Subroutine of output_constant_def: Decide whether or not we need to
2877 output the constant DESC now, and if so, do it. */
2879 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2882 rtx symbol = XEXP (desc->rtl, 0);
2883 tree exp = desc->value;
2885 if (flag_syntax_only)
2888 if (TREE_ASM_WRITTEN (exp))
2889 /* Already output; don't do it again. */
2892 /* We can always defer constants as long as the context allows
2896 /* Increment n_deferred_constants if it exists. It needs to be at
2897 least as large as the number of constants actually referred to
2898 by the function. If it's too small we'll stop looking too early
2899 and fail to emit constants; if it's too large we'll only look
2900 through the entire function when we could have stopped earlier. */
2902 n_deferred_constants++;
2906 output_constant_def_contents (symbol);
2909 /* Subroutine of output_constant_def_contents. Output the definition
2910 of constant EXP, which is pointed to by label LABEL. ALIGN is the
2911 constant's alignment in bits. */
2914 assemble_constant_contents (tree exp, const char *label, unsigned int align)
2918 size = get_constant_size (exp);
2920 /* Do any machine/system dependent processing of the constant. */
2921 #ifdef ASM_DECLARE_CONSTANT_NAME
2922 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2924 /* Standard thing is just output label for the constant. */
2925 ASM_OUTPUT_LABEL (asm_out_file, label);
2926 #endif /* ASM_DECLARE_CONSTANT_NAME */
2928 /* Output the value of EXP. */
2929 output_constant (exp, size, align);
2932 /* We must output the constant data referred to by SYMBOL; do so. */
2935 output_constant_def_contents (rtx symbol)
2937 tree exp = SYMBOL_REF_DECL (symbol);
2940 /* Make sure any other constants whose addresses appear in EXP
2941 are assigned label numbers. */
2942 output_addressed_constants (exp);
2944 /* We are no longer deferring this constant. */
2945 TREE_ASM_WRITTEN (exp) = 1;
2947 /* If the constant is part of an object block, make sure that the
2948 decl has been positioned within its block, but do not write out
2949 its definition yet. output_object_blocks will do that later. */
2950 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2951 place_block_symbol (symbol);
2954 switch_to_section (get_constant_section (exp));
2955 align = get_constant_alignment (exp);
2956 if (align > BITS_PER_UNIT)
2957 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2958 assemble_constant_contents (exp, XSTR (symbol, 0), align);
2961 mudflap_enqueue_constant (exp);
2964 /* Look up EXP in the table of constant descriptors. Return the rtl
2965 if it has been emitted, else null. */
2968 lookup_constant_def (tree exp)
2970 struct constant_descriptor_tree *desc;
2971 struct constant_descriptor_tree key;
2974 key.hash = const_hash_1 (exp);
2975 desc = htab_find_with_hash (const_desc_htab, &key, key.hash);
2977 return (desc ? desc->rtl : NULL_RTX);
2980 /* Used in the hash tables to avoid outputting the same constant
2981 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2982 are output once per function, not once per file. */
2983 /* ??? Only a few targets need per-function constant pools. Most
2984 can use one per-file pool. Should add a targetm bit to tell the
2987 struct rtx_constant_pool GTY(())
2989 /* Pointers to first and last constant in pool, as ordered by offset. */
2990 struct constant_descriptor_rtx *first;
2991 struct constant_descriptor_rtx *last;
2993 /* Hash facility for making memory-constants from constant rtl-expressions.
2994 It is used on RISC machines where immediate integer arguments and
2995 constant addresses are restricted so that such constants must be stored
2997 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
2999 /* Current offset in constant pool (does not include any
3000 machine-specific header). */
3001 HOST_WIDE_INT offset;
3004 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
3006 struct constant_descriptor_rtx *next;
3010 HOST_WIDE_INT offset;
3012 enum machine_mode mode;
3018 /* Hash and compare functions for const_rtx_htab. */
3021 const_desc_rtx_hash (const void *ptr)
3023 const struct constant_descriptor_rtx *desc = ptr;
3028 const_desc_rtx_eq (const void *a, const void *b)
3030 const struct constant_descriptor_rtx *x = a;
3031 const struct constant_descriptor_rtx *y = b;
3033 if (x->mode != y->mode)
3035 return rtx_equal_p (x->constant, y->constant);
3038 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
3041 const_rtx_hash_1 (rtx *xp, void *data)
3043 unsigned HOST_WIDE_INT hwi;
3044 enum machine_mode mode;
3050 code = GET_CODE (x);
3051 mode = GET_MODE (x);
3052 h = (hashval_t) code * 1048573 + mode;
3060 const int shift = sizeof (hashval_t) * CHAR_BIT;
3061 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3064 h ^= (hashval_t) hwi;
3065 for (i = 1; i < n; ++i)
3068 h ^= (hashval_t) hwi;
3074 if (mode == VOIDmode)
3076 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3080 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3086 for (i = XVECLEN (x, 0); i-- > 0; )
3087 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3092 h ^= htab_hash_string (XSTR (x, 0));
3096 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3100 case UNSPEC_VOLATILE:
3101 h = h * 251 + XINT (x, 1);
3109 *hp = *hp * 509 + h;
3113 /* Compute a hash value for X, which should be a constant. */
3116 const_rtx_hash (rtx x)
3119 for_each_rtx (&x, const_rtx_hash_1, &h);
3124 /* Initialize constant pool hashing for a new function. */
3127 init_varasm_status (struct function *f)
3129 struct varasm_status *p;
3130 struct rtx_constant_pool *pool;
3132 p = ggc_alloc (sizeof (struct varasm_status));
3135 pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3137 p->deferred_constants = 0;
3139 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3140 const_desc_rtx_eq, NULL);
3141 pool->first = pool->last = NULL;
3145 /* Given a MINUS expression, simplify it if both sides
3146 include the same symbol. */
3149 simplify_subtraction (rtx x)
3151 rtx r = simplify_rtx (x);
3155 /* Given a constant rtx X, make (or find) a memory constant for its value
3156 and return a MEM rtx to refer to it in memory. */
3159 force_const_mem (enum machine_mode mode, rtx x)
3161 struct constant_descriptor_rtx *desc, tmp;
3162 struct rtx_constant_pool *pool = cfun->varasm->pool;
3169 /* If we're not allowed to drop X into the constant pool, don't. */
3170 if (targetm.cannot_force_const_mem (x))
3173 /* Lookup the value in the hashtable. */
3176 hash = const_rtx_hash (x);
3177 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3180 /* If the constant was already present, return its memory. */
3182 return copy_rtx (desc->mem);
3184 /* Otherwise, create a new descriptor. */
3185 desc = ggc_alloc (sizeof (*desc));
3188 /* Align the location counter as required by EXP's data type. */
3189 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3190 #ifdef CONSTANT_ALIGNMENT
3192 tree type = lang_hooks.types.type_for_mode (mode, 0);
3193 if (type != NULL_TREE)
3194 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3198 pool->offset += (align / BITS_PER_UNIT) - 1;
3199 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3202 desc->constant = tmp.constant;
3203 desc->offset = pool->offset;
3206 desc->align = align;
3207 desc->labelno = const_labelno;
3210 pool->offset += GET_MODE_SIZE (mode);
3212 pool->last->next = desc;
3214 pool->first = pool->last = desc;
3217 /* Create a string containing the label name, in LABEL. */
3218 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3221 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3222 the constants pool. */
3223 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3225 section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3226 symbol = create_block_symbol (ggc_strdup (label),
3227 get_block_for_section (sect), -1);
3230 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3232 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3233 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3234 SET_SYMBOL_REF_CONSTANT (symbol, desc);
3235 current_function_uses_const_pool = 1;
3237 /* Construct the MEM. */
3238 desc->mem = def = gen_const_mem (mode, symbol);
3239 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3240 set_mem_align (def, align);
3242 /* If we're dropping a label to the constant pool, make sure we
3244 if (GET_CODE (x) == LABEL_REF)
3245 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3247 return copy_rtx (def);
3250 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3253 get_pool_constant (rtx addr)
3255 return SYMBOL_REF_CONSTANT (addr)->constant;
3258 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3259 and whether it has been output or not. */
3262 get_pool_constant_mark (rtx addr, bool *pmarked)
3264 struct constant_descriptor_rtx *desc;
3266 desc = SYMBOL_REF_CONSTANT (addr);
3267 *pmarked = (desc->mark != 0);
3268 return desc->constant;
3271 /* Similar, return the mode. */
3274 get_pool_mode (rtx addr)
3276 return SYMBOL_REF_CONSTANT (addr)->mode;
3279 /* Return the size of the constant pool. */
3282 get_pool_size (void)
3284 return cfun->varasm->pool->offset;
3287 /* Worker function for output_constant_pool_1. Emit assembly for X
3288 in MODE with known alignment ALIGN. */
3291 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3293 switch (GET_MODE_CLASS (mode))
3296 case MODE_DECIMAL_FLOAT:
3300 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3301 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3302 assemble_real (r, mode, align);
3307 case MODE_PARTIAL_INT:
3308 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3311 case MODE_VECTOR_FLOAT:
3312 case MODE_VECTOR_INT:
3315 enum machine_mode submode = GET_MODE_INNER (mode);
3316 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3318 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3319 units = CONST_VECTOR_NUNITS (x);
3321 for (i = 0; i < units; i++)
3323 rtx elt = CONST_VECTOR_ELT (x, i);
3324 output_constant_pool_2 (submode, elt, i ? subalign : align);
3334 /* Worker function for output_constant_pool. Emit constant DESC,
3335 giving it ALIGN bits of alignment. */
3338 output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3345 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3346 whose CODE_LABEL has been deleted. This can occur if a jump table
3347 is eliminated by optimization. If so, write a constant of zero
3348 instead. Note that this can also happen by turning the
3349 CODE_LABEL into a NOTE. */
3350 /* ??? This seems completely and utterly wrong. Certainly it's
3351 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3352 functioning even with INSN_DELETED_P and friends. */
3355 switch (GET_CODE (x))
3358 if (GET_CODE (XEXP (x, 0)) != PLUS
3359 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3361 tmp = XEXP (XEXP (x, 0), 0);
3366 gcc_assert (!INSN_DELETED_P (tmp));
3367 gcc_assert (!NOTE_P (tmp)
3368 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3375 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3376 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3377 align, desc->labelno, done);
3380 assemble_align (align);
3382 /* Output the label. */
3383 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3385 /* Output the data. */
3386 output_constant_pool_2 (desc->mode, x, align);
3388 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3389 sections have proper size. */
3390 if (align > GET_MODE_BITSIZE (desc->mode)
3392 && (in_section->common.flags & SECTION_MERGE))
3393 assemble_align (align);
3395 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3401 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3402 to as used. Emit referenced deferred strings. This function can
3403 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3406 mark_constant (rtx *current_rtx, void *data)
3408 struct rtx_constant_pool *pool = data;
3409 rtx x = *current_rtx;
3411 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3414 if (CONSTANT_POOL_ADDRESS_P (x))
3416 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
3417 if (desc->mark == 0)
3420 for_each_rtx (&desc->constant, mark_constant, pool);
3423 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3425 tree exp = SYMBOL_REF_DECL (x);
3426 if (!TREE_ASM_WRITTEN (exp))
3428 n_deferred_constants--;
3429 output_constant_def_contents (x);
3436 /* Look through appropriate parts of INSN, marking all entries in the
3437 constant pool which are actually being used. Entries that are only
3438 referenced by other constants are also marked as used. Emit
3439 deferred strings that are used. */
3442 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3447 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3448 insns, not any notes that may be attached. We don't want to mark
3449 a constant just because it happens to appear in a REG_EQUIV note. */
3450 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3452 rtx seq = PATTERN (insn);
3453 int i, n = XVECLEN (seq, 0);
3454 for (i = 0; i < n; ++i)
3456 rtx subinsn = XVECEXP (seq, 0, i);
3457 if (INSN_P (subinsn))
3458 for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3462 for_each_rtx (&PATTERN (insn), mark_constant, pool);
3465 /* Look through the instructions for this function, and mark all the
3466 entries in POOL which are actually being used. Emit deferred constants
3467 which have indeed been used. */
3470 mark_constant_pool (struct rtx_constant_pool *pool)
3474 if (pool->first == 0 && n_deferred_constants == 0)
3477 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3478 mark_constants (pool, insn);
3480 for (link = current_function_epilogue_delay_list;
3482 link = XEXP (link, 1))
3483 mark_constants (pool, XEXP (link, 0));
3486 /* Write all the constants in the constant pool. */
3489 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3490 tree fndecl ATTRIBUTE_UNUSED)
3492 struct rtx_constant_pool *pool = cfun->varasm->pool;
3493 struct constant_descriptor_rtx *desc;
3495 /* It is possible for gcc to call force_const_mem and then to later
3496 discard the instructions which refer to the constant. In such a
3497 case we do not need to output the constant. */
3498 mark_constant_pool (pool);
3500 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3501 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3504 for (desc = pool->first; desc ; desc = desc->next)
3507 /* If the constant is part of an object_block, make sure that
3508 the constant has been positioned within its block, but do not
3509 write out its definition yet. output_object_blocks will do
3511 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
3512 && SYMBOL_REF_BLOCK (desc->sym))
3513 place_block_symbol (desc->sym);
3516 switch_to_section (targetm.asm_out.select_rtx_section
3517 (desc->mode, desc->constant, desc->align));
3518 output_constant_pool_1 (desc, desc->align);
3522 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3523 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3527 /* Determine what kind of relocations EXP may need. */
3530 compute_reloc_for_constant (tree exp)
3532 int reloc = 0, reloc2;
3535 /* Give the front-end a chance to convert VALUE to something that
3536 looks more like a constant to the back-end. */
3537 exp = lang_hooks.expand_constant (exp);
3539 switch (TREE_CODE (exp))
3543 /* Go inside any operations that get_inner_reference can handle and see
3544 if what's inside is a constant: no need to do anything here for
3545 addresses of variables or functions. */
3546 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3547 tem = TREE_OPERAND (tem, 0))
3550 if (TREE_PUBLIC (tem))
3557 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3558 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3562 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3563 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3564 /* The difference of two local labels is computable at link time. */
3565 if (reloc == 1 && reloc2 == 1)
3573 case NON_LVALUE_EXPR:
3574 case VIEW_CONVERT_EXPR:
3575 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3580 unsigned HOST_WIDE_INT idx;
3581 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3583 reloc |= compute_reloc_for_constant (tem);
3593 /* Find all the constants whose addresses are referenced inside of EXP,
3594 and make sure assembler code with a label has been output for each one.
3595 Indicate whether an ADDR_EXPR has been encountered. */
3598 output_addressed_constants (tree exp)
3602 /* Give the front-end a chance to convert VALUE to something that
3603 looks more like a constant to the back-end. */
3604 exp = lang_hooks.expand_constant (exp);
3606 switch (TREE_CODE (exp))
3610 /* Go inside any operations that get_inner_reference can handle and see
3611 if what's inside is a constant: no need to do anything here for
3612 addresses of variables or functions. */
3613 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3614 tem = TREE_OPERAND (tem, 0))
3617 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3618 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3619 tem = DECL_INITIAL (tem);
3621 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3622 output_constant_def (tem, 0);
3627 output_addressed_constants (TREE_OPERAND (exp, 1));
3632 case NON_LVALUE_EXPR:
3633 case VIEW_CONVERT_EXPR:
3634 output_addressed_constants (TREE_OPERAND (exp, 0));
3639 unsigned HOST_WIDE_INT idx;
3640 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3642 output_addressed_constants (tem);
3651 /* Return nonzero if VALUE is a valid constant-valued expression
3652 for use in initializing a static variable; one that can be an
3653 element of a "constant" initializer.
3655 Return null_pointer_node if the value is absolute;
3656 if it is relocatable, return the variable that determines the relocation.
3657 We assume that VALUE has been folded as much as possible;
3658 therefore, we do not need to check for such things as
3659 arithmetic-combinations of integers. */
3662 initializer_constant_valid_p (tree value, tree endtype)
3664 /* Give the front-end a chance to convert VALUE to something that
3665 looks more like a constant to the back-end. */
3666 value = lang_hooks.expand_constant (value);
3668 switch (TREE_CODE (value))
3671 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3672 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3673 && TREE_CONSTANT (value)
3674 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value)))
3676 unsigned HOST_WIDE_INT idx;
3678 bool absolute = true;
3680 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
3683 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
3686 if (reloc != null_pointer_node)
3689 /* For a non-absolute relocation, there is no single
3690 variable that can be "the variable that determines the
3692 return absolute ? null_pointer_node : error_mark_node;
3695 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3702 return null_pointer_node;
3706 value = staticp (TREE_OPERAND (value, 0));
3709 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3710 be a constant, this is old-skool offsetof-like nonsense. */
3711 if (TREE_CODE (value) == INDIRECT_REF
3712 && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3713 return null_pointer_node;
3714 /* Taking the address of a nested function involves a trampoline. */
3715 if (TREE_CODE (value) == FUNCTION_DECL
3716 && ((decl_function_context (value)
3717 && !DECL_NO_STATIC_CHAIN (value))
3718 || DECL_DLLIMPORT_P (value)))
3720 /* "&{...}" requires a temporary to hold the constructed
3722 if (TREE_CODE (value) == CONSTRUCTOR)
3727 case VIEW_CONVERT_EXPR:
3728 case NON_LVALUE_EXPR:
3729 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3738 src = TREE_OPERAND (value, 0);
3739 src_type = TREE_TYPE (src);
3740 dest_type = TREE_TYPE (value);
3742 /* Allow conversions between pointer types, floating-point
3743 types, and offset types. */
3744 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3745 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3746 || (TREE_CODE (dest_type) == OFFSET_TYPE
3747 && TREE_CODE (src_type) == OFFSET_TYPE))
3748 return initializer_constant_valid_p (src, endtype);
3750 /* Allow length-preserving conversions between integer types. */
3751 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3752 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3753 return initializer_constant_valid_p (src, endtype);
3755 /* Allow conversions between other integer types only if
3757 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3759 tree inner = initializer_constant_valid_p (src, endtype);
3760 if (inner == null_pointer_node)
3761 return null_pointer_node;
3765 /* Allow (int) &foo provided int is as wide as a pointer. */
3766 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3767 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3768 return initializer_constant_valid_p (src, endtype);
3770 /* Likewise conversions from int to pointers, but also allow
3771 conversions from 0. */
3772 if ((POINTER_TYPE_P (dest_type)
3773 || TREE_CODE (dest_type) == OFFSET_TYPE)
3774 && INTEGRAL_TYPE_P (src_type))
3776 if (TREE_CODE (src) == INTEGER_CST
3777 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
3778 return null_pointer_node;
3779 if (integer_zerop (src))
3780 return null_pointer_node;
3781 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3782 return initializer_constant_valid_p (src, endtype);
3785 /* Allow conversions to struct or union types if the value
3787 if (TREE_CODE (dest_type) == RECORD_TYPE
3788 || TREE_CODE (dest_type) == UNION_TYPE)
3789 return initializer_constant_valid_p (src, endtype);
3794 if (! INTEGRAL_TYPE_P (endtype)
3795 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3797 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3799 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3801 /* If either term is absolute, use the other terms relocation. */
3802 if (valid0 == null_pointer_node)
3804 if (valid1 == null_pointer_node)
3810 if (! INTEGRAL_TYPE_P (endtype)
3811 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3813 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3815 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3817 /* Win if second argument is absolute. */
3818 if (valid1 == null_pointer_node)
3820 /* Win if both arguments have the same relocation.
3821 Then the value is absolute. */
3822 if (valid0 == valid1 && valid0 != 0)
3823 return null_pointer_node;
3825 /* Since GCC guarantees that string constants are unique in the
3826 generated code, a subtraction between two copies of the same
3827 constant string is absolute. */
3828 if (valid0 && TREE_CODE (valid0) == STRING_CST
3829 && valid1 && TREE_CODE (valid1) == STRING_CST
3830 && operand_equal_p (valid0, valid1, 1))
3831 return null_pointer_node;
3834 /* Support narrowing differences. */
3835 if (INTEGRAL_TYPE_P (endtype))
3839 op0 = TREE_OPERAND (value, 0);
3840 op1 = TREE_OPERAND (value, 1);
3842 /* Like STRIP_NOPS except allow the operand mode to widen.
3843 This works around a feature of fold that simplifies
3844 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3845 that the narrower operation is cheaper. */
3847 while (TREE_CODE (op0) == NOP_EXPR
3848 || TREE_CODE (op0) == CONVERT_EXPR
3849 || TREE_CODE (op0) == NON_LVALUE_EXPR)
3851 tree inner = TREE_OPERAND (op0, 0);
3852 if (inner == error_mark_node
3853 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3854 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3855 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3860 while (TREE_CODE (op1) == NOP_EXPR
3861 || TREE_CODE (op1) == CONVERT_EXPR
3862 || TREE_CODE (op1) == NON_LVALUE_EXPR)
3864 tree inner = TREE_OPERAND (op1, 0);
3865 if (inner == error_mark_node
3866 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3867 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3868 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3873 op0 = initializer_constant_valid_p (op0, endtype);
3874 op1 = initializer_constant_valid_p (op1, endtype);
3876 /* Both initializers must be known. */
3880 return null_pointer_node;
3882 /* Support differences between labels. */
3883 if (TREE_CODE (op0) == LABEL_DECL
3884 && TREE_CODE (op1) == LABEL_DECL)
3885 return null_pointer_node;
3887 if (TREE_CODE (op0) == STRING_CST
3888 && TREE_CODE (op1) == STRING_CST
3889 && operand_equal_p (op0, op1, 1))
3890 return null_pointer_node;
3902 /* Output assembler code for constant EXP to FILE, with no label.
3903 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3904 Assumes output_addressed_constants has been done on EXP already.
3906 Generate exactly SIZE bytes of assembler data, padding at the end
3907 with zeros if necessary. SIZE must always be specified.
3909 SIZE is important for structure constructors,
3910 since trailing members may have been omitted from the constructor.
3911 It is also important for initialization of arrays from string constants
3912 since the full length of the string constant might not be wanted.
3913 It is also needed for initialization of unions, where the initializer's
3914 type is just one member, and that may not be as long as the union.
3916 There a case in which we would fail to output exactly SIZE bytes:
3917 for a structure constructor that wants to produce more than SIZE bytes.
3918 But such constructors will never be generated for any possible input.
3920 ALIGN is the alignment of the data in bits. */
3923 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3925 enum tree_code code;
3926 unsigned HOST_WIDE_INT thissize;
3928 /* Some front-ends use constants other than the standard language-independent
3929 varieties, but which may still be output directly. Give the front-end a
3930 chance to convert EXP to a language-independent representation. */
3931 exp = lang_hooks.expand_constant (exp);
3933 if (size == 0 || flag_syntax_only)
3936 /* See if we're trying to initialize a pointer in a non-default mode
3937 to the address of some declaration somewhere. If the target says
3938 the mode is valid for pointers, assume the target has a way of
3940 if (TREE_CODE (exp) == NOP_EXPR
3941 && POINTER_TYPE_P (TREE_TYPE (exp))
3942 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3944 tree saved_type = TREE_TYPE (exp);
3946 /* Peel off any intermediate conversions-to-pointer for valid
3948 while (TREE_CODE (exp) == NOP_EXPR
3949 && POINTER_TYPE_P (TREE_TYPE (exp))
3950 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3951 exp = TREE_OPERAND (exp, 0);
3953 /* If what we're left with is the address of something, we can
3954 convert the address to the final type and output it that
3956 if (TREE_CODE (exp) == ADDR_EXPR)
3957 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
3958 /* Likewise for constant ints. */
3959 else if (TREE_CODE (exp) == INTEGER_CST)
3960 exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
3961 TREE_INT_CST_HIGH (exp));
3965 /* Eliminate any conversions since we'll be outputting the underlying
3967 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3968 || TREE_CODE (exp) == NON_LVALUE_EXPR
3969 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3971 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp));
3972 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)));
3974 /* Make sure eliminating the conversion is really a no-op, except with
3975 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
3976 union types to allow for Ada unchecked unions. */
3977 if (type_size > op_size
3978 && TREE_CODE (exp) != VIEW_CONVERT_EXPR
3979 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE)
3980 internal_error ("no-op convert from %wd to %wd bytes in initializer",
3981 op_size, type_size);
3983 exp = TREE_OPERAND (exp, 0);
3986 code = TREE_CODE (TREE_TYPE (exp));
3987 thissize = int_size_in_bytes (TREE_TYPE (exp));
3989 /* Allow a constructor with no elements for any data type.
3990 This means to fill the space with zeros. */
3991 if (TREE_CODE (exp) == CONSTRUCTOR
3992 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
3994 assemble_zeros (size);
3998 if (TREE_CODE (exp) == FDESC_EXPR)
4000 #ifdef ASM_OUTPUT_FDESC
4001 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4002 tree decl = TREE_OPERAND (exp, 0);
4003 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4010 /* Now output the underlying data. If we've handling the padding, return.
4011 Otherwise, break and ensure SIZE is the size written. */
4018 case REFERENCE_TYPE:
4020 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4021 EXPAND_INITIALIZER),
4022 MIN (size, thissize), align, 0))
4023 error ("initializer for integer value is too complicated");
4027 if (TREE_CODE (exp) != REAL_CST)
4028 error ("initializer for floating value is not a floating constant");
4030 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
4034 output_constant (TREE_REALPART (exp), thissize / 2, align);
4035 output_constant (TREE_IMAGPART (exp), thissize / 2,
4036 min_align (align, BITS_PER_UNIT * (thissize / 2)));
4041 switch (TREE_CODE (exp))
4044 output_constructor (exp, size, align);
4047 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
4049 assemble_string (TREE_STRING_POINTER (exp), thissize);
4056 unsigned int nalign;
4057 enum machine_mode inner;
4059 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
4060 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
4062 elt_size = GET_MODE_SIZE (inner);
4064 link = TREE_VECTOR_CST_ELTS (exp);
4065 output_constant (TREE_VALUE (link), elt_size, align);
4066 while ((link = TREE_CHAIN (link)) != NULL)
4067 output_constant (TREE_VALUE (link), elt_size, nalign);
4077 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
4078 output_constructor (exp, size, align);
4088 if (size > thissize)
4089 assemble_zeros (size - thissize);
4093 /* Subroutine of output_constructor, used for computing the size of
4094 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4095 type with an unspecified upper bound. */
4097 static unsigned HOST_WIDE_INT
4098 array_size_for_constructor (tree val)
4101 unsigned HOST_WIDE_INT cnt;
4104 /* This code used to attempt to handle string constants that are not
4105 arrays of single-bytes, but nothing else does, so there's no point in
4107 if (TREE_CODE (val) == STRING_CST)
4108 return TREE_STRING_LENGTH (val);
4110 max_index = NULL_TREE;
4111 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
4113 if (TREE_CODE (index) == RANGE_EXPR)
4114 index = TREE_OPERAND (index, 1);
4115 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4119 if (max_index == NULL_TREE)
4122 /* Compute the total number of array elements. */
4123 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4125 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4126 i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
4128 /* Multiply by the array element unit size to find number of bytes. */
4129 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4131 return tree_low_cst (i, 1);
4134 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4135 Generate at least SIZE bytes, padding if necessary. */
4138 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4141 tree type = TREE_TYPE (exp);
4144 /* Number of bytes output or skipped so far.
4145 In other words, current position within the constructor. */
4146 HOST_WIDE_INT total_bytes = 0;
4147 /* Nonzero means BYTE contains part of a byte, to be output. */
4148 int byte_buffer_in_use = 0;
4150 unsigned HOST_WIDE_INT cnt;
4151 constructor_elt *ce;
4153 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4155 if (TREE_CODE (type) == RECORD_TYPE)
4156 field = TYPE_FIELDS (type);
4158 if (TREE_CODE (type) == ARRAY_TYPE
4159 && TYPE_DOMAIN (type) != 0)
4160 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4162 /* As LINK goes through the elements of the constant,
4163 FIELD goes through the structure fields, if the constant is a structure.
4164 if the constant is a union, then we override this,
4165 by getting the field from the TREE_LIST element.
4166 But the constant could also be an array. Then FIELD is zero.
4168 There is always a maximum of one element in the chain LINK for unions
4169 (even if the initializer in a source program incorrectly contains
4172 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4173 cnt++, field = field ? TREE_CHAIN (field) : 0)
4175 tree val = ce->value;
4178 /* The element in a union constructor specifies the proper field
4180 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4181 || TREE_CODE (type) == QUAL_UNION_TYPE)
4185 else if (TREE_CODE (type) == ARRAY_TYPE)
4188 #ifdef ASM_COMMENT_START
4189 if (field && flag_verbose_asm)
4190 fprintf (asm_out_file, "%s %s:\n",
4193 ? IDENTIFIER_POINTER (DECL_NAME (field))
4197 /* Eliminate the marker that makes a cast not be an lvalue. */
4201 if (index && TREE_CODE (index) == RANGE_EXPR)
4203 unsigned HOST_WIDE_INT fieldsize
4204 = int_size_in_bytes (TREE_TYPE (type));
4205 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4206 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4207 HOST_WIDE_INT index;
4208 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4210 for (index = lo_index; index <= hi_index; index++)
4212 /* Output the element's initial value. */
4214 assemble_zeros (fieldsize);
4216 output_constant (val, fieldsize, align2);
4218 /* Count its size. */
4219 total_bytes += fieldsize;
4222 else if (field == 0 || !DECL_BIT_FIELD (field))
4224 /* An element that is not a bit-field. */
4226 unsigned HOST_WIDE_INT fieldsize;
4227 /* Since this structure is static,
4228 we know the positions are constant. */
4229 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4230 unsigned int align2;
4233 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4234 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4236 /* Output any buffered-up bit-fields preceding this element. */
4237 if (byte_buffer_in_use)
4239 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4241 byte_buffer_in_use = 0;
4244 /* Advance to offset of this element.
4245 Note no alignment needed in an array, since that is guaranteed
4246 if each element has the proper size. */
4247 if ((field != 0 || index != 0) && pos != total_bytes)
4249 gcc_assert (pos >= total_bytes);
4250 assemble_zeros (pos - total_bytes);
4254 /* Find the alignment of this element. */
4255 align2 = min_align (align, BITS_PER_UNIT * pos);
4257 /* Determine size this element should occupy. */
4262 /* If this is an array with an unspecified upper bound,
4263 the initializer determines the size. */
4264 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4265 but we cannot do this until the deprecated support for
4266 initializing zero-length array members is removed. */
4267 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4268 && TYPE_DOMAIN (TREE_TYPE (field))
4269 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4271 fieldsize = array_size_for_constructor (val);
4272 /* Given a non-empty initialization, this field had
4274 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4276 else if (DECL_SIZE_UNIT (field))
4278 /* ??? This can't be right. If the decl size overflows
4279 a host integer we will silently emit no data. */
4280 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4281 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4285 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4287 /* Output the element's initial value. */
4289 assemble_zeros (fieldsize);
4291 output_constant (val, fieldsize, align2);
4293 /* Count its size. */
4294 total_bytes += fieldsize;
4296 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4297 error ("invalid initial value for member %qs",
4298 IDENTIFIER_POINTER (DECL_NAME (field)));
4301 /* Element that is a bit-field. */
4303 HOST_WIDE_INT next_offset = int_bit_position (field);
4304 HOST_WIDE_INT end_offset
4305 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4308 val = integer_zero_node;
4310 /* If this field does not start in this (or, next) byte,
4312 if (next_offset / BITS_PER_UNIT != total_bytes)
4314 /* Output remnant of any bit field in previous bytes. */
4315 if (byte_buffer_in_use)
4317 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4319 byte_buffer_in_use = 0;
4322 /* If still not at proper byte, advance to there. */
4323 if (next_offset / BITS_PER_UNIT != total_bytes)
4325 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4326 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4327 total_bytes = next_offset / BITS_PER_UNIT;
4331 if (! byte_buffer_in_use)
4334 /* We must split the element into pieces that fall within
4335 separate bytes, and combine each byte with previous or
4336 following bit-fields. */
4338 /* next_offset is the offset n fbits from the beginning of
4339 the structure to the next bit of this element to be processed.
4340 end_offset is the offset of the first bit past the end of
4342 while (next_offset < end_offset)
4346 HOST_WIDE_INT value;
4347 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4348 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4350 /* Advance from byte to byte
4351 within this element when necessary. */
4352 while (next_byte != total_bytes)
4354 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4359 /* Number of bits we can process at once
4360 (all part of the same byte). */
4361 this_time = MIN (end_offset - next_offset,
4362 BITS_PER_UNIT - next_bit);
4363 if (BYTES_BIG_ENDIAN)
4365 /* On big-endian machine, take the most significant bits
4366 first (of the bits that are significant)
4367 and put them into bytes from the most significant end. */
4368 shift = end_offset - next_offset - this_time;
4370 /* Don't try to take a bunch of bits that cross
4371 the word boundary in the INTEGER_CST. We can
4372 only select bits from the LOW or HIGH part
4374 if (shift < HOST_BITS_PER_WIDE_INT
4375 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4377 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4378 shift = HOST_BITS_PER_WIDE_INT;
4381 /* Now get the bits from the appropriate constant word. */
4382 if (shift < HOST_BITS_PER_WIDE_INT)
4383 value = TREE_INT_CST_LOW (val);
4386 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4387 value = TREE_INT_CST_HIGH (val);
4388 shift -= HOST_BITS_PER_WIDE_INT;
4391 /* Get the result. This works only when:
4392 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4393 byte |= (((value >> shift)
4394 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4395 << (BITS_PER_UNIT - this_time - next_bit));
4399 /* On little-endian machines,
4400 take first the least significant bits of the value
4401 and pack them starting at the least significant
4402 bits of the bytes. */
4403 shift = next_offset - int_bit_position (field);
4405 /* Don't try to take a bunch of bits that cross
4406 the word boundary in the INTEGER_CST. We can
4407 only select bits from the LOW or HIGH part
4409 if (shift < HOST_BITS_PER_WIDE_INT
4410 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4411 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4413 /* Now get the bits from the appropriate constant word. */
4414 if (shift < HOST_BITS_PER_WIDE_INT)
4415 value = TREE_INT_CST_LOW (val);
4418 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4419 value = TREE_INT_CST_HIGH (val);
4420 shift -= HOST_BITS_PER_WIDE_INT;
4423 /* Get the result. This works only when:
4424 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4425 byte |= (((value >> shift)
4426 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4430 next_offset += this_time;
4431 byte_buffer_in_use = 1;
4436 if (byte_buffer_in_use)
4438 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4442 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4443 assemble_zeros (size - total_bytes);
4446 /* This TREE_LIST contains any weak symbol declarations waiting
4448 static GTY(()) tree weak_decls;
4450 /* Mark DECL as weak. */
4453 mark_weak (tree decl)
4455 DECL_WEAK (decl) = 1;
4457 if (DECL_RTL_SET_P (decl)
4458 && MEM_P (DECL_RTL (decl))
4459 && XEXP (DECL_RTL (decl), 0)
4460 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4461 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4464 /* Merge weak status between NEWDECL and OLDDECL. */
4467 merge_weak (tree newdecl, tree olddecl)
4469 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4471 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4474 /* We put the NEWDECL on the weak_decls list at some point
4475 and OLDDECL as well. Keep just OLDDECL on the list. */
4476 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4477 if (TREE_VALUE (*pwd) == newdecl)
4479 *pwd = TREE_CHAIN (*pwd);
4486 if (DECL_WEAK (newdecl))
4490 /* NEWDECL is weak, but OLDDECL is not. */
4492 /* If we already output the OLDDECL, we're in trouble; we can't
4493 go back and make it weak. This error cannot caught in
4494 declare_weak because the NEWDECL and OLDDECL was not yet
4495 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4496 if (TREE_ASM_WRITTEN (olddecl))
4497 error ("weak declaration of %q+D must precede definition",
4500 /* If we've already generated rtl referencing OLDDECL, we may
4501 have done so in a way that will not function properly with
4503 else if (TREE_USED (olddecl)
4504 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4505 warning (0, "weak declaration of %q+D after first use results "
4506 "in unspecified behavior", newdecl);
4510 /* We put the NEWDECL on the weak_decls list at some point.
4511 Replace it with the OLDDECL. */
4512 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4513 if (TREE_VALUE (wd) == newdecl)
4515 TREE_VALUE (wd) = olddecl;
4518 /* We may not find the entry on the list. If NEWDECL is a
4519 weak alias, then we will have already called
4520 globalize_decl to remove the entry; in that case, we do
4521 not need to do anything. */
4524 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4525 mark_weak (olddecl);
4528 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4529 weak. Just update NEWDECL to indicate that it's weak too. */
4530 mark_weak (newdecl);
4533 /* Declare DECL to be a weak symbol. */
4536 declare_weak (tree decl)
4538 if (! TREE_PUBLIC (decl))
4539 error ("weak declaration of %q+D must be public", decl);
4540 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4541 error ("weak declaration of %q+D must precede definition", decl);
4542 else if (SUPPORTS_WEAK)
4544 if (! DECL_WEAK (decl))
4545 weak_decls = tree_cons (NULL, decl, weak_decls);
4548 warning (0, "weak declaration of %q+D not supported", decl);
4554 weak_finish_1 (tree decl)
4556 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4557 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4560 if (! TREE_USED (decl))
4563 #ifdef ASM_WEAKEN_DECL
4564 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4566 #ifdef ASM_WEAKEN_LABEL
4567 ASM_WEAKEN_LABEL (asm_out_file, name);
4569 #ifdef ASM_OUTPUT_WEAK_ALIAS
4571 static bool warn_once = 0;
4574 warning (0, "only weak aliases are supported in this configuration");
4584 /* This TREE_LIST contains weakref targets. */
4586 static GTY(()) tree weakref_targets;
4588 /* Forward declaration. */
4589 static tree find_decl_and_mark_needed (tree decl, tree target);
4591 /* Emit any pending weak declarations. */
4598 for (t = weakref_targets; t; t = TREE_CHAIN (t))
4600 tree alias_decl = TREE_PURPOSE (t);
4601 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t));
4603 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl)))
4604 /* Remove alias_decl from the weak list, but leave entries for
4605 the target alone. */
4607 #ifndef ASM_OUTPUT_WEAKREF
4608 else if (! TREE_SYMBOL_REFERENCED (target))
4610 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
4611 defined, otherwise we and weak_finish_1 would use a
4612 different macros. */
4613 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
4614 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target));
4616 tree decl = find_decl_and_mark_needed (alias_decl, target);
4620 decl = build_decl (TREE_CODE (alias_decl), target,
4621 TREE_TYPE (alias_decl));
4623 DECL_EXTERNAL (decl) = 1;
4624 TREE_PUBLIC (decl) = 1;
4625 DECL_ARTIFICIAL (decl) = 1;
4626 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl);
4627 TREE_USED (decl) = 1;
4630 weak_finish_1 (decl);
4639 /* Remove the alias and the target from the pending weak list
4640 so that we do not emit any .weak directives for the former,
4641 nor multiple .weak directives for the latter. */
4642 for (p = &weak_decls; (t2 = *p) ; )
4644 if (TREE_VALUE (t2) == alias_decl
4645 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2)))
4646 *p = TREE_CHAIN (t2);
4648 p = &TREE_CHAIN (t2);
4651 /* Remove other weakrefs to the same target, to speed things up. */
4652 for (p = &TREE_CHAIN (t); (t2 = *p) ; )
4654 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2)))
4655 *p = TREE_CHAIN (t2);
4657 p = &TREE_CHAIN (t2);
4662 for (t = weak_decls; t; t = TREE_CHAIN (t))
4664 tree decl = TREE_VALUE (t);
4666 weak_finish_1 (decl);
4670 /* Emit the assembly bits to indicate that DECL is globally visible. */
4673 globalize_decl (tree decl)
4675 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4677 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4678 if (DECL_WEAK (decl))
4682 #ifdef ASM_WEAKEN_DECL
4683 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4685 ASM_WEAKEN_LABEL (asm_out_file, name);
4688 /* Remove this function from the pending weak list so that
4689 we do not emit multiple .weak directives for it. */
4690 for (p = &weak_decls; (t = *p) ; )
4692 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4693 *p = TREE_CHAIN (t);
4695 p = &TREE_CHAIN (t);
4698 /* Remove weakrefs to the same target from the pending weakref
4699 list, for the same reason. */
4700 for (p = &weakref_targets; (t = *p) ; )
4702 if (DECL_ASSEMBLER_NAME (decl)
4703 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4704 *p = TREE_CHAIN (t);
4706 p = &TREE_CHAIN (t);
4711 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4712 if (DECL_ONE_ONLY (decl))
4713 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4716 targetm.asm_out.globalize_label (asm_out_file, name);
4719 /* We have to be able to tell cgraph about the needed-ness of the target
4720 of an alias. This requires that the decl have been defined. Aliases
4721 that precede their definition have to be queued for later processing. */
4723 typedef struct alias_pair GTY(())
4729 /* Define gc'd vector type. */
4730 DEF_VEC_O(alias_pair);
4731 DEF_VEC_ALLOC_O(alias_pair,gc);
4733 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
4735 /* Given an assembly name, find the decl it is associated with. At the
4736 same time, mark it needed for cgraph. */
4739 find_decl_and_mark_needed (tree decl, tree target)
4741 struct cgraph_node *fnode = NULL;
4742 struct cgraph_varpool_node *vnode = NULL;
4744 if (TREE_CODE (decl) == FUNCTION_DECL)
4746 fnode = cgraph_node_for_asm (target);
4748 vnode = cgraph_varpool_node_for_asm (target);
4752 vnode = cgraph_varpool_node_for_asm (target);
4754 fnode = cgraph_node_for_asm (target);
4759 /* We can't mark function nodes as used after cgraph global info
4760 is finished. This wouldn't generally be necessary, but C++
4761 virtual table thunks are introduced late in the game and
4762 might seem like they need marking, although in fact they
4764 if (! cgraph_global_info_ready)
4765 cgraph_mark_needed_node (fnode);
4770 cgraph_varpool_mark_needed_node (vnode);
4777 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4778 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4779 tree node is DECL to have the value of the tree node TARGET. */
4782 do_assemble_alias (tree decl, tree target)
4784 if (TREE_ASM_WRITTEN (decl))
4787 TREE_ASM_WRITTEN (decl) = 1;
4788 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4790 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4792 ultimate_transparent_alias_target (&target);
4794 if (!TREE_SYMBOL_REFERENCED (target))
4795 weakref_targets = tree_cons (decl, target, weakref_targets);
4797 #ifdef ASM_OUTPUT_WEAKREF
4798 ASM_OUTPUT_WEAKREF (asm_out_file, decl,
4799 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4800 IDENTIFIER_POINTER (target));
4804 error ("%Jweakref is not supported in this configuration", decl);
4811 #ifdef ASM_OUTPUT_DEF
4812 /* Make name accessible from other files, if appropriate. */
4814 if (TREE_PUBLIC (decl))
4816 globalize_decl (decl);
4817 maybe_assemble_visibility (decl);
4820 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4821 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4823 ASM_OUTPUT_DEF (asm_out_file,
4824 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
4825 IDENTIFIER_POINTER (target));
4827 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4832 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4833 # ifdef ASM_WEAKEN_DECL
4834 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4836 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4838 /* Remove this function from the pending weak list so that
4839 we do not emit multiple .weak directives for it. */
4840 for (p = &weak_decls; (t = *p) ; )
4841 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4842 *p = TREE_CHAIN (t);
4844 p = &TREE_CHAIN (t);
4846 /* Remove weakrefs to the same target from the pending weakref
4847 list, for the same reason. */
4848 for (p = &weakref_targets; (t = *p) ; )
4850 if (DECL_ASSEMBLER_NAME (decl)
4851 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
4852 *p = TREE_CHAIN (t);
4854 p = &TREE_CHAIN (t);
4860 /* First pass of completing pending aliases. Make sure that cgraph knows
4861 which symbols will be required. */
4864 finish_aliases_1 (void)
4869 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4873 target_decl = find_decl_and_mark_needed (p->decl, p->target);
4874 if (target_decl == NULL)
4876 if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4877 error ("%q+D aliased to undefined symbol %qs",
4878 p->decl, IDENTIFIER_POINTER (p->target));
4880 else if (DECL_EXTERNAL (target_decl)
4881 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
4882 error ("%q+D aliased to external symbol %qs",
4883 p->decl, IDENTIFIER_POINTER (p->target));
4887 /* Second pass of completing pending aliases. Emit the actual assembly.
4888 This happens at the end of compilation and thus it is assured that the
4889 target symbol has been emitted. */
4892 finish_aliases_2 (void)
4897 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4898 do_assemble_alias (p->decl, p->target);
4900 VEC_truncate (alias_pair, alias_pairs, 0);
4903 /* Emit an assembler directive to make the symbol for DECL an alias to
4904 the symbol for TARGET. */
4907 assemble_alias (tree decl, tree target)
4910 bool is_weakref = false;
4912 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4914 tree alias = DECL_ASSEMBLER_NAME (decl);
4918 ultimate_transparent_alias_target (&target);
4920 if (alias == target)
4921 error ("weakref %q+D ultimately targets itself", decl);
4924 #ifndef ASM_OUTPUT_WEAKREF
4925 IDENTIFIER_TRANSPARENT_ALIAS (alias) = 1;
4926 TREE_CHAIN (alias) = target;
4929 if (TREE_PUBLIC (decl))
4930 error ("weakref %q+D must have static linkage", decl);
4934 #if !defined (ASM_OUTPUT_DEF)
4935 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4936 error ("%Jalias definitions not supported in this configuration", decl);
4939 if (!DECL_WEAK (decl))
4941 error ("%Jonly weak aliases are supported in this configuration", decl);
4948 /* We must force creation of DECL_RTL for debug info generation, even though
4949 we don't use it here. */
4950 make_decl_rtl (decl);
4951 TREE_USED (decl) = 1;
4953 /* A quirk of the initial implementation of aliases required that the user
4954 add "extern" to all of them. Which is silly, but now historical. Do
4955 note that the symbol is in fact locally defined. */
4957 DECL_EXTERNAL (decl) = 0;
4959 /* Allow aliases to aliases. */
4960 if (TREE_CODE (decl) == FUNCTION_DECL)
4961 cgraph_node (decl)->alias = true;
4963 cgraph_varpool_node (decl)->alias = true;
4965 /* If the target has already been emitted, we don't have to queue the
4966 alias. This saves a tad o memory. */
4967 target_decl = find_decl_and_mark_needed (decl, target);
4968 if (target_decl && TREE_ASM_WRITTEN (target_decl))
4969 do_assemble_alias (decl, target);
4972 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
4978 /* Emit an assembler directive to set symbol for DECL visibility to
4979 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4982 default_assemble_visibility (tree decl, int vis)
4984 static const char * const visibility_types[] = {
4985 NULL, "internal", "hidden", "protected"
4988 const char *name, *type;
4990 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4991 type = visibility_types[vis];
4993 #ifdef HAVE_GAS_HIDDEN
4994 fprintf (asm_out_file, "\t.%s\t", type);
4995 assemble_name (asm_out_file, name);
4996 fprintf (asm_out_file, "\n");
4998 warning (OPT_Wattributes, "visibility attribute not supported "
4999 "in this configuration; ignored");
5003 /* A helper function to call assemble_visibility when needed for a decl. */
5006 maybe_assemble_visibility (tree decl)
5008 enum symbol_visibility vis = DECL_VISIBILITY (decl);
5010 if (vis != VISIBILITY_DEFAULT)
5011 targetm.asm_out.visibility (decl, vis);
5014 /* Returns 1 if the target configuration supports defining public symbols
5015 so that one of them will be chosen at link time instead of generating a
5016 multiply-defined symbol error, whether through the use of weak symbols or
5017 a target-specific mechanism for having duplicates discarded. */
5020 supports_one_only (void)
5022 if (SUPPORTS_ONE_ONLY)
5024 return SUPPORTS_WEAK;
5027 /* Set up DECL as a public symbol that can be defined in multiple
5028 translation units without generating a linker error. */
5031 make_decl_one_only (tree decl)
5033 gcc_assert (TREE_CODE (decl) == VAR_DECL
5034 || TREE_CODE (decl) == FUNCTION_DECL);
5036 TREE_PUBLIC (decl) = 1;
5038 if (SUPPORTS_ONE_ONLY)
5040 #ifdef MAKE_DECL_ONE_ONLY
5041 MAKE_DECL_ONE_ONLY (decl);
5043 DECL_ONE_ONLY (decl) = 1;
5045 else if (TREE_CODE (decl) == VAR_DECL
5046 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5047 DECL_COMMON (decl) = 1;
5050 gcc_assert (SUPPORTS_WEAK);
5051 DECL_WEAK (decl) = 1;
5056 init_varasm_once (void)
5058 section_htab = htab_create_ggc (31, section_entry_hash,
5059 section_entry_eq, NULL);
5060 object_block_htab = htab_create_ggc (31, object_block_entry_hash,
5061 object_block_entry_eq, NULL);
5062 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
5063 const_desc_eq, NULL);
5065 const_alias_set = new_alias_set ();
5067 #ifdef TEXT_SECTION_ASM_OP
5068 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op,
5069 TEXT_SECTION_ASM_OP);
5072 #ifdef DATA_SECTION_ASM_OP
5073 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5074 DATA_SECTION_ASM_OP);
5077 #ifdef SDATA_SECTION_ASM_OP
5078 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5079 SDATA_SECTION_ASM_OP);
5082 #ifdef READONLY_DATA_SECTION_ASM_OP
5083 readonly_data_section = get_unnamed_section (0, output_section_asm_op,
5084 READONLY_DATA_SECTION_ASM_OP);
5087 #ifdef CTORS_SECTION_ASM_OP
5088 ctors_section = get_unnamed_section (0, output_section_asm_op,
5089 CTORS_SECTION_ASM_OP);
5092 #ifdef DTORS_SECTION_ASM_OP
5093 dtors_section = get_unnamed_section (0, output_section_asm_op,
5094 DTORS_SECTION_ASM_OP);
5097 #ifdef BSS_SECTION_ASM_OP
5098 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5099 output_section_asm_op,
5100 BSS_SECTION_ASM_OP);
5103 #ifdef SBSS_SECTION_ASM_OP
5104 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5105 output_section_asm_op,
5106 SBSS_SECTION_ASM_OP);
5109 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5110 | SECTION_COMMON, emit_tls_common);
5111 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5112 | SECTION_COMMON, emit_local);
5113 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5114 | SECTION_COMMON, emit_common);
5116 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
5117 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS,
5121 targetm.asm_out.init_sections ();
5123 if (readonly_data_section == NULL)
5124 readonly_data_section = text_section;
5128 decl_default_tls_model (tree decl)
5130 enum tls_model kind;
5133 is_local = targetm.binds_local_p (decl);
5137 kind = TLS_MODEL_LOCAL_EXEC;
5139 kind = TLS_MODEL_INITIAL_EXEC;
5142 /* Local dynamic is inefficient when we're not combining the
5143 parts of the address. */
5144 else if (optimize && is_local)
5145 kind = TLS_MODEL_LOCAL_DYNAMIC;
5147 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5148 if (kind < flag_tls_default)
5149 kind = flag_tls_default;
5154 /* Select a set of attributes for section NAME based on the properties
5155 of DECL and whether or not RELOC indicates that DECL's initializer
5156 might contain runtime relocations.
5158 We make the section read-only and executable for a function decl,
5159 read-only for a const data decl, and writable for a non-const data decl. */
5162 default_section_type_flags (tree decl, const char *name, int reloc)
5164 return default_section_type_flags_1 (decl, name, reloc, flag_pic);
5168 default_section_type_flags_1 (tree decl, const char *name, int reloc,
5173 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5174 flags = SECTION_CODE;
5175 else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
5177 else if (current_function_decl
5179 && cfun->unlikely_text_section_name
5180 && strcmp (name, cfun->unlikely_text_section_name) == 0)
5181 flags = SECTION_CODE;
5183 && (!current_function_decl || !cfun)
5184 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5185 flags = SECTION_CODE;
5187 flags = SECTION_WRITE;
5189 if (decl && DECL_ONE_ONLY (decl))
5190 flags |= SECTION_LINKONCE;
5192 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5193 flags |= SECTION_TLS | SECTION_WRITE;
5195 if (strcmp (name, ".bss") == 0
5196 || strncmp (name, ".bss.", 5) == 0
5197 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5198 || strcmp (name, ".sbss") == 0
5199 || strncmp (name, ".sbss.", 6) == 0
5200 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5201 flags |= SECTION_BSS;
5203 if (strcmp (name, ".tdata") == 0
5204 || strncmp (name, ".tdata.", 7) == 0
5205 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
5206 flags |= SECTION_TLS;
5208 if (strcmp (name, ".tbss") == 0
5209 || strncmp (name, ".tbss.", 6) == 0
5210 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
5211 flags |= SECTION_TLS | SECTION_BSS;
5213 /* These three sections have special ELF types. They are neither
5214 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
5215 want to print a section type (@progbits or @nobits). If someone
5216 is silly enough to emit code or TLS variables to one of these
5217 sections, then don't handle them specially. */
5218 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
5219 && (strcmp (name, ".init_array") == 0
5220 || strcmp (name, ".fini_array") == 0
5221 || strcmp (name, ".preinit_array") == 0))
5222 flags |= SECTION_NOTYPE;
5227 /* Return true if the target supports some form of global BSS,
5228 either through bss_noswitch_section, or by selecting a BSS
5229 section in TARGET_ASM_SELECT_SECTION. */
5232 have_global_bss_p (void)
5234 return bss_noswitch_section || targetm.have_switchable_bss_sections;
5237 /* Output assembly to switch to section NAME with attribute FLAGS.
5238 Four variants for common object file formats. */
5241 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
5242 unsigned int flags ATTRIBUTE_UNUSED,
5243 tree decl ATTRIBUTE_UNUSED)
5245 /* Some object formats don't support named sections at all. The
5246 front-end should already have flagged this as an error. */
5251 default_elf_asm_named_section (const char *name, unsigned int flags,
5252 tree decl ATTRIBUTE_UNUSED)
5254 char flagchars[10], *f = flagchars;
5256 /* If we have already declared this section, we can use an
5257 abbreviated form to switch back to it -- unless this section is
5258 part of a COMDAT groups, in which case GAS requires the full
5259 declaration every time. */
5260 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5261 && (flags & SECTION_DECLARED))
5263 fprintf (asm_out_file, "\t.section\t%s\n", name);
5267 if (!(flags & SECTION_DEBUG))
5269 if (flags & SECTION_WRITE)
5271 if (flags & SECTION_CODE)
5273 if (flags & SECTION_SMALL)
5275 if (flags & SECTION_MERGE)
5277 if (flags & SECTION_STRINGS)
5279 if (flags & SECTION_TLS)
5281 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5285 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
5287 if (!(flags & SECTION_NOTYPE))
5292 if (flags & SECTION_BSS)
5298 #ifdef ASM_COMMENT_START
5299 /* On platforms that use "@" as the assembly comment character,
5301 if (strcmp (ASM_COMMENT_START, "@") == 0)
5304 fprintf (asm_out_file, format, type);
5306 if (flags & SECTION_ENTSIZE)
5307 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
5308 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5309 fprintf (asm_out_file, ",%s,comdat",
5310 lang_hooks.decls.comdat_group (decl));
5313 putc ('\n', asm_out_file);
5317 default_coff_asm_named_section (const char *name, unsigned int flags,
5318 tree decl ATTRIBUTE_UNUSED)
5320 char flagchars[8], *f = flagchars;
5322 if (flags & SECTION_WRITE)
5324 if (flags & SECTION_CODE)
5328 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5332 default_pe_asm_named_section (const char *name, unsigned int flags,
5335 default_coff_asm_named_section (name, flags, decl);
5337 if (flags & SECTION_LINKONCE)
5339 /* Functions may have been compiled at various levels of
5340 optimization so we can't use `same_size' here.
5341 Instead, have the linker pick one. */
5342 fprintf (asm_out_file, "\t.linkonce %s\n",
5343 (flags & SECTION_CODE ? "discard" : "same_size"));
5347 /* The lame default section selector. */
5350 default_select_section (tree decl, int reloc,
5351 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5355 if (decl_readonly_section (decl, reloc))
5356 return readonly_data_section;
5358 else if (TREE_CODE (decl) == CONSTRUCTOR)
5360 if (! ((flag_pic && reloc)
5361 || !TREE_READONLY (decl)
5362 || TREE_SIDE_EFFECTS (decl)
5363 || !TREE_CONSTANT (decl)))
5364 return readonly_data_section;
5366 else if (TREE_CODE (decl) == STRING_CST)
5367 return readonly_data_section;
5368 else if (! (flag_pic && reloc))
5369 return readonly_data_section;
5371 return data_section;
5374 enum section_category
5375 categorize_decl_for_section (tree decl, int reloc, int shlib)
5377 enum section_category ret;
5379 if (TREE_CODE (decl) == FUNCTION_DECL)
5381 else if (TREE_CODE (decl) == STRING_CST)
5383 if (flag_mudflap) /* or !flag_merge_constants */
5384 return SECCAT_RODATA;
5386 return SECCAT_RODATA_MERGE_STR;
5388 else if (TREE_CODE (decl) == VAR_DECL)
5390 if (bss_initializer_p (decl))
5392 else if (! TREE_READONLY (decl)
5393 || TREE_SIDE_EFFECTS (decl)
5394 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5396 if (shlib && (reloc & 2))
5397 ret = SECCAT_DATA_REL;
5398 else if (shlib && reloc)
5399 ret = SECCAT_DATA_REL_LOCAL;
5403 else if (shlib && (reloc & 2))
5404 ret = SECCAT_DATA_REL_RO;
5405 else if (shlib && reloc)
5406 ret = SECCAT_DATA_REL_RO_LOCAL;
5407 else if (reloc || flag_merge_constants < 2)
5408 /* C and C++ don't allow different variables to share the same
5409 location. -fmerge-all-constants allows even that (at the
5410 expense of not conforming). */
5411 ret = SECCAT_RODATA;
5412 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5413 ret = SECCAT_RODATA_MERGE_STR_INIT;
5415 ret = SECCAT_RODATA_MERGE_CONST;
5417 else if (TREE_CODE (decl) == CONSTRUCTOR)
5419 if ((shlib && reloc)
5420 || TREE_SIDE_EFFECTS (decl)
5421 || ! TREE_CONSTANT (decl))
5424 ret = SECCAT_RODATA;
5427 ret = SECCAT_RODATA;
5429 /* There are no read-only thread-local sections. */
5430 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5432 /* Note that this would be *just* SECCAT_BSS, except that there's
5433 no concept of a read-only thread-local-data section. */
5434 if (ret == SECCAT_BSS
5435 || (flag_zero_initialized_in_bss
5436 && initializer_zerop (DECL_INITIAL (decl))))
5442 /* If the target uses small data sections, select it. */
5443 else if (targetm.in_small_data_p (decl))
5445 if (ret == SECCAT_BSS)
5447 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5448 ret = SECCAT_SRODATA;
5457 decl_readonly_section (tree decl, int reloc)
5459 return decl_readonly_section_1 (decl, reloc, flag_pic);
5463 decl_readonly_section_1 (tree decl, int reloc, int shlib)
5465 switch (categorize_decl_for_section (decl, reloc, shlib))
5468 case SECCAT_RODATA_MERGE_STR:
5469 case SECCAT_RODATA_MERGE_STR_INIT:
5470 case SECCAT_RODATA_MERGE_CONST:
5471 case SECCAT_SRODATA:
5480 /* Select a section based on the above categorization. */
5483 default_elf_select_section (tree decl, int reloc,
5484 unsigned HOST_WIDE_INT align)
5486 return default_elf_select_section_1 (decl, reloc, align, flag_pic);
5490 default_elf_select_section_1 (tree decl, int reloc,
5491 unsigned HOST_WIDE_INT align, int shlib)
5494 switch (categorize_decl_for_section (decl, reloc, shlib))
5497 /* We're not supposed to be called on FUNCTION_DECLs. */
5500 return readonly_data_section;
5501 case SECCAT_RODATA_MERGE_STR:
5502 return mergeable_string_section (decl, align, 0);
5503 case SECCAT_RODATA_MERGE_STR_INIT:
5504 return mergeable_string_section (DECL_INITIAL (decl), align, 0);
5505 case SECCAT_RODATA_MERGE_CONST:
5506 return mergeable_constant_section (DECL_MODE (decl), align, 0);
5507 case SECCAT_SRODATA:
5511 return data_section;
5512 case SECCAT_DATA_REL:
5513 sname = ".data.rel";
5515 case SECCAT_DATA_REL_LOCAL:
5516 sname = ".data.rel.local";
5518 case SECCAT_DATA_REL_RO:
5519 sname = ".data.rel.ro";
5521 case SECCAT_DATA_REL_RO_LOCAL:
5522 sname = ".data.rel.ro.local";
5547 return get_named_section (decl, sname, reloc);
5550 /* Construct a unique section name based on the decl name and the
5551 categorization performed above. */
5554 default_unique_section (tree decl, int reloc)
5556 default_unique_section_1 (decl, reloc, flag_pic);
5560 default_unique_section_1 (tree decl, int reloc, int shlib)
5562 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
5563 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
5564 const char *prefix, *name;
5568 switch (categorize_decl_for_section (decl, reloc, shlib))
5571 prefix = one_only ? ".gnu.linkonce.t." : ".text.";
5574 case SECCAT_RODATA_MERGE_STR:
5575 case SECCAT_RODATA_MERGE_STR_INIT:
5576 case SECCAT_RODATA_MERGE_CONST:
5577 prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
5579 case SECCAT_SRODATA:
5580 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
5583 prefix = one_only ? ".gnu.linkonce.d." : ".data.";
5585 case SECCAT_DATA_REL:
5586 prefix = one_only ? ".gnu.linkonce.d.rel." : ".data.rel.";
5588 case SECCAT_DATA_REL_LOCAL:
5589 prefix = one_only ? ".gnu.linkonce.d.rel.local." : ".data.rel.local.";
5591 case SECCAT_DATA_REL_RO:
5592 prefix = one_only ? ".gnu.linkonce.d.rel.ro." : ".data.rel.ro.";
5594 case SECCAT_DATA_REL_RO_LOCAL:
5595 prefix = one_only ? ".gnu.linkonce.d.rel.ro.local."
5596 : ".data.rel.ro.local.";
5599 prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
5602 prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
5605 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
5608 prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
5611 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
5616 plen = strlen (prefix);
5618 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5619 name = targetm.strip_name_encoding (name);
5620 nlen = strlen (name);
5622 string = alloca (nlen + plen + 1);
5623 memcpy (string, prefix, plen);
5624 memcpy (string + plen, name, nlen + 1);
5626 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5630 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5632 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5635 switch (GET_CODE (x))
5640 return data_section;
5646 return readonly_data_section;
5650 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5651 unsigned HOST_WIDE_INT align)
5653 /* ??? Handle small data here somehow. */
5656 switch (GET_CODE (x))
5660 return get_named_section (NULL, ".data.rel.ro", 3);
5663 return get_named_section (NULL, ".data.rel.ro.local", 1);
5669 return mergeable_constant_section (mode, align, 0);
5672 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5675 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5680 /* Careful not to prod global register variables. */
5683 symbol = XEXP (rtl, 0);
5684 if (GET_CODE (symbol) != SYMBOL_REF)
5687 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO;
5688 if (TREE_CODE (decl) == FUNCTION_DECL)
5689 flags |= SYMBOL_FLAG_FUNCTION;
5690 if (targetm.binds_local_p (decl))
5691 flags |= SYMBOL_FLAG_LOCAL;
5692 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5693 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
5694 else if (targetm.in_small_data_p (decl))
5695 flags |= SYMBOL_FLAG_SMALL;
5696 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5697 being PUBLIC, the thing *must* be defined in this translation unit.
5698 Prevent this buglet from being propagated into rtl code as well. */
5699 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5700 flags |= SYMBOL_FLAG_EXTERNAL;
5702 SYMBOL_REF_FLAGS (symbol) = flags;
5705 /* By default, we do nothing for encode_section_info, so we need not
5706 do anything but discard the '*' marker. */
5709 default_strip_name_encoding (const char *str)
5711 return str + (*str == '*');
5714 #ifdef ASM_OUTPUT_DEF
5715 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
5716 anchor relative to ".", the current section position. */
5719 default_asm_output_anchor (rtx symbol)
5723 sprintf (buffer, ". + " HOST_WIDE_INT_PRINT_DEC,
5724 SYMBOL_REF_BLOCK_OFFSET (symbol));
5725 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer);
5729 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
5732 default_use_anchors_for_symbol_p (rtx symbol)
5737 /* Don't use anchors for mergeable sections. The linker might move
5738 the objects around. */
5739 sect = SYMBOL_REF_BLOCK (symbol)->sect;
5740 if (sect->common.flags & SECTION_MERGE)
5743 /* Don't use anchors for small data sections. The small data register
5744 acts as an anchor for such sections. */
5745 if (sect->common.flags & SECTION_SMALL)
5748 decl = SYMBOL_REF_DECL (symbol);
5749 if (decl && DECL_P (decl))
5751 /* Don't use section anchors for decls that might be defined by
5753 if (!targetm.binds_local_p (decl))
5756 /* Don't use section anchors for decls that will be placed in a
5757 small data section. */
5758 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
5759 one above. The problem is that we only use SECTION_SMALL for
5760 sections that should be marked as small in the section directive. */
5761 if (targetm.in_small_data_p (decl))
5767 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5768 wrt cross-module name binding. */
5771 default_binds_local_p (tree exp)
5773 return default_binds_local_p_1 (exp, flag_shlib);
5777 default_binds_local_p_1 (tree exp, int shlib)
5781 /* A non-decl is an entry in the constant pool. */
5784 /* Weakrefs may not bind locally, even though the weakref itself is
5785 always static and therefore local. */
5786 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
5788 /* Static variables are always local. */
5789 else if (! TREE_PUBLIC (exp))
5791 /* A variable is local if the user has said explicitly that it will
5793 else if (DECL_VISIBILITY_SPECIFIED (exp)
5794 && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5796 /* Variables defined outside this object might not be local. */
5797 else if (DECL_EXTERNAL (exp))
5799 /* If defined in this object and visibility is not default, must be
5801 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5803 /* Default visibility weak data can be overridden by a strong symbol
5804 in another module and so are not local. */
5805 else if (DECL_WEAK (exp))
5807 /* If PIC, then assume that any global name can be overridden by
5808 symbols resolved from other modules. */
5811 /* Uninitialized COMMON variable may be unified with symbols
5812 resolved from other modules. */
5813 else if (DECL_COMMON (exp)
5814 && (DECL_INITIAL (exp) == NULL
5815 || DECL_INITIAL (exp) == error_mark_node))
5817 /* Otherwise we're left with initialized (or non-common) global data
5818 which is of necessity defined locally. */
5825 /* Determine whether or not a pointer mode is valid. Assume defaults
5826 of ptr_mode or Pmode - can be overridden. */
5828 default_valid_pointer_mode (enum machine_mode mode)
5830 return (mode == ptr_mode || mode == Pmode);
5833 /* Default function to output code that will globalize a label. A
5834 target must define GLOBAL_ASM_OP or provide its own function to
5835 globalize a label. */
5836 #ifdef GLOBAL_ASM_OP
5838 default_globalize_label (FILE * stream, const char *name)
5840 fputs (GLOBAL_ASM_OP, stream);
5841 assemble_name (stream, name);
5842 putc ('\n', stream);
5844 #endif /* GLOBAL_ASM_OP */
5846 /* Default function to output a label for unwind information. The
5847 default is to do nothing. A target that needs nonlocal labels for
5848 unwind information must provide its own function to do this. */
5850 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5851 tree decl ATTRIBUTE_UNUSED,
5852 int for_eh ATTRIBUTE_UNUSED,
5853 int empty ATTRIBUTE_UNUSED)
5857 /* Default function to output a label to divide up the exception table.
5858 The default is to do nothing. A target that needs/wants to divide
5859 up the table must provide it's own function to do this. */
5861 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED)
5865 /* This is how to output an internal numbered label where PREFIX is
5866 the class of label and LABELNO is the number within the class. */
5869 default_internal_label (FILE *stream, const char *prefix,
5870 unsigned long labelno)
5872 char *const buf = alloca (40 + strlen (prefix));
5873 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5874 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
5877 /* This is the default behavior at the beginning of a file. It's
5878 controlled by two other target-hook toggles. */
5880 default_file_start (void)
5882 if (targetm.file_start_app_off && !flag_verbose_asm)
5883 fputs (ASM_APP_OFF, asm_out_file);
5885 if (targetm.file_start_file_directive)
5886 output_file_directive (asm_out_file, main_input_filename);
5889 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5890 which emits a special section directive used to indicate whether or
5891 not this object file needs an executable stack. This is primarily
5892 a GNU extension to ELF but could be used on other targets. */
5894 int trampolines_created;
5897 file_end_indicate_exec_stack (void)
5899 unsigned int flags = SECTION_DEBUG;
5900 if (trampolines_created)
5901 flags |= SECTION_CODE;
5903 switch_to_section (get_section (".note.GNU-stack", flags, NULL));
5906 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
5907 a get_unnamed_section callback. */
5910 output_section_asm_op (const void *directive)
5912 fprintf (asm_out_file, "%s\n", (const char *) directive);
5915 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
5916 the current section is NEW_SECTION. */
5919 switch_to_section (section *new_section)
5921 if (in_section == new_section)
5924 if (new_section->common.flags & SECTION_FORGET)
5927 in_section = new_section;
5929 switch (SECTION_STYLE (new_section))
5933 && !cfun->unlikely_text_section_name
5934 && strcmp (new_section->named.name,
5935 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5936 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
5938 targetm.asm_out.named_section (new_section->named.name,
5939 new_section->named.common.flags,
5940 new_section->named.decl);
5943 case SECTION_UNNAMED:
5944 new_section->unnamed.callback (new_section->unnamed.data);
5947 case SECTION_NOSWITCH:
5952 new_section->common.flags |= SECTION_DECLARED;
5955 /* If block symbol SYMBOL has not yet been assigned an offset, place
5956 it at the end of its block. */
5959 place_block_symbol (rtx symbol)
5961 unsigned HOST_WIDE_INT size, mask, offset;
5962 struct constant_descriptor_rtx *desc;
5963 unsigned int alignment;
5964 struct object_block *block;
5967 gcc_assert (SYMBOL_REF_BLOCK (symbol));
5968 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0)
5971 /* Work out the symbol's size and alignment. */
5972 if (CONSTANT_POOL_ADDRESS_P (symbol))
5974 desc = SYMBOL_REF_CONSTANT (symbol);
5975 alignment = desc->align;
5976 size = GET_MODE_SIZE (desc->mode);
5978 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
5980 decl = SYMBOL_REF_DECL (symbol);
5981 alignment = get_constant_alignment (decl);
5982 size = get_constant_size (decl);
5986 decl = SYMBOL_REF_DECL (symbol);
5987 alignment = DECL_ALIGN (decl);
5988 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
5991 /* Calculate the object's offset from the start of the block. */
5992 block = SYMBOL_REF_BLOCK (symbol);
5993 mask = alignment / BITS_PER_UNIT - 1;
5994 offset = (block->size + mask) & ~mask;
5995 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
5997 /* Record the block's new alignment and size. */
5998 block->alignment = MAX (block->alignment, alignment);
5999 block->size = offset + size;
6001 VEC_safe_push (rtx, gc, block->objects, symbol);
6004 /* Return the anchor that should be used to address byte offset OFFSET
6005 from the first object in BLOCK. MODEL is the TLS model used
6009 get_section_anchor (struct object_block *block, HOST_WIDE_INT offset,
6010 enum tls_model model)
6013 unsigned int begin, middle, end;
6014 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta;
6017 /* Work out the anchor's offset. Use an offset of 0 for the first
6018 anchor so that we don't pessimize the case where we take the address
6019 of a variable at the beginning of the block. This is particularly
6020 useful when a block has only one variable assigned to it.
6022 We try to place anchors RANGE bytes apart, so there can then be
6023 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
6024 a ptr_mode offset. With some target settings, the lowest such
6025 anchor might be out of range for the lowest ptr_mode offset;
6026 likewise the highest anchor for the highest offset. Use anchors
6027 at the extreme ends of the ptr_mode range in such cases.
6029 All arithmetic uses unsigned integers in order to avoid
6031 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset;
6032 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset;
6033 range = max_offset - min_offset + 1;
6038 bias = 1 << (GET_MODE_BITSIZE (ptr_mode) - 1);
6041 delta = -(unsigned HOST_WIDE_INT) offset + max_offset;
6042 delta -= delta % range;
6045 offset = (HOST_WIDE_INT) (-delta);
6049 delta = (unsigned HOST_WIDE_INT) offset - min_offset;
6050 delta -= delta % range;
6051 if (delta > bias - 1)
6053 offset = (HOST_WIDE_INT) delta;
6057 /* Do a binary search to see if there's already an anchor we can use.
6058 Set BEGIN to the new anchor's index if not. */
6060 end = VEC_length (rtx, block->anchors);
6061 while (begin != end)
6063 middle = (end + begin) / 2;
6064 anchor = VEC_index (rtx, block->anchors, middle);
6065 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset)
6067 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset)
6069 else if (SYMBOL_REF_TLS_MODEL (anchor) > model)
6071 else if (SYMBOL_REF_TLS_MODEL (anchor) < model)
6077 /* Create a new anchor with a unique label. */
6078 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++);
6079 anchor = create_block_symbol (ggc_strdup (label), block, offset);
6080 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR;
6081 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT;
6083 /* Insert it at index BEGIN. */
6084 VEC_safe_insert (rtx, gc, block->anchors, begin, anchor);
6088 /* Output the objects in BLOCK. */
6091 output_object_block (struct object_block *block)
6093 struct constant_descriptor_rtx *desc;
6095 HOST_WIDE_INT offset;
6099 if (block->objects == NULL)
6102 /* Switch to the section and make sure that the first byte is
6103 suitably aligned. */
6104 switch_to_section (block->sect);
6105 assemble_align (block->alignment);
6107 /* Define the values of all anchors relative to the current section
6109 for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++)
6110 targetm.asm_out.output_anchor (symbol);
6112 /* Output the objects themselves. */
6114 for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++)
6116 /* Move to the object's offset, padding with zeros if necessary. */
6117 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset);
6118 offset = SYMBOL_REF_BLOCK_OFFSET (symbol);
6119 if (CONSTANT_POOL_ADDRESS_P (symbol))
6121 desc = SYMBOL_REF_CONSTANT (symbol);
6122 output_constant_pool_1 (desc, 1);
6123 offset += GET_MODE_SIZE (desc->mode);
6125 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6127 decl = SYMBOL_REF_DECL (symbol);
6128 assemble_constant_contents (decl, XSTR (symbol, 0),
6129 get_constant_alignment (decl));
6130 offset += get_constant_size (decl);
6134 decl = SYMBOL_REF_DECL (symbol);
6135 assemble_variable_contents (decl, XSTR (symbol, 0), false);
6136 offset += tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6141 /* A htab_traverse callback used to call output_object_block for
6142 each member of object_block_htab. */
6145 output_object_block_htab (void **slot, void *data ATTRIBUTE_UNUSED)
6147 output_object_block ((struct object_block *) (*slot));
6151 /* Output the definitions of all object_blocks. */
6154 output_object_blocks (void)
6156 htab_traverse (object_block_htab, output_object_block_htab, NULL);
6159 #include "gt-varasm.h"