1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 /* This file handles generation of all the assembler code
22 *except* the instructions of a function.
23 This includes declarations of variables and their initial values.
25 We also output the assembler code for constants stored in memory
26 and are responsible for combining constants with the same value. */
30 #include "coretypes.h"
34 #include "stor-layout.h"
35 #include "stringpool.h"
40 #include "hard-reg-set.h"
43 #include "diagnostic-core.h"
46 #include "langhooks.h"
50 #include "common/common-target.h"
51 #include "targhooks.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 #define n_deferred_constants (crtl->varasm.deferred_constants)
75 /* Number for making the label on the next
76 constant that is stored in memory. */
78 static GTY(()) int const_labelno
;
80 /* Carry information from ASM_DECLARE_OBJECT_NAME
81 to ASM_FINISH_DECLARE_OBJECT. */
83 int size_directive_output
;
85 /* The last decl for which assemble_variable was called,
86 if it did ASM_DECLARE_OBJECT_NAME.
87 If the last call to assemble_variable didn't do that,
90 tree last_assemble_variable_decl
;
92 /* The following global variable indicates if the first basic block
93 in a function belongs to the cold partition or not. */
95 bool first_function_block_is_cold
;
97 /* We give all constants their own alias set. Perhaps redundant with
98 MEM_READONLY_P, but pre-dates it. */
100 static alias_set_type const_alias_set
;
102 /* Whether we saw any functions with no_split_stack. */
104 static bool saw_no_split_stack
;
106 static const char *strip_reg_name (const char *);
107 static int contains_pointers_p (tree
);
108 #ifdef ASM_OUTPUT_EXTERNAL
109 static bool incorporeal_function_p (tree
);
111 static void decode_addr_const (tree
, struct addr_const
*);
112 static hashval_t
const_desc_hash (const void *);
113 static int const_desc_eq (const void *, const void *);
114 static hashval_t
const_hash_1 (const tree
);
115 static int compare_constant (const tree
, const tree
);
116 static void output_constant_def_contents (rtx
);
117 static void output_addressed_constants (tree
);
118 static unsigned HOST_WIDE_INT
output_constant (tree
, unsigned HOST_WIDE_INT
,
120 static void globalize_decl (tree
);
121 static bool decl_readonly_section_1 (enum section_category
);
122 #ifdef BSS_SECTION_ASM_OP
123 #ifdef ASM_OUTPUT_ALIGNED_BSS
124 static void asm_output_aligned_bss (FILE *, tree
, const char *,
125 unsigned HOST_WIDE_INT
, int)
128 #endif /* BSS_SECTION_ASM_OP */
129 static void mark_weak (tree
);
130 static void output_constant_pool (const char *, tree
);
132 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
133 section
*text_section
;
134 section
*data_section
;
135 section
*readonly_data_section
;
136 section
*sdata_section
;
137 section
*ctors_section
;
138 section
*dtors_section
;
139 section
*bss_section
;
140 section
*sbss_section
;
142 /* Various forms of common section. All are guaranteed to be nonnull. */
143 section
*tls_comm_section
;
144 section
*comm_section
;
145 section
*lcomm_section
;
147 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
149 section
*bss_noswitch_section
;
151 /* The section that holds the main exception table, when known. The section
152 is set either by the target's init_sections hook or by the first call to
153 switch_to_exception_section. */
154 section
*exception_section
;
156 /* The section that holds the DWARF2 frame unwind information, when known.
157 The section is set either by the target's init_sections hook or by the
158 first call to switch_to_eh_frame_section. */
159 section
*eh_frame_section
;
161 /* asm_out_file's current section. This is NULL if no section has yet
162 been selected or if we lose track of what the current section is. */
165 /* True if code for the current function is currently being directed
166 at the cold section. */
167 bool in_cold_section_p
;
169 /* A linked list of all the unnamed sections. */
170 static GTY(()) section
*unnamed_sections
;
172 /* Return a nonzero value if DECL has a section attribute. */
173 #define IN_NAMED_SECTION(DECL) \
174 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
175 && DECL_SECTION_NAME (DECL) != NULL)
177 /* Hash table of named sections. */
178 static GTY((param_is (section
))) htab_t section_htab
;
180 /* A table of object_blocks, indexed by section. */
181 static GTY((param_is (struct object_block
))) htab_t object_block_htab
;
183 /* The next number to use for internal anchor labels. */
184 static GTY(()) int anchor_labelno
;
186 /* A pool of constants that can be shared between functions. */
187 static GTY(()) struct rtx_constant_pool
*shared_constant_pool
;
189 /* Helper routines for maintaining section_htab. */
192 section_entry_eq (const void *p1
, const void *p2
)
194 const section
*old
= (const section
*) p1
;
195 const char *new_name
= (const char *) p2
;
197 return strcmp (old
->named
.name
, new_name
) == 0;
201 section_entry_hash (const void *p
)
203 const section
*old
= (const section
*) p
;
204 return htab_hash_string (old
->named
.name
);
207 /* Return a hash value for section SECT. */
210 hash_section (section
*sect
)
212 if (sect
->common
.flags
& SECTION_NAMED
)
213 return htab_hash_string (sect
->named
.name
);
214 return sect
->common
.flags
;
217 /* Helper routines for maintaining object_block_htab. */
220 object_block_entry_eq (const void *p1
, const void *p2
)
222 const struct object_block
*old
= (const struct object_block
*) p1
;
223 const section
*new_section
= (const section
*) p2
;
225 return old
->sect
== new_section
;
229 object_block_entry_hash (const void *p
)
231 const struct object_block
*old
= (const struct object_block
*) p
;
232 return hash_section (old
->sect
);
235 /* Return a new unnamed section with the given fields. */
238 get_unnamed_section (unsigned int flags
, void (*callback
) (const void *),
243 sect
= ggc_alloc
<section
> ();
244 sect
->unnamed
.common
.flags
= flags
| SECTION_UNNAMED
;
245 sect
->unnamed
.callback
= callback
;
246 sect
->unnamed
.data
= data
;
247 sect
->unnamed
.next
= unnamed_sections
;
249 unnamed_sections
= sect
;
253 /* Return a SECTION_NOSWITCH section with the given fields. */
256 get_noswitch_section (unsigned int flags
, noswitch_section_callback callback
)
260 sect
= ggc_alloc
<section
> ();
261 sect
->noswitch
.common
.flags
= flags
| SECTION_NOSWITCH
;
262 sect
->noswitch
.callback
= callback
;
267 /* Return the named section structure associated with NAME. Create
268 a new section with the given fields if no such structure exists. */
271 get_section (const char *name
, unsigned int flags
, tree decl
)
273 section
*sect
, **slot
;
276 htab_find_slot_with_hash (section_htab
, name
,
277 htab_hash_string (name
), INSERT
);
278 flags
|= SECTION_NAMED
;
281 sect
= ggc_alloc
<section
> ();
282 sect
->named
.common
.flags
= flags
;
283 sect
->named
.name
= ggc_strdup (name
);
284 sect
->named
.decl
= decl
;
290 if ((sect
->common
.flags
& ~SECTION_DECLARED
) != flags
291 && ((sect
->common
.flags
| flags
) & SECTION_OVERRIDE
) == 0)
293 /* It is fine if one of the section flags is
294 SECTION_WRITE | SECTION_RELRO and the other has none of these
295 flags (i.e. read-only) in named sections and either the
296 section hasn't been declared yet or has been declared as writable.
297 In that case just make sure the resulting flags are
298 SECTION_WRITE | SECTION_RELRO, ie. writable only because of
300 if (((sect
->common
.flags
^ flags
) & (SECTION_WRITE
| SECTION_RELRO
))
301 == (SECTION_WRITE
| SECTION_RELRO
)
302 && (sect
->common
.flags
303 & ~(SECTION_DECLARED
| SECTION_WRITE
| SECTION_RELRO
))
304 == (flags
& ~(SECTION_WRITE
| SECTION_RELRO
))
305 && ((sect
->common
.flags
& SECTION_DECLARED
) == 0
306 || (sect
->common
.flags
& SECTION_WRITE
)))
308 sect
->common
.flags
|= (SECTION_WRITE
| SECTION_RELRO
);
311 /* Sanity check user variables for flag changes. */
312 if (sect
->named
.decl
!= NULL
313 && DECL_P (sect
->named
.decl
)
314 && decl
!= sect
->named
.decl
)
316 if (decl
!= NULL
&& DECL_P (decl
))
317 error ("%+D causes a section type conflict with %D",
318 decl
, sect
->named
.decl
);
320 error ("section type conflict with %D", sect
->named
.decl
);
321 inform (DECL_SOURCE_LOCATION (sect
->named
.decl
),
322 "%qD was declared here", sect
->named
.decl
);
324 else if (decl
!= NULL
&& DECL_P (decl
))
325 error ("%+D causes a section type conflict", decl
);
327 error ("section type conflict");
328 /* Make sure we don't error about one section multiple times. */
329 sect
->common
.flags
|= SECTION_OVERRIDE
;
335 /* Return true if the current compilation mode benefits from having
336 objects grouped into blocks. */
339 use_object_blocks_p (void)
341 return flag_section_anchors
;
344 /* Return the object_block structure for section SECT. Create a new
345 structure if we haven't created one already. Return null if SECT
348 static struct object_block
*
349 get_block_for_section (section
*sect
)
351 struct object_block
*block
;
357 slot
= htab_find_slot_with_hash (object_block_htab
, sect
,
358 hash_section (sect
), INSERT
);
359 block
= (struct object_block
*) *slot
;
362 block
= ggc_cleared_alloc
<object_block
> ();
369 /* Create a symbol with label LABEL and place it at byte offset
370 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
371 is not yet known. LABEL must be a garbage-collected string. */
374 create_block_symbol (const char *label
, struct object_block
*block
,
375 HOST_WIDE_INT offset
)
380 /* Create the extended SYMBOL_REF. */
381 size
= RTX_HDR_SIZE
+ sizeof (struct block_symbol
);
382 symbol
= (rtx
) ggc_internal_alloc (size
);
384 /* Initialize the normal SYMBOL_REF fields. */
385 memset (symbol
, 0, size
);
386 PUT_CODE (symbol
, SYMBOL_REF
);
387 PUT_MODE (symbol
, Pmode
);
388 XSTR (symbol
, 0) = label
;
389 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_HAS_BLOCK_INFO
;
391 /* Initialize the block_symbol stuff. */
392 SYMBOL_REF_BLOCK (symbol
) = block
;
393 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
398 /* Return a section with a particular name and with whatever SECTION_*
399 flags section_type_flags deems appropriate. The name of the section
400 is taken from NAME if nonnull, otherwise it is taken from DECL's
401 DECL_SECTION_NAME. DECL is the decl associated with the section
402 (see the section comment for details) and RELOC is as for
403 section_type_flags. */
406 get_named_section (tree decl
, const char *name
, int reloc
)
412 gcc_assert (decl
&& DECL_P (decl
) && DECL_SECTION_NAME (decl
));
413 name
= DECL_SECTION_NAME (decl
);
416 flags
= targetm
.section_type_flags (decl
, name
, reloc
);
417 return get_section (name
, flags
, decl
);
420 /* Worker for resolve_unique_section. */
423 set_implicit_section (struct symtab_node
*n
, void *data ATTRIBUTE_UNUSED
)
425 n
->implicit_section
= true;
429 /* If required, set DECL_SECTION_NAME to a unique name. */
432 resolve_unique_section (tree decl
, int reloc ATTRIBUTE_UNUSED
,
433 int flag_function_or_data_sections
)
435 if (DECL_SECTION_NAME (decl
) == NULL
436 && targetm_common
.have_named_sections
437 && (flag_function_or_data_sections
438 || DECL_COMDAT_GROUP (decl
)))
440 targetm
.asm_out
.unique_section (decl
, reloc
);
441 if (DECL_SECTION_NAME (decl
))
442 symtab_node::get (decl
)->call_for_symbol_and_aliases
443 (set_implicit_section
, NULL
, true);
447 #ifdef BSS_SECTION_ASM_OP
449 #ifdef ASM_OUTPUT_ALIGNED_BSS
451 /* Utility function for targets to use in implementing
452 ASM_OUTPUT_ALIGNED_BSS.
453 ??? It is believed that this function will work in most cases so such
454 support is localized here. */
457 asm_output_aligned_bss (FILE *file
, tree decl ATTRIBUTE_UNUSED
,
458 const char *name
, unsigned HOST_WIDE_INT size
,
461 switch_to_section (bss_section
);
462 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
463 #ifdef ASM_DECLARE_OBJECT_NAME
464 last_assemble_variable_decl
= decl
;
465 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
467 /* Standard thing is just output label for the object. */
468 ASM_OUTPUT_LABEL (file
, name
);
469 #endif /* ASM_DECLARE_OBJECT_NAME */
470 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
475 #endif /* BSS_SECTION_ASM_OP */
477 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
478 /* Return the hot section for function DECL. Return text_section for
482 hot_function_section (tree decl
)
484 if (decl
!= NULL_TREE
485 && DECL_SECTION_NAME (decl
) != NULL
486 && targetm_common
.have_named_sections
)
487 return get_named_section (decl
, NULL
, 0);
493 /* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL)
496 When DECL_SECTION_NAME is non-NULL and it is implicit section and
497 NAMED_SECTION_SUFFIX is non-NULL, then produce section called
498 concatenate the name with NAMED_SECTION_SUFFIX.
499 Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */
502 get_named_text_section (tree decl
,
503 const char *text_section_name
,
504 const char *named_section_suffix
)
506 if (decl
&& DECL_SECTION_NAME (decl
))
508 if (named_section_suffix
)
510 const char *dsn
= DECL_SECTION_NAME (decl
);
511 const char *stripped_name
;
514 name
= (char *) alloca (strlen (dsn
) + 1);
518 stripped_name
= targetm
.strip_name_encoding (name
);
520 buffer
= ACONCAT ((stripped_name
, named_section_suffix
, NULL
));
521 return get_named_section (decl
, buffer
, 0);
523 else if (symtab_node::get (decl
)->implicit_section
)
527 /* Do not try to split gnu_linkonce functions. This gets somewhat
529 if (DECL_COMDAT_GROUP (decl
) && !HAVE_COMDAT_GROUP
)
531 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
532 name
= targetm
.strip_name_encoding (name
);
533 return get_named_section (decl
, ACONCAT ((text_section_name
, ".",
539 return get_named_section (decl
, text_section_name
, 0);
542 /* Choose named function section based on its frequency. */
545 default_function_section (tree decl
, enum node_frequency freq
,
546 bool startup
, bool exit
)
548 #if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG
549 /* Old GNU linkers have buggy --gc-section support, which sometimes
550 results in .gcc_except_table* sections being garbage collected. */
552 && symtab_node::get (decl
)->implicit_section
)
556 if (!flag_reorder_functions
557 || !targetm_common
.have_named_sections
)
559 /* Startup code should go to startup subsection unless it is
560 unlikely executed (this happens especially with function splitting
561 where we can split away unnecessary parts of static constructors. */
562 if (startup
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
564 /* If we do have a profile or(and) LTO phase is executed, we do not need
565 these ELF section. */
566 if (!in_lto_p
|| !flag_profile_values
)
567 return get_named_text_section (decl
, ".text.startup", NULL
);
572 /* Similarly for exit. */
573 if (exit
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
574 return get_named_text_section (decl
, ".text.exit", NULL
);
576 /* Group cold functions together, similarly for hot code. */
579 case NODE_FREQUENCY_UNLIKELY_EXECUTED
:
580 return get_named_text_section (decl
, ".text.unlikely", NULL
);
581 case NODE_FREQUENCY_HOT
:
582 /* If we do have a profile or(and) LTO phase is executed, we do not need
583 these ELF section. */
584 if (!in_lto_p
|| !flag_profile_values
)
585 return get_named_text_section (decl
, ".text.hot", NULL
);
591 /* Return the section for function DECL.
593 If DECL is NULL_TREE, return the text section. We can be passed
594 NULL_TREE under some circumstances by dbxout.c at least.
596 If FORCE_COLD is true, return cold function section ignoring
597 the frequency info of cgraph_node. */
600 function_section_1 (tree decl
, bool force_cold
)
602 section
*section
= NULL
;
603 enum node_frequency freq
= NODE_FREQUENCY_NORMAL
;
604 bool startup
= false, exit
= false;
608 struct cgraph_node
*node
= cgraph_node::get (decl
);
612 freq
= node
->frequency
;
613 startup
= node
->only_called_at_startup
;
614 exit
= node
->only_called_at_exit
;
618 freq
= NODE_FREQUENCY_UNLIKELY_EXECUTED
;
620 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
621 if (decl
!= NULL_TREE
622 && DECL_SECTION_NAME (decl
) != NULL
)
624 if (targetm
.asm_out
.function_section
)
625 section
= targetm
.asm_out
.function_section (decl
, freq
,
629 return get_named_section (decl
, NULL
, 0);
632 return targetm
.asm_out
.select_section
633 (decl
, freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
,
636 if (targetm
.asm_out
.function_section
)
637 section
= targetm
.asm_out
.function_section (decl
, freq
, startup
, exit
);
640 return hot_function_section (decl
);
644 /* Return the section for function DECL.
646 If DECL is NULL_TREE, return the text section. We can be passed
647 NULL_TREE under some circumstances by dbxout.c at least. */
650 function_section (tree decl
)
652 /* Handle cases where function splitting code decides
653 to put function entry point into unlikely executed section
654 despite the fact that the function itself is not cold
655 (i.e. it is called rarely but contains a hot loop that is
656 better to live in hot subsection for the code locality). */
657 return function_section_1 (decl
,
658 first_function_block_is_cold
);
661 /* Return the section for the current function, take IN_COLD_SECTION_P
665 current_function_section (void)
667 return function_section_1 (current_function_decl
, in_cold_section_p
);
670 /* Tell assembler to switch to unlikely-to-be-executed text section. */
673 unlikely_text_section (void)
675 return function_section_1 (current_function_decl
, true);
678 /* When called within a function context, return true if the function
679 has been assigned a cold text section and if SECT is that section.
680 When called outside a function context, return true if SECT is the
681 default cold section. */
684 unlikely_text_section_p (section
*sect
)
686 return sect
== function_section_1 (current_function_decl
, true);
689 /* Return the read-only data section associated with function DECL. */
692 default_function_rodata_section (tree decl
)
694 if (decl
!= NULL_TREE
&& DECL_SECTION_NAME (decl
))
696 const char *name
= DECL_SECTION_NAME (decl
);
698 if (DECL_COMDAT_GROUP (decl
) && HAVE_COMDAT_GROUP
)
704 dot
= strchr (name
+ 1, '.');
707 len
= strlen (dot
) + 8;
708 rname
= (char *) alloca (len
);
710 strcpy (rname
, ".rodata");
712 return get_section (rname
, SECTION_LINKONCE
, decl
);
714 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
715 else if (DECL_COMDAT_GROUP (decl
)
716 && strncmp (name
, ".gnu.linkonce.t.", 16) == 0)
718 size_t len
= strlen (name
) + 1;
719 char *rname
= (char *) alloca (len
);
721 memcpy (rname
, name
, len
);
723 return get_section (rname
, SECTION_LINKONCE
, decl
);
725 /* For .text.foo we want to use .rodata.foo. */
726 else if (flag_function_sections
&& flag_data_sections
727 && strncmp (name
, ".text.", 6) == 0)
729 size_t len
= strlen (name
) + 1;
730 char *rname
= (char *) alloca (len
+ 2);
732 memcpy (rname
, ".rodata", 7);
733 memcpy (rname
+ 7, name
+ 5, len
- 5);
734 return get_section (rname
, 0, decl
);
738 return readonly_data_section
;
741 /* Return the read-only data section associated with function DECL
742 for targets where that section should be always the single
743 readonly data section. */
746 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED
)
748 return readonly_data_section
;
751 /* Return the section to use for string merging. */
754 mergeable_string_section (tree decl ATTRIBUTE_UNUSED
,
755 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
756 unsigned int flags ATTRIBUTE_UNUSED
)
760 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
761 && TREE_CODE (decl
) == STRING_CST
762 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
764 && (len
= int_size_in_bytes (TREE_TYPE (decl
))) > 0
765 && TREE_STRING_LENGTH (decl
) >= len
)
767 enum machine_mode mode
;
768 unsigned int modesize
;
772 const char *prefix
= targetm
.asm_out
.mergeable_rodata_prefix
;
773 char *name
= (char *) alloca (strlen (prefix
) + 30);
775 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
776 modesize
= GET_MODE_BITSIZE (mode
);
777 if (modesize
>= 8 && modesize
<= 256
778 && (modesize
& (modesize
- 1)) == 0)
780 if (align
< modesize
)
783 str
= TREE_STRING_POINTER (decl
);
784 unit
= GET_MODE_SIZE (mode
);
786 /* Check for embedded NUL characters. */
787 for (i
= 0; i
< len
; i
+= unit
)
789 for (j
= 0; j
< unit
; j
++)
790 if (str
[i
+ j
] != '\0')
797 sprintf (name
, "%s.str%d.%d", prefix
,
798 modesize
/ 8, (int) (align
/ 8));
799 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
800 return get_section (name
, flags
, NULL
);
805 return readonly_data_section
;
808 /* Return the section to use for constant merging. */
811 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED
,
812 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
813 unsigned int flags ATTRIBUTE_UNUSED
)
815 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
817 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
823 && (align
& (align
- 1)) == 0)
825 const char *prefix
= targetm
.asm_out
.mergeable_rodata_prefix
;
826 char *name
= (char *) alloca (strlen (prefix
) + 30);
828 sprintf (name
, "%s.cst%d", prefix
, (int) (align
/ 8));
829 flags
|= (align
/ 8) | SECTION_MERGE
;
830 return get_section (name
, flags
, NULL
);
832 return readonly_data_section
;
835 /* Given NAME, a putative register name, discard any customary prefixes. */
838 strip_reg_name (const char *name
)
840 #ifdef REGISTER_PREFIX
841 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
842 name
+= strlen (REGISTER_PREFIX
);
844 if (name
[0] == '%' || name
[0] == '#')
849 /* The user has asked for a DECL to have a particular name. Set (or
850 change) it in such a way that we don't prefix an underscore to
853 set_user_assembler_name (tree decl
, const char *name
)
855 char *starred
= (char *) alloca (strlen (name
) + 2);
857 strcpy (starred
+ 1, name
);
858 symtab
->change_decl_assembler_name (decl
, get_identifier (starred
));
859 SET_DECL_RTL (decl
, NULL_RTX
);
862 /* Decode an `asm' spec for a declaration as a register name.
863 Return the register number, or -1 if nothing specified,
864 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
865 or -3 if ASMSPEC is `cc' and is not recognized,
866 or -4 if ASMSPEC is `memory' and is not recognized.
867 Accept an exact spelling or a decimal number.
868 Prefixes such as % are optional. */
871 decode_reg_name_and_count (const char *asmspec
, int *pnregs
)
873 /* Presume just one register is clobbered. */
880 /* Get rid of confusing prefixes. */
881 asmspec
= strip_reg_name (asmspec
);
883 /* Allow a decimal number as a "register name". */
884 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
885 if (! ISDIGIT (asmspec
[i
]))
887 if (asmspec
[0] != 0 && i
< 0)
890 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
896 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
898 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
901 #ifdef OVERLAPPING_REGISTER_NAMES
905 const char *const name
;
908 } table
[] = OVERLAPPING_REGISTER_NAMES
;
910 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
912 && ! strcmp (asmspec
, table
[i
].name
))
914 *pnregs
= table
[i
].nregs
;
915 return table
[i
].number
;
918 #endif /* OVERLAPPING_REGISTER_NAMES */
920 #ifdef ADDITIONAL_REGISTER_NAMES
922 static const struct { const char *const name
; const int number
; } table
[]
923 = ADDITIONAL_REGISTER_NAMES
;
925 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
927 && ! strcmp (asmspec
, table
[i
].name
))
928 return table
[i
].number
;
930 #endif /* ADDITIONAL_REGISTER_NAMES */
932 if (!strcmp (asmspec
, "memory"))
935 if (!strcmp (asmspec
, "cc"))
945 decode_reg_name (const char *name
)
948 return decode_reg_name_and_count (name
, &count
);
952 /* Return true if DECL's initializer is suitable for a BSS section. */
955 bss_initializer_p (const_tree decl
)
957 return (DECL_INITIAL (decl
) == NULL
958 /* In LTO we have no errors in program; error_mark_node is used
959 to mark offlined constructors. */
960 || (DECL_INITIAL (decl
) == error_mark_node
962 || (flag_zero_initialized_in_bss
963 /* Leave constant zeroes in .rodata so they
965 && !TREE_READONLY (decl
)
966 && initializer_zerop (DECL_INITIAL (decl
))));
969 /* Compute the alignment of variable specified by DECL.
970 DONT_OUTPUT_DATA is from assemble_variable. */
973 align_variable (tree decl
, bool dont_output_data
)
975 unsigned int align
= DECL_ALIGN (decl
);
977 /* In the case for initialing an array whose length isn't specified,
978 where we have not yet been able to do the layout,
979 figure out the proper alignment now. */
980 if (dont_output_data
&& DECL_SIZE (decl
) == 0
981 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
982 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
984 /* Some object file formats have a maximum alignment which they support.
985 In particular, a.out format supports a maximum alignment of 4. */
986 if (align
> MAX_OFILE_ALIGNMENT
)
988 error ("alignment of %q+D is greater than maximum object "
989 "file alignment %d", decl
,
990 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
991 align
= MAX_OFILE_ALIGNMENT
;
994 if (! DECL_USER_ALIGN (decl
))
996 #ifdef DATA_ABI_ALIGNMENT
997 unsigned int data_abi_align
998 = DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
999 /* For backwards compatibility, don't assume the ABI alignment for
1001 if (! DECL_THREAD_LOCAL_P (decl
) || data_abi_align
<= BITS_PER_WORD
)
1002 align
= data_abi_align
;
1005 /* On some machines, it is good to increase alignment sometimes.
1006 But as DECL_ALIGN is used both for actually emitting the variable
1007 and for code accessing the variable as guaranteed alignment, we
1008 can only increase the alignment if it is a performance optimization
1009 if the references to it must bind to the current definition. */
1010 if (decl_binds_to_current_def_p (decl
)
1011 && !DECL_VIRTUAL_P (decl
))
1013 #ifdef DATA_ALIGNMENT
1014 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1015 /* Don't increase alignment too much for TLS variables - TLS space
1017 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
1020 #ifdef CONSTANT_ALIGNMENT
1021 if (DECL_INITIAL (decl
) != 0
1022 /* In LTO we have no errors in program; error_mark_node is used
1023 to mark offlined constructors. */
1024 && (in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
))
1026 unsigned int const_align
1027 = CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1028 /* Don't increase alignment too much for TLS variables - TLS
1029 space is too precious. */
1030 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1031 align
= const_align
;
1037 /* Reset the alignment in case we have made it tighter, so we can benefit
1038 from it in get_pointer_alignment. */
1039 DECL_ALIGN (decl
) = align
;
1042 /* Return DECL_ALIGN (decl), possibly increased for optimization purposes
1043 beyond what align_variable returned. */
1046 get_variable_align (tree decl
)
1048 unsigned int align
= DECL_ALIGN (decl
);
1050 /* For user aligned vars or static vars align_variable already did
1052 if (DECL_USER_ALIGN (decl
) || !TREE_PUBLIC (decl
))
1055 #ifdef DATA_ABI_ALIGNMENT
1056 if (DECL_THREAD_LOCAL_P (decl
))
1057 align
= DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
1060 /* For decls that bind to the current definition, align_variable
1061 did also everything, except for not assuming ABI required alignment
1062 of TLS variables. For other vars, increase the alignment here
1063 as an optimization. */
1064 if (!decl_binds_to_current_def_p (decl
))
1066 /* On some machines, it is good to increase alignment sometimes. */
1067 #ifdef DATA_ALIGNMENT
1068 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1069 /* Don't increase alignment too much for TLS variables - TLS space
1071 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
1074 #ifdef CONSTANT_ALIGNMENT
1075 if (DECL_INITIAL (decl
) != 0
1076 /* In LTO we have no errors in program; error_mark_node is used
1077 to mark offlined constructors. */
1078 && (in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
))
1080 unsigned int const_align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
),
1082 /* Don't increase alignment too much for TLS variables - TLS space
1084 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1085 align
= const_align
;
1093 /* Return the section into which the given VAR_DECL or CONST_DECL
1094 should be placed. PREFER_NOSWITCH_P is true if a noswitch
1095 section should be used wherever possible. */
1098 get_variable_section (tree decl
, bool prefer_noswitch_p
)
1100 addr_space_t as
= ADDR_SPACE_GENERIC
;
1102 varpool_node
*vnode
= varpool_node::get (decl
);
1105 vnode
= vnode
->ultimate_alias_target ();
1109 if (TREE_TYPE (decl
) != error_mark_node
)
1110 as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1112 /* We need the constructor to figure out reloc flag. */
1114 vnode
->get_constructor ();
1116 if (DECL_COMMON (decl
))
1118 /* If the decl has been given an explicit section name, or it resides
1119 in a non-generic address space, then it isn't common, and shouldn't
1120 be handled as such. */
1121 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
1122 && ADDR_SPACE_GENERIC_P (as
));
1123 if (DECL_THREAD_LOCAL_P (decl
))
1124 return tls_comm_section
;
1125 else if (TREE_PUBLIC (decl
) && bss_initializer_p (decl
))
1126 return comm_section
;
1129 if (DECL_INITIAL (decl
) == error_mark_node
)
1130 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1131 else if (DECL_INITIAL (decl
))
1132 reloc
= compute_reloc_for_constant (DECL_INITIAL (decl
));
1136 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1137 if (IN_NAMED_SECTION (decl
))
1138 return get_named_section (decl
, NULL
, reloc
);
1140 if (ADDR_SPACE_GENERIC_P (as
)
1141 && !DECL_THREAD_LOCAL_P (decl
)
1142 && !(prefer_noswitch_p
&& targetm
.have_switchable_bss_sections
)
1143 && bss_initializer_p (decl
))
1145 if (!TREE_PUBLIC (decl
)
1146 && !((flag_sanitize
& SANITIZE_ADDRESS
)
1147 && asan_protect_global (decl
)))
1148 return lcomm_section
;
1149 if (bss_noswitch_section
)
1150 return bss_noswitch_section
;
1153 return targetm
.asm_out
.select_section (decl
, reloc
,
1154 get_variable_align (decl
));
1157 /* Return the block into which object_block DECL should be placed. */
1159 static struct object_block
*
1160 get_block_for_decl (tree decl
)
1164 if (TREE_CODE (decl
) == VAR_DECL
)
1166 /* The object must be defined in this translation unit. */
1167 if (DECL_EXTERNAL (decl
))
1170 /* There's no point using object blocks for something that is
1171 isolated by definition. */
1172 if (DECL_COMDAT_GROUP (decl
))
1176 /* We can only calculate block offsets if the decl has a known
1178 if (DECL_SIZE_UNIT (decl
) == NULL
)
1180 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (decl
)))
1183 /* Find out which section should contain DECL. We cannot put it into
1184 an object block if it requires a standalone definition. */
1185 if (TREE_CODE (decl
) == VAR_DECL
)
1186 align_variable (decl
, 0);
1187 sect
= get_variable_section (decl
, true);
1188 if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
1191 return get_block_for_section (sect
);
1194 /* Make sure block symbol SYMBOL is in block BLOCK. */
1197 change_symbol_block (rtx symbol
, struct object_block
*block
)
1199 if (block
!= SYMBOL_REF_BLOCK (symbol
))
1201 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol
) < 0);
1202 SYMBOL_REF_BLOCK (symbol
) = block
;
1206 /* Return true if it is possible to put DECL in an object_block. */
1209 use_blocks_for_decl_p (tree decl
)
1211 struct symtab_node
*snode
;
1213 /* Only data DECLs can be placed into object blocks. */
1214 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != CONST_DECL
)
1217 /* Detect decls created by dw2_force_const_mem. Such decls are
1218 special because DECL_INITIAL doesn't specify the decl's true value.
1219 dw2_output_indirect_constants will instead call assemble_variable
1220 with dont_output_data set to 1 and then print the contents itself. */
1221 if (DECL_INITIAL (decl
) == decl
)
1224 /* If this decl is an alias, then we don't want to emit a
1226 if (TREE_CODE (decl
) == VAR_DECL
1227 && (snode
= symtab_node::get (decl
)) != NULL
1231 return targetm
.use_blocks_for_decl_p (decl
);
1234 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
1235 have static storage duration. In other words, it should not be an
1236 automatic variable, including PARM_DECLs.
1238 There is, however, one exception: this function handles variables
1239 explicitly placed in a particular register by the user.
1241 This is never called for PARM_DECL nodes. */
1244 make_decl_rtl (tree decl
)
1246 const char *name
= 0;
1250 /* Check that we are not being given an automatic variable. */
1251 gcc_assert (TREE_CODE (decl
) != PARM_DECL
1252 && TREE_CODE (decl
) != RESULT_DECL
);
1254 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1255 gcc_assert (TREE_CODE (decl
) != VAR_DECL
1256 || TREE_STATIC (decl
)
1257 || TREE_PUBLIC (decl
)
1258 || DECL_EXTERNAL (decl
)
1259 || DECL_REGISTER (decl
));
1261 /* And that we were not given a type or a label. */
1262 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
1263 && TREE_CODE (decl
) != LABEL_DECL
);
1265 /* For a duplicate declaration, we can be called twice on the
1266 same DECL node. Don't discard the RTL already made. */
1267 if (DECL_RTL_SET_P (decl
))
1269 /* If the old RTL had the wrong mode, fix the mode. */
1270 x
= DECL_RTL (decl
);
1271 if (GET_MODE (x
) != DECL_MODE (decl
))
1272 SET_DECL_RTL (decl
, adjust_address_nv (x
, DECL_MODE (decl
), 0));
1274 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1277 /* ??? Another way to do this would be to maintain a hashed
1278 table of such critters. Instead of adding stuff to a DECL
1279 to give certain attributes to it, we could use an external
1280 hash map from DECL to set of attributes. */
1282 /* Let the target reassign the RTL if it wants.
1283 This is necessary, for example, when one machine specific
1284 decl attribute overrides another. */
1285 targetm
.encode_section_info (decl
, DECL_RTL (decl
), false);
1287 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1288 on the new decl information. */
1290 && GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
1291 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x
, 0)))
1292 change_symbol_block (XEXP (x
, 0), get_block_for_decl (decl
));
1297 /* If this variable belongs to the global constant pool, retrieve the
1298 pre-computed RTL or recompute it in LTO mode. */
1299 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_IN_CONSTANT_POOL (decl
))
1301 SET_DECL_RTL (decl
, output_constant_def (DECL_INITIAL (decl
), 1));
1305 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1307 if (name
[0] != '*' && TREE_CODE (decl
) != FUNCTION_DECL
1308 && DECL_REGISTER (decl
))
1310 error ("register name not specified for %q+D", decl
);
1312 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1314 const char *asmspec
= name
+1;
1315 enum machine_mode mode
= DECL_MODE (decl
);
1316 reg_number
= decode_reg_name (asmspec
);
1317 /* First detect errors in declaring global registers. */
1318 if (reg_number
== -1)
1319 error ("register name not specified for %q+D", decl
);
1320 else if (reg_number
< 0)
1321 error ("invalid register name for %q+D", decl
);
1322 else if (mode
== BLKmode
)
1323 error ("data type of %q+D isn%'t suitable for a register",
1325 else if (!in_hard_reg_set_p (accessible_reg_set
, mode
, reg_number
))
1326 error ("the register specified for %q+D cannot be accessed"
1327 " by the current target", decl
);
1328 else if (!in_hard_reg_set_p (operand_reg_set
, mode
, reg_number
))
1329 error ("the register specified for %q+D is not general enough"
1330 " to be used as a register variable", decl
);
1331 else if (!HARD_REGNO_MODE_OK (reg_number
, mode
))
1332 error ("register specified for %q+D isn%'t suitable for data type",
1334 /* Now handle properly declared static register variables. */
1339 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
1341 DECL_INITIAL (decl
) = 0;
1342 error ("global register variable has initial value");
1344 if (TREE_THIS_VOLATILE (decl
))
1345 warning (OPT_Wvolatile_register_var
,
1346 "optimization may eliminate reads and/or "
1347 "writes to register variables");
1349 /* If the user specified one of the eliminables registers here,
1350 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1351 confused with that register and be eliminated. This usage is
1352 somewhat suspect... */
1354 SET_DECL_RTL (decl
, gen_rtx_raw_REG (mode
, reg_number
));
1355 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
1356 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
1358 if (TREE_STATIC (decl
))
1360 /* Make this register global, so not usable for anything
1362 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1363 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1364 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
1366 nregs
= hard_regno_nregs
[reg_number
][mode
];
1368 globalize_reg (decl
, reg_number
+ --nregs
);
1371 /* As a register variable, it has no section. */
1375 /* Now handle ordinary static variables and functions (in memory).
1376 Also handle vars declared register invalidly. */
1377 else if (name
[0] == '*')
1379 #ifdef REGISTER_PREFIX
1380 if (strlen (REGISTER_PREFIX
) != 0)
1382 reg_number
= decode_reg_name (name
);
1383 if (reg_number
>= 0 || reg_number
== -3)
1384 error ("register name given for non-register variable %q+D", decl
);
1389 /* Specifying a section attribute on a variable forces it into a
1390 non-.bss section, and thus it cannot be common. */
1391 /* FIXME: In general this code should not be necessary because
1392 visibility pass is doing the same work. But notice_global_symbol
1393 is called early and it needs to make DECL_RTL to get the name.
1394 we take care of recomputing the DECL_RTL after visibility is changed. */
1395 if (TREE_CODE (decl
) == VAR_DECL
1396 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
1397 && DECL_SECTION_NAME (decl
) != NULL
1398 && DECL_INITIAL (decl
) == NULL_TREE
1399 && DECL_COMMON (decl
))
1400 DECL_COMMON (decl
) = 0;
1402 /* Variables can't be both common and weak. */
1403 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_WEAK (decl
))
1404 DECL_COMMON (decl
) = 0;
1406 if (use_object_blocks_p () && use_blocks_for_decl_p (decl
))
1407 x
= create_block_symbol (name
, get_block_for_decl (decl
), -1);
1410 enum machine_mode address_mode
= Pmode
;
1411 if (TREE_TYPE (decl
) != error_mark_node
)
1413 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1414 address_mode
= targetm
.addr_space
.address_mode (as
);
1416 x
= gen_rtx_SYMBOL_REF (address_mode
, name
);
1418 SYMBOL_REF_WEAK (x
) = DECL_WEAK (decl
);
1419 SET_SYMBOL_REF_DECL (x
, decl
);
1421 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
1422 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1423 set_mem_attributes (x
, decl
, 1);
1424 SET_DECL_RTL (decl
, x
);
1426 /* Optionally set flags or add text to the name to record information
1427 such as that it is a function name.
1428 If the name is changed, the macro ASM_OUTPUT_LABELREF
1429 will have to know how to strip this information. */
1430 targetm
.encode_section_info (decl
, DECL_RTL (decl
), true);
1433 /* Like make_decl_rtl, but inhibit creation of new alias sets when
1434 calling make_decl_rtl. Also, reset DECL_RTL before returning the
1438 make_decl_rtl_for_debug (tree decl
)
1440 unsigned int save_aliasing_flag
;
1443 if (DECL_RTL_SET_P (decl
))
1444 return DECL_RTL (decl
);
1446 /* Kludge alert! Somewhere down the call chain, make_decl_rtl will
1447 call new_alias_set. If running with -fcompare-debug, sometimes
1448 we do not want to create alias sets that will throw the alias
1449 numbers off in the comparison dumps. So... clearing
1450 flag_strict_aliasing will keep new_alias_set() from creating a
1452 save_aliasing_flag
= flag_strict_aliasing
;
1453 flag_strict_aliasing
= 0;
1455 rtl
= DECL_RTL (decl
);
1456 /* Reset DECL_RTL back, as various parts of the compiler expects
1457 DECL_RTL set meaning it is actually going to be output. */
1458 SET_DECL_RTL (decl
, NULL
);
1460 flag_strict_aliasing
= save_aliasing_flag
;
1464 /* Output a string of literal assembler code
1465 for an `asm' keyword used between functions. */
1468 assemble_asm (tree string
)
1473 if (TREE_CODE (string
) == ADDR_EXPR
)
1474 string
= TREE_OPERAND (string
, 0);
1476 p
= TREE_STRING_POINTER (string
);
1477 fprintf (asm_out_file
, "%s%s\n", p
[0] == '\t' ? "" : "\t", p
);
1480 /* Write the address of the entity given by SYMBOL to SEC. */
1482 assemble_addr_to_section (rtx symbol
, section
*sec
)
1484 switch_to_section (sec
);
1485 assemble_align (POINTER_SIZE
);
1486 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1489 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1490 not) section for PRIORITY. */
1492 get_cdtor_priority_section (int priority
, bool constructor_p
)
1496 /* ??? This only works reliably with the GNU linker. */
1497 sprintf (buf
, "%s.%.5u",
1498 constructor_p
? ".ctors" : ".dtors",
1499 /* Invert the numbering so the linker puts us in the proper
1500 order; constructors are run from right to left, and the
1501 linker sorts in increasing order. */
1502 MAX_INIT_PRIORITY
- priority
);
1503 return get_section (buf
, SECTION_WRITE
, NULL
);
1507 default_named_section_asm_out_destructor (rtx symbol
, int priority
)
1511 if (priority
!= DEFAULT_INIT_PRIORITY
)
1512 sec
= get_cdtor_priority_section (priority
,
1513 /*constructor_p=*/false);
1515 sec
= get_section (".dtors", SECTION_WRITE
, NULL
);
1517 assemble_addr_to_section (symbol
, sec
);
1520 #ifdef DTORS_SECTION_ASM_OP
1522 default_dtor_section_asm_out_destructor (rtx symbol
,
1523 int priority ATTRIBUTE_UNUSED
)
1525 assemble_addr_to_section (symbol
, dtors_section
);
1530 default_named_section_asm_out_constructor (rtx symbol
, int priority
)
1534 if (priority
!= DEFAULT_INIT_PRIORITY
)
1535 sec
= get_cdtor_priority_section (priority
,
1536 /*constructor_p=*/true);
1538 sec
= get_section (".ctors", SECTION_WRITE
, NULL
);
1540 assemble_addr_to_section (symbol
, sec
);
1543 #ifdef CTORS_SECTION_ASM_OP
1545 default_ctor_section_asm_out_constructor (rtx symbol
,
1546 int priority ATTRIBUTE_UNUSED
)
1548 assemble_addr_to_section (symbol
, ctors_section
);
1552 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1553 a nonzero value if the constant pool should be output before the
1554 start of the function, or a zero value if the pool should output
1555 after the end of the function. The default is to put it before the
1558 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1559 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1562 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1563 to be output to assembler.
1564 Set first_global_object_name and weak_global_object_name as appropriate. */
1567 notice_global_symbol (tree decl
)
1569 const char **type
= &first_global_object_name
;
1571 if (first_global_object_name
1572 || !TREE_PUBLIC (decl
)
1573 || DECL_EXTERNAL (decl
)
1574 || !DECL_NAME (decl
)
1575 || (TREE_CODE (decl
) != FUNCTION_DECL
1576 && (TREE_CODE (decl
) != VAR_DECL
1577 || (DECL_COMMON (decl
)
1578 && (DECL_INITIAL (decl
) == 0
1579 || DECL_INITIAL (decl
) == error_mark_node
))))
1580 || !MEM_P (DECL_RTL (decl
)))
1583 /* We win when global object is found, but it is useful to know about weak
1584 symbol as well so we can produce nicer unique names. */
1585 if (DECL_WEAK (decl
) || DECL_ONE_ONLY (decl
) || flag_shlib
)
1586 type
= &weak_global_object_name
;
1592 rtx decl_rtl
= DECL_RTL (decl
);
1594 p
= targetm
.strip_name_encoding (XSTR (XEXP (decl_rtl
, 0), 0));
1595 name
= ggc_strdup (p
);
1601 /* If not using flag_reorder_blocks_and_partition, decide early whether the
1602 current function goes into the cold section, so that targets can use
1603 current_function_section during RTL expansion. DECL describes the
1607 decide_function_section (tree decl
)
1609 first_function_block_is_cold
= false;
1611 if (flag_reorder_blocks_and_partition
)
1612 /* We will decide in assemble_start_function. */
1615 if (DECL_SECTION_NAME (decl
))
1617 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1618 /* Calls to function_section rely on first_function_block_is_cold
1620 first_function_block_is_cold
= (node
1622 == NODE_FREQUENCY_UNLIKELY_EXECUTED
);
1625 in_cold_section_p
= first_function_block_is_cold
;
1628 /* Output assembler code for the constant pool of a function and associated
1629 with defining the name of the function. DECL describes the function.
1630 NAME is the function's name. For the constant pool, we use the current
1631 constant pool data. */
1634 assemble_start_function (tree decl
, const char *fnname
)
1637 char tmp_label
[100];
1638 bool hot_label_written
= false;
1640 if (flag_reorder_blocks_and_partition
)
1642 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTB", const_labelno
);
1643 crtl
->subsections
.hot_section_label
= ggc_strdup (tmp_label
);
1644 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDB", const_labelno
);
1645 crtl
->subsections
.cold_section_label
= ggc_strdup (tmp_label
);
1646 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTE", const_labelno
);
1647 crtl
->subsections
.hot_section_end_label
= ggc_strdup (tmp_label
);
1648 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDE", const_labelno
);
1649 crtl
->subsections
.cold_section_end_label
= ggc_strdup (tmp_label
);
1654 crtl
->subsections
.hot_section_label
= NULL
;
1655 crtl
->subsections
.cold_section_label
= NULL
;
1656 crtl
->subsections
.hot_section_end_label
= NULL
;
1657 crtl
->subsections
.cold_section_end_label
= NULL
;
1660 /* The following code does not need preprocessing in the assembler. */
1664 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1665 output_constant_pool (fnname
, decl
);
1667 /* Make sure the not and cold text (code) sections are properly
1668 aligned. This is necessary here in the case where the function
1669 has both hot and cold sections, because we don't want to re-set
1670 the alignment when the section switch happens mid-function. */
1672 if (flag_reorder_blocks_and_partition
)
1674 first_function_block_is_cold
= false;
1676 switch_to_section (unlikely_text_section ());
1677 assemble_align (DECL_ALIGN (decl
));
1678 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_label
);
1680 /* When the function starts with a cold section, we need to explicitly
1681 align the hot section and write out the hot section label.
1682 But if the current function is a thunk, we do not have a CFG. */
1684 && BB_PARTITION (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
) == BB_COLD_PARTITION
)
1686 switch_to_section (text_section
);
1687 assemble_align (DECL_ALIGN (decl
));
1688 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1689 hot_label_written
= true;
1690 first_function_block_is_cold
= true;
1692 in_cold_section_p
= first_function_block_is_cold
;
1696 /* Switch to the correct text section for the start of the function. */
1698 switch_to_section (function_section (decl
));
1699 if (flag_reorder_blocks_and_partition
1700 && !hot_label_written
)
1701 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1703 /* Tell assembler to move to target machine's alignment for functions. */
1704 align
= floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
);
1707 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1710 /* Handle a user-specified function alignment.
1711 Note that we still need to align to DECL_ALIGN, as above,
1712 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1713 if (! DECL_USER_ALIGN (decl
)
1714 && align_functions_log
> align
1715 && optimize_function_for_speed_p (cfun
))
1717 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1718 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1719 align_functions_log
, align_functions
- 1);
1721 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1725 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1726 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1729 if (!DECL_IGNORED_P (decl
))
1730 (*debug_hooks
->begin_function
) (decl
);
1732 /* Make function name accessible from other files, if appropriate. */
1734 if (TREE_PUBLIC (decl
))
1736 notice_global_symbol (decl
);
1738 globalize_decl (decl
);
1740 maybe_assemble_visibility (decl
);
1743 if (DECL_PRESERVE_P (decl
))
1744 targetm
.asm_out
.mark_decl_preserved (fnname
);
1746 /* Do any machine/system dependent processing of the function name. */
1747 #ifdef ASM_DECLARE_FUNCTION_NAME
1748 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1750 /* Standard thing is just output label for the function. */
1751 ASM_OUTPUT_FUNCTION_LABEL (asm_out_file
, fnname
, current_function_decl
);
1752 #endif /* ASM_DECLARE_FUNCTION_NAME */
1754 if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl
)))
1755 saw_no_split_stack
= true;
1758 /* Output assembler code associated with defining the size of the
1759 function. DECL describes the function. NAME is the function's name. */
1762 assemble_end_function (tree decl
, const char *fnname ATTRIBUTE_UNUSED
)
1764 #ifdef ASM_DECLARE_FUNCTION_SIZE
1765 /* We could have switched section in the middle of the function. */
1766 if (flag_reorder_blocks_and_partition
)
1767 switch_to_section (function_section (decl
));
1768 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1770 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1772 output_constant_pool (fnname
, decl
);
1773 switch_to_section (function_section (decl
)); /* need to switch back */
1775 /* Output labels for end of hot/cold text sections (to be used by
1777 if (flag_reorder_blocks_and_partition
)
1779 section
*save_text_section
;
1781 save_text_section
= in_section
;
1782 switch_to_section (unlikely_text_section ());
1783 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_end_label
);
1784 if (first_function_block_is_cold
)
1785 switch_to_section (text_section
);
1787 switch_to_section (function_section (decl
));
1788 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_end_label
);
1789 switch_to_section (save_text_section
);
1793 /* Assemble code to leave SIZE bytes of zeros. */
1796 assemble_zeros (unsigned HOST_WIDE_INT size
)
1798 /* Do no output if -fsyntax-only. */
1799 if (flag_syntax_only
)
1802 #ifdef ASM_NO_SKIP_IN_TEXT
1803 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1804 so we must output 0s explicitly in the text section. */
1805 if (ASM_NO_SKIP_IN_TEXT
&& (in_section
->common
.flags
& SECTION_CODE
) != 0)
1807 unsigned HOST_WIDE_INT i
;
1808 for (i
= 0; i
< size
; i
++)
1809 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1814 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1817 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1820 assemble_align (int align
)
1822 if (align
> BITS_PER_UNIT
)
1824 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1828 /* Assemble a string constant with the specified C string as contents. */
1831 assemble_string (const char *p
, int size
)
1836 /* If the string is very long, split it up. */
1840 int thissize
= size
- pos
;
1841 if (thissize
> maximum
)
1844 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1852 /* A noswitch_section_callback for lcomm_section. */
1855 emit_local (tree decl ATTRIBUTE_UNUSED
,
1856 const char *name ATTRIBUTE_UNUSED
,
1857 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1858 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1860 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1861 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, decl
, name
,
1862 size
, DECL_ALIGN (decl
));
1864 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1865 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, DECL_ALIGN (decl
));
1868 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1873 /* A noswitch_section_callback for bss_noswitch_section. */
1875 #if defined ASM_OUTPUT_ALIGNED_BSS
1877 emit_bss (tree decl ATTRIBUTE_UNUSED
,
1878 const char *name ATTRIBUTE_UNUSED
,
1879 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1880 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1882 #if defined ASM_OUTPUT_ALIGNED_BSS
1883 ASM_OUTPUT_ALIGNED_BSS (asm_out_file
, decl
, name
, size
,
1884 get_variable_align (decl
));
1890 /* A noswitch_section_callback for comm_section. */
1893 emit_common (tree decl ATTRIBUTE_UNUSED
,
1894 const char *name ATTRIBUTE_UNUSED
,
1895 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1896 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1898 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1899 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, decl
, name
,
1900 size
, get_variable_align (decl
));
1902 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1903 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, name
, size
,
1904 get_variable_align (decl
));
1907 ASM_OUTPUT_COMMON (asm_out_file
, name
, size
, rounded
);
1912 /* A noswitch_section_callback for tls_comm_section. */
1915 emit_tls_common (tree decl ATTRIBUTE_UNUSED
,
1916 const char *name ATTRIBUTE_UNUSED
,
1917 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1918 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1920 #ifdef ASM_OUTPUT_TLS_COMMON
1921 ASM_OUTPUT_TLS_COMMON (asm_out_file
, decl
, name
, size
);
1924 sorry ("thread-local COMMON data not implemented");
1929 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1930 NAME is the name of DECL's SYMBOL_REF. */
1933 assemble_noswitch_variable (tree decl
, const char *name
, section
*sect
,
1936 unsigned HOST_WIDE_INT size
, rounded
;
1938 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
1941 if ((flag_sanitize
& SANITIZE_ADDRESS
) && asan_protect_global (decl
))
1942 size
+= asan_red_zone_size (size
);
1944 /* Don't allocate zero bytes of common,
1945 since that means "undefined external" in the linker. */
1949 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1950 so that each uninitialized object starts on such a boundary. */
1951 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1952 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1953 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1955 if (!sect
->noswitch
.callback (decl
, name
, size
, rounded
)
1956 && (unsigned HOST_WIDE_INT
) (align
/ BITS_PER_UNIT
) > rounded
)
1957 error ("requested alignment for %q+D is greater than "
1958 "implemented alignment of %wu", decl
, rounded
);
1961 /* A subroutine of assemble_variable. Output the label and contents of
1962 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
1963 is as for assemble_variable. */
1966 assemble_variable_contents (tree decl
, const char *name
,
1967 bool dont_output_data
)
1969 /* Do any machine/system dependent processing of the object. */
1970 #ifdef ASM_DECLARE_OBJECT_NAME
1971 last_assemble_variable_decl
= decl
;
1972 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1974 /* Standard thing is just output label for the object. */
1975 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1976 #endif /* ASM_DECLARE_OBJECT_NAME */
1978 if (!dont_output_data
)
1980 /* Caller is supposed to use varpool_get_constructor when it wants
1981 to output the body. */
1982 gcc_assert (!in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
);
1983 if (DECL_INITIAL (decl
)
1984 && DECL_INITIAL (decl
) != error_mark_node
1985 && !initializer_zerop (DECL_INITIAL (decl
)))
1986 /* Output the actual data. */
1987 output_constant (DECL_INITIAL (decl
),
1988 tree_to_uhwi (DECL_SIZE_UNIT (decl
)),
1989 get_variable_align (decl
));
1991 /* Leave space for it. */
1992 assemble_zeros (tree_to_uhwi (DECL_SIZE_UNIT (decl
)));
1996 /* Assemble everything that is needed for a variable or function declaration.
1997 Not used for automatic variables, and not used for function definitions.
1998 Should not be called for variables of incomplete structure type.
2000 TOP_LEVEL is nonzero if this variable has file scope.
2001 AT_END is nonzero if this is the special handling, at end of compilation,
2002 to define things that have had only tentative definitions.
2003 DONT_OUTPUT_DATA if nonzero means don't actually output the
2004 initial value (that will be done by the caller). */
2007 assemble_variable (tree decl
, int top_level ATTRIBUTE_UNUSED
,
2008 int at_end ATTRIBUTE_UNUSED
, int dont_output_data
)
2011 rtx decl_rtl
, symbol
;
2014 bool asan_protected
= false;
2016 /* This function is supposed to handle VARIABLES. Ensure we have one. */
2017 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2019 /* Emulated TLS had better not get this far. */
2020 gcc_checking_assert (targetm
.have_tls
|| !DECL_THREAD_LOCAL_P (decl
));
2022 last_assemble_variable_decl
= 0;
2024 /* Normally no need to say anything here for external references,
2025 since assemble_external is called by the language-specific code
2026 when a declaration is first seen. */
2028 if (DECL_EXTERNAL (decl
))
2031 /* Do nothing for global register variables. */
2032 if (DECL_RTL_SET_P (decl
) && REG_P (DECL_RTL (decl
)))
2034 TREE_ASM_WRITTEN (decl
) = 1;
2038 /* If type was incomplete when the variable was declared,
2039 see if it is complete now. */
2041 if (DECL_SIZE (decl
) == 0)
2042 layout_decl (decl
, 0);
2044 /* Still incomplete => don't allocate it; treat the tentative defn
2045 (which is what it must have been) as an `extern' reference. */
2047 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
2049 error ("storage size of %q+D isn%'t known", decl
);
2050 TREE_ASM_WRITTEN (decl
) = 1;
2054 /* The first declaration of a variable that comes through this function
2055 decides whether it is global (in C, has external linkage)
2056 or local (in C, has internal linkage). So do nothing more
2057 if this function has already run. */
2059 if (TREE_ASM_WRITTEN (decl
))
2062 /* Make sure targetm.encode_section_info is invoked before we set
2064 decl_rtl
= DECL_RTL (decl
);
2066 TREE_ASM_WRITTEN (decl
) = 1;
2068 /* Do no output if -fsyntax-only. */
2069 if (flag_syntax_only
)
2072 if (! dont_output_data
2073 && ! valid_constant_size_p (DECL_SIZE_UNIT (decl
)))
2075 error ("size of variable %q+D is too large", decl
);
2079 gcc_assert (MEM_P (decl_rtl
));
2080 gcc_assert (GET_CODE (XEXP (decl_rtl
, 0)) == SYMBOL_REF
);
2081 symbol
= XEXP (decl_rtl
, 0);
2083 /* If this symbol belongs to the tree constant pool, output the constant
2084 if it hasn't already been written. */
2085 if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
2087 tree decl
= SYMBOL_REF_DECL (symbol
);
2088 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
2089 output_constant_def_contents (symbol
);
2095 name
= XSTR (symbol
, 0);
2096 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
2097 notice_global_symbol (decl
);
2099 /* Compute the alignment of this data. */
2101 align_variable (decl
, dont_output_data
);
2103 if ((flag_sanitize
& SANITIZE_ADDRESS
)
2104 && asan_protect_global (decl
))
2106 asan_protected
= true;
2107 DECL_ALIGN (decl
) = MAX (DECL_ALIGN (decl
),
2108 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
2111 set_mem_align (decl_rtl
, DECL_ALIGN (decl
));
2113 align
= get_variable_align (decl
);
2115 if (TREE_PUBLIC (decl
))
2116 maybe_assemble_visibility (decl
);
2118 if (DECL_PRESERVE_P (decl
))
2119 targetm
.asm_out
.mark_decl_preserved (name
);
2121 /* First make the assembler name(s) global if appropriate. */
2122 sect
= get_variable_section (decl
, false);
2123 if (TREE_PUBLIC (decl
)
2124 && (sect
->common
.flags
& SECTION_COMMON
) == 0)
2125 globalize_decl (decl
);
2127 /* Output any data that we will need to use the address of. */
2128 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
2129 output_addressed_constants (DECL_INITIAL (decl
));
2131 /* dbxout.c needs to know this. */
2132 if (sect
&& (sect
->common
.flags
& SECTION_CODE
) != 0)
2133 DECL_IN_TEXT_SECTION (decl
) = 1;
2135 /* If the decl is part of an object_block, make sure that the decl
2136 has been positioned within its block, but do not write out its
2137 definition yet. output_object_blocks will do that later. */
2138 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
2140 gcc_assert (!dont_output_data
);
2141 place_block_symbol (symbol
);
2143 else if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
2144 assemble_noswitch_variable (decl
, name
, sect
, align
);
2147 /* The following bit of code ensures that vtable_map
2148 variables are not only in the comdat section, but that
2149 each variable has its own unique comdat name. If this
2150 code is removed, the variables end up in the same section
2151 with a single comdat name.
2153 FIXME: resolve_unique_section needs to deal better with
2154 decls with both DECL_SECTION_NAME and DECL_ONE_ONLY. Once
2155 that is fixed, this if-else statement can be replaced with
2156 a single call to "switch_to_section (sect)". */
2157 if (sect
->named
.name
2158 && (strcmp (sect
->named
.name
, ".vtable_map_vars") == 0))
2160 #if defined (OBJECT_FORMAT_ELF)
2161 targetm
.asm_out
.named_section (sect
->named
.name
,
2162 sect
->named
.common
.flags
2167 switch_to_section (sect
);
2171 switch_to_section (sect
);
2172 if (align
> BITS_PER_UNIT
)
2173 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2174 assemble_variable_contents (decl
, name
, dont_output_data
);
2177 unsigned HOST_WIDE_INT
int size
2178 = tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2179 assemble_zeros (asan_red_zone_size (size
));
2185 /* Given a function declaration (FN_DECL), this function assembles the
2186 function into the .preinit_array section. */
2189 assemble_vtv_preinit_initializer (tree fn_decl
)
2192 unsigned flags
= SECTION_WRITE
;
2193 rtx symbol
= XEXP (DECL_RTL (fn_decl
), 0);
2195 flags
|= SECTION_NOTYPE
;
2196 sect
= get_section (".preinit_array", flags
, fn_decl
);
2197 switch_to_section (sect
);
2198 assemble_addr_to_section (symbol
, sect
);
2201 /* Return 1 if type TYPE contains any pointers. */
2204 contains_pointers_p (tree type
)
2206 switch (TREE_CODE (type
))
2209 case REFERENCE_TYPE
:
2210 /* I'm not sure whether OFFSET_TYPE needs this treatment,
2211 so I'll play safe and return 1. */
2217 case QUAL_UNION_TYPE
:
2220 /* For a type that has fields, see if the fields have pointers. */
2221 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
2222 if (TREE_CODE (fields
) == FIELD_DECL
2223 && contains_pointers_p (TREE_TYPE (fields
)))
2229 /* An array type contains pointers if its element type does. */
2230 return contains_pointers_p (TREE_TYPE (type
));
2237 /* We delay assemble_external processing until
2238 the compilation unit is finalized. This is the best we can do for
2239 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2240 it all the way to final. See PR 17982 for further discussion. */
2241 static GTY(()) tree pending_assemble_externals
;
2243 #ifdef ASM_OUTPUT_EXTERNAL
2244 /* Some targets delay some output to final using TARGET_ASM_FILE_END.
2245 As a result, assemble_external can be called after the list of externals
2246 is processed and the pointer set destroyed. */
2247 static bool pending_assemble_externals_processed
;
2249 /* Avoid O(external_decls**2) lookups in the pending_assemble_externals
2250 TREE_LIST in assemble_external. */
2251 static hash_set
<tree
> *pending_assemble_externals_set
;
2253 /* True if DECL is a function decl for which no out-of-line copy exists.
2254 It is assumed that DECL's assembler name has been set. */
2257 incorporeal_function_p (tree decl
)
2259 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
2263 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2264 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2265 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2268 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2269 /* Atomic or sync builtins which have survived this far will be
2270 resolved externally and therefore are not incorporeal. */
2271 if (strncmp (name
, "__builtin_", 10) == 0)
2277 /* Actually do the tests to determine if this is necessary, and invoke
2278 ASM_OUTPUT_EXTERNAL. */
2280 assemble_external_real (tree decl
)
2282 rtx rtl
= DECL_RTL (decl
);
2284 if (MEM_P (rtl
) && GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
2285 && !SYMBOL_REF_USED (XEXP (rtl
, 0))
2286 && !incorporeal_function_p (decl
))
2288 /* Some systems do require some output. */
2289 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
2290 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
2296 process_pending_assemble_externals (void)
2298 #ifdef ASM_OUTPUT_EXTERNAL
2300 for (list
= pending_assemble_externals
; list
; list
= TREE_CHAIN (list
))
2301 assemble_external_real (TREE_VALUE (list
));
2303 pending_assemble_externals
= 0;
2304 pending_assemble_externals_processed
= true;
2305 delete pending_assemble_externals_set
;
2309 /* This TREE_LIST contains any weak symbol declarations waiting
2311 static GTY(()) tree weak_decls
;
2313 /* Output something to declare an external symbol to the assembler,
2314 and qualifiers such as weakness. (Most assemblers don't need
2315 extern declaration, so we normally output nothing.) Do nothing if
2316 DECL is not external. */
2319 assemble_external (tree decl ATTRIBUTE_UNUSED
)
2321 /* Make sure that the ASM_OUT_FILE is open.
2322 If it's not, we should not be calling this function. */
2323 gcc_assert (asm_out_file
);
2325 /* In a perfect world, the following condition would be true.
2326 Sadly, the Java and Go front ends emit assembly *from the front end*,
2327 bypassing the call graph. See PR52739. Fix before GCC 4.8. */
2329 /* This function should only be called if we are expanding, or have
2331 Ideally, only final.c would be calling this function, but it is
2332 not clear whether that would break things somehow. See PR 17982
2333 for further discussion. */
2334 gcc_assert (state
== EXPANSION
2335 || state
== FINISHED
);
2338 if (!DECL_P (decl
) || !DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
))
2341 /* We want to output annotation for weak and external symbols at
2342 very last to check if they are references or not. */
2344 if (TARGET_SUPPORTS_WEAK
2346 /* TREE_STATIC is a weird and abused creature which is not
2347 generally the right test for whether an entity has been
2348 locally emitted, inlined or otherwise not-really-extern, but
2349 for declarations that can be weak, it happens to be
2351 && !TREE_STATIC (decl
)
2352 && lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
2353 && value_member (decl
, weak_decls
) == NULL_TREE
)
2354 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
2356 #ifdef ASM_OUTPUT_EXTERNAL
2357 if (pending_assemble_externals_processed
)
2359 assemble_external_real (decl
);
2363 if (! pending_assemble_externals_set
->add (decl
))
2364 pending_assemble_externals
= tree_cons (NULL
, decl
,
2365 pending_assemble_externals
);
2369 /* Similar, for calling a library function FUN. */
2372 assemble_external_libcall (rtx fun
)
2374 /* Declare library function name external when first used, if nec. */
2375 if (! SYMBOL_REF_USED (fun
))
2377 SYMBOL_REF_USED (fun
) = 1;
2378 targetm
.asm_out
.external_libcall (fun
);
2382 /* Assemble a label named NAME. */
2385 assemble_label (FILE *file
, const char *name
)
2387 ASM_OUTPUT_LABEL (file
, name
);
2390 /* Set the symbol_referenced flag for ID. */
2392 mark_referenced (tree id
)
2394 TREE_SYMBOL_REFERENCED (id
) = 1;
2397 /* Set the symbol_referenced flag for DECL and notify callgraph. */
2399 mark_decl_referenced (tree decl
)
2401 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2403 /* Extern inline functions don't become needed when referenced.
2404 If we know a method will be emitted in other TU and no new
2405 functions can be marked reachable, just use the external
2407 struct cgraph_node
*node
= cgraph_node::get_create (decl
);
2408 if (!DECL_EXTERNAL (decl
)
2409 && !node
->definition
)
2410 node
->mark_force_output ();
2412 else if (TREE_CODE (decl
) == VAR_DECL
)
2414 varpool_node
*node
= varpool_node::get_create (decl
);
2415 /* C++ frontend use mark_decl_references to force COMDAT variables
2416 to be output that might appear dead otherwise. */
2417 node
->force_output
= true;
2419 /* else do nothing - we can get various sorts of CST nodes here,
2420 which do not need to be marked. */
2424 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2425 until we find an identifier that is not itself a transparent alias.
2426 Modify the alias passed to it by reference (and all aliases on the
2427 way to the ultimate target), such that they do not have to be
2428 followed again, and return the ultimate target of the alias
2432 ultimate_transparent_alias_target (tree
*alias
)
2434 tree target
= *alias
;
2436 if (IDENTIFIER_TRANSPARENT_ALIAS (target
))
2438 gcc_assert (TREE_CHAIN (target
));
2439 target
= ultimate_transparent_alias_target (&TREE_CHAIN (target
));
2440 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
2441 && ! TREE_CHAIN (target
));
2448 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2449 starts with a *, the rest of NAME is output verbatim. Otherwise
2450 NAME is transformed in a target-specific way (usually by the
2451 addition of an underscore). */
2454 assemble_name_raw (FILE *file
, const char *name
)
2457 fputs (&name
[1], file
);
2459 ASM_OUTPUT_LABELREF (file
, name
);
2462 /* Like assemble_name_raw, but should be used when NAME might refer to
2463 an entity that is also represented as a tree (like a function or
2464 variable). If NAME does refer to such an entity, that entity will
2465 be marked as referenced. */
2468 assemble_name (FILE *file
, const char *name
)
2470 const char *real_name
;
2473 real_name
= targetm
.strip_name_encoding (name
);
2475 id
= maybe_get_identifier (real_name
);
2480 mark_referenced (id
);
2481 ultimate_transparent_alias_target (&id
);
2483 name
= IDENTIFIER_POINTER (id
);
2484 gcc_assert (! TREE_CHAIN (id
));
2487 assemble_name_raw (file
, name
);
2490 /* Allocate SIZE bytes writable static space with a gensym name
2491 and return an RTX to refer to its address. */
2494 assemble_static_space (unsigned HOST_WIDE_INT size
)
2497 const char *namestring
;
2500 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
2502 namestring
= ggc_strdup (name
);
2504 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
2505 SYMBOL_REF_FLAGS (x
) = SYMBOL_FLAG_LOCAL
;
2507 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2508 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
2511 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2512 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
2515 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2516 so that each uninitialized object starts on such a boundary. */
2517 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2518 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2519 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
2520 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2521 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2522 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
2529 /* Assemble the static constant template for function entry trampolines.
2530 This is done at most once per compilation.
2531 Returns an RTX for the address of the template. */
2533 static GTY(()) rtx initial_trampoline
;
2536 assemble_trampoline_template (void)
2543 gcc_assert (targetm
.asm_out
.trampoline_template
!= NULL
);
2545 if (initial_trampoline
)
2546 return initial_trampoline
;
2548 /* By default, put trampoline templates in read-only data section. */
2550 #ifdef TRAMPOLINE_SECTION
2551 switch_to_section (TRAMPOLINE_SECTION
);
2553 switch_to_section (readonly_data_section
);
2556 /* Write the assembler code to define one. */
2557 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
2559 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
2561 targetm
.asm_out
.internal_label (asm_out_file
, "LTRAMP", 0);
2562 targetm
.asm_out
.trampoline_template (asm_out_file
);
2564 /* Record the rtl to refer to it. */
2565 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
2566 name
= ggc_strdup (label
);
2567 symbol
= gen_rtx_SYMBOL_REF (Pmode
, name
);
2568 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2570 initial_trampoline
= gen_const_mem (BLKmode
, symbol
);
2571 set_mem_align (initial_trampoline
, TRAMPOLINE_ALIGNMENT
);
2572 set_mem_size (initial_trampoline
, TRAMPOLINE_SIZE
);
2574 return initial_trampoline
;
2577 /* A and B are either alignments or offsets. Return the minimum alignment
2578 that may be assumed after adding the two together. */
2580 static inline unsigned
2581 min_align (unsigned int a
, unsigned int b
)
2583 return (a
| b
) & -(a
| b
);
2586 /* Return the assembler directive for creating a given kind of integer
2587 object. SIZE is the number of bytes in the object and ALIGNED_P
2588 indicates whether it is known to be aligned. Return NULL if the
2589 assembly dialect has no such directive.
2591 The returned string should be printed at the start of a new line and
2592 be followed immediately by the object's initial value. */
2595 integer_asm_op (int size
, int aligned_p
)
2597 struct asm_int_op
*ops
;
2600 ops
= &targetm
.asm_out
.aligned_op
;
2602 ops
= &targetm
.asm_out
.unaligned_op
;
2607 return targetm
.asm_out
.byte_op
;
2621 /* Use directive OP to assemble an integer object X. Print OP at the
2622 start of the line, followed immediately by the value of X. */
2625 assemble_integer_with_op (const char *op
, rtx x
)
2627 fputs (op
, asm_out_file
);
2628 output_addr_const (asm_out_file
, x
);
2629 fputc ('\n', asm_out_file
);
2632 /* The default implementation of the asm_out.integer target hook. */
2635 default_assemble_integer (rtx x ATTRIBUTE_UNUSED
,
2636 unsigned int size ATTRIBUTE_UNUSED
,
2637 int aligned_p ATTRIBUTE_UNUSED
)
2639 const char *op
= integer_asm_op (size
, aligned_p
);
2640 /* Avoid GAS bugs for large values. Specifically negative values whose
2641 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2642 if (size
> UNITS_PER_WORD
&& size
> POINTER_SIZE
/ BITS_PER_UNIT
)
2644 return op
&& (assemble_integer_with_op (op
, x
), true);
2647 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2648 the alignment of the integer in bits. Return 1 if we were able to output
2649 the constant, otherwise 0. We must be able to output the constant,
2650 if FORCE is nonzero. */
2653 assemble_integer (rtx x
, unsigned int size
, unsigned int align
, int force
)
2657 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
2659 /* See if the target hook can handle this kind of object. */
2660 if (targetm
.asm_out
.integer (x
, size
, aligned_p
))
2663 /* If the object is a multi-byte one, try splitting it up. Split
2664 it into words it if is multi-word, otherwise split it into bytes. */
2667 enum machine_mode omode
, imode
;
2668 unsigned int subalign
;
2669 unsigned int subsize
, i
;
2670 enum mode_class mclass
;
2672 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
2673 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
2674 if (GET_CODE (x
) == CONST_FIXED
)
2675 mclass
= GET_MODE_CLASS (GET_MODE (x
));
2679 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, mclass
, 0);
2680 imode
= mode_for_size (size
* BITS_PER_UNIT
, mclass
, 0);
2682 for (i
= 0; i
< size
; i
+= subsize
)
2684 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
2685 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
2691 /* If we've printed some of it, but not all of it, there's no going
2696 gcc_assert (!force
);
2702 assemble_real (REAL_VALUE_TYPE d
, enum machine_mode mode
, unsigned int align
)
2704 long data
[4] = {0, 0, 0, 0};
2706 int bitsize
, nelts
, nunits
, units_per
;
2708 /* This is hairy. We have a quantity of known size. real_to_target
2709 will put it into an array of *host* longs, 32 bits per element
2710 (even if long is more than 32 bits). We need to determine the
2711 number of array elements that are occupied (nelts) and the number
2712 of *target* min-addressable units that will be occupied in the
2713 object file (nunits). We cannot assume that 32 divides the
2714 mode's bitsize (size * BITS_PER_UNIT) evenly.
2716 size * BITS_PER_UNIT is used here to make sure that padding bits
2717 (which might appear at either end of the value; real_to_target
2718 will include the padding bits in its output array) are included. */
2720 nunits
= GET_MODE_SIZE (mode
);
2721 bitsize
= nunits
* BITS_PER_UNIT
;
2722 nelts
= CEIL (bitsize
, 32);
2723 units_per
= 32 / BITS_PER_UNIT
;
2725 real_to_target (data
, &d
, mode
);
2727 /* Put out the first word with the specified alignment. */
2728 assemble_integer (GEN_INT (data
[0]), MIN (nunits
, units_per
), align
, 1);
2729 nunits
-= units_per
;
2731 /* Subsequent words need only 32-bit alignment. */
2732 align
= min_align (align
, 32);
2734 for (i
= 1; i
< nelts
; i
++)
2736 assemble_integer (GEN_INT (data
[i
]), MIN (nunits
, units_per
), align
, 1);
2737 nunits
-= units_per
;
2741 /* Given an expression EXP with a constant value,
2742 reduce it to the sum of an assembler symbol and an integer.
2743 Store them both in the structure *VALUE.
2744 EXP must be reducible. */
2748 HOST_WIDE_INT offset
;
2752 decode_addr_const (tree exp
, struct addr_const
*value
)
2754 tree target
= TREE_OPERAND (exp
, 0);
2760 if (TREE_CODE (target
) == COMPONENT_REF
2761 && tree_fits_shwi_p (byte_position (TREE_OPERAND (target
, 1))))
2763 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2764 target
= TREE_OPERAND (target
, 0);
2766 else if (TREE_CODE (target
) == ARRAY_REF
2767 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2769 offset
+= (tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (target
)))
2770 * tree_to_shwi (TREE_OPERAND (target
, 1)));
2771 target
= TREE_OPERAND (target
, 0);
2773 else if (TREE_CODE (target
) == MEM_REF
2774 && TREE_CODE (TREE_OPERAND (target
, 0)) == ADDR_EXPR
)
2776 offset
+= mem_ref_offset (target
).to_short_addr ();
2777 target
= TREE_OPERAND (TREE_OPERAND (target
, 0), 0);
2779 else if (TREE_CODE (target
) == INDIRECT_REF
2780 && TREE_CODE (TREE_OPERAND (target
, 0)) == NOP_EXPR
2781 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target
, 0), 0))
2783 target
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target
, 0), 0), 0);
2788 switch (TREE_CODE (target
))
2792 x
= DECL_RTL (target
);
2796 x
= gen_rtx_MEM (FUNCTION_MODE
,
2797 gen_rtx_LABEL_REF (Pmode
, force_label_rtx (target
)));
2806 x
= output_constant_def (target
, 1);
2813 gcc_assert (MEM_P (x
));
2817 value
->offset
= offset
;
2821 static GTY((param_is (struct constant_descriptor_tree
)))
2822 htab_t const_desc_htab
;
2824 static void maybe_output_constant_def_contents (struct constant_descriptor_tree
*, int);
2826 /* Constant pool accessor function. */
2829 constant_pool_htab (void)
2831 return const_desc_htab
;
2834 /* Compute a hash code for a constant expression. */
2837 const_desc_hash (const void *ptr
)
2839 return ((const struct constant_descriptor_tree
*)ptr
)->hash
;
2843 const_hash_1 (const tree exp
)
2848 enum tree_code code
= TREE_CODE (exp
);
2850 /* Either set P and LEN to the address and len of something to hash and
2851 exit the switch or return a value. */
2856 p
= (char *) &TREE_INT_CST_ELT (exp
, 0);
2857 len
= TREE_INT_CST_NUNITS (exp
) * sizeof (HOST_WIDE_INT
);
2861 return real_hash (TREE_REAL_CST_PTR (exp
));
2864 return fixed_hash (TREE_FIXED_CST_PTR (exp
));
2867 p
= TREE_STRING_POINTER (exp
);
2868 len
= TREE_STRING_LENGTH (exp
);
2872 return (const_hash_1 (TREE_REALPART (exp
)) * 5
2873 + const_hash_1 (TREE_IMAGPART (exp
)));
2879 hi
= 7 + VECTOR_CST_NELTS (exp
);
2881 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
2882 hi
= hi
* 563 + const_hash_1 (VECTOR_CST_ELT (exp
, i
));
2889 unsigned HOST_WIDE_INT idx
;
2892 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
2894 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, value
)
2896 hi
= hi
* 603 + const_hash_1 (value
);
2904 struct addr_const value
;
2906 decode_addr_const (exp
, &value
);
2907 switch (GET_CODE (value
.base
))
2910 /* Don't hash the address of the SYMBOL_REF;
2911 only use the offset and the symbol name. */
2913 p
= XSTR (value
.base
, 0);
2914 for (i
= 0; p
[i
] != 0; i
++)
2915 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2919 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2929 case POINTER_PLUS_EXPR
:
2931 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
2932 + const_hash_1 (TREE_OPERAND (exp
, 1)));
2935 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
2938 /* A language specific constant. Just hash the code. */
2942 /* Compute hashing function. */
2944 for (i
= 0; i
< len
; i
++)
2945 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2950 /* Wrapper of compare_constant, for the htab interface. */
2952 const_desc_eq (const void *p1
, const void *p2
)
2954 const struct constant_descriptor_tree
*const c1
2955 = (const struct constant_descriptor_tree
*) p1
;
2956 const struct constant_descriptor_tree
*const c2
2957 = (const struct constant_descriptor_tree
*) p2
;
2958 if (c1
->hash
!= c2
->hash
)
2960 return compare_constant (c1
->value
, c2
->value
);
2963 /* Compare t1 and t2, and return 1 only if they are known to result in
2964 the same bit pattern on output. */
2967 compare_constant (const tree t1
, const tree t2
)
2969 enum tree_code typecode
;
2971 if (t1
== NULL_TREE
)
2972 return t2
== NULL_TREE
;
2973 if (t2
== NULL_TREE
)
2976 if (TREE_CODE (t1
) != TREE_CODE (t2
))
2979 switch (TREE_CODE (t1
))
2982 /* Integer constants are the same only if the same width of type. */
2983 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2985 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
2987 return tree_int_cst_equal (t1
, t2
);
2990 /* Real constants are the same only if the same width of type. */
2991 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2994 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2997 /* Fixed constants are the same only if the same width of type. */
2998 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3001 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
3004 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
3007 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3008 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3009 TREE_STRING_LENGTH (t1
)));
3012 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
3013 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
3019 if (VECTOR_CST_NELTS (t1
) != VECTOR_CST_NELTS (t2
))
3022 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
3023 if (!compare_constant (VECTOR_CST_ELT (t1
, i
),
3024 VECTOR_CST_ELT (t2
, i
)))
3032 vec
<constructor_elt
, va_gc
> *v1
, *v2
;
3033 unsigned HOST_WIDE_INT idx
;
3035 typecode
= TREE_CODE (TREE_TYPE (t1
));
3036 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
3039 if (typecode
== ARRAY_TYPE
)
3041 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
3042 /* For arrays, check that the sizes all match. */
3043 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
3045 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
)))
3050 /* For record and union constructors, require exact type
3052 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
3056 v1
= CONSTRUCTOR_ELTS (t1
);
3057 v2
= CONSTRUCTOR_ELTS (t2
);
3058 if (vec_safe_length (v1
) != vec_safe_length (v2
))
3061 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
3063 constructor_elt
*c1
= &(*v1
)[idx
];
3064 constructor_elt
*c2
= &(*v2
)[idx
];
3066 /* Check that each value is the same... */
3067 if (!compare_constant (c1
->value
, c2
->value
))
3069 /* ... and that they apply to the same fields! */
3070 if (typecode
== ARRAY_TYPE
)
3072 if (!compare_constant (c1
->index
, c2
->index
))
3077 if (c1
->index
!= c2
->index
)
3088 struct addr_const value1
, value2
;
3092 decode_addr_const (t1
, &value1
);
3093 decode_addr_const (t2
, &value2
);
3095 if (value1
.offset
!= value2
.offset
)
3098 code
= GET_CODE (value1
.base
);
3099 if (code
!= GET_CODE (value2
.base
))
3105 ret
= (strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
3109 ret
= (CODE_LABEL_NUMBER (XEXP (value1
.base
, 0))
3110 == CODE_LABEL_NUMBER (XEXP (value2
.base
, 0)));
3120 case POINTER_PLUS_EXPR
:
3123 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3124 && compare_constant (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3127 case VIEW_CONVERT_EXPR
:
3128 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3137 /* Return the section into which constant EXP should be placed. */
3140 get_constant_section (tree exp
, unsigned int align
)
3142 return targetm
.asm_out
.select_section (exp
,
3143 compute_reloc_for_constant (exp
),
3147 /* Return the size of constant EXP in bytes. */
3149 static HOST_WIDE_INT
3150 get_constant_size (tree exp
)
3154 size
= int_size_in_bytes (TREE_TYPE (exp
));
3155 if (TREE_CODE (exp
) == STRING_CST
)
3156 size
= MAX (TREE_STRING_LENGTH (exp
), size
);
3160 /* Subroutine of output_constant_def:
3161 No constant equal to EXP is known to have been output.
3162 Make a constant descriptor to enter EXP in the hash table.
3163 Assign the label number and construct RTL to refer to the
3164 constant's location in memory.
3165 Caller is responsible for updating the hash table. */
3167 static struct constant_descriptor_tree
*
3168 build_constant_desc (tree exp
)
3170 struct constant_descriptor_tree
*desc
;
3176 desc
= ggc_alloc
<constant_descriptor_tree
> ();
3179 /* Create a string containing the label name, in LABEL. */
3180 labelno
= const_labelno
++;
3181 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
3183 /* Construct the VAR_DECL associated with the constant. */
3184 decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
, get_identifier (label
),
3186 DECL_ARTIFICIAL (decl
) = 1;
3187 DECL_IGNORED_P (decl
) = 1;
3188 TREE_READONLY (decl
) = 1;
3189 TREE_STATIC (decl
) = 1;
3190 TREE_ADDRESSABLE (decl
) = 1;
3191 /* We don't set the RTL yet as this would cause varpool to assume that the
3192 variable is referenced. Moreover, it would just be dropped in LTO mode.
3193 Instead we set the flag that will be recognized in make_decl_rtl. */
3194 DECL_IN_CONSTANT_POOL (decl
) = 1;
3195 DECL_INITIAL (decl
) = desc
->value
;
3196 /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most
3197 architectures so use DATA_ALIGNMENT as well, except for strings. */
3198 if (TREE_CODE (exp
) == STRING_CST
)
3200 #ifdef CONSTANT_ALIGNMENT
3201 DECL_ALIGN (decl
) = CONSTANT_ALIGNMENT (exp
, DECL_ALIGN (decl
));
3205 align_variable (decl
, 0);
3207 /* Now construct the SYMBOL_REF and the MEM. */
3208 if (use_object_blocks_p ())
3210 section
*sect
= get_constant_section (exp
, DECL_ALIGN (decl
));
3211 symbol
= create_block_symbol (ggc_strdup (label
),
3212 get_block_for_section (sect
), -1);
3215 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3216 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3217 SET_SYMBOL_REF_DECL (symbol
, decl
);
3218 TREE_CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3220 rtl
= gen_const_mem (TYPE_MODE (TREE_TYPE (exp
)), symbol
);
3221 set_mem_attributes (rtl
, exp
, 1);
3222 set_mem_alias_set (rtl
, 0);
3223 set_mem_alias_set (rtl
, const_alias_set
);
3225 /* We cannot share RTX'es in pool entries.
3226 Mark this piece of RTL as required for unsharing. */
3227 RTX_FLAG (rtl
, used
) = 1;
3229 /* Set flags or add text to the name to record information, such as
3230 that it is a local symbol. If the name is changed, the macro
3231 ASM_OUTPUT_LABELREF will have to know how to strip this
3232 information. This call might invalidate our local variable
3233 SYMBOL; we can't use it afterward. */
3234 targetm
.encode_section_info (exp
, rtl
, true);
3241 /* Return an rtx representing a reference to constant data in memory
3242 for the constant expression EXP.
3244 If assembler code for such a constant has already been output,
3245 return an rtx to refer to it.
3246 Otherwise, output such a constant in memory
3247 and generate an rtx for it.
3249 If DEFER is nonzero, this constant can be deferred and output only
3250 if referenced in the function after all optimizations.
3252 `const_desc_table' records which constants already have label strings. */
3255 output_constant_def (tree exp
, int defer
)
3257 struct constant_descriptor_tree
*desc
;
3258 struct constant_descriptor_tree key
;
3261 /* Look up EXP in the table of constant descriptors. If we didn't find
3262 it, create a new one. */
3264 key
.hash
= const_hash_1 (exp
);
3265 loc
= htab_find_slot_with_hash (const_desc_htab
, &key
, key
.hash
, INSERT
);
3267 desc
= (struct constant_descriptor_tree
*) *loc
;
3270 desc
= build_constant_desc (exp
);
3271 desc
->hash
= key
.hash
;
3275 maybe_output_constant_def_contents (desc
, defer
);
3279 /* Subroutine of output_constant_def: Decide whether or not we need to
3280 output the constant DESC now, and if so, do it. */
3282 maybe_output_constant_def_contents (struct constant_descriptor_tree
*desc
,
3285 rtx symbol
= XEXP (desc
->rtl
, 0);
3286 tree exp
= desc
->value
;
3288 if (flag_syntax_only
)
3291 if (TREE_ASM_WRITTEN (exp
))
3292 /* Already output; don't do it again. */
3295 /* We can always defer constants as long as the context allows
3299 /* Increment n_deferred_constants if it exists. It needs to be at
3300 least as large as the number of constants actually referred to
3301 by the function. If it's too small we'll stop looking too early
3302 and fail to emit constants; if it's too large we'll only look
3303 through the entire function when we could have stopped earlier. */
3305 n_deferred_constants
++;
3309 output_constant_def_contents (symbol
);
3312 /* Subroutine of output_constant_def_contents. Output the definition
3313 of constant EXP, which is pointed to by label LABEL. ALIGN is the
3314 constant's alignment in bits. */
3317 assemble_constant_contents (tree exp
, const char *label
, unsigned int align
)
3321 size
= get_constant_size (exp
);
3323 /* Do any machine/system dependent processing of the constant. */
3324 targetm
.asm_out
.declare_constant_name (asm_out_file
, label
, exp
, size
);
3326 /* Output the value of EXP. */
3327 output_constant (exp
, size
, align
);
3330 /* We must output the constant data referred to by SYMBOL; do so. */
3333 output_constant_def_contents (rtx symbol
)
3335 tree decl
= SYMBOL_REF_DECL (symbol
);
3336 tree exp
= DECL_INITIAL (decl
);
3338 bool asan_protected
= false;
3340 /* Make sure any other constants whose addresses appear in EXP
3341 are assigned label numbers. */
3342 output_addressed_constants (exp
);
3344 /* We are no longer deferring this constant. */
3345 TREE_ASM_WRITTEN (decl
) = TREE_ASM_WRITTEN (exp
) = 1;
3347 if ((flag_sanitize
& SANITIZE_ADDRESS
)
3348 && TREE_CODE (exp
) == STRING_CST
3349 && asan_protect_global (exp
))
3351 asan_protected
= true;
3352 DECL_ALIGN (decl
) = MAX (DECL_ALIGN (decl
),
3353 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
3356 /* If the constant is part of an object block, make sure that the
3357 decl has been positioned within its block, but do not write out
3358 its definition yet. output_object_blocks will do that later. */
3359 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
3360 place_block_symbol (symbol
);
3363 align
= DECL_ALIGN (decl
);
3364 switch_to_section (get_constant_section (exp
, align
));
3365 if (align
> BITS_PER_UNIT
)
3366 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3367 assemble_constant_contents (exp
, XSTR (symbol
, 0), align
);
3370 HOST_WIDE_INT size
= get_constant_size (exp
);
3371 assemble_zeros (asan_red_zone_size (size
));
3376 /* Look up EXP in the table of constant descriptors. Return the rtl
3377 if it has been emitted, else null. */
3380 lookup_constant_def (tree exp
)
3382 struct constant_descriptor_tree
*desc
;
3383 struct constant_descriptor_tree key
;
3386 key
.hash
= const_hash_1 (exp
);
3387 desc
= (struct constant_descriptor_tree
*)
3388 htab_find_with_hash (const_desc_htab
, &key
, key
.hash
);
3390 return (desc
? desc
->rtl
: NULL_RTX
);
3393 /* Return a tree representing a reference to constant data in memory
3394 for the constant expression EXP.
3396 This is the counterpart of output_constant_def at the Tree level. */
3399 tree_output_constant_def (tree exp
)
3401 struct constant_descriptor_tree
*desc
, key
;
3405 /* Look up EXP in the table of constant descriptors. If we didn't find
3406 it, create a new one. */
3408 key
.hash
= const_hash_1 (exp
);
3409 loc
= htab_find_slot_with_hash (const_desc_htab
, &key
, key
.hash
, INSERT
);
3411 desc
= (struct constant_descriptor_tree
*) *loc
;
3414 desc
= build_constant_desc (exp
);
3415 desc
->hash
= key
.hash
;
3419 decl
= SYMBOL_REF_DECL (XEXP (desc
->rtl
, 0));
3420 varpool_node::finalize_decl (decl
);
3424 /* Used in the hash tables to avoid outputting the same constant
3425 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3426 are output once per function, not once per file. */
3427 /* ??? Only a few targets need per-function constant pools. Most
3428 can use one per-file pool. Should add a targetm bit to tell the
3431 struct GTY(()) rtx_constant_pool
{
3432 /* Pointers to first and last constant in pool, as ordered by offset. */
3433 struct constant_descriptor_rtx
*first
;
3434 struct constant_descriptor_rtx
*last
;
3436 /* Hash facility for making memory-constants from constant rtl-expressions.
3437 It is used on RISC machines where immediate integer arguments and
3438 constant addresses are restricted so that such constants must be stored
3440 htab_t
GTY((param_is (struct constant_descriptor_rtx
))) const_rtx_htab
;
3442 /* Current offset in constant pool (does not include any
3443 machine-specific header). */
3444 HOST_WIDE_INT offset
;
3447 struct GTY((chain_next ("%h.next"))) constant_descriptor_rtx
{
3448 struct constant_descriptor_rtx
*next
;
3452 HOST_WIDE_INT offset
;
3454 enum machine_mode mode
;
3460 /* Hash and compare functions for const_rtx_htab. */
3463 const_desc_rtx_hash (const void *ptr
)
3465 const struct constant_descriptor_rtx
*const desc
3466 = (const struct constant_descriptor_rtx
*) ptr
;
3471 const_desc_rtx_eq (const void *a
, const void *b
)
3473 const struct constant_descriptor_rtx
*const x
3474 = (const struct constant_descriptor_rtx
*) a
;
3475 const struct constant_descriptor_rtx
*const y
3476 = (const struct constant_descriptor_rtx
*) b
;
3478 if (x
->mode
!= y
->mode
)
3480 return rtx_equal_p (x
->constant
, y
->constant
);
3483 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
3486 const_rtx_hash_1 (rtx
*xp
, void *data
)
3488 unsigned HOST_WIDE_INT hwi
;
3489 enum machine_mode mode
;
3496 code
= GET_CODE (x
);
3497 mode
= GET_MODE (x
);
3498 h
= (hashval_t
) code
* 1048573 + mode
;
3507 int shift
= sizeof (hashval_t
) * CHAR_BIT
;
3508 const int n
= sizeof (HOST_WIDE_INT
) / sizeof (hashval_t
);
3510 h
^= (hashval_t
) hwi
;
3511 for (i
= 1; i
< n
; ++i
)
3514 h
^= (hashval_t
) hwi
;
3519 case CONST_WIDE_INT
:
3520 hwi
= GET_MODE_PRECISION (mode
);
3522 for (i
= 0; i
< CONST_WIDE_INT_NUNITS (x
); i
++)
3523 hwi
^= CONST_WIDE_INT_ELT (x
, i
);
3528 if (TARGET_SUPPORTS_WIDE_INT
== 0 && mode
== VOIDmode
)
3530 hwi
= CONST_DOUBLE_LOW (x
) ^ CONST_DOUBLE_HIGH (x
);
3534 h
^= real_hash (CONST_DOUBLE_REAL_VALUE (x
));
3538 h
^= fixed_hash (CONST_FIXED_VALUE (x
));
3544 for (i
= XVECLEN (x
, 0); i
-- > 0; )
3545 h
= h
* 251 + const_rtx_hash_1 (&XVECEXP (x
, 0, i
), data
);
3550 h
^= htab_hash_string (XSTR (x
, 0));
3554 h
= h
* 251 + CODE_LABEL_NUMBER (XEXP (x
, 0));
3558 case UNSPEC_VOLATILE
:
3559 h
= h
* 251 + XINT (x
, 1);
3566 hp
= (hashval_t
*) data
;
3567 *hp
= *hp
* 509 + h
;
3571 /* Compute a hash value for X, which should be a constant. */
3574 const_rtx_hash (rtx x
)
3577 for_each_rtx (&x
, const_rtx_hash_1
, &h
);
3582 /* Create and return a new rtx constant pool. */
3584 static struct rtx_constant_pool
*
3585 create_constant_pool (void)
3587 struct rtx_constant_pool
*pool
;
3589 pool
= ggc_alloc
<rtx_constant_pool
> ();
3590 pool
->const_rtx_htab
= htab_create_ggc (31, const_desc_rtx_hash
,
3591 const_desc_rtx_eq
, NULL
);
3598 /* Initialize constant pool hashing for a new function. */
3601 init_varasm_status (void)
3603 crtl
->varasm
.pool
= create_constant_pool ();
3604 crtl
->varasm
.deferred_constants
= 0;
3607 /* Given a MINUS expression, simplify it if both sides
3608 include the same symbol. */
3611 simplify_subtraction (rtx x
)
3613 rtx r
= simplify_rtx (x
);
3617 /* Given a constant rtx X, make (or find) a memory constant for its value
3618 and return a MEM rtx to refer to it in memory. */
3621 force_const_mem (enum machine_mode mode
, rtx x
)
3623 struct constant_descriptor_rtx
*desc
, tmp
;
3624 struct rtx_constant_pool
*pool
;
3631 /* If we're not allowed to drop X into the constant pool, don't. */
3632 if (targetm
.cannot_force_const_mem (mode
, x
))
3635 /* Record that this function has used a constant pool entry. */
3636 crtl
->uses_const_pool
= 1;
3638 /* Decide which pool to use. */
3639 pool
= (targetm
.use_blocks_for_constant_p (mode
, x
)
3640 ? shared_constant_pool
3641 : crtl
->varasm
.pool
);
3643 /* Lookup the value in the hashtable. */
3646 hash
= const_rtx_hash (x
);
3647 slot
= htab_find_slot_with_hash (pool
->const_rtx_htab
, &tmp
, hash
, INSERT
);
3648 desc
= (struct constant_descriptor_rtx
*) *slot
;
3650 /* If the constant was already present, return its memory. */
3652 return copy_rtx (desc
->mem
);
3654 /* Otherwise, create a new descriptor. */
3655 desc
= ggc_alloc
<constant_descriptor_rtx
> ();
3658 /* Align the location counter as required by EXP's data type. */
3659 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3660 #ifdef CONSTANT_ALIGNMENT
3662 tree type
= lang_hooks
.types
.type_for_mode (mode
, 0);
3663 if (type
!= NULL_TREE
)
3664 align
= CONSTANT_ALIGNMENT (make_tree (type
, x
), align
);
3668 pool
->offset
+= (align
/ BITS_PER_UNIT
) - 1;
3669 pool
->offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3672 desc
->constant
= copy_rtx (tmp
.constant
);
3673 desc
->offset
= pool
->offset
;
3676 desc
->align
= align
;
3677 desc
->labelno
= const_labelno
;
3680 pool
->offset
+= GET_MODE_SIZE (mode
);
3682 pool
->last
->next
= desc
;
3684 pool
->first
= pool
->last
= desc
;
3687 /* Create a string containing the label name, in LABEL. */
3688 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3691 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3692 the constants pool. */
3693 if (use_object_blocks_p () && targetm
.use_blocks_for_constant_p (mode
, x
))
3695 section
*sect
= targetm
.asm_out
.select_rtx_section (mode
, x
, align
);
3696 symbol
= create_block_symbol (ggc_strdup (label
),
3697 get_block_for_section (sect
), -1);
3700 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3702 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3703 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3704 SET_SYMBOL_REF_CONSTANT (symbol
, desc
);
3706 /* Construct the MEM. */
3707 desc
->mem
= def
= gen_const_mem (mode
, symbol
);
3708 set_mem_attributes (def
, lang_hooks
.types
.type_for_mode (mode
, 0), 1);
3709 set_mem_align (def
, align
);
3711 /* If we're dropping a label to the constant pool, make sure we
3713 if (GET_CODE (x
) == LABEL_REF
)
3714 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3716 return copy_rtx (def
);
3719 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3722 get_pool_constant (rtx addr
)
3724 return SYMBOL_REF_CONSTANT (addr
)->constant
;
3727 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3728 and whether it has been output or not. */
3731 get_pool_constant_mark (rtx addr
, bool *pmarked
)
3733 struct constant_descriptor_rtx
*desc
;
3735 desc
= SYMBOL_REF_CONSTANT (addr
);
3736 *pmarked
= (desc
->mark
!= 0);
3737 return desc
->constant
;
3740 /* Similar, return the mode. */
3743 get_pool_mode (const_rtx addr
)
3745 return SYMBOL_REF_CONSTANT (addr
)->mode
;
3748 /* Return the size of the constant pool. */
3751 get_pool_size (void)
3753 return crtl
->varasm
.pool
->offset
;
3756 /* Worker function for output_constant_pool_1. Emit assembly for X
3757 in MODE with known alignment ALIGN. */
3760 output_constant_pool_2 (enum machine_mode mode
, rtx x
, unsigned int align
)
3762 switch (GET_MODE_CLASS (mode
))
3765 case MODE_DECIMAL_FLOAT
:
3769 gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x
));
3770 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
3771 assemble_real (r
, mode
, align
);
3776 case MODE_PARTIAL_INT
:
3781 assemble_integer (x
, GET_MODE_SIZE (mode
), align
, 1);
3784 case MODE_VECTOR_FLOAT
:
3785 case MODE_VECTOR_INT
:
3786 case MODE_VECTOR_FRACT
:
3787 case MODE_VECTOR_UFRACT
:
3788 case MODE_VECTOR_ACCUM
:
3789 case MODE_VECTOR_UACCUM
:
3792 enum machine_mode submode
= GET_MODE_INNER (mode
);
3793 unsigned int subalign
= MIN (align
, GET_MODE_BITSIZE (submode
));
3795 gcc_assert (GET_CODE (x
) == CONST_VECTOR
);
3796 units
= CONST_VECTOR_NUNITS (x
);
3798 for (i
= 0; i
< units
; i
++)
3800 rtx elt
= CONST_VECTOR_ELT (x
, i
);
3801 output_constant_pool_2 (submode
, elt
, i
? subalign
: align
);
3811 /* Worker function for output_constant_pool. Emit constant DESC,
3812 giving it ALIGN bits of alignment. */
3815 output_constant_pool_1 (struct constant_descriptor_rtx
*desc
,
3822 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3823 whose CODE_LABEL has been deleted. This can occur if a jump table
3824 is eliminated by optimization. If so, write a constant of zero
3825 instead. Note that this can also happen by turning the
3826 CODE_LABEL into a NOTE. */
3827 /* ??? This seems completely and utterly wrong. Certainly it's
3828 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3829 functioning even with INSN_DELETED_P and friends. */
3832 switch (GET_CODE (tmp
))
3835 if (GET_CODE (XEXP (tmp
, 0)) != PLUS
3836 || GET_CODE (XEXP (XEXP (tmp
, 0), 0)) != LABEL_REF
)
3838 tmp
= XEXP (XEXP (tmp
, 0), 0);
3842 tmp
= XEXP (tmp
, 0);
3843 gcc_assert (!INSN_DELETED_P (tmp
));
3844 gcc_assert (!NOTE_P (tmp
)
3845 || NOTE_KIND (tmp
) != NOTE_INSN_DELETED
);
3852 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3853 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, desc
->mode
,
3854 align
, desc
->labelno
, done
);
3857 assemble_align (align
);
3859 /* Output the label. */
3860 targetm
.asm_out
.internal_label (asm_out_file
, "LC", desc
->labelno
);
3862 /* Output the data. */
3863 output_constant_pool_2 (desc
->mode
, x
, align
);
3865 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3866 sections have proper size. */
3867 if (align
> GET_MODE_BITSIZE (desc
->mode
)
3869 && (in_section
->common
.flags
& SECTION_MERGE
))
3870 assemble_align (align
);
3872 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3878 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3879 to as used. Emit referenced deferred strings. This function can
3880 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3883 mark_constant (rtx
*current_rtx
, void *data ATTRIBUTE_UNUSED
)
3885 rtx x
= *current_rtx
;
3887 if (x
== NULL_RTX
|| GET_CODE (x
) != SYMBOL_REF
)
3890 if (CONSTANT_POOL_ADDRESS_P (x
))
3892 struct constant_descriptor_rtx
*desc
= SYMBOL_REF_CONSTANT (x
);
3893 if (desc
->mark
== 0)
3896 for_each_rtx (&desc
->constant
, mark_constant
, NULL
);
3899 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
3901 tree decl
= SYMBOL_REF_DECL (x
);
3902 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
3904 n_deferred_constants
--;
3905 output_constant_def_contents (x
);
3912 /* Look through appropriate parts of INSN, marking all entries in the
3913 constant pool which are actually being used. Entries that are only
3914 referenced by other constants are also marked as used. Emit
3915 deferred strings that are used. */
3918 mark_constants (rtx_insn
*insn
)
3923 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3924 insns, not any notes that may be attached. We don't want to mark
3925 a constant just because it happens to appear in a REG_EQUIV note. */
3926 if (GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3928 rtx seq
= PATTERN (insn
);
3929 int i
, n
= XVECLEN (seq
, 0);
3930 for (i
= 0; i
< n
; ++i
)
3932 rtx subinsn
= XVECEXP (seq
, 0, i
);
3933 if (INSN_P (subinsn
))
3934 for_each_rtx (&PATTERN (subinsn
), mark_constant
, NULL
);
3938 for_each_rtx (&PATTERN (insn
), mark_constant
, NULL
);
3941 /* Look through the instructions for this function, and mark all the
3942 entries in POOL which are actually being used. Emit deferred constants
3943 which have indeed been used. */
3946 mark_constant_pool (void)
3950 if (!crtl
->uses_const_pool
&& n_deferred_constants
== 0)
3953 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3954 mark_constants (insn
);
3957 /* Write all the constants in POOL. */
3960 output_constant_pool_contents (struct rtx_constant_pool
*pool
)
3962 struct constant_descriptor_rtx
*desc
;
3964 for (desc
= pool
->first
; desc
; desc
= desc
->next
)
3967 /* If the constant is part of an object_block, make sure that
3968 the constant has been positioned within its block, but do not
3969 write out its definition yet. output_object_blocks will do
3971 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc
->sym
)
3972 && SYMBOL_REF_BLOCK (desc
->sym
))
3973 place_block_symbol (desc
->sym
);
3976 switch_to_section (targetm
.asm_out
.select_rtx_section
3977 (desc
->mode
, desc
->constant
, desc
->align
));
3978 output_constant_pool_1 (desc
, desc
->align
);
3983 /* Mark all constants that are used in the current function, then write
3984 out the function's private constant pool. */
3987 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED
,
3988 tree fndecl ATTRIBUTE_UNUSED
)
3990 struct rtx_constant_pool
*pool
= crtl
->varasm
.pool
;
3992 /* It is possible for gcc to call force_const_mem and then to later
3993 discard the instructions which refer to the constant. In such a
3994 case we do not need to output the constant. */
3995 mark_constant_pool ();
3997 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3998 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4001 output_constant_pool_contents (pool
);
4003 #ifdef ASM_OUTPUT_POOL_EPILOGUE
4004 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4008 /* Write the contents of the shared constant pool. */
4011 output_shared_constant_pool (void)
4013 output_constant_pool_contents (shared_constant_pool
);
4016 /* Determine what kind of relocations EXP may need. */
4019 compute_reloc_for_constant (tree exp
)
4021 int reloc
= 0, reloc2
;
4024 switch (TREE_CODE (exp
))
4028 /* Go inside any operations that get_inner_reference can handle and see
4029 if what's inside is a constant: no need to do anything here for
4030 addresses of variables or functions. */
4031 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4032 tem
= TREE_OPERAND (tem
, 0))
4035 if (TREE_CODE (tem
) == MEM_REF
4036 && TREE_CODE (TREE_OPERAND (tem
, 0)) == ADDR_EXPR
)
4038 reloc
= compute_reloc_for_constant (TREE_OPERAND (tem
, 0));
4042 if (!targetm
.binds_local_p (tem
))
4049 case POINTER_PLUS_EXPR
:
4050 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4051 reloc
|= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4055 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4056 reloc2
= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4057 /* The difference of two local labels is computable at link time. */
4058 if (reloc
== 1 && reloc2
== 1)
4065 case VIEW_CONVERT_EXPR
:
4066 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4071 unsigned HOST_WIDE_INT idx
;
4072 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4074 reloc
|= compute_reloc_for_constant (tem
);
4084 /* Find all the constants whose addresses are referenced inside of EXP,
4085 and make sure assembler code with a label has been output for each one.
4086 Indicate whether an ADDR_EXPR has been encountered. */
4089 output_addressed_constants (tree exp
)
4093 switch (TREE_CODE (exp
))
4097 /* Go inside any operations that get_inner_reference can handle and see
4098 if what's inside is a constant: no need to do anything here for
4099 addresses of variables or functions. */
4100 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4101 tem
= TREE_OPERAND (tem
, 0))
4104 /* If we have an initialized CONST_DECL, retrieve the initializer. */
4105 if (TREE_CODE (tem
) == CONST_DECL
&& DECL_INITIAL (tem
))
4106 tem
= DECL_INITIAL (tem
);
4108 if (CONSTANT_CLASS_P (tem
) || TREE_CODE (tem
) == CONSTRUCTOR
)
4109 output_constant_def (tem
, 0);
4111 if (TREE_CODE (tem
) == MEM_REF
)
4112 output_addressed_constants (TREE_OPERAND (tem
, 0));
4116 case POINTER_PLUS_EXPR
:
4118 output_addressed_constants (TREE_OPERAND (exp
, 1));
4122 case VIEW_CONVERT_EXPR
:
4123 output_addressed_constants (TREE_OPERAND (exp
, 0));
4128 unsigned HOST_WIDE_INT idx
;
4129 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4131 output_addressed_constants (tem
);
4140 /* Whether a constructor CTOR is a valid static constant initializer if all
4141 its elements are. This used to be internal to initializer_constant_valid_p
4142 and has been exposed to let other functions like categorize_ctor_elements
4143 evaluate the property while walking a constructor for other purposes. */
4146 constructor_static_from_elts_p (const_tree ctor
)
4148 return (TREE_CONSTANT (ctor
)
4149 && (TREE_CODE (TREE_TYPE (ctor
)) == UNION_TYPE
4150 || TREE_CODE (TREE_TYPE (ctor
)) == RECORD_TYPE
4151 || TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
));
4154 static tree
initializer_constant_valid_p_1 (tree value
, tree endtype
,
4157 /* A subroutine of initializer_constant_valid_p. VALUE is a MINUS_EXPR,
4158 PLUS_EXPR or POINTER_PLUS_EXPR. This looks for cases of VALUE
4159 which are valid when ENDTYPE is an integer of any size; in
4160 particular, this does not accept a pointer minus a constant. This
4161 returns null_pointer_node if the VALUE is an absolute constant
4162 which can be used to initialize a static variable. Otherwise it
4166 narrowing_initializer_constant_valid_p (tree value
, tree endtype
, tree
*cache
)
4170 if (!INTEGRAL_TYPE_P (endtype
))
4173 op0
= TREE_OPERAND (value
, 0);
4174 op1
= TREE_OPERAND (value
, 1);
4176 /* Like STRIP_NOPS except allow the operand mode to widen. This
4177 works around a feature of fold that simplifies (int)(p1 - p2) to
4178 ((int)p1 - (int)p2) under the theory that the narrower operation
4181 while (CONVERT_EXPR_P (op0
)
4182 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4184 tree inner
= TREE_OPERAND (op0
, 0);
4185 if (inner
== error_mark_node
4186 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4187 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
4188 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4193 while (CONVERT_EXPR_P (op1
)
4194 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
4196 tree inner
= TREE_OPERAND (op1
, 0);
4197 if (inner
== error_mark_node
4198 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4199 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
4200 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4205 op0
= initializer_constant_valid_p_1 (op0
, endtype
, cache
);
4209 op1
= initializer_constant_valid_p_1 (op1
, endtype
,
4210 cache
? cache
+ 2 : NULL
);
4211 /* Both initializers must be known. */
4215 && (op0
== null_pointer_node
4216 || TREE_CODE (value
) == MINUS_EXPR
))
4217 return null_pointer_node
;
4219 /* Support differences between labels. */
4220 if (TREE_CODE (op0
) == LABEL_DECL
4221 && TREE_CODE (op1
) == LABEL_DECL
)
4222 return null_pointer_node
;
4224 if (TREE_CODE (op0
) == STRING_CST
4225 && TREE_CODE (op1
) == STRING_CST
4226 && operand_equal_p (op0
, op1
, 1))
4227 return null_pointer_node
;
4233 /* Helper function of initializer_constant_valid_p.
4234 Return nonzero if VALUE is a valid constant-valued expression
4235 for use in initializing a static variable; one that can be an
4236 element of a "constant" initializer.
4238 Return null_pointer_node if the value is absolute;
4239 if it is relocatable, return the variable that determines the relocation.
4240 We assume that VALUE has been folded as much as possible;
4241 therefore, we do not need to check for such things as
4242 arithmetic-combinations of integers.
4244 Use CACHE (pointer to 2 tree values) for caching if non-NULL. */
4247 initializer_constant_valid_p_1 (tree value
, tree endtype
, tree
*cache
)
4251 switch (TREE_CODE (value
))
4254 if (constructor_static_from_elts_p (value
))
4256 unsigned HOST_WIDE_INT idx
;
4258 bool absolute
= true;
4260 if (cache
&& cache
[0] == value
)
4262 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4265 reloc
= initializer_constant_valid_p_1 (elt
, TREE_TYPE (elt
),
4272 cache
[1] = NULL_TREE
;
4276 if (reloc
!= null_pointer_node
)
4279 /* For a non-absolute relocation, there is no single
4280 variable that can be "the variable that determines the
4285 cache
[1] = absolute
? null_pointer_node
: error_mark_node
;
4287 return absolute
? null_pointer_node
: error_mark_node
;
4290 return TREE_STATIC (value
) ? null_pointer_node
: NULL_TREE
;
4298 return null_pointer_node
;
4303 tree op0
= staticp (TREE_OPERAND (value
, 0));
4306 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out
4307 to be a constant, this is old-skool offsetof-like nonsense. */
4308 if (TREE_CODE (op0
) == INDIRECT_REF
4309 && TREE_CONSTANT (TREE_OPERAND (op0
, 0)))
4310 return null_pointer_node
;
4311 /* Taking the address of a nested function involves a trampoline,
4312 unless we don't need or want one. */
4313 if (TREE_CODE (op0
) == FUNCTION_DECL
4314 && DECL_STATIC_CHAIN (op0
)
4315 && !TREE_NO_TRAMPOLINE (value
))
4317 /* "&{...}" requires a temporary to hold the constructed
4319 if (TREE_CODE (op0
) == CONSTRUCTOR
)
4325 case NON_LVALUE_EXPR
:
4326 return initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4329 case VIEW_CONVERT_EXPR
:
4331 tree src
= TREE_OPERAND (value
, 0);
4332 tree src_type
= TREE_TYPE (src
);
4333 tree dest_type
= TREE_TYPE (value
);
4335 /* Allow view-conversions from aggregate to non-aggregate type only
4336 if the bit pattern is fully preserved afterwards; otherwise, the
4337 RTL expander won't be able to apply a subsequent transformation
4338 to the underlying constructor. */
4339 if (AGGREGATE_TYPE_P (src_type
) && !AGGREGATE_TYPE_P (dest_type
))
4341 if (TYPE_MODE (endtype
) == TYPE_MODE (dest_type
))
4342 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4347 /* Allow all other kinds of view-conversion. */
4348 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4353 tree src
= TREE_OPERAND (value
, 0);
4354 tree src_type
= TREE_TYPE (src
);
4355 tree dest_type
= TREE_TYPE (value
);
4357 /* Allow conversions between pointer types, floating-point
4358 types, and offset types. */
4359 if ((POINTER_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
))
4360 || (FLOAT_TYPE_P (dest_type
) && FLOAT_TYPE_P (src_type
))
4361 || (TREE_CODE (dest_type
) == OFFSET_TYPE
4362 && TREE_CODE (src_type
) == OFFSET_TYPE
))
4363 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4365 /* Allow length-preserving conversions between integer types. */
4366 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
)
4367 && (TYPE_PRECISION (dest_type
) == TYPE_PRECISION (src_type
)))
4368 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4370 /* Allow conversions between other integer types only if
4372 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
))
4374 tree inner
= initializer_constant_valid_p_1 (src
, endtype
, cache
);
4375 if (inner
== null_pointer_node
)
4376 return null_pointer_node
;
4380 /* Allow (int) &foo provided int is as wide as a pointer. */
4381 if (INTEGRAL_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
)
4382 && (TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
)))
4383 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4385 /* Likewise conversions from int to pointers, but also allow
4386 conversions from 0. */
4387 if ((POINTER_TYPE_P (dest_type
)
4388 || TREE_CODE (dest_type
) == OFFSET_TYPE
)
4389 && INTEGRAL_TYPE_P (src_type
))
4391 if (TREE_CODE (src
) == INTEGER_CST
4392 && TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
))
4393 return null_pointer_node
;
4394 if (integer_zerop (src
))
4395 return null_pointer_node
;
4396 else if (TYPE_PRECISION (dest_type
) <= TYPE_PRECISION (src_type
))
4397 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4400 /* Allow conversions to struct or union types if the value
4402 if (TREE_CODE (dest_type
) == RECORD_TYPE
4403 || TREE_CODE (dest_type
) == UNION_TYPE
)
4404 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4408 case POINTER_PLUS_EXPR
:
4410 /* Any valid floating-point constants will have been folded by now;
4411 with -frounding-math we hit this with addition of two constants. */
4412 if (TREE_CODE (endtype
) == REAL_TYPE
)
4414 if (cache
&& cache
[0] == value
)
4416 if (! INTEGRAL_TYPE_P (endtype
)
4417 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4419 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4421 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4424 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4425 endtype
, ncache
+ 2);
4426 /* If either term is absolute, use the other term's relocation. */
4427 if (valid0
== null_pointer_node
)
4429 else if (valid1
== null_pointer_node
)
4431 /* Support narrowing pointer differences. */
4433 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4437 /* Support narrowing pointer differences. */
4438 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4447 if (TREE_CODE (endtype
) == REAL_TYPE
)
4449 if (cache
&& cache
[0] == value
)
4451 if (! INTEGRAL_TYPE_P (endtype
)
4452 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4454 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4456 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4459 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4460 endtype
, ncache
+ 2);
4461 /* Win if second argument is absolute. */
4462 if (valid1
== null_pointer_node
)
4464 /* Win if both arguments have the same relocation.
4465 Then the value is absolute. */
4466 else if (valid0
== valid1
&& valid0
!= 0)
4467 ret
= null_pointer_node
;
4468 /* Since GCC guarantees that string constants are unique in the
4469 generated code, a subtraction between two copies of the same
4470 constant string is absolute. */
4471 else if (valid0
&& TREE_CODE (valid0
) == STRING_CST
4472 && valid1
&& TREE_CODE (valid1
) == STRING_CST
4473 && operand_equal_p (valid0
, valid1
, 1))
4474 ret
= null_pointer_node
;
4475 /* Support narrowing differences. */
4477 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4481 /* Support narrowing differences. */
4482 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4497 /* Return nonzero if VALUE is a valid constant-valued expression
4498 for use in initializing a static variable; one that can be an
4499 element of a "constant" initializer.
4501 Return null_pointer_node if the value is absolute;
4502 if it is relocatable, return the variable that determines the relocation.
4503 We assume that VALUE has been folded as much as possible;
4504 therefore, we do not need to check for such things as
4505 arithmetic-combinations of integers. */
4507 initializer_constant_valid_p (tree value
, tree endtype
)
4509 return initializer_constant_valid_p_1 (value
, endtype
, NULL
);
4512 /* Return true if VALUE is a valid constant-valued expression
4513 for use in initializing a static bit-field; one that can be
4514 an element of a "constant" initializer. */
4517 initializer_constant_valid_for_bitfield_p (tree value
)
4519 /* For bitfields we support integer constants or possibly nested aggregates
4521 switch (TREE_CODE (value
))
4525 unsigned HOST_WIDE_INT idx
;
4528 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4529 if (!initializer_constant_valid_for_bitfield_p (elt
))
4538 case VIEW_CONVERT_EXPR
:
4539 case NON_LVALUE_EXPR
:
4541 initializer_constant_valid_for_bitfield_p (TREE_OPERAND (value
, 0));
4550 /* output_constructor outer state of relevance in recursive calls, typically
4551 for nested aggregate bitfields. */
4554 unsigned int bit_offset
; /* current position in ... */
4555 int byte
; /* ... the outer byte buffer. */
4558 static unsigned HOST_WIDE_INT
4559 output_constructor (tree
, unsigned HOST_WIDE_INT
, unsigned int,
4562 /* Output assembler code for constant EXP, with no label.
4563 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4564 Assumes output_addressed_constants has been done on EXP already.
4566 Generate at least SIZE bytes of assembler data, padding at the end
4567 with zeros if necessary. SIZE must always be specified. The returned
4568 value is the actual number of bytes of assembler data generated, which
4569 may be bigger than SIZE if the object contains a variable length field.
4571 SIZE is important for structure constructors,
4572 since trailing members may have been omitted from the constructor.
4573 It is also important for initialization of arrays from string constants
4574 since the full length of the string constant might not be wanted.
4575 It is also needed for initialization of unions, where the initializer's
4576 type is just one member, and that may not be as long as the union.
4578 There a case in which we would fail to output exactly SIZE bytes:
4579 for a structure constructor that wants to produce more than SIZE bytes.
4580 But such constructors will never be generated for any possible input.
4582 ALIGN is the alignment of the data in bits. */
4584 static unsigned HOST_WIDE_INT
4585 output_constant (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
)
4587 enum tree_code code
;
4588 unsigned HOST_WIDE_INT thissize
;
4590 if (size
== 0 || flag_syntax_only
)
4593 /* See if we're trying to initialize a pointer in a non-default mode
4594 to the address of some declaration somewhere. If the target says
4595 the mode is valid for pointers, assume the target has a way of
4597 if (TREE_CODE (exp
) == NOP_EXPR
4598 && POINTER_TYPE_P (TREE_TYPE (exp
))
4599 && targetm
.addr_space
.valid_pointer_mode
4600 (TYPE_MODE (TREE_TYPE (exp
)),
4601 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4603 tree saved_type
= TREE_TYPE (exp
);
4605 /* Peel off any intermediate conversions-to-pointer for valid
4607 while (TREE_CODE (exp
) == NOP_EXPR
4608 && POINTER_TYPE_P (TREE_TYPE (exp
))
4609 && targetm
.addr_space
.valid_pointer_mode
4610 (TYPE_MODE (TREE_TYPE (exp
)),
4611 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4612 exp
= TREE_OPERAND (exp
, 0);
4614 /* If what we're left with is the address of something, we can
4615 convert the address to the final type and output it that
4617 if (TREE_CODE (exp
) == ADDR_EXPR
)
4618 exp
= build1 (ADDR_EXPR
, saved_type
, TREE_OPERAND (exp
, 0));
4619 /* Likewise for constant ints. */
4620 else if (TREE_CODE (exp
) == INTEGER_CST
)
4621 exp
= wide_int_to_tree (saved_type
, exp
);
4625 /* Eliminate any conversions since we'll be outputting the underlying
4627 while (CONVERT_EXPR_P (exp
)
4628 || TREE_CODE (exp
) == NON_LVALUE_EXPR
4629 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
4631 HOST_WIDE_INT type_size
= int_size_in_bytes (TREE_TYPE (exp
));
4632 HOST_WIDE_INT op_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4634 /* Make sure eliminating the conversion is really a no-op, except with
4635 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4636 union types to allow for Ada unchecked unions. */
4637 if (type_size
> op_size
4638 && TREE_CODE (exp
) != VIEW_CONVERT_EXPR
4639 && TREE_CODE (TREE_TYPE (exp
)) != UNION_TYPE
)
4640 /* Keep the conversion. */
4643 exp
= TREE_OPERAND (exp
, 0);
4646 code
= TREE_CODE (TREE_TYPE (exp
));
4647 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
4649 /* Allow a constructor with no elements for any data type.
4650 This means to fill the space with zeros. */
4651 if (TREE_CODE (exp
) == CONSTRUCTOR
4652 && vec_safe_is_empty (CONSTRUCTOR_ELTS (exp
)))
4654 assemble_zeros (size
);
4658 if (TREE_CODE (exp
) == FDESC_EXPR
)
4660 #ifdef ASM_OUTPUT_FDESC
4661 HOST_WIDE_INT part
= tree_to_shwi (TREE_OPERAND (exp
, 1));
4662 tree decl
= TREE_OPERAND (exp
, 0);
4663 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
4670 /* Now output the underlying data. If we've handling the padding, return.
4671 Otherwise, break and ensure SIZE is the size written. */
4678 case REFERENCE_TYPE
:
4680 case FIXED_POINT_TYPE
:
4682 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4683 EXPAND_INITIALIZER
),
4684 MIN (size
, thissize
), align
, 0))
4685 error ("initializer for integer/fixed-point value is too complicated");
4689 if (TREE_CODE (exp
) != REAL_CST
)
4690 error ("initializer for floating value is not a floating constant");
4692 assemble_real (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)), align
);
4696 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
4697 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
4698 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
4703 switch (TREE_CODE (exp
))
4706 return output_constructor (exp
, size
, align
, NULL
);
4709 = MIN ((unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
), size
);
4710 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
4714 enum machine_mode inner
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
4715 unsigned int nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
4716 int elt_size
= GET_MODE_SIZE (inner
);
4717 output_constant (VECTOR_CST_ELT (exp
, 0), elt_size
, align
);
4718 thissize
= elt_size
;
4719 for (unsigned int i
= 1; i
< VECTOR_CST_NELTS (exp
); i
++)
4721 output_constant (VECTOR_CST_ELT (exp
, i
), elt_size
, nalign
);
4722 thissize
+= elt_size
;
4733 gcc_assert (TREE_CODE (exp
) == CONSTRUCTOR
);
4734 return output_constructor (exp
, size
, align
, NULL
);
4743 if (size
> thissize
)
4744 assemble_zeros (size
- thissize
);
4750 /* Subroutine of output_constructor, used for computing the size of
4751 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4752 type with an unspecified upper bound. */
4754 static unsigned HOST_WIDE_INT
4755 array_size_for_constructor (tree val
)
4758 unsigned HOST_WIDE_INT cnt
;
4759 tree index
, value
, tmp
;
4762 /* This code used to attempt to handle string constants that are not
4763 arrays of single-bytes, but nothing else does, so there's no point in
4765 if (TREE_CODE (val
) == STRING_CST
)
4766 return TREE_STRING_LENGTH (val
);
4768 max_index
= NULL_TREE
;
4769 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val
), cnt
, index
, value
)
4771 if (TREE_CODE (index
) == RANGE_EXPR
)
4772 index
= TREE_OPERAND (index
, 1);
4773 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4777 if (max_index
== NULL_TREE
)
4780 /* Compute the total number of array elements. */
4781 tmp
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)));
4782 i
= wi::to_offset (max_index
) - wi::to_offset (tmp
) + 1;
4784 /* Multiply by the array element unit size to find number of bytes. */
4785 i
*= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4787 gcc_assert (wi::fits_uhwi_p (i
));
4788 return i
.to_uhwi ();
4791 /* Other datastructures + helpers for output_constructor. */
4793 /* output_constructor local state to support interaction with helpers. */
4797 /* Received arguments. */
4798 tree exp
; /* Constructor expression. */
4799 tree type
; /* Type of constructor expression. */
4800 unsigned HOST_WIDE_INT size
; /* # bytes to output - pad if necessary. */
4801 unsigned int align
; /* Known initial alignment. */
4802 tree min_index
; /* Lower bound if specified for an array. */
4804 /* Output processing state. */
4805 HOST_WIDE_INT total_bytes
; /* # bytes output so far / current position. */
4806 int byte
; /* Part of a bitfield byte yet to be output. */
4807 int last_relative_index
; /* Implicit or explicit index of the last
4808 array element output within a bitfield. */
4809 bool byte_buffer_in_use
; /* Whether BYTE is in use. */
4811 /* Current element. */
4812 tree field
; /* Current field decl in a record. */
4813 tree val
; /* Current element value. */
4814 tree index
; /* Current element index. */
4818 /* Helper for output_constructor. From the current LOCAL state, output a
4819 RANGE_EXPR element. */
4822 output_constructor_array_range (oc_local_state
*local
)
4824 unsigned HOST_WIDE_INT fieldsize
4825 = int_size_in_bytes (TREE_TYPE (local
->type
));
4827 HOST_WIDE_INT lo_index
4828 = tree_to_shwi (TREE_OPERAND (local
->index
, 0));
4829 HOST_WIDE_INT hi_index
4830 = tree_to_shwi (TREE_OPERAND (local
->index
, 1));
4831 HOST_WIDE_INT index
;
4834 = min_align (local
->align
, fieldsize
* BITS_PER_UNIT
);
4836 for (index
= lo_index
; index
<= hi_index
; index
++)
4838 /* Output the element's initial value. */
4839 if (local
->val
== NULL_TREE
)
4840 assemble_zeros (fieldsize
);
4842 fieldsize
= output_constant (local
->val
, fieldsize
, align2
);
4844 /* Count its size. */
4845 local
->total_bytes
+= fieldsize
;
4849 /* Helper for output_constructor. From the current LOCAL state, output a
4850 field element that is not true bitfield or part of an outer one. */
4853 output_constructor_regular_field (oc_local_state
*local
)
4855 /* Field size and position. Since this structure is static, we know the
4856 positions are constant. */
4857 unsigned HOST_WIDE_INT fieldsize
;
4858 HOST_WIDE_INT fieldpos
;
4860 unsigned int align2
;
4862 if (local
->index
!= NULL_TREE
)
4864 /* Perform the index calculation in modulo arithmetic but
4865 sign-extend the result because Ada has negative DECL_FIELD_OFFSETs
4866 but we are using an unsigned sizetype. */
4867 unsigned prec
= TYPE_PRECISION (sizetype
);
4868 offset_int idx
= wi::sext (wi::to_offset (local
->index
)
4869 - wi::to_offset (local
->min_index
), prec
);
4870 fieldpos
= (idx
* wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (local
->val
))))
4873 else if (local
->field
!= NULL_TREE
)
4874 fieldpos
= int_byte_position (local
->field
);
4878 /* Output any buffered-up bit-fields preceding this element. */
4879 if (local
->byte_buffer_in_use
)
4881 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
4882 local
->total_bytes
++;
4883 local
->byte_buffer_in_use
= false;
4886 /* Advance to offset of this element.
4887 Note no alignment needed in an array, since that is guaranteed
4888 if each element has the proper size. */
4889 if ((local
->field
!= NULL_TREE
|| local
->index
!= NULL_TREE
)
4890 && fieldpos
> local
->total_bytes
)
4892 assemble_zeros (fieldpos
- local
->total_bytes
);
4893 local
->total_bytes
= fieldpos
;
4896 /* Find the alignment of this element. */
4897 align2
= min_align (local
->align
, BITS_PER_UNIT
* fieldpos
);
4899 /* Determine size this element should occupy. */
4904 /* If this is an array with an unspecified upper bound,
4905 the initializer determines the size. */
4906 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4907 but we cannot do this until the deprecated support for
4908 initializing zero-length array members is removed. */
4909 if (TREE_CODE (TREE_TYPE (local
->field
)) == ARRAY_TYPE
4910 && TYPE_DOMAIN (TREE_TYPE (local
->field
))
4911 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (local
->field
))))
4913 fieldsize
= array_size_for_constructor (local
->val
);
4914 /* Given a non-empty initialization, this field had
4916 gcc_assert (!fieldsize
|| !DECL_CHAIN (local
->field
));
4919 fieldsize
= tree_to_uhwi (DECL_SIZE_UNIT (local
->field
));
4922 fieldsize
= int_size_in_bytes (TREE_TYPE (local
->type
));
4924 /* Output the element's initial value. */
4925 if (local
->val
== NULL_TREE
)
4926 assemble_zeros (fieldsize
);
4928 fieldsize
= output_constant (local
->val
, fieldsize
, align2
);
4930 /* Count its size. */
4931 local
->total_bytes
+= fieldsize
;
4934 /* Helper for output_constructor. From the LOCAL state, output an element
4935 that is a true bitfield or part of an outer one. BIT_OFFSET is the offset
4936 from the start of a possibly ongoing outer byte buffer. */
4939 output_constructor_bitfield (oc_local_state
*local
, unsigned int bit_offset
)
4941 /* Bit size of this element. */
4942 HOST_WIDE_INT ebitsize
4944 ? tree_to_uhwi (DECL_SIZE (local
->field
))
4945 : tree_to_uhwi (TYPE_SIZE (TREE_TYPE (local
->type
))));
4947 /* Relative index of this element if this is an array component. */
4948 HOST_WIDE_INT relative_index
4951 ? (tree_to_shwi (local
->index
)
4952 - tree_to_shwi (local
->min_index
))
4953 : local
->last_relative_index
+ 1)
4956 /* Bit position of this element from the start of the containing
4958 HOST_WIDE_INT constructor_relative_ebitpos
4960 ? int_bit_position (local
->field
)
4961 : ebitsize
* relative_index
);
4963 /* Bit position of this element from the start of a possibly ongoing
4964 outer byte buffer. */
4965 HOST_WIDE_INT byte_relative_ebitpos
4966 = bit_offset
+ constructor_relative_ebitpos
;
4968 /* From the start of a possibly ongoing outer byte buffer, offsets to
4969 the first bit of this element and to the first bit past the end of
4971 HOST_WIDE_INT next_offset
= byte_relative_ebitpos
;
4972 HOST_WIDE_INT end_offset
= byte_relative_ebitpos
+ ebitsize
;
4974 local
->last_relative_index
= relative_index
;
4976 if (local
->val
== NULL_TREE
)
4977 local
->val
= integer_zero_node
;
4979 while (TREE_CODE (local
->val
) == VIEW_CONVERT_EXPR
4980 || TREE_CODE (local
->val
) == NON_LVALUE_EXPR
)
4981 local
->val
= TREE_OPERAND (local
->val
, 0);
4983 if (TREE_CODE (local
->val
) != INTEGER_CST
4984 && TREE_CODE (local
->val
) != CONSTRUCTOR
)
4986 error ("invalid initial value for member %qE", DECL_NAME (local
->field
));
4990 /* If this field does not start in this (or next) byte, skip some bytes. */
4991 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
4993 /* Output remnant of any bit field in previous bytes. */
4994 if (local
->byte_buffer_in_use
)
4996 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
4997 local
->total_bytes
++;
4998 local
->byte_buffer_in_use
= false;
5001 /* If still not at proper byte, advance to there. */
5002 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
5004 gcc_assert (next_offset
/ BITS_PER_UNIT
>= local
->total_bytes
);
5005 assemble_zeros (next_offset
/ BITS_PER_UNIT
- local
->total_bytes
);
5006 local
->total_bytes
= next_offset
/ BITS_PER_UNIT
;
5010 /* Set up the buffer if necessary. */
5011 if (!local
->byte_buffer_in_use
)
5015 local
->byte_buffer_in_use
= true;
5018 /* If this is nested constructor, recurse passing the bit offset and the
5019 pending data, then retrieve the new pending data afterwards. */
5020 if (TREE_CODE (local
->val
) == CONSTRUCTOR
)
5022 oc_outer_state temp_state
;
5023 temp_state
.bit_offset
= next_offset
% BITS_PER_UNIT
;
5024 temp_state
.byte
= local
->byte
;
5026 += output_constructor (local
->val
, 0, 0, &temp_state
);
5027 local
->byte
= temp_state
.byte
;
5031 /* Otherwise, we must split the element into pieces that fall within
5032 separate bytes, and combine each byte with previous or following
5034 while (next_offset
< end_offset
)
5038 HOST_WIDE_INT value
;
5039 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
5040 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
5042 /* Advance from byte to byte within this element when necessary. */
5043 while (next_byte
!= local
->total_bytes
)
5045 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5046 local
->total_bytes
++;
5050 /* Number of bits we can process at once (all part of the same byte). */
5051 this_time
= MIN (end_offset
- next_offset
, BITS_PER_UNIT
- next_bit
);
5052 if (BYTES_BIG_ENDIAN
)
5054 /* On big-endian machine, take the most significant bits (of the
5055 bits that are significant) first and put them into bytes from
5056 the most significant end. */
5057 shift
= end_offset
- next_offset
- this_time
;
5059 /* Don't try to take a bunch of bits that cross
5060 the word boundary in the INTEGER_CST. We can
5061 only select bits from one element. */
5062 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5063 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5065 const int end
= shift
+ this_time
- 1;
5066 shift
= end
& -HOST_BITS_PER_WIDE_INT
;
5067 this_time
= end
- shift
+ 1;
5070 /* Now get the bits from the appropriate constant word. */
5071 value
= TREE_INT_CST_ELT (local
->val
, shift
/ HOST_BITS_PER_WIDE_INT
);
5072 shift
= shift
& (HOST_BITS_PER_WIDE_INT
- 1);
5074 /* Get the result. This works only when:
5075 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5076 local
->byte
|= (((value
>> shift
)
5077 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
5078 << (BITS_PER_UNIT
- this_time
- next_bit
));
5082 /* On little-endian machines, take the least significant bits of
5083 the value first and pack them starting at the least significant
5084 bits of the bytes. */
5085 shift
= next_offset
- byte_relative_ebitpos
;
5087 /* Don't try to take a bunch of bits that cross
5088 the word boundary in the INTEGER_CST. We can
5089 only select bits from one element. */
5090 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5091 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5093 = HOST_BITS_PER_WIDE_INT
- (shift
& (HOST_BITS_PER_WIDE_INT
- 1));
5095 /* Now get the bits from the appropriate constant word. */
5096 value
= TREE_INT_CST_ELT (local
->val
, shift
/ HOST_BITS_PER_WIDE_INT
);
5097 shift
= shift
& (HOST_BITS_PER_WIDE_INT
- 1);
5099 /* Get the result. This works only when:
5100 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5101 local
->byte
|= (((value
>> shift
)
5102 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
5106 next_offset
+= this_time
;
5107 local
->byte_buffer_in_use
= true;
5111 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
5112 Generate at least SIZE bytes, padding if necessary. OUTER designates the
5113 caller output state of relevance in recursive invocations. */
5115 static unsigned HOST_WIDE_INT
5116 output_constructor (tree exp
, unsigned HOST_WIDE_INT size
,
5117 unsigned int align
, oc_outer_state
*outer
)
5119 unsigned HOST_WIDE_INT cnt
;
5120 constructor_elt
*ce
;
5122 oc_local_state local
;
5124 /* Setup our local state to communicate with helpers. */
5126 local
.type
= TREE_TYPE (exp
);
5128 local
.align
= align
;
5129 if (TREE_CODE (local
.type
) == ARRAY_TYPE
&& TYPE_DOMAIN (local
.type
))
5130 local
.min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (local
.type
));
5132 local
.min_index
= NULL_TREE
;
5134 local
.total_bytes
= 0;
5135 local
.byte_buffer_in_use
= outer
!= NULL
;
5136 local
.byte
= outer
? outer
->byte
: 0;
5137 local
.last_relative_index
= -1;
5139 gcc_assert (HOST_BITS_PER_WIDE_INT
>= BITS_PER_UNIT
);
5141 /* As CE goes through the elements of the constant, FIELD goes through the
5142 structure fields if the constant is a structure. If the constant is a
5143 union, we override this by getting the field from the TREE_LIST element.
5144 But the constant could also be an array. Then FIELD is zero.
5146 There is always a maximum of one element in the chain LINK for unions
5147 (even if the initializer in a source program incorrectly contains
5150 if (TREE_CODE (local
.type
) == RECORD_TYPE
)
5151 local
.field
= TYPE_FIELDS (local
.type
);
5153 local
.field
= NULL_TREE
;
5156 vec_safe_iterate (CONSTRUCTOR_ELTS (exp
), cnt
, &ce
);
5157 cnt
++, local
.field
= local
.field
? DECL_CHAIN (local
.field
) : 0)
5159 local
.val
= ce
->value
;
5160 local
.index
= NULL_TREE
;
5162 /* The element in a union constructor specifies the proper field
5164 if (RECORD_OR_UNION_TYPE_P (local
.type
) && ce
->index
!= NULL_TREE
)
5165 local
.field
= ce
->index
;
5167 else if (TREE_CODE (local
.type
) == ARRAY_TYPE
)
5168 local
.index
= ce
->index
;
5170 if (local
.field
&& flag_verbose_asm
)
5171 fprintf (asm_out_file
, "%s %s:\n",
5173 DECL_NAME (local
.field
)
5174 ? IDENTIFIER_POINTER (DECL_NAME (local
.field
))
5177 /* Eliminate the marker that makes a cast not be an lvalue. */
5178 if (local
.val
!= NULL_TREE
)
5179 STRIP_NOPS (local
.val
);
5181 /* Output the current element, using the appropriate helper ... */
5183 /* For an array slice not part of an outer bitfield. */
5185 && local
.index
!= NULL_TREE
5186 && TREE_CODE (local
.index
) == RANGE_EXPR
)
5187 output_constructor_array_range (&local
);
5189 /* For a field that is neither a true bitfield nor part of an outer one,
5190 known to be at least byte aligned and multiple-of-bytes long. */
5192 && (local
.field
== NULL_TREE
5193 || !CONSTRUCTOR_BITFIELD_P (local
.field
)))
5194 output_constructor_regular_field (&local
);
5196 /* For a true bitfield or part of an outer one. Only INTEGER_CSTs are
5197 supported for scalar fields, so we may need to convert first. */
5200 if (TREE_CODE (local
.val
) == REAL_CST
)
5202 = fold_unary (VIEW_CONVERT_EXPR
,
5203 build_nonstandard_integer_type
5204 (TYPE_PRECISION (TREE_TYPE (local
.val
)), 0),
5206 output_constructor_bitfield (&local
, outer
? outer
->bit_offset
: 0);
5210 /* If we are not at toplevel, save the pending data for our caller.
5211 Otherwise output the pending data and padding zeros as needed. */
5213 outer
->byte
= local
.byte
;
5216 if (local
.byte_buffer_in_use
)
5218 assemble_integer (GEN_INT (local
.byte
), 1, BITS_PER_UNIT
, 1);
5219 local
.total_bytes
++;
5222 if ((unsigned HOST_WIDE_INT
)local
.total_bytes
< local
.size
)
5224 assemble_zeros (local
.size
- local
.total_bytes
);
5225 local
.total_bytes
= local
.size
;
5229 return local
.total_bytes
;
5232 /* Mark DECL as weak. */
5235 mark_weak (tree decl
)
5237 DECL_WEAK (decl
) = 1;
5239 if (DECL_RTL_SET_P (decl
)
5240 && MEM_P (DECL_RTL (decl
))
5241 && XEXP (DECL_RTL (decl
), 0)
5242 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
5243 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
5246 /* Merge weak status between NEWDECL and OLDDECL. */
5249 merge_weak (tree newdecl
, tree olddecl
)
5251 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
5253 if (DECL_WEAK (newdecl
) && TARGET_SUPPORTS_WEAK
)
5256 /* We put the NEWDECL on the weak_decls list at some point
5257 and OLDDECL as well. Keep just OLDDECL on the list. */
5258 for (pwd
= &weak_decls
; *pwd
; pwd
= &TREE_CHAIN (*pwd
))
5259 if (TREE_VALUE (*pwd
) == newdecl
)
5261 *pwd
= TREE_CHAIN (*pwd
);
5268 if (DECL_WEAK (newdecl
))
5272 /* NEWDECL is weak, but OLDDECL is not. */
5274 /* If we already output the OLDDECL, we're in trouble; we can't
5275 go back and make it weak. This should never happen in
5276 unit-at-a-time compilation. */
5277 gcc_assert (!TREE_ASM_WRITTEN (olddecl
));
5279 /* If we've already generated rtl referencing OLDDECL, we may
5280 have done so in a way that will not function properly with
5281 a weak symbol. Again in unit-at-a-time this should be
5283 gcc_assert (!TREE_USED (olddecl
)
5284 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)));
5286 if (TARGET_SUPPORTS_WEAK
)
5288 /* We put the NEWDECL on the weak_decls list at some point.
5289 Replace it with the OLDDECL. */
5290 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
5291 if (TREE_VALUE (wd
) == newdecl
)
5293 TREE_VALUE (wd
) = olddecl
;
5296 /* We may not find the entry on the list. If NEWDECL is a
5297 weak alias, then we will have already called
5298 globalize_decl to remove the entry; in that case, we do
5299 not need to do anything. */
5302 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
5303 mark_weak (olddecl
);
5306 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
5307 weak. Just update NEWDECL to indicate that it's weak too. */
5308 mark_weak (newdecl
);
5311 /* Declare DECL to be a weak symbol. */
5314 declare_weak (tree decl
)
5316 gcc_assert (TREE_CODE (decl
) != FUNCTION_DECL
|| !TREE_ASM_WRITTEN (decl
));
5317 if (! TREE_PUBLIC (decl
))
5318 error ("weak declaration of %q+D must be public", decl
);
5319 else if (!TARGET_SUPPORTS_WEAK
)
5320 warning (0, "weak declaration of %q+D not supported", decl
);
5323 if (!lookup_attribute ("weak", DECL_ATTRIBUTES (decl
)))
5324 DECL_ATTRIBUTES (decl
)
5325 = tree_cons (get_identifier ("weak"), NULL
, DECL_ATTRIBUTES (decl
));
5329 weak_finish_1 (tree decl
)
5331 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
5332 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5335 if (! TREE_USED (decl
))
5338 #ifdef ASM_WEAKEN_DECL
5339 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
5341 #ifdef ASM_WEAKEN_LABEL
5342 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5344 #ifdef ASM_OUTPUT_WEAK_ALIAS
5346 static bool warn_once
= 0;
5349 warning (0, "only weak aliases are supported in this configuration");
5359 /* Fiven an assembly name, find the decl it is associated with. */
5361 find_decl (tree target
)
5363 symtab_node
*node
= symtab_node::get_for_asmname (target
);
5369 /* This TREE_LIST contains weakref targets. */
5371 static GTY(()) tree weakref_targets
;
5373 /* Emit any pending weak declarations. */
5380 for (t
= weakref_targets
; t
; t
= TREE_CHAIN (t
))
5382 tree alias_decl
= TREE_PURPOSE (t
);
5383 tree target
= ultimate_transparent_alias_target (&TREE_VALUE (t
));
5385 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl
)))
5386 /* Remove alias_decl from the weak list, but leave entries for
5387 the target alone. */
5389 #ifndef ASM_OUTPUT_WEAKREF
5390 else if (! TREE_SYMBOL_REFERENCED (target
))
5392 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
5393 defined, otherwise we and weak_finish_1 would use
5394 different macros. */
5395 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
5396 ASM_WEAKEN_LABEL (asm_out_file
, IDENTIFIER_POINTER (target
));
5398 tree decl
= find_decl (target
);
5402 decl
= build_decl (DECL_SOURCE_LOCATION (alias_decl
),
5403 TREE_CODE (alias_decl
), target
,
5404 TREE_TYPE (alias_decl
));
5406 DECL_EXTERNAL (decl
) = 1;
5407 TREE_PUBLIC (decl
) = 1;
5408 DECL_ARTIFICIAL (decl
) = 1;
5409 TREE_NOTHROW (decl
) = TREE_NOTHROW (alias_decl
);
5410 TREE_USED (decl
) = 1;
5413 weak_finish_1 (decl
);
5422 /* Remove the alias and the target from the pending weak list
5423 so that we do not emit any .weak directives for the former,
5424 nor multiple .weak directives for the latter. */
5425 for (p
= &weak_decls
; (t2
= *p
) ; )
5427 if (TREE_VALUE (t2
) == alias_decl
5428 || target
== DECL_ASSEMBLER_NAME (TREE_VALUE (t2
)))
5429 *p
= TREE_CHAIN (t2
);
5431 p
= &TREE_CHAIN (t2
);
5434 /* Remove other weakrefs to the same target, to speed things up. */
5435 for (p
= &TREE_CHAIN (t
); (t2
= *p
) ; )
5437 if (target
== ultimate_transparent_alias_target (&TREE_VALUE (t2
)))
5438 *p
= TREE_CHAIN (t2
);
5440 p
= &TREE_CHAIN (t2
);
5445 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
5447 tree decl
= TREE_VALUE (t
);
5449 weak_finish_1 (decl
);
5453 /* Emit the assembly bits to indicate that DECL is globally visible. */
5456 globalize_decl (tree decl
)
5459 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5460 if (DECL_WEAK (decl
))
5462 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
5465 #ifdef ASM_WEAKEN_DECL
5466 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
5468 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5471 /* Remove this function from the pending weak list so that
5472 we do not emit multiple .weak directives for it. */
5473 for (p
= &weak_decls
; (t
= *p
) ; )
5475 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5476 *p
= TREE_CHAIN (t
);
5478 p
= &TREE_CHAIN (t
);
5481 /* Remove weakrefs to the same target from the pending weakref
5482 list, for the same reason. */
5483 for (p
= &weakref_targets
; (t
= *p
) ; )
5485 if (DECL_ASSEMBLER_NAME (decl
)
5486 == ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5487 *p
= TREE_CHAIN (t
);
5489 p
= &TREE_CHAIN (t
);
5496 targetm
.asm_out
.globalize_decl_name (asm_out_file
, decl
);
5499 vec
<alias_pair
, va_gc
> *alias_pairs
;
5501 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
5502 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
5503 tree node is DECL to have the value of the tree node TARGET. */
5506 do_assemble_alias (tree decl
, tree target
)
5508 /* Emulated TLS had better not get this var. */
5509 gcc_assert (!(!targetm
.have_tls
5510 && TREE_CODE (decl
) == VAR_DECL
5511 && DECL_THREAD_LOCAL_P (decl
)));
5513 if (TREE_ASM_WRITTEN (decl
))
5516 /* We must force creation of DECL_RTL for debug info generation, even though
5517 we don't use it here. */
5518 make_decl_rtl (decl
);
5520 TREE_ASM_WRITTEN (decl
) = 1;
5521 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
5523 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5525 ultimate_transparent_alias_target (&target
);
5527 if (!TREE_SYMBOL_REFERENCED (target
))
5528 weakref_targets
= tree_cons (decl
, target
, weakref_targets
);
5530 #ifdef ASM_OUTPUT_WEAKREF
5531 ASM_OUTPUT_WEAKREF (asm_out_file
, decl
,
5532 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
5533 IDENTIFIER_POINTER (target
));
5535 if (!TARGET_SUPPORTS_WEAK
)
5537 error_at (DECL_SOURCE_LOCATION (decl
),
5538 "weakref is not supported in this configuration");
5545 #ifdef ASM_OUTPUT_DEF
5546 /* Make name accessible from other files, if appropriate. */
5548 if (TREE_PUBLIC (decl
))
5550 globalize_decl (decl
);
5551 maybe_assemble_visibility (decl
);
5553 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
5555 #if defined (ASM_OUTPUT_TYPE_DIRECTIVE)
5556 if (targetm
.has_ifunc_p ())
5557 ASM_OUTPUT_TYPE_DIRECTIVE
5558 (asm_out_file
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
5562 error_at (DECL_SOURCE_LOCATION (decl
),
5563 "ifunc is not supported on this target");
5566 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
5567 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
5569 ASM_OUTPUT_DEF (asm_out_file
,
5570 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
5571 IDENTIFIER_POINTER (target
));
5573 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5578 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5579 # ifdef ASM_WEAKEN_DECL
5580 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
5582 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
5584 /* Remove this function from the pending weak list so that
5585 we do not emit multiple .weak directives for it. */
5586 for (p
= &weak_decls
; (t
= *p
) ; )
5587 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5588 *p
= TREE_CHAIN (t
);
5590 p
= &TREE_CHAIN (t
);
5592 /* Remove weakrefs to the same target from the pending weakref
5593 list, for the same reason. */
5594 for (p
= &weakref_targets
; (t
= *p
) ; )
5596 if (DECL_ASSEMBLER_NAME (decl
)
5597 == ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5598 *p
= TREE_CHAIN (t
);
5600 p
= &TREE_CHAIN (t
);
5606 /* Emit an assembler directive to make the symbol for DECL an alias to
5607 the symbol for TARGET. */
5610 assemble_alias (tree decl
, tree target
)
5614 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5616 tree alias
= DECL_ASSEMBLER_NAME (decl
);
5618 ultimate_transparent_alias_target (&target
);
5620 if (alias
== target
)
5621 error ("weakref %q+D ultimately targets itself", decl
);
5622 if (TREE_PUBLIC (decl
))
5623 error ("weakref %q+D must have static linkage", decl
);
5627 #if !defined (ASM_OUTPUT_DEF)
5628 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
5629 error_at (DECL_SOURCE_LOCATION (decl
),
5630 "alias definitions not supported in this configuration");
5631 TREE_ASM_WRITTEN (decl
) = 1;
5634 if (!DECL_WEAK (decl
))
5636 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
5637 error_at (DECL_SOURCE_LOCATION (decl
),
5638 "ifunc is not supported in this configuration");
5640 error_at (DECL_SOURCE_LOCATION (decl
),
5641 "only weak aliases are supported in this configuration");
5642 TREE_ASM_WRITTEN (decl
) = 1;
5648 TREE_USED (decl
) = 1;
5650 /* Allow aliases to aliases. */
5651 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5652 cgraph_node::get_create (decl
)->alias
= true;
5654 varpool_node::get_create (decl
)->alias
= true;
5656 /* If the target has already been emitted, we don't have to queue the
5657 alias. This saves a tad of memory. */
5658 if (symtab
->global_info_ready
)
5659 target_decl
= find_decl (target
);
5662 if ((target_decl
&& TREE_ASM_WRITTEN (target_decl
))
5663 || symtab
->state
>= EXPANSION
)
5664 do_assemble_alias (decl
, target
);
5667 alias_pair p
= {decl
, target
};
5668 vec_safe_push (alias_pairs
, p
);
5672 /* Record and output a table of translations from original function
5673 to its transaction aware clone. Note that tm_pure functions are
5674 considered to be their own clone. */
5676 static GTY((if_marked ("tree_map_marked_p"), param_is (struct tree_map
)))
5677 htab_t tm_clone_hash
;
5680 record_tm_clone_pair (tree o
, tree n
)
5682 struct tree_map
**slot
, *h
;
5684 if (tm_clone_hash
== NULL
)
5685 tm_clone_hash
= htab_create_ggc (32, tree_map_hash
, tree_map_eq
, 0);
5687 h
= ggc_alloc
<tree_map
> ();
5688 h
->hash
= htab_hash_pointer (o
);
5692 slot
= (struct tree_map
**)
5693 htab_find_slot_with_hash (tm_clone_hash
, h
, h
->hash
, INSERT
);
5698 get_tm_clone_pair (tree o
)
5702 struct tree_map
*h
, in
;
5705 in
.hash
= htab_hash_pointer (o
);
5706 h
= (struct tree_map
*) htab_find_with_hash (tm_clone_hash
,
5714 typedef struct tm_alias_pair
5722 /* Helper function for finish_tm_clone_pairs. Dump a hash table entry
5723 into a VEC in INFO. */
5726 dump_tm_clone_to_vec (void **slot
, void *info
)
5728 struct tree_map
*map
= (struct tree_map
*) *slot
;
5729 vec
<tm_alias_pair
> *tm_alias_pairs
= (vec
<tm_alias_pair
> *) info
;
5730 tm_alias_pair p
= {DECL_UID (map
->base
.from
), map
->base
.from
, map
->to
};
5731 tm_alias_pairs
->safe_push (p
);
5735 /* Dump the actual pairs to the .tm_clone_table section. */
5738 dump_tm_clone_pairs (vec
<tm_alias_pair
> tm_alias_pairs
)
5742 bool switched
= false;
5744 FOR_EACH_VEC_ELT (tm_alias_pairs
, i
, p
)
5748 struct cgraph_node
*src_n
= cgraph_node::get (src
);
5749 struct cgraph_node
*dst_n
= cgraph_node::get (dst
);
5751 /* The function ipa_tm_create_version() marks the clone as needed if
5752 the original function was needed. But we also mark the clone as
5753 needed if we ever called the clone indirectly through
5754 TM_GETTMCLONE. If neither of these are true, we didn't generate
5755 a clone, and we didn't call it indirectly... no sense keeping it
5756 in the clone table. */
5757 if (!dst_n
|| !dst_n
->definition
)
5760 /* This covers the case where we have optimized the original
5761 function away, and only access the transactional clone. */
5762 if (!src_n
|| !src_n
->definition
)
5767 switch_to_section (targetm
.asm_out
.tm_clone_table_section ());
5768 assemble_align (POINTER_SIZE
);
5772 assemble_integer (XEXP (DECL_RTL (src
), 0),
5773 POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
5774 assemble_integer (XEXP (DECL_RTL (dst
), 0),
5775 POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
5779 /* Provide a default for the tm_clone_table section. */
5782 default_clone_table_section (void)
5784 return get_named_section (NULL
, ".tm_clone_table", 3);
5787 /* Helper comparison function for qsorting by the DECL_UID stored in
5788 alias_pair->emitted_diags. */
5791 tm_alias_pair_cmp (const void *x
, const void *y
)
5793 const tm_alias_pair
*p1
= (const tm_alias_pair
*) x
;
5794 const tm_alias_pair
*p2
= (const tm_alias_pair
*) y
;
5795 if (p1
->uid
< p2
->uid
)
5797 if (p1
->uid
> p2
->uid
)
5803 finish_tm_clone_pairs (void)
5805 vec
<tm_alias_pair
> tm_alias_pairs
= vNULL
;
5807 if (tm_clone_hash
== NULL
)
5810 /* We need a determenistic order for the .tm_clone_table, otherwise
5811 we will get bootstrap comparison failures, so dump the hash table
5812 to a vector, sort it, and dump the vector. */
5814 /* Dump the hashtable to a vector. */
5815 htab_traverse_noresize (tm_clone_hash
, dump_tm_clone_to_vec
,
5816 (void *) &tm_alias_pairs
);
5818 tm_alias_pairs
.qsort (tm_alias_pair_cmp
);
5821 dump_tm_clone_pairs (tm_alias_pairs
);
5823 htab_delete (tm_clone_hash
);
5824 tm_clone_hash
= NULL
;
5825 tm_alias_pairs
.release ();
5829 /* Emit an assembler directive to set symbol for DECL visibility to
5830 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
5833 default_assemble_visibility (tree decl ATTRIBUTE_UNUSED
,
5834 int vis ATTRIBUTE_UNUSED
)
5836 #ifdef HAVE_GAS_HIDDEN
5837 static const char * const visibility_types
[] = {
5838 NULL
, "protected", "hidden", "internal"
5841 const char *name
, *type
;
5843 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5844 type
= visibility_types
[vis
];
5846 fprintf (asm_out_file
, "\t.%s\t", type
);
5847 assemble_name (asm_out_file
, name
);
5848 fprintf (asm_out_file
, "\n");
5850 if (!DECL_ARTIFICIAL (decl
))
5851 warning (OPT_Wattributes
, "visibility attribute not supported "
5852 "in this configuration; ignored");
5856 /* A helper function to call assemble_visibility when needed for a decl. */
5859 maybe_assemble_visibility (tree decl
)
5861 enum symbol_visibility vis
= DECL_VISIBILITY (decl
);
5863 if (vis
!= VISIBILITY_DEFAULT
)
5865 targetm
.asm_out
.assemble_visibility (decl
, vis
);
5872 /* Returns 1 if the target configuration supports defining public symbols
5873 so that one of them will be chosen at link time instead of generating a
5874 multiply-defined symbol error, whether through the use of weak symbols or
5875 a target-specific mechanism for having duplicates discarded. */
5878 supports_one_only (void)
5880 if (SUPPORTS_ONE_ONLY
)
5882 return TARGET_SUPPORTS_WEAK
;
5885 /* Set up DECL as a public symbol that can be defined in multiple
5886 translation units without generating a linker error. */
5889 make_decl_one_only (tree decl
, tree comdat_group
)
5891 struct symtab_node
*symbol
;
5892 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5893 || TREE_CODE (decl
) == FUNCTION_DECL
);
5895 TREE_PUBLIC (decl
) = 1;
5897 if (TREE_CODE (decl
) == VAR_DECL
)
5898 symbol
= varpool_node::get_create (decl
);
5900 symbol
= cgraph_node::get_create (decl
);
5902 if (SUPPORTS_ONE_ONLY
)
5904 #ifdef MAKE_DECL_ONE_ONLY
5905 MAKE_DECL_ONE_ONLY (decl
);
5907 symbol
->set_comdat_group (comdat_group
);
5909 else if (TREE_CODE (decl
) == VAR_DECL
5910 && (DECL_INITIAL (decl
) == 0
5911 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
5912 DECL_COMMON (decl
) = 1;
5915 gcc_assert (TARGET_SUPPORTS_WEAK
);
5916 DECL_WEAK (decl
) = 1;
5921 init_varasm_once (void)
5923 section_htab
= htab_create_ggc (31, section_entry_hash
,
5924 section_entry_eq
, NULL
);
5925 object_block_htab
= htab_create_ggc (31, object_block_entry_hash
,
5926 object_block_entry_eq
, NULL
);
5927 const_desc_htab
= htab_create_ggc (1009, const_desc_hash
,
5928 const_desc_eq
, NULL
);
5930 const_alias_set
= new_alias_set ();
5931 shared_constant_pool
= create_constant_pool ();
5933 #ifdef TEXT_SECTION_ASM_OP
5934 text_section
= get_unnamed_section (SECTION_CODE
, output_section_asm_op
,
5935 TEXT_SECTION_ASM_OP
);
5938 #ifdef DATA_SECTION_ASM_OP
5939 data_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
5940 DATA_SECTION_ASM_OP
);
5943 #ifdef SDATA_SECTION_ASM_OP
5944 sdata_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
5945 SDATA_SECTION_ASM_OP
);
5948 #ifdef READONLY_DATA_SECTION_ASM_OP
5949 readonly_data_section
= get_unnamed_section (0, output_section_asm_op
,
5950 READONLY_DATA_SECTION_ASM_OP
);
5953 #ifdef CTORS_SECTION_ASM_OP
5954 ctors_section
= get_unnamed_section (0, output_section_asm_op
,
5955 CTORS_SECTION_ASM_OP
);
5958 #ifdef DTORS_SECTION_ASM_OP
5959 dtors_section
= get_unnamed_section (0, output_section_asm_op
,
5960 DTORS_SECTION_ASM_OP
);
5963 #ifdef BSS_SECTION_ASM_OP
5964 bss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
5965 output_section_asm_op
,
5966 BSS_SECTION_ASM_OP
);
5969 #ifdef SBSS_SECTION_ASM_OP
5970 sbss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
5971 output_section_asm_op
,
5972 SBSS_SECTION_ASM_OP
);
5975 tls_comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
5976 | SECTION_COMMON
, emit_tls_common
);
5977 lcomm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
5978 | SECTION_COMMON
, emit_local
);
5979 comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
5980 | SECTION_COMMON
, emit_common
);
5982 #if defined ASM_OUTPUT_ALIGNED_BSS
5983 bss_noswitch_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
,
5987 targetm
.asm_out
.init_sections ();
5989 if (readonly_data_section
== NULL
)
5990 readonly_data_section
= text_section
;
5992 #ifdef ASM_OUTPUT_EXTERNAL
5993 pending_assemble_externals_set
= new hash_set
<tree
>;
5998 decl_default_tls_model (const_tree decl
)
6000 enum tls_model kind
;
6003 is_local
= targetm
.binds_local_p (decl
);
6007 kind
= TLS_MODEL_LOCAL_EXEC
;
6009 kind
= TLS_MODEL_INITIAL_EXEC
;
6012 /* Local dynamic is inefficient when we're not combining the
6013 parts of the address. */
6014 else if (optimize
&& is_local
)
6015 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
6017 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6018 if (kind
< flag_tls_default
)
6019 kind
= flag_tls_default
;
6024 /* Select a set of attributes for section NAME based on the properties
6025 of DECL and whether or not RELOC indicates that DECL's initializer
6026 might contain runtime relocations.
6028 We make the section read-only and executable for a function decl,
6029 read-only for a const data decl, and writable for a non-const data decl. */
6032 default_section_type_flags (tree decl
, const char *name
, int reloc
)
6036 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6037 flags
= SECTION_CODE
;
6040 enum section_category category
6041 = categorize_decl_for_section (decl
, reloc
);
6042 if (decl_readonly_section_1 (category
))
6044 else if (category
== SECCAT_DATA_REL_RO
6045 || category
== SECCAT_DATA_REL_RO_LOCAL
)
6046 flags
= SECTION_WRITE
| SECTION_RELRO
;
6048 flags
= SECTION_WRITE
;
6052 flags
= SECTION_WRITE
;
6053 if (strcmp (name
, ".data.rel.ro") == 0
6054 || strcmp (name
, ".data.rel.ro.local") == 0)
6055 flags
|= SECTION_RELRO
;
6058 if (decl
&& DECL_P (decl
) && DECL_COMDAT_GROUP (decl
))
6059 flags
|= SECTION_LINKONCE
;
6061 if (strcmp (name
, ".vtable_map_vars") == 0)
6062 flags
|= SECTION_LINKONCE
;
6064 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6065 flags
|= SECTION_TLS
| SECTION_WRITE
;
6067 if (strcmp (name
, ".bss") == 0
6068 || strncmp (name
, ".bss.", 5) == 0
6069 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
6070 || strcmp (name
, ".sbss") == 0
6071 || strncmp (name
, ".sbss.", 6) == 0
6072 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
6073 flags
|= SECTION_BSS
;
6075 if (strcmp (name
, ".tdata") == 0
6076 || strncmp (name
, ".tdata.", 7) == 0
6077 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0)
6078 flags
|= SECTION_TLS
;
6080 if (strcmp (name
, ".tbss") == 0
6081 || strncmp (name
, ".tbss.", 6) == 0
6082 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
6083 flags
|= SECTION_TLS
| SECTION_BSS
;
6085 /* These three sections have special ELF types. They are neither
6086 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
6087 want to print a section type (@progbits or @nobits). If someone
6088 is silly enough to emit code or TLS variables to one of these
6089 sections, then don't handle them specially. */
6090 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
6091 && (strcmp (name
, ".init_array") == 0
6092 || strcmp (name
, ".fini_array") == 0
6093 || strcmp (name
, ".preinit_array") == 0))
6094 flags
|= SECTION_NOTYPE
;
6099 /* Return true if the target supports some form of global BSS,
6100 either through bss_noswitch_section, or by selecting a BSS
6101 section in TARGET_ASM_SELECT_SECTION. */
6104 have_global_bss_p (void)
6106 return bss_noswitch_section
|| targetm
.have_switchable_bss_sections
;
6109 /* Output assembly to switch to section NAME with attribute FLAGS.
6110 Four variants for common object file formats. */
6113 default_no_named_section (const char *name ATTRIBUTE_UNUSED
,
6114 unsigned int flags ATTRIBUTE_UNUSED
,
6115 tree decl ATTRIBUTE_UNUSED
)
6117 /* Some object formats don't support named sections at all. The
6118 front-end should already have flagged this as an error. */
6122 #ifndef TLS_SECTION_ASM_FLAG
6123 #define TLS_SECTION_ASM_FLAG 'T'
6127 default_elf_asm_named_section (const char *name
, unsigned int flags
,
6128 tree decl ATTRIBUTE_UNUSED
)
6130 char flagchars
[10], *f
= flagchars
;
6132 /* If we have already declared this section, we can use an
6133 abbreviated form to switch back to it -- unless this section is
6134 part of a COMDAT groups, in which case GAS requires the full
6135 declaration every time. */
6136 if (!(HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6137 && (flags
& SECTION_DECLARED
))
6139 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
6143 if (!(flags
& SECTION_DEBUG
))
6145 if (flags
& SECTION_EXCLUDE
)
6147 if (flags
& SECTION_WRITE
)
6149 if (flags
& SECTION_CODE
)
6151 if (flags
& SECTION_SMALL
)
6153 if (flags
& SECTION_MERGE
)
6155 if (flags
& SECTION_STRINGS
)
6157 if (flags
& SECTION_TLS
)
6158 *f
++ = TLS_SECTION_ASM_FLAG
;
6159 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6163 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
6165 if (!(flags
& SECTION_NOTYPE
))
6170 if (flags
& SECTION_BSS
)
6176 /* On platforms that use "@" as the assembly comment character,
6178 if (strcmp (ASM_COMMENT_START
, "@") == 0)
6180 fprintf (asm_out_file
, format
, type
);
6182 if (flags
& SECTION_ENTSIZE
)
6183 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
6184 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6186 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6187 fprintf (asm_out_file
, ",%s,comdat", IDENTIFIER_POINTER (decl
));
6189 fprintf (asm_out_file
, ",%s,comdat",
6190 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl
)));
6194 putc ('\n', asm_out_file
);
6198 default_coff_asm_named_section (const char *name
, unsigned int flags
,
6199 tree decl ATTRIBUTE_UNUSED
)
6201 char flagchars
[8], *f
= flagchars
;
6203 if (flags
& SECTION_WRITE
)
6205 if (flags
& SECTION_CODE
)
6209 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
6213 default_pe_asm_named_section (const char *name
, unsigned int flags
,
6216 default_coff_asm_named_section (name
, flags
, decl
);
6218 if (flags
& SECTION_LINKONCE
)
6220 /* Functions may have been compiled at various levels of
6221 optimization so we can't use `same_size' here.
6222 Instead, have the linker pick one. */
6223 fprintf (asm_out_file
, "\t.linkonce %s\n",
6224 (flags
& SECTION_CODE
? "discard" : "same_size"));
6228 /* The lame default section selector. */
6231 default_select_section (tree decl
, int reloc
,
6232 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6236 if (decl_readonly_section (decl
, reloc
))
6237 return readonly_data_section
;
6239 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6241 if (! ((flag_pic
&& reloc
)
6242 || !TREE_READONLY (decl
)
6243 || TREE_SIDE_EFFECTS (decl
)
6244 || !TREE_CONSTANT (decl
)))
6245 return readonly_data_section
;
6247 else if (TREE_CODE (decl
) == STRING_CST
)
6248 return readonly_data_section
;
6249 else if (! (flag_pic
&& reloc
))
6250 return readonly_data_section
;
6252 return data_section
;
6255 enum section_category
6256 categorize_decl_for_section (const_tree decl
, int reloc
)
6258 enum section_category ret
;
6260 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6262 else if (TREE_CODE (decl
) == STRING_CST
)
6264 if ((flag_sanitize
& SANITIZE_ADDRESS
)
6265 && asan_protect_global (CONST_CAST_TREE (decl
)))
6266 /* or !flag_merge_constants */
6267 return SECCAT_RODATA
;
6269 return SECCAT_RODATA_MERGE_STR
;
6271 else if (TREE_CODE (decl
) == VAR_DECL
)
6273 if (bss_initializer_p (decl
))
6275 else if (! TREE_READONLY (decl
)
6276 || TREE_SIDE_EFFECTS (decl
)
6277 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6279 /* Here the reloc_rw_mask is not testing whether the section should
6280 be read-only or not, but whether the dynamic link will have to
6281 do something. If so, we wish to segregate the data in order to
6282 minimize cache misses inside the dynamic linker. */
6283 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6284 ret
= reloc
== 1 ? SECCAT_DATA_REL_LOCAL
: SECCAT_DATA_REL
;
6288 else if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6289 ret
= reloc
== 1 ? SECCAT_DATA_REL_RO_LOCAL
: SECCAT_DATA_REL_RO
;
6290 else if (reloc
|| flag_merge_constants
< 2
6291 || ((flag_sanitize
& SANITIZE_ADDRESS
)
6292 && asan_protect_global (CONST_CAST_TREE (decl
))))
6293 /* C and C++ don't allow different variables to share the same
6294 location. -fmerge-all-constants allows even that (at the
6295 expense of not conforming). */
6296 ret
= SECCAT_RODATA
;
6297 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
6298 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
6300 ret
= SECCAT_RODATA_MERGE_CONST
;
6302 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6304 if ((reloc
& targetm
.asm_out
.reloc_rw_mask ())
6305 || TREE_SIDE_EFFECTS (decl
)
6306 || ! TREE_CONSTANT (decl
))
6309 ret
= SECCAT_RODATA
;
6312 ret
= SECCAT_RODATA
;
6314 /* There are no read-only thread-local sections. */
6315 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6317 /* Note that this would be *just* SECCAT_BSS, except that there's
6318 no concept of a read-only thread-local-data section. */
6319 if (ret
== SECCAT_BSS
6320 || (flag_zero_initialized_in_bss
6321 && initializer_zerop (DECL_INITIAL (decl
))))
6327 /* If the target uses small data sections, select it. */
6328 else if (targetm
.in_small_data_p (decl
))
6330 if (ret
== SECCAT_BSS
)
6332 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
6333 ret
= SECCAT_SRODATA
;
6342 decl_readonly_section_1 (enum section_category category
)
6347 case SECCAT_RODATA_MERGE_STR
:
6348 case SECCAT_RODATA_MERGE_STR_INIT
:
6349 case SECCAT_RODATA_MERGE_CONST
:
6350 case SECCAT_SRODATA
:
6358 decl_readonly_section (const_tree decl
, int reloc
)
6360 return decl_readonly_section_1 (categorize_decl_for_section (decl
, reloc
));
6363 /* Select a section based on the above categorization. */
6366 default_elf_select_section (tree decl
, int reloc
,
6367 unsigned HOST_WIDE_INT align
)
6370 switch (categorize_decl_for_section (decl
, reloc
))
6373 /* We're not supposed to be called on FUNCTION_DECLs. */
6376 return readonly_data_section
;
6377 case SECCAT_RODATA_MERGE_STR
:
6378 return mergeable_string_section (decl
, align
, 0);
6379 case SECCAT_RODATA_MERGE_STR_INIT
:
6380 return mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
6381 case SECCAT_RODATA_MERGE_CONST
:
6382 return mergeable_constant_section (DECL_MODE (decl
), align
, 0);
6383 case SECCAT_SRODATA
:
6387 return data_section
;
6388 case SECCAT_DATA_REL
:
6389 sname
= ".data.rel";
6391 case SECCAT_DATA_REL_LOCAL
:
6392 sname
= ".data.rel.local";
6394 case SECCAT_DATA_REL_RO
:
6395 sname
= ".data.rel.ro";
6397 case SECCAT_DATA_REL_RO_LOCAL
:
6398 sname
= ".data.rel.ro.local";
6421 return get_named_section (decl
, sname
, reloc
);
6424 /* Construct a unique section name based on the decl name and the
6425 categorization performed above. */
6428 default_unique_section (tree decl
, int reloc
)
6430 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
6431 bool one_only
= DECL_ONE_ONLY (decl
) && !HAVE_COMDAT_GROUP
;
6432 const char *prefix
, *name
, *linkonce
;
6435 switch (categorize_decl_for_section (decl
, reloc
))
6438 prefix
= one_only
? ".t" : ".text";
6441 case SECCAT_RODATA_MERGE_STR
:
6442 case SECCAT_RODATA_MERGE_STR_INIT
:
6443 case SECCAT_RODATA_MERGE_CONST
:
6444 prefix
= one_only
? ".r" : ".rodata";
6446 case SECCAT_SRODATA
:
6447 prefix
= one_only
? ".s2" : ".sdata2";
6450 prefix
= one_only
? ".d" : ".data";
6452 case SECCAT_DATA_REL
:
6453 prefix
= one_only
? ".d.rel" : ".data.rel";
6455 case SECCAT_DATA_REL_LOCAL
:
6456 prefix
= one_only
? ".d.rel.local" : ".data.rel.local";
6458 case SECCAT_DATA_REL_RO
:
6459 prefix
= one_only
? ".d.rel.ro" : ".data.rel.ro";
6461 case SECCAT_DATA_REL_RO_LOCAL
:
6462 prefix
= one_only
? ".d.rel.ro.local" : ".data.rel.ro.local";
6465 prefix
= one_only
? ".s" : ".sdata";
6468 prefix
= one_only
? ".b" : ".bss";
6471 prefix
= one_only
? ".sb" : ".sbss";
6474 prefix
= one_only
? ".td" : ".tdata";
6477 prefix
= one_only
? ".tb" : ".tbss";
6483 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
6484 name
= targetm
.strip_name_encoding (name
);
6486 /* If we're using one_only, then there needs to be a .gnu.linkonce
6487 prefix to the section name. */
6488 linkonce
= one_only
? ".gnu.linkonce" : "";
6490 string
= ACONCAT ((linkonce
, prefix
, ".", name
, NULL
));
6492 set_decl_section_name (decl
, string
);
6495 /* Like compute_reloc_for_constant, except for an RTX. The return value
6496 is a mask for which bit 1 indicates a global relocation, and bit 0
6497 indicates a local relocation. */
6500 compute_reloc_for_rtx_1 (rtx
*xp
, void *data
)
6502 int *preloc
= (int *) data
;
6505 switch (GET_CODE (x
))
6508 *preloc
|= SYMBOL_REF_LOCAL_P (x
) ? 1 : 2;
6521 compute_reloc_for_rtx (rtx x
)
6525 switch (GET_CODE (x
))
6531 for_each_rtx (&x
, compute_reloc_for_rtx_1
, &reloc
);
6540 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED
,
6542 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6544 if (compute_reloc_for_rtx (x
) & targetm
.asm_out
.reloc_rw_mask ())
6545 return data_section
;
6547 return readonly_data_section
;
6551 default_elf_select_rtx_section (enum machine_mode mode
, rtx x
,
6552 unsigned HOST_WIDE_INT align
)
6554 int reloc
= compute_reloc_for_rtx (x
);
6556 /* ??? Handle small data here somehow. */
6558 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6561 return get_named_section (NULL
, ".data.rel.ro.local", 1);
6563 return get_named_section (NULL
, ".data.rel.ro", 3);
6566 return mergeable_constant_section (mode
, align
, 0);
6569 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
6572 default_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
6577 /* Careful not to prod global register variables. */
6580 symbol
= XEXP (rtl
, 0);
6581 if (GET_CODE (symbol
) != SYMBOL_REF
)
6584 flags
= SYMBOL_REF_FLAGS (symbol
) & SYMBOL_FLAG_HAS_BLOCK_INFO
;
6585 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6586 flags
|= SYMBOL_FLAG_FUNCTION
;
6587 if (targetm
.binds_local_p (decl
))
6588 flags
|= SYMBOL_FLAG_LOCAL
;
6589 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6590 flags
|= DECL_TLS_MODEL (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
6591 else if (targetm
.in_small_data_p (decl
))
6592 flags
|= SYMBOL_FLAG_SMALL
;
6593 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
6594 being PUBLIC, the thing *must* be defined in this translation unit.
6595 Prevent this buglet from being propagated into rtl code as well. */
6596 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
6597 flags
|= SYMBOL_FLAG_EXTERNAL
;
6599 SYMBOL_REF_FLAGS (symbol
) = flags
;
6602 /* By default, we do nothing for encode_section_info, so we need not
6603 do anything but discard the '*' marker. */
6606 default_strip_name_encoding (const char *str
)
6608 return str
+ (*str
== '*');
6611 #ifdef ASM_OUTPUT_DEF
6612 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
6613 anchor relative to ".", the current section position. */
6616 default_asm_output_anchor (rtx symbol
)
6620 sprintf (buffer
, "*. + " HOST_WIDE_INT_PRINT_DEC
,
6621 SYMBOL_REF_BLOCK_OFFSET (symbol
));
6622 ASM_OUTPUT_DEF (asm_out_file
, XSTR (symbol
, 0), buffer
);
6626 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
6629 default_use_anchors_for_symbol_p (const_rtx symbol
)
6634 /* Don't use anchors for mergeable sections. The linker might move
6635 the objects around. */
6636 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
6637 if (sect
->common
.flags
& SECTION_MERGE
)
6640 /* Don't use anchors for small data sections. The small data register
6641 acts as an anchor for such sections. */
6642 if (sect
->common
.flags
& SECTION_SMALL
)
6645 decl
= SYMBOL_REF_DECL (symbol
);
6646 if (decl
&& DECL_P (decl
))
6648 /* Don't use section anchors for decls that might be defined or
6649 usurped by other modules. */
6650 if (TREE_PUBLIC (decl
) && !decl_binds_to_current_def_p (decl
))
6653 /* Don't use section anchors for decls that will be placed in a
6654 small data section. */
6655 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
6656 one above. The problem is that we only use SECTION_SMALL for
6657 sections that should be marked as small in the section directive. */
6658 if (targetm
.in_small_data_p (decl
))
6664 /* Return true when RESOLUTION indicate that symbol will be bound to the
6665 definition provided by current .o file. */
6668 resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution
)
6670 return (resolution
== LDPR_PREVAILING_DEF
6671 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
6672 || resolution
== LDPR_PREVAILING_DEF_IRONLY
);
6675 /* Return true when RESOLUTION indicate that symbol will be bound locally
6676 within current executable or DSO. */
6679 resolution_local_p (enum ld_plugin_symbol_resolution resolution
)
6681 return (resolution
== LDPR_PREVAILING_DEF
6682 || resolution
== LDPR_PREVAILING_DEF_IRONLY
6683 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
6684 || resolution
== LDPR_PREEMPTED_REG
6685 || resolution
== LDPR_PREEMPTED_IR
6686 || resolution
== LDPR_RESOLVED_IR
6687 || resolution
== LDPR_RESOLVED_EXEC
);
6690 /* Assume ELF-ish defaults, since that's pretty much the most liberal
6691 wrt cross-module name binding. */
6694 default_binds_local_p (const_tree exp
)
6696 return default_binds_local_p_1 (exp
, flag_shlib
);
6700 default_binds_local_p_1 (const_tree exp
, int shlib
)
6703 bool resolved_locally
= false;
6704 bool resolved_to_local_def
= false;
6706 /* With resolution file in hands, take look into resolutions.
6707 We can't just return true for resolved_locally symbols,
6708 because dynamic linking might overwrite symbols
6709 in shared libraries. */
6710 if (TREE_CODE (exp
) == VAR_DECL
&& TREE_PUBLIC (exp
)
6711 && (TREE_STATIC (exp
) || DECL_EXTERNAL (exp
)))
6713 varpool_node
*vnode
= varpool_node::get (exp
);
6714 if (vnode
&& (resolution_local_p (vnode
->resolution
) || vnode
->in_other_partition
))
6715 resolved_locally
= true;
6717 && resolution_to_local_definition_p (vnode
->resolution
))
6718 resolved_to_local_def
= true;
6720 else if (TREE_CODE (exp
) == FUNCTION_DECL
&& TREE_PUBLIC (exp
))
6722 struct cgraph_node
*node
= cgraph_node::get (exp
);
6724 && (resolution_local_p (node
->resolution
) || node
->in_other_partition
))
6725 resolved_locally
= true;
6727 && resolution_to_local_definition_p (node
->resolution
))
6728 resolved_to_local_def
= true;
6731 /* A non-decl is an entry in the constant pool. */
6734 /* Weakrefs may not bind locally, even though the weakref itself is always
6735 static and therefore local. Similarly, the resolver for ifunc functions
6736 might resolve to a non-local function.
6737 FIXME: We can resolve the weakref case more curefuly by looking at the
6739 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp
))
6740 || (TREE_CODE (exp
) == FUNCTION_DECL
6741 && lookup_attribute ("ifunc", DECL_ATTRIBUTES (exp
))))
6743 /* Static variables are always local. */
6744 else if (! TREE_PUBLIC (exp
))
6746 /* A variable is local if the user has said explicitly that it will
6748 else if ((DECL_VISIBILITY_SPECIFIED (exp
)
6749 || resolved_to_local_def
)
6750 && DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
)
6752 /* Variables defined outside this object might not be local. */
6753 else if (DECL_EXTERNAL (exp
) && !resolved_locally
)
6755 /* If defined in this object and visibility is not default, must be
6757 else if (DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
)
6759 /* Default visibility weak data can be overridden by a strong symbol
6760 in another module and so are not local. */
6761 else if (DECL_WEAK (exp
)
6762 && !resolved_locally
)
6764 /* If PIC, then assume that any global name can be overridden by
6765 symbols resolved from other modules. */
6768 /* Uninitialized COMMON variable may be unified with symbols
6769 resolved from other modules. */
6770 else if (DECL_COMMON (exp
)
6771 && !resolved_locally
6772 && (DECL_INITIAL (exp
) == NULL
6773 || (!in_lto_p
&& DECL_INITIAL (exp
) == error_mark_node
)))
6775 /* Otherwise we're left with initialized (or non-common) global data
6776 which is of necessity defined locally. */
6783 /* Return true when references to DECL must bind to current definition in
6786 The condition is usually equivalent to whether the function binds to the
6787 current module (shared library or executable), that is to binds_local_p.
6788 We use this fact to avoid need for another target hook and implement
6789 the logic using binds_local_p and just special cases where
6790 decl_binds_to_current_def_p is stronger than binds_local_p. In particular
6791 the weak definitions (that can be overwritten at linktime by other
6792 definition from different object file) and when resolution info is available
6793 we simply use the knowledge passed to us by linker plugin. */
6795 decl_binds_to_current_def_p (const_tree decl
)
6797 gcc_assert (DECL_P (decl
));
6798 if (!targetm
.binds_local_p (decl
))
6800 if (!TREE_PUBLIC (decl
))
6802 /* When resolution is available, just use it. */
6803 if (TREE_CODE (decl
) == VAR_DECL
6804 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
6806 varpool_node
*vnode
= varpool_node::get (decl
);
6808 && vnode
->resolution
!= LDPR_UNKNOWN
)
6809 return resolution_to_local_definition_p (vnode
->resolution
);
6811 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6813 struct cgraph_node
*node
= cgraph_node::get (decl
);
6815 && node
->resolution
!= LDPR_UNKNOWN
)
6816 return resolution_to_local_definition_p (node
->resolution
);
6818 /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
6819 binds locally but still can be overwritten), DECL_COMMON (can be merged
6820 with a non-common definition somewhere in the same module) or
6822 This rely on fact that binds_local_p behave as decl_replaceable_p
6823 for all other declaration types. */
6824 if (DECL_WEAK (decl
))
6826 if (DECL_COMMON (decl
)
6827 && (DECL_INITIAL (decl
) == NULL
6828 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
6830 if (DECL_EXTERNAL (decl
))
6835 /* A replaceable function or variable is one which may be replaced
6836 at link-time with an entirely different definition, provided that the
6837 replacement has the same type. For example, functions declared
6838 with __attribute__((weak)) on most systems are replaceable.
6840 COMDAT functions are not replaceable, since all definitions of the
6841 function must be equivalent. It is important that COMDAT functions
6842 not be treated as replaceable so that use of C++ template
6843 instantiations is not penalized. */
6846 decl_replaceable_p (tree decl
)
6848 gcc_assert (DECL_P (decl
));
6849 if (!TREE_PUBLIC (decl
) || DECL_COMDAT (decl
))
6851 if (!flag_semantic_interposition
6852 && !DECL_WEAK (decl
))
6854 return !decl_binds_to_current_def_p (decl
);
6857 /* Default function to output code that will globalize a label. A
6858 target must define GLOBAL_ASM_OP or provide its own function to
6859 globalize a label. */
6860 #ifdef GLOBAL_ASM_OP
6862 default_globalize_label (FILE * stream
, const char *name
)
6864 fputs (GLOBAL_ASM_OP
, stream
);
6865 assemble_name (stream
, name
);
6866 putc ('\n', stream
);
6868 #endif /* GLOBAL_ASM_OP */
6870 /* Default function to output code that will globalize a declaration. */
6872 default_globalize_decl_name (FILE * stream
, tree decl
)
6874 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
6875 targetm
.asm_out
.globalize_label (stream
, name
);
6878 /* Default function to output a label for unwind information. The
6879 default is to do nothing. A target that needs nonlocal labels for
6880 unwind information must provide its own function to do this. */
6882 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED
,
6883 tree decl ATTRIBUTE_UNUSED
,
6884 int for_eh ATTRIBUTE_UNUSED
,
6885 int empty ATTRIBUTE_UNUSED
)
6889 /* Default function to output a label to divide up the exception table.
6890 The default is to do nothing. A target that needs/wants to divide
6891 up the table must provide it's own function to do this. */
6893 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED
)
6897 /* This is how to output an internal numbered label where PREFIX is
6898 the class of label and LABELNO is the number within the class. */
6901 default_generate_internal_label (char *buf
, const char *prefix
,
6902 unsigned long labelno
)
6904 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
6907 /* This is how to output an internal numbered label where PREFIX is
6908 the class of label and LABELNO is the number within the class. */
6911 default_internal_label (FILE *stream
, const char *prefix
,
6912 unsigned long labelno
)
6914 char *const buf
= (char *) alloca (40 + strlen (prefix
));
6915 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
6916 ASM_OUTPUT_INTERNAL_LABEL (stream
, buf
);
6920 /* The default implementation of ASM_DECLARE_CONSTANT_NAME. */
6923 default_asm_declare_constant_name (FILE *file
, const char *name
,
6924 const_tree exp ATTRIBUTE_UNUSED
,
6925 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
6927 assemble_label (file
, name
);
6930 /* This is the default behavior at the beginning of a file. It's
6931 controlled by two other target-hook toggles. */
6933 default_file_start (void)
6935 if (targetm
.asm_file_start_app_off
6936 && !(flag_verbose_asm
|| flag_debug_asm
|| flag_dump_rtl_in_asm
))
6937 fputs (ASM_APP_OFF
, asm_out_file
);
6939 if (targetm
.asm_file_start_file_directive
)
6940 output_file_directive (asm_out_file
, main_input_filename
);
6943 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
6944 which emits a special section directive used to indicate whether or
6945 not this object file needs an executable stack. This is primarily
6946 a GNU extension to ELF but could be used on other targets. */
6948 int trampolines_created
;
6951 file_end_indicate_exec_stack (void)
6953 unsigned int flags
= SECTION_DEBUG
;
6954 if (trampolines_created
)
6955 flags
|= SECTION_CODE
;
6957 switch_to_section (get_section (".note.GNU-stack", flags
, NULL
));
6960 /* Emit a special section directive to indicate that this object file
6961 was compiled with -fsplit-stack. This is used to let the linker
6962 detect calls between split-stack code and non-split-stack code, so
6963 that it can modify the split-stack code to allocate a sufficiently
6964 large stack. We emit another special section if there are any
6965 functions in this file which have the no_split_stack attribute, to
6966 prevent the linker from warning about being unable to convert the
6967 functions if they call non-split-stack code. */
6970 file_end_indicate_split_stack (void)
6972 if (flag_split_stack
)
6974 switch_to_section (get_section (".note.GNU-split-stack", SECTION_DEBUG
,
6976 if (saw_no_split_stack
)
6977 switch_to_section (get_section (".note.GNU-no-split-stack",
6978 SECTION_DEBUG
, NULL
));
6982 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
6983 a get_unnamed_section callback. */
6986 output_section_asm_op (const void *directive
)
6988 fprintf (asm_out_file
, "%s\n", (const char *) directive
);
6991 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
6992 the current section is NEW_SECTION. */
6995 switch_to_section (section
*new_section
)
6997 if (in_section
== new_section
)
7000 if (new_section
->common
.flags
& SECTION_FORGET
)
7003 in_section
= new_section
;
7005 switch (SECTION_STYLE (new_section
))
7008 targetm
.asm_out
.named_section (new_section
->named
.name
,
7009 new_section
->named
.common
.flags
,
7010 new_section
->named
.decl
);
7013 case SECTION_UNNAMED
:
7014 new_section
->unnamed
.callback (new_section
->unnamed
.data
);
7017 case SECTION_NOSWITCH
:
7022 new_section
->common
.flags
|= SECTION_DECLARED
;
7025 /* If block symbol SYMBOL has not yet been assigned an offset, place
7026 it at the end of its block. */
7029 place_block_symbol (rtx symbol
)
7031 unsigned HOST_WIDE_INT size
, mask
, offset
;
7032 struct constant_descriptor_rtx
*desc
;
7033 unsigned int alignment
;
7034 struct object_block
*block
;
7037 gcc_assert (SYMBOL_REF_BLOCK (symbol
));
7038 if (SYMBOL_REF_BLOCK_OFFSET (symbol
) >= 0)
7041 /* Work out the symbol's size and alignment. */
7042 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7044 desc
= SYMBOL_REF_CONSTANT (symbol
);
7045 alignment
= desc
->align
;
7046 size
= GET_MODE_SIZE (desc
->mode
);
7048 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7050 decl
= SYMBOL_REF_DECL (symbol
);
7051 alignment
= DECL_ALIGN (decl
);
7052 size
= get_constant_size (DECL_INITIAL (decl
));
7053 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7054 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7055 && asan_protect_global (DECL_INITIAL (decl
)))
7056 size
+= asan_red_zone_size (size
);
7060 struct symtab_node
*snode
;
7061 decl
= SYMBOL_REF_DECL (symbol
);
7063 snode
= symtab_node::get (decl
);
7066 rtx target
= DECL_RTL (snode
->ultimate_alias_target ()->decl
);
7068 place_block_symbol (target
);
7069 SYMBOL_REF_BLOCK_OFFSET (symbol
) = SYMBOL_REF_BLOCK_OFFSET (target
);
7072 alignment
= get_variable_align (decl
);
7073 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7074 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7075 && asan_protect_global (decl
))
7077 size
+= asan_red_zone_size (size
);
7078 alignment
= MAX (alignment
,
7079 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
7083 /* Calculate the object's offset from the start of the block. */
7084 block
= SYMBOL_REF_BLOCK (symbol
);
7085 mask
= alignment
/ BITS_PER_UNIT
- 1;
7086 offset
= (block
->size
+ mask
) & ~mask
;
7087 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
7089 /* Record the block's new alignment and size. */
7090 block
->alignment
= MAX (block
->alignment
, alignment
);
7091 block
->size
= offset
+ size
;
7093 vec_safe_push (block
->objects
, symbol
);
7096 /* Return the anchor that should be used to address byte offset OFFSET
7097 from the first object in BLOCK. MODEL is the TLS model used
7101 get_section_anchor (struct object_block
*block
, HOST_WIDE_INT offset
,
7102 enum tls_model model
)
7105 unsigned int begin
, middle
, end
;
7106 unsigned HOST_WIDE_INT min_offset
, max_offset
, range
, bias
, delta
;
7109 /* Work out the anchor's offset. Use an offset of 0 for the first
7110 anchor so that we don't pessimize the case where we take the address
7111 of a variable at the beginning of the block. This is particularly
7112 useful when a block has only one variable assigned to it.
7114 We try to place anchors RANGE bytes apart, so there can then be
7115 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
7116 a ptr_mode offset. With some target settings, the lowest such
7117 anchor might be out of range for the lowest ptr_mode offset;
7118 likewise the highest anchor for the highest offset. Use anchors
7119 at the extreme ends of the ptr_mode range in such cases.
7121 All arithmetic uses unsigned integers in order to avoid
7123 max_offset
= (unsigned HOST_WIDE_INT
) targetm
.max_anchor_offset
;
7124 min_offset
= (unsigned HOST_WIDE_INT
) targetm
.min_anchor_offset
;
7125 range
= max_offset
- min_offset
+ 1;
7130 bias
= 1 << (GET_MODE_BITSIZE (ptr_mode
) - 1);
7133 delta
= -(unsigned HOST_WIDE_INT
) offset
+ max_offset
;
7134 delta
-= delta
% range
;
7137 offset
= (HOST_WIDE_INT
) (-delta
);
7141 delta
= (unsigned HOST_WIDE_INT
) offset
- min_offset
;
7142 delta
-= delta
% range
;
7143 if (delta
> bias
- 1)
7145 offset
= (HOST_WIDE_INT
) delta
;
7149 /* Do a binary search to see if there's already an anchor we can use.
7150 Set BEGIN to the new anchor's index if not. */
7152 end
= vec_safe_length (block
->anchors
);
7153 while (begin
!= end
)
7155 middle
= (end
+ begin
) / 2;
7156 anchor
= (*block
->anchors
)[middle
];
7157 if (SYMBOL_REF_BLOCK_OFFSET (anchor
) > offset
)
7159 else if (SYMBOL_REF_BLOCK_OFFSET (anchor
) < offset
)
7161 else if (SYMBOL_REF_TLS_MODEL (anchor
) > model
)
7163 else if (SYMBOL_REF_TLS_MODEL (anchor
) < model
)
7169 /* Create a new anchor with a unique label. */
7170 ASM_GENERATE_INTERNAL_LABEL (label
, "LANCHOR", anchor_labelno
++);
7171 anchor
= create_block_symbol (ggc_strdup (label
), block
, offset
);
7172 SYMBOL_REF_FLAGS (anchor
) |= SYMBOL_FLAG_LOCAL
| SYMBOL_FLAG_ANCHOR
;
7173 SYMBOL_REF_FLAGS (anchor
) |= model
<< SYMBOL_FLAG_TLS_SHIFT
;
7175 /* Insert it at index BEGIN. */
7176 vec_safe_insert (block
->anchors
, begin
, anchor
);
7180 /* Output the objects in BLOCK. */
7183 output_object_block (struct object_block
*block
)
7185 struct constant_descriptor_rtx
*desc
;
7187 HOST_WIDE_INT offset
;
7191 if (!block
->objects
)
7194 /* Switch to the section and make sure that the first byte is
7195 suitably aligned. */
7196 switch_to_section (block
->sect
);
7197 assemble_align (block
->alignment
);
7199 /* Define the values of all anchors relative to the current section
7201 FOR_EACH_VEC_SAFE_ELT (block
->anchors
, i
, symbol
)
7202 targetm
.asm_out
.output_anchor (symbol
);
7204 /* Output the objects themselves. */
7206 FOR_EACH_VEC_ELT (*block
->objects
, i
, symbol
)
7208 /* Move to the object's offset, padding with zeros if necessary. */
7209 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol
) - offset
);
7210 offset
= SYMBOL_REF_BLOCK_OFFSET (symbol
);
7211 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7213 desc
= SYMBOL_REF_CONSTANT (symbol
);
7214 output_constant_pool_1 (desc
, 1);
7215 offset
+= GET_MODE_SIZE (desc
->mode
);
7217 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7220 decl
= SYMBOL_REF_DECL (symbol
);
7221 assemble_constant_contents (DECL_INITIAL (decl
), XSTR (symbol
, 0),
7223 size
= get_constant_size (DECL_INITIAL (decl
));
7225 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7226 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7227 && asan_protect_global (DECL_INITIAL (decl
)))
7229 size
= asan_red_zone_size (size
);
7230 assemble_zeros (size
);
7237 decl
= SYMBOL_REF_DECL (symbol
);
7238 assemble_variable_contents (decl
, XSTR (symbol
, 0), false);
7239 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7241 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7242 && asan_protect_global (decl
))
7244 size
= asan_red_zone_size (size
);
7245 assemble_zeros (size
);
7252 /* A htab_traverse callback used to call output_object_block for
7253 each member of object_block_htab. */
7256 output_object_block_htab (void **slot
, void *data ATTRIBUTE_UNUSED
)
7258 output_object_block ((struct object_block
*) (*slot
));
7262 /* Output the definitions of all object_blocks. */
7265 output_object_blocks (void)
7267 htab_traverse (object_block_htab
, output_object_block_htab
, NULL
);
7270 /* This function provides a possible implementation of the
7271 TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered
7272 by -frecord-gcc-switches it creates a new mergeable, string section in the
7273 assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which
7274 contains the switches in ASCII format.
7276 FIXME: This code does not correctly handle double quote characters
7277 that appear inside strings, (it strips them rather than preserving them).
7278 FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL
7279 characters - instead it treats them as sub-string separators. Since
7280 we want to emit NUL strings terminators into the object file we have to use
7284 elf_record_gcc_switches (print_switch_type type
, const char * name
)
7288 case SWITCH_TYPE_PASSED
:
7289 ASM_OUTPUT_ASCII (asm_out_file
, name
, strlen (name
));
7290 ASM_OUTPUT_SKIP (asm_out_file
, (unsigned HOST_WIDE_INT
) 1);
7293 case SWITCH_TYPE_DESCRIPTIVE
:
7296 /* Distinguish between invocations where name is NULL. */
7297 static bool started
= false;
7303 sec
= get_section (targetm
.asm_out
.record_gcc_switches_section
,
7307 | (SECTION_ENTSIZE
& 1),
7309 switch_to_section (sec
);
7318 /* The return value is currently ignored by the caller, but must be 0.
7319 For -fverbose-asm the return value would be the number of characters
7320 emitted into the assembler file. */
7324 /* Emit text to declare externally defined symbols. It is needed to
7325 properly support non-default visibility. */
7327 default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED
,
7329 const char *name ATTRIBUTE_UNUSED
)
7331 /* We output the name if and only if TREE_SYMBOL_REFERENCED is
7332 set in order to avoid putting out names that are never really
7334 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
7335 && targetm
.binds_local_p (decl
))
7336 maybe_assemble_visibility (decl
);
7339 /* The default hook for TARGET_ASM_OUTPUT_SOURCE_FILENAME. */
7342 default_asm_output_source_filename (FILE *file
, const char *name
)
7344 #ifdef ASM_OUTPUT_SOURCE_FILENAME
7345 ASM_OUTPUT_SOURCE_FILENAME (file
, name
);
7347 fprintf (file
, "\t.file\t");
7348 output_quoted_string (file
, name
);
7353 /* Output a file name in the form wanted by System V. */
7356 output_file_directive (FILE *asm_file
, const char *input_name
)
7361 if (input_name
== NULL
)
7362 input_name
= "<stdin>";
7364 input_name
= remap_debug_filename (input_name
);
7366 len
= strlen (input_name
);
7367 na
= input_name
+ len
;
7369 /* NA gets INPUT_NAME sans directory names. */
7370 while (na
> input_name
)
7372 if (IS_DIR_SEPARATOR (na
[-1]))
7377 targetm
.asm_out
.output_source_filename (asm_file
, na
);
7380 /* Create a DEBUG_EXPR_DECL / DEBUG_EXPR pair from RTL expression
7383 make_debug_expr_from_rtl (const_rtx exp
)
7385 tree ddecl
= make_node (DEBUG_EXPR_DECL
), type
;
7386 enum machine_mode mode
= GET_MODE (exp
);
7389 DECL_ARTIFICIAL (ddecl
) = 1;
7390 if (REG_P (exp
) && REG_EXPR (exp
))
7391 type
= TREE_TYPE (REG_EXPR (exp
));
7392 else if (MEM_P (exp
) && MEM_EXPR (exp
))
7393 type
= TREE_TYPE (MEM_EXPR (exp
));
7396 if (type
&& TYPE_MODE (type
) == mode
)
7397 TREE_TYPE (ddecl
) = type
;
7399 TREE_TYPE (ddecl
) = lang_hooks
.types
.type_for_mode (mode
, 1);
7400 DECL_MODE (ddecl
) = mode
;
7401 dval
= gen_rtx_DEBUG_EXPR (mode
);
7402 DEBUG_EXPR_TREE_DECL (dval
) = ddecl
;
7403 SET_DECL_RTL (ddecl
, dval
);
7407 #ifdef ELF_ASCII_ESCAPES
7408 /* Default ASM_OUTPUT_LIMITED_STRING for ELF targets. */
7411 default_elf_asm_output_limited_string (FILE *f
, const char *s
)
7416 fputs (STRING_ASM_OP
, f
);
7421 escape
= ELF_ASCII_ESCAPES
[c
];
7428 /* TODO: Print in hex with fast function, important for -flto. */
7429 fprintf (f
, "\\%03o", c
);
7442 /* Default ASM_OUTPUT_ASCII for ELF targets. */
7445 default_elf_asm_output_ascii (FILE *f
, const char *s
, unsigned int len
)
7447 const char *limit
= s
+ len
;
7448 const char *last_null
= NULL
;
7449 unsigned bytes_in_chunk
= 0;
7453 for (; s
< limit
; s
++)
7457 if (bytes_in_chunk
>= 60)
7466 for (p
= s
; p
< limit
&& *p
!= '\0'; p
++)
7473 if (p
< limit
&& (p
- s
) <= (long) ELF_STRING_LIMIT
)
7475 if (bytes_in_chunk
> 0)
7482 default_elf_asm_output_limited_string (f
, s
);
7487 if (bytes_in_chunk
== 0)
7488 fputs (ASCII_DATA_ASM_OP
"\"", f
);
7491 escape
= ELF_ASCII_ESCAPES
[c
];
7499 /* TODO: Print in hex with fast function, important for -flto. */
7500 fprintf (f
, "\\%03o", c
);
7501 bytes_in_chunk
+= 4;
7506 bytes_in_chunk
+= 2;
7513 if (bytes_in_chunk
> 0)
7521 static GTY(()) section
*elf_init_array_section
;
7522 static GTY(()) section
*elf_fini_array_section
;
7525 get_elf_initfini_array_priority_section (int priority
,
7529 if (priority
!= DEFAULT_INIT_PRIORITY
)
7532 sprintf (buf
, "%s.%.5u",
7533 constructor_p
? ".init_array" : ".fini_array",
7535 sec
= get_section (buf
, SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7541 if (elf_init_array_section
== NULL
)
7542 elf_init_array_section
7543 = get_section (".init_array",
7544 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7545 sec
= elf_init_array_section
;
7549 if (elf_fini_array_section
== NULL
)
7550 elf_fini_array_section
7551 = get_section (".fini_array",
7552 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7553 sec
= elf_fini_array_section
;
7559 /* Use .init_array section for constructors. */
7562 default_elf_init_array_asm_out_constructor (rtx symbol
, int priority
)
7564 section
*sec
= get_elf_initfini_array_priority_section (priority
,
7566 assemble_addr_to_section (symbol
, sec
);
7569 /* Use .fini_array section for destructors. */
7572 default_elf_fini_array_asm_out_destructor (rtx symbol
, int priority
)
7574 section
*sec
= get_elf_initfini_array_priority_section (priority
,
7576 assemble_addr_to_section (symbol
, sec
);
7579 /* Default TARGET_ASM_OUTPUT_IDENT hook.
7581 This is a bit of a cheat. The real default is a no-op, but this
7582 hook is the default for all targets with a .ident directive. */
7585 default_asm_output_ident_directive (const char *ident_str
)
7587 const char *ident_asm_op
= "\t.ident\t";
7589 /* If we are still in the front end, do not write out the string
7590 to asm_out_file. Instead, add a fake top-level asm statement.
7591 This allows the front ends to use this hook without actually
7592 writing to asm_out_file, to handle #ident or Pragma Ident. */
7593 if (symtab
->state
== PARSING
)
7595 char *buf
= ACONCAT ((ident_asm_op
, "\"", ident_str
, "\"\n", NULL
));
7596 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
7599 fprintf (asm_out_file
, "%s\"%s\"\n", ident_asm_op
, ident_str
);
7602 #include "gt-varasm.h"