1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987-2020 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"
38 #include "stringpool.h"
42 #include "diagnostic-core.h"
43 #include "fold-const.h"
44 #include "stor-layout.h"
52 #include "langhooks.h"
54 #include "common/common-target.h"
55 #include "stringpool.h"
59 #include "file-prefix-map.h" /* remap_debug_filename() */
61 #ifdef XCOFF_DEBUGGING_INFO
62 #include "xcoffout.h" /* Needed for external data declarations. */
65 /* The (assembler) name of the first globally-visible object output. */
66 extern GTY(()) const char *first_global_object_name
;
67 extern GTY(()) const char *weak_global_object_name
;
69 const char *first_global_object_name
;
70 const char *weak_global_object_name
;
73 class constant_descriptor_rtx
;
74 struct rtx_constant_pool
;
76 #define n_deferred_constants (crtl->varasm.deferred_constants)
78 /* Number for making the label on the next
79 constant that is stored in memory. */
81 static GTY(()) int const_labelno
;
83 /* Carry information from ASM_DECLARE_OBJECT_NAME
84 to ASM_FINISH_DECLARE_OBJECT. */
86 int size_directive_output
;
88 /* The last decl for which assemble_variable was called,
89 if it did ASM_DECLARE_OBJECT_NAME.
90 If the last call to assemble_variable didn't do that,
93 tree last_assemble_variable_decl
;
95 /* The following global variable indicates if the first basic block
96 in a function belongs to the cold partition or not. */
98 bool first_function_block_is_cold
;
100 /* Whether we saw any functions with no_split_stack. */
102 static bool saw_no_split_stack
;
104 static const char *strip_reg_name (const char *);
105 static int contains_pointers_p (tree
);
106 #ifdef ASM_OUTPUT_EXTERNAL
107 static bool incorporeal_function_p (tree
);
109 static void decode_addr_const (tree
, class addr_const
*);
110 static hashval_t
const_hash_1 (const tree
);
111 static int compare_constant (const tree
, const tree
);
112 static void output_constant_def_contents (rtx
);
113 static void output_addressed_constants (tree
);
114 static unsigned HOST_WIDE_INT
output_constant (tree
, unsigned HOST_WIDE_INT
,
115 unsigned int, bool, bool);
116 static void globalize_decl (tree
);
117 static bool decl_readonly_section_1 (enum section_category
);
118 #ifdef BSS_SECTION_ASM_OP
119 #ifdef ASM_OUTPUT_ALIGNED_BSS
120 static void asm_output_aligned_bss (FILE *, tree
, const char *,
121 unsigned HOST_WIDE_INT
, int)
124 #endif /* BSS_SECTION_ASM_OP */
125 static void mark_weak (tree
);
126 static void output_constant_pool (const char *, tree
);
127 static void handle_vtv_comdat_section (section
*, const_tree
);
129 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
130 section
*text_section
;
131 section
*data_section
;
132 section
*readonly_data_section
;
133 section
*sdata_section
;
134 section
*ctors_section
;
135 section
*dtors_section
;
136 section
*bss_section
;
137 section
*sbss_section
;
139 /* Various forms of common section. All are guaranteed to be nonnull. */
140 section
*tls_comm_section
;
141 section
*comm_section
;
142 section
*lcomm_section
;
144 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
146 section
*bss_noswitch_section
;
148 /* The section that holds the main exception table, when known. The section
149 is set either by the target's init_sections hook or by the first call to
150 switch_to_exception_section. */
151 section
*exception_section
;
153 /* The section that holds the DWARF2 frame unwind information, when known.
154 The section is set either by the target's init_sections hook or by the
155 first call to switch_to_eh_frame_section. */
156 section
*eh_frame_section
;
158 /* asm_out_file's current section. This is NULL if no section has yet
159 been selected or if we lose track of what the current section is. */
162 /* True if code for the current function is currently being directed
163 at the cold section. */
164 bool in_cold_section_p
;
166 /* The following global holds the "function name" for the code in the
167 cold section of a function, if hot/cold function splitting is enabled
168 and there was actually code that went into the cold section. A
169 pseudo function name is needed for the cold section of code for some
170 debugging tools that perform symbolization. */
171 tree cold_function_name
= NULL_TREE
;
173 /* A linked list of all the unnamed sections. */
174 static GTY(()) section
*unnamed_sections
;
176 /* Return a nonzero value if DECL has a section attribute. */
177 #define IN_NAMED_SECTION(DECL) \
178 (VAR_OR_FUNCTION_DECL_P (DECL) && DECL_SECTION_NAME (DECL) != NULL)
180 struct section_hasher
: ggc_ptr_hash
<section
>
182 typedef const char *compare_type
;
184 static hashval_t
hash (section
*);
185 static bool equal (section
*, const char *);
188 /* Hash table of named sections. */
189 static GTY(()) hash_table
<section_hasher
> *section_htab
;
191 struct object_block_hasher
: ggc_ptr_hash
<object_block
>
193 typedef const section
*compare_type
;
195 static hashval_t
hash (object_block
*);
196 static bool equal (object_block
*, const section
*);
199 /* A table of object_blocks, indexed by section. */
200 static GTY(()) hash_table
<object_block_hasher
> *object_block_htab
;
202 /* The next number to use for internal anchor labels. */
203 static GTY(()) int anchor_labelno
;
205 /* A pool of constants that can be shared between functions. */
206 static GTY(()) struct rtx_constant_pool
*shared_constant_pool
;
208 /* Helper routines for maintaining section_htab. */
211 section_hasher::equal (section
*old
, const char *new_name
)
213 return strcmp (old
->named
.name
, new_name
) == 0;
217 section_hasher::hash (section
*old
)
219 return htab_hash_string (old
->named
.name
);
222 /* Return a hash value for section SECT. */
225 hash_section (section
*sect
)
227 if (sect
->common
.flags
& SECTION_NAMED
)
228 return htab_hash_string (sect
->named
.name
);
229 return sect
->common
.flags
& ~SECTION_DECLARED
;
232 /* Helper routines for maintaining object_block_htab. */
235 object_block_hasher::equal (object_block
*old
, const section
*new_section
)
237 return old
->sect
== new_section
;
241 object_block_hasher::hash (object_block
*old
)
243 return hash_section (old
->sect
);
246 /* Return a new unnamed section with the given fields. */
249 get_unnamed_section (unsigned int flags
, void (*callback
) (const void *),
254 sect
= ggc_alloc
<section
> ();
255 sect
->unnamed
.common
.flags
= flags
| SECTION_UNNAMED
;
256 sect
->unnamed
.callback
= callback
;
257 sect
->unnamed
.data
= data
;
258 sect
->unnamed
.next
= unnamed_sections
;
260 unnamed_sections
= sect
;
264 /* Return a SECTION_NOSWITCH section with the given fields. */
267 get_noswitch_section (unsigned int flags
, noswitch_section_callback callback
)
271 sect
= ggc_alloc
<section
> ();
272 sect
->noswitch
.common
.flags
= flags
| SECTION_NOSWITCH
;
273 sect
->noswitch
.callback
= callback
;
278 /* Return the named section structure associated with NAME. Create
279 a new section with the given fields if no such structure exists. */
282 get_section (const char *name
, unsigned int flags
, tree decl
)
284 section
*sect
, **slot
;
286 slot
= section_htab
->find_slot_with_hash (name
, htab_hash_string (name
),
288 flags
|= SECTION_NAMED
;
291 sect
= ggc_alloc
<section
> ();
292 sect
->named
.common
.flags
= flags
;
293 sect
->named
.name
= ggc_strdup (name
);
294 sect
->named
.decl
= decl
;
300 /* It is fine if one of the sections has SECTION_NOTYPE as long as
301 the other has none of the contrary flags (see the logic at the end
302 of default_section_type_flags, below). */
303 if (((sect
->common
.flags
^ flags
) & SECTION_NOTYPE
)
304 && !((sect
->common
.flags
| flags
)
305 & (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
| SECTION_ENTSIZE
306 | (HAVE_COMDAT_GROUP
? SECTION_LINKONCE
: 0))))
308 sect
->common
.flags
|= SECTION_NOTYPE
;
309 flags
|= SECTION_NOTYPE
;
311 if ((sect
->common
.flags
& ~SECTION_DECLARED
) != flags
312 && ((sect
->common
.flags
| flags
) & SECTION_OVERRIDE
) == 0)
314 /* It is fine if one of the section flags is
315 SECTION_WRITE | SECTION_RELRO and the other has none of these
316 flags (i.e. read-only) in named sections and either the
317 section hasn't been declared yet or has been declared as writable.
318 In that case just make sure the resulting flags are
319 SECTION_WRITE | SECTION_RELRO, ie. writable only because of
321 if (((sect
->common
.flags
^ flags
) & (SECTION_WRITE
| SECTION_RELRO
))
322 == (SECTION_WRITE
| SECTION_RELRO
)
323 && (sect
->common
.flags
324 & ~(SECTION_DECLARED
| SECTION_WRITE
| SECTION_RELRO
))
325 == (flags
& ~(SECTION_WRITE
| SECTION_RELRO
))
326 && ((sect
->common
.flags
& SECTION_DECLARED
) == 0
327 || (sect
->common
.flags
& SECTION_WRITE
)))
329 sect
->common
.flags
|= (SECTION_WRITE
| SECTION_RELRO
);
332 /* Sanity check user variables for flag changes. */
333 if (sect
->named
.decl
!= NULL
334 && DECL_P (sect
->named
.decl
)
335 && decl
!= sect
->named
.decl
)
337 if (decl
!= NULL
&& DECL_P (decl
))
338 error ("%+qD causes a section type conflict with %qD",
339 decl
, sect
->named
.decl
);
341 error ("section type conflict with %qD", sect
->named
.decl
);
342 inform (DECL_SOURCE_LOCATION (sect
->named
.decl
),
343 "%qD was declared here", sect
->named
.decl
);
345 else if (decl
!= NULL
&& DECL_P (decl
))
346 error ("%+qD causes a section type conflict", decl
);
348 error ("section type conflict");
349 /* Make sure we don't error about one section multiple times. */
350 sect
->common
.flags
|= SECTION_OVERRIDE
;
356 /* Return true if the current compilation mode benefits from having
357 objects grouped into blocks. */
360 use_object_blocks_p (void)
362 return flag_section_anchors
;
365 /* Return the object_block structure for section SECT. Create a new
366 structure if we haven't created one already. Return null if SECT
367 itself is null. Return also null for mergeable sections since
368 section anchors can't be used in mergeable sections anyway,
369 because the linker might move objects around, and using the
370 object blocks infrastructure in that case is both a waste and a
371 maintenance burden. */
373 static struct object_block
*
374 get_block_for_section (section
*sect
)
376 struct object_block
*block
;
381 if (sect
->common
.flags
& SECTION_MERGE
)
385 = object_block_htab
->find_slot_with_hash (sect
, hash_section (sect
),
390 block
= ggc_cleared_alloc
<object_block
> ();
397 /* Create a symbol with label LABEL and place it at byte offset
398 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
399 is not yet known. LABEL must be a garbage-collected string. */
402 create_block_symbol (const char *label
, struct object_block
*block
,
403 HOST_WIDE_INT offset
)
408 /* Create the extended SYMBOL_REF. */
409 size
= RTX_HDR_SIZE
+ sizeof (struct block_symbol
);
410 symbol
= (rtx
) ggc_internal_alloc (size
);
412 /* Initialize the normal SYMBOL_REF fields. */
413 memset (symbol
, 0, size
);
414 PUT_CODE (symbol
, SYMBOL_REF
);
415 PUT_MODE (symbol
, Pmode
);
416 XSTR (symbol
, 0) = label
;
417 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_HAS_BLOCK_INFO
;
419 /* Initialize the block_symbol stuff. */
420 SYMBOL_REF_BLOCK (symbol
) = block
;
421 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
426 /* Return a section with a particular name and with whatever SECTION_*
427 flags section_type_flags deems appropriate. The name of the section
428 is taken from NAME if nonnull, otherwise it is taken from DECL's
429 DECL_SECTION_NAME. DECL is the decl associated with the section
430 (see the section comment for details) and RELOC is as for
431 section_type_flags. */
434 get_named_section (tree decl
, const char *name
, int reloc
)
440 gcc_assert (decl
&& DECL_P (decl
) && DECL_SECTION_NAME (decl
));
441 name
= DECL_SECTION_NAME (decl
);
444 flags
= targetm
.section_type_flags (decl
, name
, reloc
);
445 return get_section (name
, flags
, decl
);
448 /* Worker for resolve_unique_section. */
451 set_implicit_section (struct symtab_node
*n
, void *data ATTRIBUTE_UNUSED
)
453 n
->implicit_section
= true;
457 /* If required, set DECL_SECTION_NAME to a unique name. */
460 resolve_unique_section (tree decl
, int reloc ATTRIBUTE_UNUSED
,
461 int flag_function_or_data_sections
)
463 if (DECL_SECTION_NAME (decl
) == NULL
464 && targetm_common
.have_named_sections
465 && (flag_function_or_data_sections
466 || DECL_COMDAT_GROUP (decl
)))
468 targetm
.asm_out
.unique_section (decl
, reloc
);
469 if (DECL_SECTION_NAME (decl
))
470 symtab_node::get (decl
)->call_for_symbol_and_aliases
471 (set_implicit_section
, NULL
, true);
475 #ifdef BSS_SECTION_ASM_OP
477 #ifdef ASM_OUTPUT_ALIGNED_BSS
479 /* Utility function for targets to use in implementing
480 ASM_OUTPUT_ALIGNED_BSS.
481 ??? It is believed that this function will work in most cases so such
482 support is localized here. */
485 asm_output_aligned_bss (FILE *file
, tree decl ATTRIBUTE_UNUSED
,
486 const char *name
, unsigned HOST_WIDE_INT size
,
489 switch_to_section (bss_section
);
490 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
491 #ifdef ASM_DECLARE_OBJECT_NAME
492 last_assemble_variable_decl
= decl
;
493 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
495 /* Standard thing is just output label for the object. */
496 ASM_OUTPUT_LABEL (file
, name
);
497 #endif /* ASM_DECLARE_OBJECT_NAME */
498 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
503 #endif /* BSS_SECTION_ASM_OP */
505 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
506 /* Return the hot section for function DECL. Return text_section for
510 hot_function_section (tree decl
)
512 if (decl
!= NULL_TREE
513 && DECL_SECTION_NAME (decl
) != NULL
514 && targetm_common
.have_named_sections
)
515 return get_named_section (decl
, NULL
, 0);
521 /* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL)
524 When DECL_SECTION_NAME is non-NULL and it is implicit section and
525 NAMED_SECTION_SUFFIX is non-NULL, then produce section called
526 concatenate the name with NAMED_SECTION_SUFFIX.
527 Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */
530 get_named_text_section (tree decl
,
531 const char *text_section_name
,
532 const char *named_section_suffix
)
534 if (decl
&& DECL_SECTION_NAME (decl
))
536 if (named_section_suffix
)
538 const char *dsn
= DECL_SECTION_NAME (decl
);
539 const char *stripped_name
;
542 name
= (char *) alloca (strlen (dsn
) + 1);
546 stripped_name
= targetm
.strip_name_encoding (name
);
548 buffer
= ACONCAT ((stripped_name
, named_section_suffix
, NULL
));
549 return get_named_section (decl
, buffer
, 0);
551 else if (symtab_node::get (decl
)->implicit_section
)
555 /* Do not try to split gnu_linkonce functions. This gets somewhat
557 if (DECL_COMDAT_GROUP (decl
) && !HAVE_COMDAT_GROUP
)
559 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
560 name
= targetm
.strip_name_encoding (name
);
561 return get_named_section (decl
, ACONCAT ((text_section_name
, ".",
567 return get_named_section (decl
, text_section_name
, 0);
570 /* Choose named function section based on its frequency. */
573 default_function_section (tree decl
, enum node_frequency freq
,
574 bool startup
, bool exit
)
576 #if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG
577 /* Old GNU linkers have buggy --gc-section support, which sometimes
578 results in .gcc_except_table* sections being garbage collected. */
580 && symtab_node::get (decl
)->implicit_section
)
584 if (!flag_reorder_functions
585 || !targetm_common
.have_named_sections
)
587 /* Startup code should go to startup subsection unless it is
588 unlikely executed (this happens especially with function splitting
589 where we can split away unnecessary parts of static constructors. */
590 if (startup
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
592 /* During LTO the tp_first_run profiling will naturally place all
593 initialization code first. Using separate section is counter-productive
594 because startup only code may call functions which are no longer
597 || !cgraph_node::get (decl
)->tp_first_run
598 || !opt_for_fn (decl
, flag_profile_reorder_functions
))
599 return get_named_text_section (decl
, ".text.startup", NULL
);
604 /* Similarly for exit. */
605 if (exit
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
606 return get_named_text_section (decl
, ".text.exit", NULL
);
608 /* Group cold functions together, similarly for hot code. */
611 case NODE_FREQUENCY_UNLIKELY_EXECUTED
:
612 return get_named_text_section (decl
, ".text.unlikely", NULL
);
613 case NODE_FREQUENCY_HOT
:
614 return get_named_text_section (decl
, ".text.hot", NULL
);
621 /* Return the section for function DECL.
623 If DECL is NULL_TREE, return the text section. We can be passed
624 NULL_TREE under some circumstances by dbxout.c at least.
626 If FORCE_COLD is true, return cold function section ignoring
627 the frequency info of cgraph_node. */
630 function_section_1 (tree decl
, bool force_cold
)
632 section
*section
= NULL
;
633 enum node_frequency freq
= NODE_FREQUENCY_NORMAL
;
634 bool startup
= false, exit
= false;
638 struct cgraph_node
*node
= cgraph_node::get (decl
);
642 freq
= node
->frequency
;
643 startup
= node
->only_called_at_startup
;
644 exit
= node
->only_called_at_exit
;
648 freq
= NODE_FREQUENCY_UNLIKELY_EXECUTED
;
650 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
651 if (decl
!= NULL_TREE
652 && DECL_SECTION_NAME (decl
) != NULL
)
654 if (targetm
.asm_out
.function_section
)
655 section
= targetm
.asm_out
.function_section (decl
, freq
,
659 return get_named_section (decl
, NULL
, 0);
662 return targetm
.asm_out
.select_section
663 (decl
, freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
,
664 symtab_node::get (decl
)->definition_alignment ());
666 if (targetm
.asm_out
.function_section
)
667 section
= targetm
.asm_out
.function_section (decl
, freq
, startup
, exit
);
670 return hot_function_section (decl
);
674 /* Return the section for function DECL.
676 If DECL is NULL_TREE, return the text section. We can be passed
677 NULL_TREE under some circumstances by dbxout.c at least. */
680 function_section (tree decl
)
682 /* Handle cases where function splitting code decides
683 to put function entry point into unlikely executed section
684 despite the fact that the function itself is not cold
685 (i.e. it is called rarely but contains a hot loop that is
686 better to live in hot subsection for the code locality). */
687 return function_section_1 (decl
,
688 first_function_block_is_cold
);
691 /* Return the section for the current function, take IN_COLD_SECTION_P
695 current_function_section (void)
697 return function_section_1 (current_function_decl
, in_cold_section_p
);
700 /* Tell assembler to switch to unlikely-to-be-executed text section. */
703 unlikely_text_section (void)
705 return function_section_1 (current_function_decl
, true);
708 /* When called within a function context, return true if the function
709 has been assigned a cold text section and if SECT is that section.
710 When called outside a function context, return true if SECT is the
711 default cold section. */
714 unlikely_text_section_p (section
*sect
)
716 return sect
== function_section_1 (current_function_decl
, true);
719 /* Switch to the other function partition (if inside of hot section
720 into cold section, otherwise into the hot section). */
723 switch_to_other_text_partition (void)
725 in_cold_section_p
= !in_cold_section_p
;
726 switch_to_section (current_function_section ());
729 /* Return the read-only data section associated with function DECL. */
732 default_function_rodata_section (tree decl
)
734 if (decl
!= NULL_TREE
&& DECL_SECTION_NAME (decl
))
736 const char *name
= DECL_SECTION_NAME (decl
);
738 if (DECL_COMDAT_GROUP (decl
) && HAVE_COMDAT_GROUP
)
744 dot
= strchr (name
+ 1, '.');
747 len
= strlen (dot
) + 8;
748 rname
= (char *) alloca (len
);
750 strcpy (rname
, ".rodata");
752 return get_section (rname
, SECTION_LINKONCE
, decl
);
754 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
755 else if (DECL_COMDAT_GROUP (decl
)
756 && strncmp (name
, ".gnu.linkonce.t.", 16) == 0)
758 size_t len
= strlen (name
) + 1;
759 char *rname
= (char *) alloca (len
);
761 memcpy (rname
, name
, len
);
763 return get_section (rname
, SECTION_LINKONCE
, decl
);
765 /* For .text.foo we want to use .rodata.foo. */
766 else if (flag_function_sections
&& flag_data_sections
767 && strncmp (name
, ".text.", 6) == 0)
769 size_t len
= strlen (name
) + 1;
770 char *rname
= (char *) alloca (len
+ 2);
772 memcpy (rname
, ".rodata", 7);
773 memcpy (rname
+ 7, name
+ 5, len
- 5);
774 return get_section (rname
, 0, decl
);
778 return readonly_data_section
;
781 /* Return the read-only data section associated with function DECL
782 for targets where that section should be always the single
783 readonly data section. */
786 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED
)
788 return readonly_data_section
;
791 /* A subroutine of mergeable_string_section and mergeable_constant_section. */
794 function_mergeable_rodata_prefix (void)
796 section
*s
= targetm
.asm_out
.function_rodata_section (current_function_decl
);
797 if (SECTION_STYLE (s
) == SECTION_NAMED
)
798 return s
->named
.name
;
800 return targetm
.asm_out
.mergeable_rodata_prefix
;
803 /* Return the section to use for string merging. */
806 mergeable_string_section (tree decl ATTRIBUTE_UNUSED
,
807 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
808 unsigned int flags ATTRIBUTE_UNUSED
)
812 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
813 && TREE_CODE (decl
) == STRING_CST
814 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
816 && (len
= int_size_in_bytes (TREE_TYPE (decl
))) > 0
817 && TREE_STRING_LENGTH (decl
) == len
)
819 scalar_int_mode mode
;
820 unsigned int modesize
;
824 const char *prefix
= function_mergeable_rodata_prefix ();
825 char *name
= (char *) alloca (strlen (prefix
) + 30);
827 mode
= SCALAR_INT_TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
828 modesize
= GET_MODE_BITSIZE (mode
);
829 if (modesize
>= 8 && modesize
<= 256
830 && (modesize
& (modesize
- 1)) == 0)
832 if (align
< modesize
)
835 if (!HAVE_LD_ALIGNED_SHF_MERGE
&& align
> 8)
836 return readonly_data_section
;
838 str
= TREE_STRING_POINTER (decl
);
839 unit
= GET_MODE_SIZE (mode
);
841 /* Check for embedded NUL characters. */
842 for (i
= 0; i
< len
; i
+= unit
)
844 for (j
= 0; j
< unit
; j
++)
845 if (str
[i
+ j
] != '\0')
850 if (i
== len
- unit
|| (unit
== 1 && i
== len
))
852 sprintf (name
, "%s.str%d.%d", prefix
,
853 modesize
/ 8, (int) (align
/ 8));
854 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
855 return get_section (name
, flags
, NULL
);
860 return readonly_data_section
;
863 /* Return the section to use for constant merging. */
866 mergeable_constant_section (machine_mode mode ATTRIBUTE_UNUSED
,
867 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
868 unsigned int flags ATTRIBUTE_UNUSED
)
870 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
873 && known_le (GET_MODE_BITSIZE (mode
), align
)
876 && (align
& (align
- 1)) == 0
877 && (HAVE_LD_ALIGNED_SHF_MERGE
? 1 : align
== 8))
879 const char *prefix
= function_mergeable_rodata_prefix ();
880 char *name
= (char *) alloca (strlen (prefix
) + 30);
882 sprintf (name
, "%s.cst%d", prefix
, (int) (align
/ 8));
883 flags
|= (align
/ 8) | SECTION_MERGE
;
884 return get_section (name
, flags
, NULL
);
886 return readonly_data_section
;
889 /* Given NAME, a putative register name, discard any customary prefixes. */
892 strip_reg_name (const char *name
)
894 #ifdef REGISTER_PREFIX
895 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
896 name
+= strlen (REGISTER_PREFIX
);
898 if (name
[0] == '%' || name
[0] == '#')
903 /* The user has asked for a DECL to have a particular name. Set (or
904 change) it in such a way that we don't prefix an underscore to
907 set_user_assembler_name (tree decl
, const char *name
)
909 char *starred
= (char *) alloca (strlen (name
) + 2);
911 strcpy (starred
+ 1, name
);
912 symtab
->change_decl_assembler_name (decl
, get_identifier (starred
));
913 SET_DECL_RTL (decl
, NULL_RTX
);
916 /* Decode an `asm' spec for a declaration as a register name.
917 Return the register number, or -1 if nothing specified,
918 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
919 or -3 if ASMSPEC is `cc' and is not recognized,
920 or -4 if ASMSPEC is `memory' and is not recognized.
921 Accept an exact spelling or a decimal number.
922 Prefixes such as % are optional. */
925 decode_reg_name_and_count (const char *asmspec
, int *pnregs
)
927 /* Presume just one register is clobbered. */
934 /* Get rid of confusing prefixes. */
935 asmspec
= strip_reg_name (asmspec
);
937 /* Allow a decimal number as a "register name". */
938 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
939 if (! ISDIGIT (asmspec
[i
]))
941 if (asmspec
[0] != 0 && i
< 0)
944 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0 && reg_names
[i
][0])
950 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
952 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
955 #ifdef OVERLAPPING_REGISTER_NAMES
959 const char *const name
;
962 } table
[] = OVERLAPPING_REGISTER_NAMES
;
964 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
966 && ! strcmp (asmspec
, table
[i
].name
))
968 *pnregs
= table
[i
].nregs
;
969 return table
[i
].number
;
972 #endif /* OVERLAPPING_REGISTER_NAMES */
974 #ifdef ADDITIONAL_REGISTER_NAMES
976 static const struct { const char *const name
; const int number
; } table
[]
977 = ADDITIONAL_REGISTER_NAMES
;
979 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
981 && ! strcmp (asmspec
, table
[i
].name
)
982 && reg_names
[table
[i
].number
][0])
983 return table
[i
].number
;
985 #endif /* ADDITIONAL_REGISTER_NAMES */
987 if (!strcmp (asmspec
, "memory"))
990 if (!strcmp (asmspec
, "cc"))
1000 decode_reg_name (const char *name
)
1003 return decode_reg_name_and_count (name
, &count
);
1007 /* Return true if DECL's initializer is suitable for a BSS section. */
1010 bss_initializer_p (const_tree decl
, bool named
)
1012 /* Do not put non-common constants into the .bss section, they belong in
1013 a readonly section, except when NAMED is true. */
1014 return ((!TREE_READONLY (decl
) || DECL_COMMON (decl
) || named
)
1015 && (DECL_INITIAL (decl
) == NULL
1016 /* In LTO we have no errors in program; error_mark_node is used
1017 to mark offlined constructors. */
1018 || (DECL_INITIAL (decl
) == error_mark_node
1020 || (flag_zero_initialized_in_bss
1021 && initializer_zerop (DECL_INITIAL (decl
)))));
1024 /* Compute the alignment of variable specified by DECL.
1025 DONT_OUTPUT_DATA is from assemble_variable. */
1028 align_variable (tree decl
, bool dont_output_data
)
1030 unsigned int align
= DECL_ALIGN (decl
);
1032 /* In the case for initialing an array whose length isn't specified,
1033 where we have not yet been able to do the layout,
1034 figure out the proper alignment now. */
1035 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1036 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1037 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1039 /* Some object file formats have a maximum alignment which they support.
1040 In particular, a.out format supports a maximum alignment of 4. */
1041 if (align
> MAX_OFILE_ALIGNMENT
)
1043 error ("alignment of %q+D is greater than maximum object "
1044 "file alignment %d", decl
,
1045 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1046 align
= MAX_OFILE_ALIGNMENT
;
1049 if (! DECL_USER_ALIGN (decl
))
1051 #ifdef DATA_ABI_ALIGNMENT
1052 unsigned int data_abi_align
1053 = DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
1054 /* For backwards compatibility, don't assume the ABI alignment for
1056 if (! DECL_THREAD_LOCAL_P (decl
) || data_abi_align
<= BITS_PER_WORD
)
1057 align
= data_abi_align
;
1060 /* On some machines, it is good to increase alignment sometimes.
1061 But as DECL_ALIGN is used both for actually emitting the variable
1062 and for code accessing the variable as guaranteed alignment, we
1063 can only increase the alignment if it is a performance optimization
1064 if the references to it must bind to the current definition. */
1065 if (decl_binds_to_current_def_p (decl
)
1066 && !DECL_VIRTUAL_P (decl
))
1068 #ifdef DATA_ALIGNMENT
1069 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1070 /* Don't increase alignment too much for TLS variables - TLS space
1072 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
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
1081 = targetm
.constant_alignment (DECL_INITIAL (decl
), align
);
1082 /* Don't increase alignment too much for TLS variables - TLS
1083 space is too precious. */
1084 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1085 align
= const_align
;
1090 /* Reset the alignment in case we have made it tighter, so we can benefit
1091 from it in get_pointer_alignment. */
1092 SET_DECL_ALIGN (decl
, align
);
1095 /* Return DECL_ALIGN (decl), possibly increased for optimization purposes
1096 beyond what align_variable returned. */
1099 get_variable_align (tree decl
)
1101 unsigned int align
= DECL_ALIGN (decl
);
1103 /* For user aligned vars or static vars align_variable already did
1105 if (DECL_USER_ALIGN (decl
) || !TREE_PUBLIC (decl
))
1108 #ifdef DATA_ABI_ALIGNMENT
1109 if (DECL_THREAD_LOCAL_P (decl
))
1110 align
= DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
1113 /* For decls that bind to the current definition, align_variable
1114 did also everything, except for not assuming ABI required alignment
1115 of TLS variables. For other vars, increase the alignment here
1116 as an optimization. */
1117 if (!decl_binds_to_current_def_p (decl
))
1119 /* On some machines, it is good to increase alignment sometimes. */
1120 #ifdef DATA_ALIGNMENT
1121 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1122 /* Don't increase alignment too much for TLS variables - TLS space
1124 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
1127 if (DECL_INITIAL (decl
) != 0
1128 /* In LTO we have no errors in program; error_mark_node is used
1129 to mark offlined constructors. */
1130 && (in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
))
1132 unsigned int const_align
1133 = targetm
.constant_alignment (DECL_INITIAL (decl
), align
);
1134 /* Don't increase alignment too much for TLS variables - TLS space
1136 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1137 align
= const_align
;
1144 /* Return the section into which the given VAR_DECL or CONST_DECL
1145 should be placed. PREFER_NOSWITCH_P is true if a noswitch
1146 section should be used wherever possible. */
1149 get_variable_section (tree decl
, bool prefer_noswitch_p
)
1151 addr_space_t as
= ADDR_SPACE_GENERIC
;
1153 varpool_node
*vnode
= varpool_node::get (decl
);
1156 vnode
= vnode
->ultimate_alias_target ();
1160 if (TREE_TYPE (decl
) != error_mark_node
)
1161 as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1163 /* We need the constructor to figure out reloc flag. */
1165 vnode
->get_constructor ();
1167 if (DECL_COMMON (decl
))
1169 /* If the decl has been given an explicit section name, or it resides
1170 in a non-generic address space, then it isn't common, and shouldn't
1171 be handled as such. */
1172 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
1173 && ADDR_SPACE_GENERIC_P (as
));
1174 if (DECL_THREAD_LOCAL_P (decl
))
1175 return tls_comm_section
;
1176 else if (TREE_PUBLIC (decl
) && bss_initializer_p (decl
))
1177 return comm_section
;
1180 if (DECL_INITIAL (decl
) == error_mark_node
)
1181 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1182 else if (DECL_INITIAL (decl
))
1183 reloc
= compute_reloc_for_constant (DECL_INITIAL (decl
));
1187 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1188 if (IN_NAMED_SECTION (decl
))
1190 section
*sect
= get_named_section (decl
, NULL
, reloc
);
1192 if ((sect
->common
.flags
& SECTION_BSS
)
1193 && !bss_initializer_p (decl
, true))
1195 error_at (DECL_SOURCE_LOCATION (decl
),
1196 "only zero initializers are allowed in section %qs",
1198 DECL_INITIAL (decl
) = error_mark_node
;
1203 if (ADDR_SPACE_GENERIC_P (as
)
1204 && !DECL_THREAD_LOCAL_P (decl
)
1205 && !(prefer_noswitch_p
&& targetm
.have_switchable_bss_sections
)
1206 && bss_initializer_p (decl
))
1208 if (!TREE_PUBLIC (decl
)
1209 && !((flag_sanitize
& SANITIZE_ADDRESS
)
1210 && asan_protect_global (decl
)))
1211 return lcomm_section
;
1212 if (bss_noswitch_section
)
1213 return bss_noswitch_section
;
1216 return targetm
.asm_out
.select_section (decl
, reloc
,
1217 get_variable_align (decl
));
1220 /* Return the block into which object_block DECL should be placed. */
1222 static struct object_block
*
1223 get_block_for_decl (tree decl
)
1229 /* The object must be defined in this translation unit. */
1230 if (DECL_EXTERNAL (decl
))
1233 /* There's no point using object blocks for something that is
1234 isolated by definition. */
1235 if (DECL_COMDAT_GROUP (decl
))
1239 /* We can only calculate block offsets if the decl has a known
1241 if (DECL_SIZE_UNIT (decl
) == NULL
)
1243 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (decl
)))
1246 /* Find out which section should contain DECL. We cannot put it into
1247 an object block if it requires a standalone definition. */
1249 align_variable (decl
, 0);
1250 sect
= get_variable_section (decl
, true);
1251 if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
1254 return get_block_for_section (sect
);
1257 /* Make sure block symbol SYMBOL is in block BLOCK. */
1260 change_symbol_block (rtx symbol
, struct object_block
*block
)
1262 if (block
!= SYMBOL_REF_BLOCK (symbol
))
1264 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol
) < 0);
1265 SYMBOL_REF_BLOCK (symbol
) = block
;
1269 /* Return true if it is possible to put DECL in an object_block. */
1272 use_blocks_for_decl_p (tree decl
)
1274 struct symtab_node
*snode
;
1276 /* Only data DECLs can be placed into object blocks. */
1277 if (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
1280 /* DECL_INITIAL (decl) set to decl is a hack used for some decls that
1281 are never used from code directly and we never want object block handling
1283 if (DECL_INITIAL (decl
) == decl
)
1286 /* If this decl is an alias, then we don't want to emit a
1289 && (snode
= symtab_node::get (decl
)) != NULL
1293 return targetm
.use_blocks_for_decl_p (decl
);
1296 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
1297 until we find an identifier that is not itself a transparent alias.
1298 Modify the alias passed to it by reference (and all aliases on the
1299 way to the ultimate target), such that they do not have to be
1300 followed again, and return the ultimate target of the alias
1304 ultimate_transparent_alias_target (tree
*alias
)
1306 tree target
= *alias
;
1308 if (IDENTIFIER_TRANSPARENT_ALIAS (target
))
1310 gcc_assert (TREE_CHAIN (target
));
1311 target
= ultimate_transparent_alias_target (&TREE_CHAIN (target
));
1312 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
1313 && ! TREE_CHAIN (target
));
1320 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
1321 have static storage duration. In other words, it should not be an
1322 automatic variable, including PARM_DECLs.
1324 There is, however, one exception: this function handles variables
1325 explicitly placed in a particular register by the user.
1327 This is never called for PARM_DECL nodes. */
1330 make_decl_rtl (tree decl
)
1332 const char *name
= 0;
1337 /* Check that we are not being given an automatic variable. */
1338 gcc_assert (TREE_CODE (decl
) != PARM_DECL
1339 && TREE_CODE (decl
) != RESULT_DECL
);
1341 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1342 gcc_assert (!VAR_P (decl
)
1343 || TREE_STATIC (decl
)
1344 || TREE_PUBLIC (decl
)
1345 || DECL_EXTERNAL (decl
)
1346 || DECL_REGISTER (decl
));
1348 /* And that we were not given a type or a label. */
1349 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
1350 && TREE_CODE (decl
) != LABEL_DECL
);
1352 /* For a duplicate declaration, we can be called twice on the
1353 same DECL node. Don't discard the RTL already made. */
1354 if (DECL_RTL_SET_P (decl
))
1356 /* If the old RTL had the wrong mode, fix the mode. */
1357 x
= DECL_RTL (decl
);
1358 if (GET_MODE (x
) != DECL_MODE (decl
))
1359 SET_DECL_RTL (decl
, adjust_address_nv (x
, DECL_MODE (decl
), 0));
1361 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1364 /* ??? Another way to do this would be to maintain a hashed
1365 table of such critters. Instead of adding stuff to a DECL
1366 to give certain attributes to it, we could use an external
1367 hash map from DECL to set of attributes. */
1369 /* Let the target reassign the RTL if it wants.
1370 This is necessary, for example, when one machine specific
1371 decl attribute overrides another. */
1372 targetm
.encode_section_info (decl
, DECL_RTL (decl
), false);
1374 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1375 on the new decl information. */
1377 && GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
1378 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x
, 0)))
1379 change_symbol_block (XEXP (x
, 0), get_block_for_decl (decl
));
1384 /* If this variable belongs to the global constant pool, retrieve the
1385 pre-computed RTL or recompute it in LTO mode. */
1386 if (VAR_P (decl
) && DECL_IN_CONSTANT_POOL (decl
))
1388 SET_DECL_RTL (decl
, output_constant_def (DECL_INITIAL (decl
), 1));
1392 id
= DECL_ASSEMBLER_NAME (decl
);
1393 name
= IDENTIFIER_POINTER (id
);
1395 if (name
[0] != '*' && TREE_CODE (decl
) != FUNCTION_DECL
1396 && DECL_REGISTER (decl
))
1398 error ("register name not specified for %q+D", decl
);
1400 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1402 const char *asmspec
= name
+1;
1403 machine_mode mode
= DECL_MODE (decl
);
1404 reg_number
= decode_reg_name (asmspec
);
1405 /* First detect errors in declaring global registers. */
1406 if (reg_number
== -1)
1407 error ("register name not specified for %q+D", decl
);
1408 else if (reg_number
< 0)
1409 error ("invalid register name for %q+D", decl
);
1410 else if (mode
== BLKmode
)
1411 error ("data type of %q+D isn%'t suitable for a register",
1413 else if (!in_hard_reg_set_p (accessible_reg_set
, mode
, reg_number
))
1414 error ("the register specified for %q+D cannot be accessed"
1415 " by the current target", decl
);
1416 else if (!in_hard_reg_set_p (operand_reg_set
, mode
, reg_number
))
1417 error ("the register specified for %q+D is not general enough"
1418 " to be used as a register variable", decl
);
1419 else if (!targetm
.hard_regno_mode_ok (reg_number
, mode
))
1420 error ("register specified for %q+D isn%'t suitable for data type",
1422 /* Now handle properly declared static register variables. */
1427 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
1429 DECL_INITIAL (decl
) = 0;
1430 error ("global register variable has initial value");
1432 if (TREE_THIS_VOLATILE (decl
))
1433 warning (OPT_Wvolatile_register_var
,
1434 "optimization may eliminate reads and/or "
1435 "writes to register variables");
1437 /* If the user specified one of the eliminables registers here,
1438 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1439 confused with that register and be eliminated. This usage is
1440 somewhat suspect... */
1442 SET_DECL_RTL (decl
, gen_raw_REG (mode
, reg_number
));
1443 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
1444 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
1446 if (TREE_STATIC (decl
))
1448 /* Make this register global, so not usable for anything
1450 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1451 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1452 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
1454 nregs
= hard_regno_nregs (reg_number
, mode
);
1456 globalize_reg (decl
, reg_number
+ --nregs
);
1459 /* As a register variable, it has no section. */
1462 /* Avoid internal errors from invalid register
1464 SET_DECL_ASSEMBLER_NAME (decl
, NULL_TREE
);
1465 DECL_HARD_REGISTER (decl
) = 0;
1466 /* Also avoid SSA inconsistencies by pretending this is an external
1468 DECL_EXTERNAL (decl
) = 1;
1471 /* Now handle ordinary static variables and functions (in memory).
1472 Also handle vars declared register invalidly. */
1473 else if (name
[0] == '*')
1475 #ifdef REGISTER_PREFIX
1476 if (strlen (REGISTER_PREFIX
) != 0)
1478 reg_number
= decode_reg_name (name
);
1479 if (reg_number
>= 0 || reg_number
== -3)
1480 error ("register name given for non-register variable %q+D", decl
);
1485 /* Specifying a section attribute on a variable forces it into a
1486 non-.bss section, and thus it cannot be common. */
1487 /* FIXME: In general this code should not be necessary because
1488 visibility pass is doing the same work. But notice_global_symbol
1489 is called early and it needs to make DECL_RTL to get the name.
1490 we take care of recomputing the DECL_RTL after visibility is changed. */
1492 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
1493 && DECL_SECTION_NAME (decl
) != NULL
1494 && DECL_INITIAL (decl
) == NULL_TREE
1495 && DECL_COMMON (decl
))
1496 DECL_COMMON (decl
) = 0;
1498 /* Variables can't be both common and weak. */
1499 if (VAR_P (decl
) && DECL_WEAK (decl
))
1500 DECL_COMMON (decl
) = 0;
1502 if (use_object_blocks_p () && use_blocks_for_decl_p (decl
))
1503 x
= create_block_symbol (name
, get_block_for_decl (decl
), -1);
1506 machine_mode address_mode
= Pmode
;
1507 if (TREE_TYPE (decl
) != error_mark_node
)
1509 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1510 address_mode
= targetm
.addr_space
.address_mode (as
);
1512 x
= gen_rtx_SYMBOL_REF (address_mode
, name
);
1514 SYMBOL_REF_WEAK (x
) = DECL_WEAK (decl
);
1515 SET_SYMBOL_REF_DECL (x
, decl
);
1517 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
1518 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1519 set_mem_attributes (x
, decl
, 1);
1520 SET_DECL_RTL (decl
, x
);
1522 /* Optionally set flags or add text to the name to record information
1523 such as that it is a function name.
1524 If the name is changed, the macro ASM_OUTPUT_LABELREF
1525 will have to know how to strip this information. */
1526 targetm
.encode_section_info (decl
, DECL_RTL (decl
), true);
1529 /* Like make_decl_rtl, but inhibit creation of new alias sets when
1530 calling make_decl_rtl. Also, reset DECL_RTL before returning the
1534 make_decl_rtl_for_debug (tree decl
)
1536 unsigned int save_aliasing_flag
;
1539 if (DECL_RTL_SET_P (decl
))
1540 return DECL_RTL (decl
);
1542 /* Kludge alert! Somewhere down the call chain, make_decl_rtl will
1543 call new_alias_set. If running with -fcompare-debug, sometimes
1544 we do not want to create alias sets that will throw the alias
1545 numbers off in the comparison dumps. So... clearing
1546 flag_strict_aliasing will keep new_alias_set() from creating a
1548 save_aliasing_flag
= flag_strict_aliasing
;
1549 flag_strict_aliasing
= 0;
1551 rtl
= DECL_RTL (decl
);
1552 /* Reset DECL_RTL back, as various parts of the compiler expects
1553 DECL_RTL set meaning it is actually going to be output. */
1554 SET_DECL_RTL (decl
, NULL
);
1556 flag_strict_aliasing
= save_aliasing_flag
;
1560 /* Output a string of literal assembler code
1561 for an `asm' keyword used between functions. */
1564 assemble_asm (tree string
)
1569 if (TREE_CODE (string
) == ADDR_EXPR
)
1570 string
= TREE_OPERAND (string
, 0);
1572 p
= TREE_STRING_POINTER (string
);
1573 fprintf (asm_out_file
, "%s%s\n", p
[0] == '\t' ? "" : "\t", p
);
1576 /* Write the address of the entity given by SYMBOL to SEC. */
1578 assemble_addr_to_section (rtx symbol
, section
*sec
)
1580 switch_to_section (sec
);
1581 assemble_align (POINTER_SIZE
);
1582 assemble_integer (symbol
, POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
1585 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1586 not) section for PRIORITY. */
1588 get_cdtor_priority_section (int priority
, bool constructor_p
)
1590 /* Buffer conservatively large enough for the full range of a 32-bit
1591 int plus the text below. */
1594 /* ??? This only works reliably with the GNU linker. */
1595 sprintf (buf
, "%s.%.5u",
1596 constructor_p
? ".ctors" : ".dtors",
1597 /* Invert the numbering so the linker puts us in the proper
1598 order; constructors are run from right to left, and the
1599 linker sorts in increasing order. */
1600 MAX_INIT_PRIORITY
- priority
);
1601 return get_section (buf
, SECTION_WRITE
, NULL
);
1605 default_named_section_asm_out_destructor (rtx symbol
, int priority
)
1609 if (priority
!= DEFAULT_INIT_PRIORITY
)
1610 sec
= get_cdtor_priority_section (priority
,
1611 /*constructor_p=*/false);
1613 sec
= get_section (".dtors", SECTION_WRITE
, NULL
);
1615 assemble_addr_to_section (symbol
, sec
);
1618 #ifdef DTORS_SECTION_ASM_OP
1620 default_dtor_section_asm_out_destructor (rtx symbol
,
1621 int priority ATTRIBUTE_UNUSED
)
1623 assemble_addr_to_section (symbol
, dtors_section
);
1628 default_named_section_asm_out_constructor (rtx symbol
, int priority
)
1632 if (priority
!= DEFAULT_INIT_PRIORITY
)
1633 sec
= get_cdtor_priority_section (priority
,
1634 /*constructor_p=*/true);
1636 sec
= get_section (".ctors", SECTION_WRITE
, NULL
);
1638 assemble_addr_to_section (symbol
, sec
);
1641 #ifdef CTORS_SECTION_ASM_OP
1643 default_ctor_section_asm_out_constructor (rtx symbol
,
1644 int priority ATTRIBUTE_UNUSED
)
1646 assemble_addr_to_section (symbol
, ctors_section
);
1650 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1651 a nonzero value if the constant pool should be output before the
1652 start of the function, or a zero value if the pool should output
1653 after the end of the function. The default is to put it before the
1656 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1657 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1660 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1661 to be output to assembler.
1662 Set first_global_object_name and weak_global_object_name as appropriate. */
1665 notice_global_symbol (tree decl
)
1667 const char **t
= &first_global_object_name
;
1669 if (first_global_object_name
1670 || !TREE_PUBLIC (decl
)
1671 || DECL_EXTERNAL (decl
)
1672 || !DECL_NAME (decl
)
1673 || (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
1674 || (TREE_CODE (decl
) != FUNCTION_DECL
1676 || (DECL_COMMON (decl
)
1677 && (DECL_INITIAL (decl
) == 0
1678 || DECL_INITIAL (decl
) == error_mark_node
)))))
1681 /* We win when global object is found, but it is useful to know about weak
1682 symbol as well so we can produce nicer unique names. */
1683 if (DECL_WEAK (decl
) || DECL_ONE_ONLY (decl
) || flag_shlib
)
1684 t
= &weak_global_object_name
;
1688 tree id
= DECL_ASSEMBLER_NAME (decl
);
1689 ultimate_transparent_alias_target (&id
);
1690 *t
= ggc_strdup (targetm
.strip_name_encoding (IDENTIFIER_POINTER (id
)));
1694 /* If not using flag_reorder_blocks_and_partition, decide early whether the
1695 current function goes into the cold section, so that targets can use
1696 current_function_section during RTL expansion. DECL describes the
1700 decide_function_section (tree decl
)
1702 first_function_block_is_cold
= false;
1704 if (DECL_SECTION_NAME (decl
))
1706 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1707 /* Calls to function_section rely on first_function_block_is_cold
1709 first_function_block_is_cold
= (node
1711 == NODE_FREQUENCY_UNLIKELY_EXECUTED
);
1714 in_cold_section_p
= first_function_block_is_cold
;
1717 /* Get the function's name, as described by its RTL. This may be
1718 different from the DECL_NAME name used in the source file. */
1720 get_fnname_from_decl (tree decl
)
1722 rtx x
= DECL_RTL (decl
);
1723 gcc_assert (MEM_P (x
));
1725 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
1729 /* Output assembler code for the constant pool of a function and associated
1730 with defining the name of the function. DECL describes the function.
1731 NAME is the function's name. For the constant pool, we use the current
1732 constant pool data. */
1735 assemble_start_function (tree decl
, const char *fnname
)
1738 char tmp_label
[100];
1739 bool hot_label_written
= false;
1741 if (crtl
->has_bb_partition
)
1743 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTB", const_labelno
);
1744 crtl
->subsections
.hot_section_label
= ggc_strdup (tmp_label
);
1745 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDB", const_labelno
);
1746 crtl
->subsections
.cold_section_label
= ggc_strdup (tmp_label
);
1747 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTE", const_labelno
);
1748 crtl
->subsections
.hot_section_end_label
= ggc_strdup (tmp_label
);
1749 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDE", const_labelno
);
1750 crtl
->subsections
.cold_section_end_label
= ggc_strdup (tmp_label
);
1752 cold_function_name
= NULL_TREE
;
1756 crtl
->subsections
.hot_section_label
= NULL
;
1757 crtl
->subsections
.cold_section_label
= NULL
;
1758 crtl
->subsections
.hot_section_end_label
= NULL
;
1759 crtl
->subsections
.cold_section_end_label
= NULL
;
1762 /* The following code does not need preprocessing in the assembler. */
1766 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1767 output_constant_pool (fnname
, decl
);
1769 align
= symtab_node::get (decl
)->definition_alignment ();
1771 /* Make sure the not and cold text (code) sections are properly
1772 aligned. This is necessary here in the case where the function
1773 has both hot and cold sections, because we don't want to re-set
1774 the alignment when the section switch happens mid-function. */
1776 if (crtl
->has_bb_partition
)
1778 first_function_block_is_cold
= false;
1780 switch_to_section (unlikely_text_section ());
1781 assemble_align (align
);
1782 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_label
);
1784 /* When the function starts with a cold section, we need to explicitly
1785 align the hot section and write out the hot section label.
1786 But if the current function is a thunk, we do not have a CFG. */
1788 && BB_PARTITION (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
) == BB_COLD_PARTITION
)
1790 switch_to_section (text_section
);
1791 assemble_align (align
);
1792 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1793 hot_label_written
= true;
1794 first_function_block_is_cold
= true;
1796 in_cold_section_p
= first_function_block_is_cold
;
1800 /* Switch to the correct text section for the start of the function. */
1802 switch_to_section (function_section (decl
));
1803 if (crtl
->has_bb_partition
&& !hot_label_written
)
1804 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1806 /* Tell assembler to move to target machine's alignment for functions. */
1807 align
= floor_log2 (align
/ BITS_PER_UNIT
);
1810 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1813 /* Handle a user-specified function alignment.
1814 Note that we still need to align to DECL_ALIGN, as above,
1815 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1816 if (! DECL_USER_ALIGN (decl
)
1817 && align_functions
.levels
[0].log
> align
1818 && optimize_function_for_speed_p (cfun
))
1820 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1821 int align_log
= align_functions
.levels
[0].log
;
1823 int max_skip
= align_functions
.levels
[0].maxskip
;
1824 if (flag_limit_function_alignment
&& crtl
->max_insn_address
> 0
1825 && max_skip
>= crtl
->max_insn_address
)
1826 max_skip
= crtl
->max_insn_address
- 1;
1828 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1829 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
, align_log
, max_skip
);
1830 if (max_skip
== align_functions
.levels
[0].maxskip
)
1831 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1832 align_functions
.levels
[1].log
,
1833 align_functions
.levels
[1].maxskip
);
1835 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions
.levels
[0].log
);
1839 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1840 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1843 if (!DECL_IGNORED_P (decl
))
1844 (*debug_hooks
->begin_function
) (decl
);
1846 /* Make function name accessible from other files, if appropriate. */
1848 if (TREE_PUBLIC (decl
))
1850 notice_global_symbol (decl
);
1852 globalize_decl (decl
);
1854 maybe_assemble_visibility (decl
);
1857 if (DECL_PRESERVE_P (decl
))
1858 targetm
.asm_out
.mark_decl_preserved (fnname
);
1860 unsigned HOST_WIDE_INT patch_area_size
= function_entry_patch_area_size
;
1861 unsigned HOST_WIDE_INT patch_area_entry
= function_entry_patch_area_start
;
1863 tree patchable_function_entry_attr
1864 = lookup_attribute ("patchable_function_entry", DECL_ATTRIBUTES (decl
));
1865 if (patchable_function_entry_attr
)
1867 tree pp_val
= TREE_VALUE (patchable_function_entry_attr
);
1868 tree patchable_function_entry_value1
= TREE_VALUE (pp_val
);
1870 patch_area_size
= tree_to_uhwi (patchable_function_entry_value1
);
1871 patch_area_entry
= 0;
1872 if (TREE_CHAIN (pp_val
) != NULL_TREE
)
1874 tree patchable_function_entry_value2
1875 = TREE_VALUE (TREE_CHAIN (pp_val
));
1876 patch_area_entry
= tree_to_uhwi (patchable_function_entry_value2
);
1880 if (patch_area_entry
> patch_area_size
)
1882 if (patch_area_size
> 0)
1883 warning (OPT_Wattributes
,
1884 "patchable function entry %wu exceeds size %wu",
1885 patch_area_entry
, patch_area_size
);
1886 patch_area_entry
= 0;
1889 /* Emit the patching area before the entry label, if any. */
1890 if (patch_area_entry
> 0)
1891 targetm
.asm_out
.print_patchable_function_entry (asm_out_file
,
1892 patch_area_entry
, true);
1894 /* Do any machine/system dependent processing of the function name. */
1895 #ifdef ASM_DECLARE_FUNCTION_NAME
1896 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1898 /* Standard thing is just output label for the function. */
1899 ASM_OUTPUT_FUNCTION_LABEL (asm_out_file
, fnname
, current_function_decl
);
1900 #endif /* ASM_DECLARE_FUNCTION_NAME */
1902 /* And the area after the label. Record it if we haven't done so yet. */
1903 if (patch_area_size
> patch_area_entry
)
1904 targetm
.asm_out
.print_patchable_function_entry (asm_out_file
,
1907 patch_area_entry
== 0);
1909 if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl
)))
1910 saw_no_split_stack
= true;
1913 /* Output assembler code associated with defining the size of the
1914 function. DECL describes the function. NAME is the function's name. */
1917 assemble_end_function (tree decl
, const char *fnname ATTRIBUTE_UNUSED
)
1919 #ifdef ASM_DECLARE_FUNCTION_SIZE
1920 /* We could have switched section in the middle of the function. */
1921 if (crtl
->has_bb_partition
)
1922 switch_to_section (function_section (decl
));
1923 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1925 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1927 output_constant_pool (fnname
, decl
);
1928 switch_to_section (function_section (decl
)); /* need to switch back */
1930 /* Output labels for end of hot/cold text sections (to be used by
1932 if (crtl
->has_bb_partition
)
1934 section
*save_text_section
;
1936 save_text_section
= in_section
;
1937 switch_to_section (unlikely_text_section ());
1938 #ifdef ASM_DECLARE_COLD_FUNCTION_SIZE
1939 if (cold_function_name
!= NULL_TREE
)
1940 ASM_DECLARE_COLD_FUNCTION_SIZE (asm_out_file
,
1941 IDENTIFIER_POINTER (cold_function_name
),
1944 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_end_label
);
1945 if (first_function_block_is_cold
)
1946 switch_to_section (text_section
);
1948 switch_to_section (function_section (decl
));
1949 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_end_label
);
1950 switch_to_section (save_text_section
);
1954 /* Assemble code to leave SIZE bytes of zeros. */
1957 assemble_zeros (unsigned HOST_WIDE_INT size
)
1959 /* Do no output if -fsyntax-only. */
1960 if (flag_syntax_only
)
1963 #ifdef ASM_NO_SKIP_IN_TEXT
1964 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1965 so we must output 0s explicitly in the text section. */
1966 if (ASM_NO_SKIP_IN_TEXT
&& (in_section
->common
.flags
& SECTION_CODE
) != 0)
1968 unsigned HOST_WIDE_INT i
;
1969 for (i
= 0; i
< size
; i
++)
1970 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1975 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1978 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1981 assemble_align (unsigned int align
)
1983 if (align
> BITS_PER_UNIT
)
1985 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1989 /* Assemble a string constant with the specified C string as contents. */
1992 assemble_string (const char *p
, int size
)
1997 /* If the string is very long, split it up. */
2001 int thissize
= size
- pos
;
2002 if (thissize
> maximum
)
2005 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
2013 /* A noswitch_section_callback for lcomm_section. */
2016 emit_local (tree decl ATTRIBUTE_UNUSED
,
2017 const char *name ATTRIBUTE_UNUSED
,
2018 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
2019 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
2021 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
2022 unsigned int align
= symtab_node::get (decl
)->definition_alignment ();
2023 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, decl
, name
,
2026 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
2027 unsigned int align
= symtab_node::get (decl
)->definition_alignment ();
2028 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, align
);
2031 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
2036 /* A noswitch_section_callback for bss_noswitch_section. */
2038 #if defined ASM_OUTPUT_ALIGNED_BSS
2040 emit_bss (tree decl ATTRIBUTE_UNUSED
,
2041 const char *name ATTRIBUTE_UNUSED
,
2042 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
2043 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
2045 ASM_OUTPUT_ALIGNED_BSS (asm_out_file
, decl
, name
, size
,
2046 get_variable_align (decl
));
2051 /* A noswitch_section_callback for comm_section. */
2054 emit_common (tree decl ATTRIBUTE_UNUSED
,
2055 const char *name ATTRIBUTE_UNUSED
,
2056 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
2057 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
2059 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
2060 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, decl
, name
,
2061 size
, get_variable_align (decl
));
2063 #elif defined ASM_OUTPUT_ALIGNED_COMMON
2064 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, name
, size
,
2065 get_variable_align (decl
));
2068 ASM_OUTPUT_COMMON (asm_out_file
, name
, size
, rounded
);
2073 /* A noswitch_section_callback for tls_comm_section. */
2076 emit_tls_common (tree decl ATTRIBUTE_UNUSED
,
2077 const char *name ATTRIBUTE_UNUSED
,
2078 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
2079 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
2081 #ifdef ASM_OUTPUT_TLS_COMMON
2082 ASM_OUTPUT_TLS_COMMON (asm_out_file
, decl
, name
, size
);
2085 sorry ("thread-local COMMON data not implemented");
2090 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
2091 NAME is the name of DECL's SYMBOL_REF. */
2094 assemble_noswitch_variable (tree decl
, const char *name
, section
*sect
,
2097 unsigned HOST_WIDE_INT size
, rounded
;
2099 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2102 if ((flag_sanitize
& SANITIZE_ADDRESS
) && asan_protect_global (decl
))
2103 size
+= asan_red_zone_size (size
);
2105 /* Don't allocate zero bytes of common,
2106 since that means "undefined external" in the linker. */
2110 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2111 so that each uninitialized object starts on such a boundary. */
2112 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
2113 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2114 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2116 if (!sect
->noswitch
.callback (decl
, name
, size
, rounded
)
2117 && (unsigned HOST_WIDE_INT
) (align
/ BITS_PER_UNIT
) > rounded
)
2118 error ("requested alignment for %q+D is greater than "
2119 "implemented alignment of %wu", decl
, rounded
);
2122 /* A subroutine of assemble_variable. Output the label and contents of
2123 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
2124 is as for assemble_variable. */
2127 assemble_variable_contents (tree decl
, const char *name
,
2128 bool dont_output_data
, bool merge_strings
)
2130 /* Do any machine/system dependent processing of the object. */
2131 #ifdef ASM_DECLARE_OBJECT_NAME
2132 last_assemble_variable_decl
= decl
;
2133 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
2135 /* Standard thing is just output label for the object. */
2136 ASM_OUTPUT_LABEL (asm_out_file
, name
);
2137 #endif /* ASM_DECLARE_OBJECT_NAME */
2139 if (!dont_output_data
)
2141 /* Caller is supposed to use varpool_get_constructor when it wants
2142 to output the body. */
2143 gcc_assert (!in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
);
2144 if (DECL_INITIAL (decl
)
2145 && DECL_INITIAL (decl
) != error_mark_node
2146 && !initializer_zerop (DECL_INITIAL (decl
)))
2147 /* Output the actual data. */
2148 output_constant (DECL_INITIAL (decl
),
2149 tree_to_uhwi (DECL_SIZE_UNIT (decl
)),
2150 get_variable_align (decl
),
2151 false, merge_strings
);
2153 /* Leave space for it. */
2154 assemble_zeros (tree_to_uhwi (DECL_SIZE_UNIT (decl
)));
2155 targetm
.asm_out
.decl_end ();
2159 /* Write out assembly for the variable DECL, which is not defined in
2160 the current translation unit. */
2162 assemble_undefined_decl (tree decl
)
2164 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
2165 targetm
.asm_out
.assemble_undefined_decl (asm_out_file
, name
, decl
);
2168 /* Assemble everything that is needed for a variable or function declaration.
2169 Not used for automatic variables, and not used for function definitions.
2170 Should not be called for variables of incomplete structure type.
2172 TOP_LEVEL is nonzero if this variable has file scope.
2173 AT_END is nonzero if this is the special handling, at end of compilation,
2174 to define things that have had only tentative definitions.
2175 DONT_OUTPUT_DATA if nonzero means don't actually output the
2176 initial value (that will be done by the caller). */
2179 assemble_variable (tree decl
, int top_level ATTRIBUTE_UNUSED
,
2180 int at_end ATTRIBUTE_UNUSED
, int dont_output_data
)
2183 rtx decl_rtl
, symbol
;
2186 bool asan_protected
= false;
2188 /* This function is supposed to handle VARIABLES. Ensure we have one. */
2189 gcc_assert (VAR_P (decl
));
2191 /* Emulated TLS had better not get this far. */
2192 gcc_checking_assert (targetm
.have_tls
|| !DECL_THREAD_LOCAL_P (decl
));
2194 last_assemble_variable_decl
= 0;
2196 /* Normally no need to say anything here for external references,
2197 since assemble_external is called by the language-specific code
2198 when a declaration is first seen. */
2200 if (DECL_EXTERNAL (decl
))
2203 /* Do nothing for global register variables. */
2204 if (DECL_RTL_SET_P (decl
) && REG_P (DECL_RTL (decl
)))
2206 TREE_ASM_WRITTEN (decl
) = 1;
2210 /* If type was incomplete when the variable was declared,
2211 see if it is complete now. */
2213 if (DECL_SIZE (decl
) == 0)
2214 layout_decl (decl
, 0);
2216 /* Still incomplete => don't allocate it; treat the tentative defn
2217 (which is what it must have been) as an `extern' reference. */
2219 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
2221 error ("storage size of %q+D isn%'t known", decl
);
2222 TREE_ASM_WRITTEN (decl
) = 1;
2226 /* The first declaration of a variable that comes through this function
2227 decides whether it is global (in C, has external linkage)
2228 or local (in C, has internal linkage). So do nothing more
2229 if this function has already run. */
2231 if (TREE_ASM_WRITTEN (decl
))
2234 /* Make sure targetm.encode_section_info is invoked before we set
2236 decl_rtl
= DECL_RTL (decl
);
2238 TREE_ASM_WRITTEN (decl
) = 1;
2240 /* Do no output if -fsyntax-only. */
2241 if (flag_syntax_only
)
2244 if (! dont_output_data
2245 && ! valid_constant_size_p (DECL_SIZE_UNIT (decl
)))
2247 error ("size of variable %q+D is too large", decl
);
2251 gcc_assert (MEM_P (decl_rtl
));
2252 gcc_assert (GET_CODE (XEXP (decl_rtl
, 0)) == SYMBOL_REF
);
2253 symbol
= XEXP (decl_rtl
, 0);
2255 /* If this symbol belongs to the tree constant pool, output the constant
2256 if it hasn't already been written. */
2257 if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
2259 tree decl
= SYMBOL_REF_DECL (symbol
);
2260 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
2261 output_constant_def_contents (symbol
);
2267 name
= XSTR (symbol
, 0);
2268 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
2269 notice_global_symbol (decl
);
2271 /* Compute the alignment of this data. */
2273 align_variable (decl
, dont_output_data
);
2275 if ((flag_sanitize
& SANITIZE_ADDRESS
)
2276 && asan_protect_global (decl
))
2278 asan_protected
= true;
2279 SET_DECL_ALIGN (decl
, MAX (DECL_ALIGN (decl
),
2280 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
));
2283 set_mem_align (decl_rtl
, DECL_ALIGN (decl
));
2285 align
= get_variable_align (decl
);
2287 if (TREE_PUBLIC (decl
))
2288 maybe_assemble_visibility (decl
);
2290 if (DECL_PRESERVE_P (decl
))
2291 targetm
.asm_out
.mark_decl_preserved (name
);
2293 /* First make the assembler name(s) global if appropriate. */
2294 sect
= get_variable_section (decl
, false);
2295 if (TREE_PUBLIC (decl
)
2296 && (sect
->common
.flags
& SECTION_COMMON
) == 0)
2297 globalize_decl (decl
);
2299 /* Output any data that we will need to use the address of. */
2300 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
2301 output_addressed_constants (DECL_INITIAL (decl
));
2303 /* dbxout.c needs to know this. */
2304 if (sect
&& (sect
->common
.flags
& SECTION_CODE
) != 0)
2305 DECL_IN_TEXT_SECTION (decl
) = 1;
2307 /* If the decl is part of an object_block, make sure that the decl
2308 has been positioned within its block, but do not write out its
2309 definition yet. output_object_blocks will do that later. */
2310 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
2312 gcc_assert (!dont_output_data
);
2313 place_block_symbol (symbol
);
2315 else if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
2316 assemble_noswitch_variable (decl
, name
, sect
, align
);
2319 /* Special-case handling of vtv comdat sections. */
2320 if (sect
->named
.name
2321 && (strcmp (sect
->named
.name
, ".vtable_map_vars") == 0))
2322 handle_vtv_comdat_section (sect
, decl
);
2324 switch_to_section (sect
);
2325 if (align
> BITS_PER_UNIT
)
2326 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2327 assemble_variable_contents (decl
, name
, dont_output_data
,
2328 (sect
->common
.flags
& SECTION_MERGE
)
2329 && (sect
->common
.flags
& SECTION_STRINGS
));
2332 unsigned HOST_WIDE_INT
int size
2333 = tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2334 assemble_zeros (asan_red_zone_size (size
));
2340 /* Given a function declaration (FN_DECL), this function assembles the
2341 function into the .preinit_array section. */
2344 assemble_vtv_preinit_initializer (tree fn_decl
)
2347 unsigned flags
= SECTION_WRITE
;
2348 rtx symbol
= XEXP (DECL_RTL (fn_decl
), 0);
2350 flags
|= SECTION_NOTYPE
;
2351 sect
= get_section (".preinit_array", flags
, fn_decl
);
2352 switch_to_section (sect
);
2353 assemble_addr_to_section (symbol
, sect
);
2356 /* Return 1 if type TYPE contains any pointers. */
2359 contains_pointers_p (tree type
)
2361 switch (TREE_CODE (type
))
2364 case REFERENCE_TYPE
:
2365 /* I'm not sure whether OFFSET_TYPE needs this treatment,
2366 so I'll play safe and return 1. */
2372 case QUAL_UNION_TYPE
:
2375 /* For a type that has fields, see if the fields have pointers. */
2376 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
2377 if (TREE_CODE (fields
) == FIELD_DECL
2378 && contains_pointers_p (TREE_TYPE (fields
)))
2384 /* An array type contains pointers if its element type does. */
2385 return contains_pointers_p (TREE_TYPE (type
));
2392 /* We delay assemble_external processing until
2393 the compilation unit is finalized. This is the best we can do for
2394 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2395 it all the way to final. See PR 17982 for further discussion. */
2396 static GTY(()) tree pending_assemble_externals
;
2398 #ifdef ASM_OUTPUT_EXTERNAL
2399 /* Some targets delay some output to final using TARGET_ASM_FILE_END.
2400 As a result, assemble_external can be called after the list of externals
2401 is processed and the pointer set destroyed. */
2402 static bool pending_assemble_externals_processed
;
2404 /* Avoid O(external_decls**2) lookups in the pending_assemble_externals
2405 TREE_LIST in assemble_external. */
2406 static hash_set
<tree
> *pending_assemble_externals_set
;
2408 /* True if DECL is a function decl for which no out-of-line copy exists.
2409 It is assumed that DECL's assembler name has been set. */
2412 incorporeal_function_p (tree decl
)
2414 if (TREE_CODE (decl
) == FUNCTION_DECL
&& fndecl_built_in_p (decl
))
2418 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2419 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl
)))
2422 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2423 /* Atomic or sync builtins which have survived this far will be
2424 resolved externally and therefore are not incorporeal. */
2425 if (strncmp (name
, "__builtin_", 10) == 0)
2431 /* Actually do the tests to determine if this is necessary, and invoke
2432 ASM_OUTPUT_EXTERNAL. */
2434 assemble_external_real (tree decl
)
2436 rtx rtl
= DECL_RTL (decl
);
2438 if (MEM_P (rtl
) && GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
2439 && !SYMBOL_REF_USED (XEXP (rtl
, 0))
2440 && !incorporeal_function_p (decl
))
2442 /* Some systems do require some output. */
2443 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
2444 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
2450 process_pending_assemble_externals (void)
2452 #ifdef ASM_OUTPUT_EXTERNAL
2454 for (list
= pending_assemble_externals
; list
; list
= TREE_CHAIN (list
))
2455 assemble_external_real (TREE_VALUE (list
));
2457 pending_assemble_externals
= 0;
2458 pending_assemble_externals_processed
= true;
2459 delete pending_assemble_externals_set
;
2463 /* This TREE_LIST contains any weak symbol declarations waiting
2465 static GTY(()) tree weak_decls
;
2467 /* Output something to declare an external symbol to the assembler,
2468 and qualifiers such as weakness. (Most assemblers don't need
2469 extern declaration, so we normally output nothing.) Do nothing if
2470 DECL is not external. */
2473 assemble_external (tree decl ATTRIBUTE_UNUSED
)
2475 /* Make sure that the ASM_OUT_FILE is open.
2476 If it's not, we should not be calling this function. */
2477 gcc_assert (asm_out_file
);
2479 /* In a perfect world, the following condition would be true.
2480 Sadly, the Go front end emit assembly *from the front end*,
2481 bypassing the call graph. See PR52739. Fix before GCC 4.8. */
2483 /* This function should only be called if we are expanding, or have
2485 Ideally, only final.c would be calling this function, but it is
2486 not clear whether that would break things somehow. See PR 17982
2487 for further discussion. */
2488 gcc_assert (state
== EXPANSION
2489 || state
== FINISHED
);
2492 if (!DECL_P (decl
) || !DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
))
2495 /* We want to output annotation for weak and external symbols at
2496 very last to check if they are references or not. */
2498 if (TARGET_SUPPORTS_WEAK
2500 /* TREE_STATIC is a weird and abused creature which is not
2501 generally the right test for whether an entity has been
2502 locally emitted, inlined or otherwise not-really-extern, but
2503 for declarations that can be weak, it happens to be
2505 && !TREE_STATIC (decl
)
2506 && lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
2507 && value_member (decl
, weak_decls
) == NULL_TREE
)
2508 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
2510 #ifdef ASM_OUTPUT_EXTERNAL
2511 if (pending_assemble_externals_processed
)
2513 assemble_external_real (decl
);
2517 if (! pending_assemble_externals_set
->add (decl
))
2518 pending_assemble_externals
= tree_cons (NULL
, decl
,
2519 pending_assemble_externals
);
2523 /* Similar, for calling a library function FUN. */
2526 assemble_external_libcall (rtx fun
)
2528 /* Declare library function name external when first used, if nec. */
2529 if (! SYMBOL_REF_USED (fun
))
2531 SYMBOL_REF_USED (fun
) = 1;
2532 targetm
.asm_out
.external_libcall (fun
);
2536 /* Assemble a label named NAME. */
2539 assemble_label (FILE *file
, const char *name
)
2541 ASM_OUTPUT_LABEL (file
, name
);
2544 /* Set the symbol_referenced flag for ID. */
2546 mark_referenced (tree id
)
2548 TREE_SYMBOL_REFERENCED (id
) = 1;
2551 /* Set the symbol_referenced flag for DECL and notify callgraph. */
2553 mark_decl_referenced (tree decl
)
2555 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2557 /* Extern inline functions don't become needed when referenced.
2558 If we know a method will be emitted in other TU and no new
2559 functions can be marked reachable, just use the external
2561 struct cgraph_node
*node
= cgraph_node::get_create (decl
);
2562 if (!DECL_EXTERNAL (decl
)
2563 && !node
->definition
)
2564 node
->mark_force_output ();
2566 else if (VAR_P (decl
))
2568 varpool_node
*node
= varpool_node::get_create (decl
);
2569 /* C++ frontend use mark_decl_references to force COMDAT variables
2570 to be output that might appear dead otherwise. */
2571 node
->force_output
= true;
2573 /* else do nothing - we can get various sorts of CST nodes here,
2574 which do not need to be marked. */
2578 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2579 starts with a *, the rest of NAME is output verbatim. Otherwise
2580 NAME is transformed in a target-specific way (usually by the
2581 addition of an underscore). */
2584 assemble_name_raw (FILE *file
, const char *name
)
2587 fputs (&name
[1], file
);
2589 ASM_OUTPUT_LABELREF (file
, name
);
2592 /* Return NAME that should actually be emitted, looking through
2593 transparent aliases. If NAME refers to an entity that is also
2594 represented as a tree (like a function or variable), mark the entity
2597 assemble_name_resolve (const char *name
)
2599 const char *real_name
= targetm
.strip_name_encoding (name
);
2600 tree id
= maybe_get_identifier (real_name
);
2606 mark_referenced (id
);
2607 ultimate_transparent_alias_target (&id
);
2609 name
= IDENTIFIER_POINTER (id
);
2610 gcc_assert (! TREE_CHAIN (id
));
2616 /* Like assemble_name_raw, but should be used when NAME might refer to
2617 an entity that is also represented as a tree (like a function or
2618 variable). If NAME does refer to such an entity, that entity will
2619 be marked as referenced. */
2622 assemble_name (FILE *file
, const char *name
)
2624 assemble_name_raw (file
, assemble_name_resolve (name
));
2627 /* Allocate SIZE bytes writable static space with a gensym name
2628 and return an RTX to refer to its address. */
2631 assemble_static_space (unsigned HOST_WIDE_INT size
)
2634 const char *namestring
;
2637 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
2639 namestring
= ggc_strdup (name
);
2641 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
2642 SYMBOL_REF_FLAGS (x
) = SYMBOL_FLAG_LOCAL
;
2644 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2645 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
2648 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2649 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
2652 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2653 so that each uninitialized object starts on such a boundary. */
2654 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2655 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2656 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
2657 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2658 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2659 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
2666 /* Assemble the static constant template for function entry trampolines.
2667 This is done at most once per compilation.
2668 Returns an RTX for the address of the template. */
2670 static GTY(()) rtx initial_trampoline
;
2673 assemble_trampoline_template (void)
2680 gcc_assert (targetm
.asm_out
.trampoline_template
!= NULL
);
2682 if (initial_trampoline
)
2683 return initial_trampoline
;
2685 /* By default, put trampoline templates in read-only data section. */
2687 #ifdef TRAMPOLINE_SECTION
2688 switch_to_section (TRAMPOLINE_SECTION
);
2690 switch_to_section (readonly_data_section
);
2693 /* Write the assembler code to define one. */
2694 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
2696 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
2698 targetm
.asm_out
.internal_label (asm_out_file
, "LTRAMP", 0);
2699 targetm
.asm_out
.trampoline_template (asm_out_file
);
2701 /* Record the rtl to refer to it. */
2702 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
2703 name
= ggc_strdup (label
);
2704 symbol
= gen_rtx_SYMBOL_REF (Pmode
, name
);
2705 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2707 initial_trampoline
= gen_const_mem (BLKmode
, symbol
);
2708 set_mem_align (initial_trampoline
, TRAMPOLINE_ALIGNMENT
);
2709 set_mem_size (initial_trampoline
, TRAMPOLINE_SIZE
);
2711 return initial_trampoline
;
2714 /* A and B are either alignments or offsets. Return the minimum alignment
2715 that may be assumed after adding the two together. */
2717 static inline unsigned
2718 min_align (unsigned int a
, unsigned int b
)
2720 return least_bit_hwi (a
| b
);
2723 /* Return the assembler directive for creating a given kind of integer
2724 object. SIZE is the number of bytes in the object and ALIGNED_P
2725 indicates whether it is known to be aligned. Return NULL if the
2726 assembly dialect has no such directive.
2728 The returned string should be printed at the start of a new line and
2729 be followed immediately by the object's initial value. */
2732 integer_asm_op (int size
, int aligned_p
)
2734 struct asm_int_op
*ops
;
2737 ops
= &targetm
.asm_out
.aligned_op
;
2739 ops
= &targetm
.asm_out
.unaligned_op
;
2744 return targetm
.asm_out
.byte_op
;
2772 /* Use directive OP to assemble an integer object X. Print OP at the
2773 start of the line, followed immediately by the value of X. */
2776 assemble_integer_with_op (const char *op
, rtx x
)
2778 fputs (op
, asm_out_file
);
2779 output_addr_const (asm_out_file
, x
);
2780 fputc ('\n', asm_out_file
);
2783 /* The default implementation of the asm_out.integer target hook. */
2786 default_assemble_integer (rtx x ATTRIBUTE_UNUSED
,
2787 unsigned int size ATTRIBUTE_UNUSED
,
2788 int aligned_p ATTRIBUTE_UNUSED
)
2790 const char *op
= integer_asm_op (size
, aligned_p
);
2791 /* Avoid GAS bugs for large values. Specifically negative values whose
2792 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2793 if (size
> UNITS_PER_WORD
&& size
> POINTER_SIZE_UNITS
)
2795 return op
&& (assemble_integer_with_op (op
, x
), true);
2798 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2799 the alignment of the integer in bits. Return 1 if we were able to output
2800 the constant, otherwise 0. We must be able to output the constant,
2801 if FORCE is nonzero. */
2804 assemble_integer (rtx x
, unsigned int size
, unsigned int align
, int force
)
2808 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
2810 /* See if the target hook can handle this kind of object. */
2811 if (targetm
.asm_out
.integer (x
, size
, aligned_p
))
2814 /* If the object is a multi-byte one, try splitting it up. Split
2815 it into words it if is multi-word, otherwise split it into bytes. */
2818 machine_mode omode
, imode
;
2819 unsigned int subalign
;
2820 unsigned int subsize
, i
;
2821 enum mode_class mclass
;
2823 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
2824 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
2825 if (GET_CODE (x
) == CONST_FIXED
)
2826 mclass
= GET_MODE_CLASS (GET_MODE (x
));
2830 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, mclass
, 0).require ();
2831 imode
= mode_for_size (size
* BITS_PER_UNIT
, mclass
, 0).require ();
2833 for (i
= 0; i
< size
; i
+= subsize
)
2835 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
2836 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
2842 /* If we've printed some of it, but not all of it, there's no going
2847 gcc_assert (!force
);
2852 /* Assemble the floating-point constant D into an object of size MODE. ALIGN
2853 is the alignment of the constant in bits. If REVERSE is true, D is output
2854 in reverse storage order. */
2857 assemble_real (REAL_VALUE_TYPE d
, scalar_float_mode mode
, unsigned int align
,
2860 long data
[4] = {0, 0, 0, 0};
2861 int bitsize
, nelts
, nunits
, units_per
;
2864 /* This is hairy. We have a quantity of known size. real_to_target
2865 will put it into an array of *host* longs, 32 bits per element
2866 (even if long is more than 32 bits). We need to determine the
2867 number of array elements that are occupied (nelts) and the number
2868 of *target* min-addressable units that will be occupied in the
2869 object file (nunits). We cannot assume that 32 divides the
2870 mode's bitsize (size * BITS_PER_UNIT) evenly.
2872 size * BITS_PER_UNIT is used here to make sure that padding bits
2873 (which might appear at either end of the value; real_to_target
2874 will include the padding bits in its output array) are included. */
2876 nunits
= GET_MODE_SIZE (mode
);
2877 bitsize
= nunits
* BITS_PER_UNIT
;
2878 nelts
= CEIL (bitsize
, 32);
2879 units_per
= 32 / BITS_PER_UNIT
;
2881 real_to_target (data
, &d
, mode
);
2883 /* Put out the first word with the specified alignment. */
2884 unsigned int chunk_nunits
= MIN (nunits
, units_per
);
2886 elt
= flip_storage_order (SImode
, gen_int_mode (data
[nelts
- 1], SImode
));
2888 elt
= GEN_INT (sext_hwi (data
[0], chunk_nunits
* BITS_PER_UNIT
));
2889 assemble_integer (elt
, chunk_nunits
, align
, 1);
2890 nunits
-= chunk_nunits
;
2892 /* Subsequent words need only 32-bit alignment. */
2893 align
= min_align (align
, 32);
2895 for (int i
= 1; i
< nelts
; i
++)
2897 chunk_nunits
= MIN (nunits
, units_per
);
2899 elt
= flip_storage_order (SImode
,
2900 gen_int_mode (data
[nelts
- 1 - i
], SImode
));
2902 elt
= GEN_INT (sext_hwi (data
[i
], chunk_nunits
* BITS_PER_UNIT
));
2903 assemble_integer (elt
, chunk_nunits
, align
, 1);
2904 nunits
-= chunk_nunits
;
2908 /* Given an expression EXP with a constant value,
2909 reduce it to the sum of an assembler symbol and an integer.
2910 Store them both in the structure *VALUE.
2911 EXP must be reducible. */
2920 decode_addr_const (tree exp
, class addr_const
*value
)
2922 tree target
= TREE_OPERAND (exp
, 0);
2923 poly_int64 offset
= 0;
2929 if (TREE_CODE (target
) == COMPONENT_REF
2930 && poly_int_tree_p (byte_position (TREE_OPERAND (target
, 1)),
2934 target
= TREE_OPERAND (target
, 0);
2936 else if (TREE_CODE (target
) == ARRAY_REF
2937 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2939 /* Truncate big offset. */
2941 += (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (target
)))
2942 * wi::to_poly_widest (TREE_OPERAND (target
, 1)).force_shwi ());
2943 target
= TREE_OPERAND (target
, 0);
2945 else if (TREE_CODE (target
) == MEM_REF
2946 && TREE_CODE (TREE_OPERAND (target
, 0)) == ADDR_EXPR
)
2948 offset
+= mem_ref_offset (target
).force_shwi ();
2949 target
= TREE_OPERAND (TREE_OPERAND (target
, 0), 0);
2951 else if (TREE_CODE (target
) == INDIRECT_REF
2952 && TREE_CODE (TREE_OPERAND (target
, 0)) == NOP_EXPR
2953 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target
, 0), 0))
2955 target
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target
, 0), 0), 0);
2960 switch (TREE_CODE (target
))
2964 x
= DECL_RTL (target
);
2968 x
= gen_rtx_MEM (FUNCTION_MODE
,
2969 gen_rtx_LABEL_REF (Pmode
, force_label_rtx (target
)));
2978 x
= lookup_constant_def (target
);
2979 /* Should have been added by output_addressed_constants. */
2984 /* This deals with absolute addresses. */
2985 offset
+= tree_to_shwi (TREE_OPERAND (target
, 0));
2986 x
= gen_rtx_MEM (QImode
,
2987 gen_rtx_SYMBOL_REF (Pmode
, "origin of addresses"));
2990 case COMPOUND_LITERAL_EXPR
:
2991 gcc_assert (COMPOUND_LITERAL_EXPR_DECL (target
));
2992 x
= DECL_RTL (COMPOUND_LITERAL_EXPR_DECL (target
));
2999 gcc_assert (MEM_P (x
));
3003 value
->offset
= offset
;
3006 static GTY(()) hash_table
<tree_descriptor_hasher
> *const_desc_htab
;
3008 static void maybe_output_constant_def_contents (struct constant_descriptor_tree
*, int);
3010 /* Constant pool accessor function. */
3012 hash_table
<tree_descriptor_hasher
> *
3013 constant_pool_htab (void)
3015 return const_desc_htab
;
3018 /* Compute a hash code for a constant expression. */
3021 tree_descriptor_hasher::hash (constant_descriptor_tree
*ptr
)
3027 const_hash_1 (const tree exp
)
3032 enum tree_code code
= TREE_CODE (exp
);
3034 /* Either set P and LEN to the address and len of something to hash and
3035 exit the switch or return a value. */
3040 p
= (char *) &TREE_INT_CST_ELT (exp
, 0);
3041 len
= TREE_INT_CST_NUNITS (exp
) * sizeof (HOST_WIDE_INT
);
3045 return real_hash (TREE_REAL_CST_PTR (exp
));
3048 return fixed_hash (TREE_FIXED_CST_PTR (exp
));
3051 p
= TREE_STRING_POINTER (exp
);
3052 len
= TREE_STRING_LENGTH (exp
);
3056 return (const_hash_1 (TREE_REALPART (exp
)) * 5
3057 + const_hash_1 (TREE_IMAGPART (exp
)));
3061 hi
= 7 + VECTOR_CST_NPATTERNS (exp
);
3062 hi
= hi
* 563 + VECTOR_CST_NELTS_PER_PATTERN (exp
);
3063 unsigned int count
= vector_cst_encoded_nelts (exp
);
3064 for (unsigned int i
= 0; i
< count
; ++i
)
3065 hi
= hi
* 563 + const_hash_1 (VECTOR_CST_ENCODED_ELT (exp
, i
));
3071 unsigned HOST_WIDE_INT idx
;
3074 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
3076 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, value
)
3078 hi
= hi
* 603 + const_hash_1 (value
);
3084 if (CONSTANT_CLASS_P (TREE_OPERAND (exp
, 0)))
3085 return const_hash_1 (TREE_OPERAND (exp
, 0));
3090 class addr_const value
;
3092 decode_addr_const (exp
, &value
);
3093 switch (GET_CODE (value
.base
))
3096 /* Don't hash the address of the SYMBOL_REF;
3097 only use the offset and the symbol name. */
3098 hi
= value
.offset
.coeffs
[0];
3099 p
= XSTR (value
.base
, 0);
3100 for (i
= 0; p
[i
] != 0; i
++)
3101 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
3105 hi
= (value
.offset
.coeffs
[0]
3106 + CODE_LABEL_NUMBER (label_ref_label (value
.base
)) * 13);
3116 case POINTER_PLUS_EXPR
:
3118 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
3119 + const_hash_1 (TREE_OPERAND (exp
, 1)));
3122 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
3125 /* A language specific constant. Just hash the code. */
3129 /* Compute hashing function. */
3131 for (i
= 0; i
< len
; i
++)
3132 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
3137 /* Wrapper of compare_constant, for the htab interface. */
3139 tree_descriptor_hasher::equal (constant_descriptor_tree
*c1
,
3140 constant_descriptor_tree
*c2
)
3142 if (c1
->hash
!= c2
->hash
)
3144 return compare_constant (c1
->value
, c2
->value
);
3147 /* Compare t1 and t2, and return 1 only if they are known to result in
3148 the same bit pattern on output. */
3151 compare_constant (const tree t1
, const tree t2
)
3153 enum tree_code typecode
;
3155 if (t1
== NULL_TREE
)
3156 return t2
== NULL_TREE
;
3157 if (t2
== NULL_TREE
)
3160 if (TREE_CODE (t1
) != TREE_CODE (t2
))
3163 switch (TREE_CODE (t1
))
3166 /* Integer constants are the same only if the same width of type. */
3167 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3169 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
3171 return tree_int_cst_equal (t1
, t2
);
3174 /* Real constants are the same only if the same width of type. In
3175 addition to the same width, we need to check whether the modes are the
3176 same. There might be two floating point modes that are the same size
3177 but have different representations, such as the PowerPC that has 2
3178 different 128-bit floating point types (IBM extended double and IEEE
3179 128-bit floating point). */
3180 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3182 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
3184 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3187 /* Fixed constants are the same only if the same width of type. */
3188 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3191 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
3194 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
3195 || int_size_in_bytes (TREE_TYPE (t1
))
3196 != int_size_in_bytes (TREE_TYPE (t2
)))
3199 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3200 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3201 TREE_STRING_LENGTH (t1
)));
3204 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
3205 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
3209 if (VECTOR_CST_NPATTERNS (t1
)
3210 != VECTOR_CST_NPATTERNS (t2
))
3213 if (VECTOR_CST_NELTS_PER_PATTERN (t1
)
3214 != VECTOR_CST_NELTS_PER_PATTERN (t2
))
3217 unsigned int count
= vector_cst_encoded_nelts (t1
);
3218 for (unsigned int i
= 0; i
< count
; ++i
)
3219 if (!compare_constant (VECTOR_CST_ENCODED_ELT (t1
, i
),
3220 VECTOR_CST_ENCODED_ELT (t2
, i
)))
3228 vec
<constructor_elt
, va_gc
> *v1
, *v2
;
3229 unsigned HOST_WIDE_INT idx
;
3231 typecode
= TREE_CODE (TREE_TYPE (t1
));
3232 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
3235 if (typecode
== ARRAY_TYPE
)
3237 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
3238 /* For arrays, check that mode, size and storage order match. */
3239 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
3241 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
))
3242 || TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t1
))
3243 != TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t2
)))
3248 /* For record and union constructors, require exact type
3250 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
3254 v1
= CONSTRUCTOR_ELTS (t1
);
3255 v2
= CONSTRUCTOR_ELTS (t2
);
3256 if (vec_safe_length (v1
) != vec_safe_length (v2
))
3259 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
3261 constructor_elt
*c1
= &(*v1
)[idx
];
3262 constructor_elt
*c2
= &(*v2
)[idx
];
3264 /* Check that each value is the same... */
3265 if (!compare_constant (c1
->value
, c2
->value
))
3267 /* ... and that they apply to the same fields! */
3268 if (typecode
== ARRAY_TYPE
)
3270 if (!compare_constant (c1
->index
, c2
->index
))
3275 if (c1
->index
!= c2
->index
)
3286 class addr_const value1
, value2
;
3290 decode_addr_const (t1
, &value1
);
3291 decode_addr_const (t2
, &value2
);
3293 if (maybe_ne (value1
.offset
, value2
.offset
))
3296 code
= GET_CODE (value1
.base
);
3297 if (code
!= GET_CODE (value2
.base
))
3303 ret
= (strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
3307 ret
= (CODE_LABEL_NUMBER (label_ref_label (value1
.base
))
3308 == CODE_LABEL_NUMBER (label_ref_label (value2
.base
)));
3318 case POINTER_PLUS_EXPR
:
3321 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3322 && compare_constant (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3325 case VIEW_CONVERT_EXPR
:
3326 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3335 /* Return the section into which constant EXP should be placed. */
3338 get_constant_section (tree exp
, unsigned int align
)
3340 return targetm
.asm_out
.select_section (exp
,
3341 compute_reloc_for_constant (exp
),
3345 /* Return the size of constant EXP in bytes. */
3347 static HOST_WIDE_INT
3348 get_constant_size (tree exp
)
3352 size
= int_size_in_bytes (TREE_TYPE (exp
));
3353 gcc_checking_assert (size
>= 0);
3354 gcc_checking_assert (TREE_CODE (exp
) != STRING_CST
3355 || size
>= TREE_STRING_LENGTH (exp
));
3359 /* Subroutine of output_constant_def:
3360 No constant equal to EXP is known to have been output.
3361 Make a constant descriptor to enter EXP in the hash table.
3362 Assign the label number and construct RTL to refer to the
3363 constant's location in memory.
3364 Caller is responsible for updating the hash table. */
3366 static struct constant_descriptor_tree
*
3367 build_constant_desc (tree exp
)
3369 struct constant_descriptor_tree
*desc
;
3375 desc
= ggc_alloc
<constant_descriptor_tree
> ();
3378 /* Create a string containing the label name, in LABEL. */
3379 labelno
= const_labelno
++;
3380 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
3382 /* Construct the VAR_DECL associated with the constant. */
3383 decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
, get_identifier (label
),
3385 DECL_ARTIFICIAL (decl
) = 1;
3386 DECL_IGNORED_P (decl
) = 1;
3387 TREE_READONLY (decl
) = 1;
3388 TREE_STATIC (decl
) = 1;
3389 TREE_ADDRESSABLE (decl
) = 1;
3390 /* We don't set the RTL yet as this would cause varpool to assume that the
3391 variable is referenced. Moreover, it would just be dropped in LTO mode.
3392 Instead we set the flag that will be recognized in make_decl_rtl. */
3393 DECL_IN_CONSTANT_POOL (decl
) = 1;
3394 DECL_INITIAL (decl
) = desc
->value
;
3395 /* ??? targetm.constant_alignment hasn't been updated for vector types on
3396 most architectures so use DATA_ALIGNMENT as well, except for strings. */
3397 if (TREE_CODE (exp
) == STRING_CST
)
3398 SET_DECL_ALIGN (decl
, targetm
.constant_alignment (exp
, DECL_ALIGN (decl
)));
3401 align_variable (decl
, 0);
3402 if (DECL_ALIGN (decl
) < GET_MODE_ALIGNMENT (DECL_MODE (decl
))
3403 && ((optab_handler (movmisalign_optab
, DECL_MODE (decl
))
3404 != CODE_FOR_nothing
)
3405 || targetm
.slow_unaligned_access (DECL_MODE (decl
),
3406 DECL_ALIGN (decl
))))
3407 SET_DECL_ALIGN (decl
, GET_MODE_ALIGNMENT (DECL_MODE (decl
)));
3410 /* Now construct the SYMBOL_REF and the MEM. */
3411 if (use_object_blocks_p ())
3413 int align
= (TREE_CODE (decl
) == CONST_DECL
3414 || (VAR_P (decl
) && DECL_IN_CONSTANT_POOL (decl
))
3416 : symtab_node::get (decl
)->definition_alignment ());
3417 section
*sect
= get_constant_section (exp
, align
);
3418 symbol
= create_block_symbol (ggc_strdup (label
),
3419 get_block_for_section (sect
), -1);
3422 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3423 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3424 SET_SYMBOL_REF_DECL (symbol
, decl
);
3425 TREE_CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3427 rtl
= gen_const_mem (TYPE_MODE (TREE_TYPE (exp
)), symbol
);
3428 set_mem_attributes (rtl
, exp
, 1);
3429 set_mem_alias_set (rtl
, 0);
3431 /* Putting EXP into the literal pool might have imposed a different
3432 alignment which should be visible in the RTX as well. */
3433 set_mem_align (rtl
, DECL_ALIGN (decl
));
3435 /* We cannot share RTX'es in pool entries.
3436 Mark this piece of RTL as required for unsharing. */
3437 RTX_FLAG (rtl
, used
) = 1;
3439 /* Set flags or add text to the name to record information, such as
3440 that it is a local symbol. If the name is changed, the macro
3441 ASM_OUTPUT_LABELREF will have to know how to strip this
3442 information. This call might invalidate our local variable
3443 SYMBOL; we can't use it afterward. */
3444 targetm
.encode_section_info (exp
, rtl
, true);
3451 /* Subroutine of output_constant_def and tree_output_constant_def:
3452 Add a constant to the hash table that tracks which constants
3453 already have labels. */
3455 static constant_descriptor_tree
*
3456 add_constant_to_table (tree exp
)
3458 /* The hash table methods may call output_constant_def for addressed
3459 constants, so handle them first. */
3460 output_addressed_constants (exp
);
3462 /* Sanity check to catch recursive insertion. */
3463 static bool inserting
;
3464 gcc_assert (!inserting
);
3467 /* Look up EXP in the table of constant descriptors. If we didn't
3468 find it, create a new one. */
3469 struct constant_descriptor_tree key
;
3471 key
.hash
= const_hash_1 (exp
);
3472 constant_descriptor_tree
**loc
3473 = const_desc_htab
->find_slot_with_hash (&key
, key
.hash
, INSERT
);
3477 struct constant_descriptor_tree
*desc
= *loc
;
3480 desc
= build_constant_desc (exp
);
3481 desc
->hash
= key
.hash
;
3488 /* Return an rtx representing a reference to constant data in memory
3489 for the constant expression EXP.
3491 If assembler code for such a constant has already been output,
3492 return an rtx to refer to it.
3493 Otherwise, output such a constant in memory
3494 and generate an rtx for it.
3496 If DEFER is nonzero, this constant can be deferred and output only
3497 if referenced in the function after all optimizations.
3499 `const_desc_table' records which constants already have label strings. */
3502 output_constant_def (tree exp
, int defer
)
3504 struct constant_descriptor_tree
*desc
= add_constant_to_table (exp
);
3505 maybe_output_constant_def_contents (desc
, defer
);
3509 /* Subroutine of output_constant_def: Decide whether or not we need to
3510 output the constant DESC now, and if so, do it. */
3512 maybe_output_constant_def_contents (struct constant_descriptor_tree
*desc
,
3515 rtx symbol
= XEXP (desc
->rtl
, 0);
3516 tree exp
= desc
->value
;
3518 if (flag_syntax_only
)
3521 if (TREE_ASM_WRITTEN (exp
))
3522 /* Already output; don't do it again. */
3525 /* We can always defer constants as long as the context allows
3529 /* Increment n_deferred_constants if it exists. It needs to be at
3530 least as large as the number of constants actually referred to
3531 by the function. If it's too small we'll stop looking too early
3532 and fail to emit constants; if it's too large we'll only look
3533 through the entire function when we could have stopped earlier. */
3535 n_deferred_constants
++;
3539 output_constant_def_contents (symbol
);
3542 /* Subroutine of output_constant_def_contents. Output the definition
3543 of constant EXP, which is pointed to by label LABEL. ALIGN is the
3544 constant's alignment in bits. */
3547 assemble_constant_contents (tree exp
, const char *label
, unsigned int align
,
3552 size
= get_constant_size (exp
);
3554 /* Do any machine/system dependent processing of the constant. */
3555 targetm
.asm_out
.declare_constant_name (asm_out_file
, label
, exp
, size
);
3557 /* Output the value of EXP. */
3558 output_constant (exp
, size
, align
, false, merge_strings
);
3560 targetm
.asm_out
.decl_end ();
3563 /* We must output the constant data referred to by SYMBOL; do so. */
3566 output_constant_def_contents (rtx symbol
)
3568 tree decl
= SYMBOL_REF_DECL (symbol
);
3569 tree exp
= DECL_INITIAL (decl
);
3570 bool asan_protected
= false;
3572 /* Make sure any other constants whose addresses appear in EXP
3573 are assigned label numbers. */
3574 output_addressed_constants (exp
);
3576 /* We are no longer deferring this constant. */
3577 TREE_ASM_WRITTEN (decl
) = TREE_ASM_WRITTEN (exp
) = 1;
3579 if ((flag_sanitize
& SANITIZE_ADDRESS
)
3580 && TREE_CODE (exp
) == STRING_CST
3581 && asan_protect_global (exp
))
3583 asan_protected
= true;
3584 SET_DECL_ALIGN (decl
, MAX (DECL_ALIGN (decl
),
3585 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
));
3588 /* If the constant is part of an object block, make sure that the
3589 decl has been positioned within its block, but do not write out
3590 its definition yet. output_object_blocks will do that later. */
3591 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
3592 place_block_symbol (symbol
);
3595 int align
= (TREE_CODE (decl
) == CONST_DECL
3596 || (VAR_P (decl
) && DECL_IN_CONSTANT_POOL (decl
))
3598 : symtab_node::get (decl
)->definition_alignment ());
3599 section
*sect
= get_constant_section (exp
, align
);
3600 switch_to_section (sect
);
3601 if (align
> BITS_PER_UNIT
)
3602 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3603 assemble_constant_contents (exp
, XSTR (symbol
, 0), align
,
3604 (sect
->common
.flags
& SECTION_MERGE
)
3605 && (sect
->common
.flags
& SECTION_STRINGS
));
3608 HOST_WIDE_INT size
= get_constant_size (exp
);
3609 assemble_zeros (asan_red_zone_size (size
));
3614 /* Look up EXP in the table of constant descriptors. Return the rtl
3615 if it has been emitted, else null. */
3618 lookup_constant_def (tree exp
)
3620 struct constant_descriptor_tree key
;
3623 key
.hash
= const_hash_1 (exp
);
3624 constant_descriptor_tree
*desc
3625 = const_desc_htab
->find_with_hash (&key
, key
.hash
);
3627 return (desc
? desc
->rtl
: NULL_RTX
);
3630 /* Return a tree representing a reference to constant data in memory
3631 for the constant expression EXP.
3633 This is the counterpart of output_constant_def at the Tree level. */
3636 tree_output_constant_def (tree exp
)
3638 struct constant_descriptor_tree
*desc
= add_constant_to_table (exp
);
3639 tree decl
= SYMBOL_REF_DECL (XEXP (desc
->rtl
, 0));
3640 varpool_node::finalize_decl (decl
);
3644 class GTY((chain_next ("%h.next"), for_user
)) constant_descriptor_rtx
{
3646 class constant_descriptor_rtx
*next
;
3650 HOST_WIDE_INT offset
;
3652 fixed_size_mode mode
;
3658 struct const_rtx_desc_hasher
: ggc_ptr_hash
<constant_descriptor_rtx
>
3660 static hashval_t
hash (constant_descriptor_rtx
*);
3661 static bool equal (constant_descriptor_rtx
*, constant_descriptor_rtx
*);
3664 /* Used in the hash tables to avoid outputting the same constant
3665 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3666 are output once per function, not once per file. */
3667 /* ??? Only a few targets need per-function constant pools. Most
3668 can use one per-file pool. Should add a targetm bit to tell the
3671 struct GTY(()) rtx_constant_pool
{
3672 /* Pointers to first and last constant in pool, as ordered by offset. */
3673 class constant_descriptor_rtx
*first
;
3674 class constant_descriptor_rtx
*last
;
3676 /* Hash facility for making memory-constants from constant rtl-expressions.
3677 It is used on RISC machines where immediate integer arguments and
3678 constant addresses are restricted so that such constants must be stored
3680 hash_table
<const_rtx_desc_hasher
> *const_rtx_htab
;
3682 /* Current offset in constant pool (does not include any
3683 machine-specific header). */
3684 HOST_WIDE_INT offset
;
3687 /* Hash and compare functions for const_rtx_htab. */
3690 const_rtx_desc_hasher::hash (constant_descriptor_rtx
*desc
)
3696 const_rtx_desc_hasher::equal (constant_descriptor_rtx
*x
,
3697 constant_descriptor_rtx
*y
)
3699 if (x
->mode
!= y
->mode
)
3701 return rtx_equal_p (x
->constant
, y
->constant
);
3704 /* Hash one component of a constant. */
3707 const_rtx_hash_1 (const_rtx x
)
3709 unsigned HOST_WIDE_INT hwi
;
3715 code
= GET_CODE (x
);
3716 mode
= GET_MODE (x
);
3717 h
= (hashval_t
) code
* 1048573 + mode
;
3726 int shift
= sizeof (hashval_t
) * CHAR_BIT
;
3727 const int n
= sizeof (HOST_WIDE_INT
) / sizeof (hashval_t
);
3729 h
^= (hashval_t
) hwi
;
3730 for (i
= 1; i
< n
; ++i
)
3733 h
^= (hashval_t
) hwi
;
3738 case CONST_WIDE_INT
:
3741 for (i
= 0; i
< CONST_WIDE_INT_NUNITS (x
); i
++)
3742 hwi
^= CONST_WIDE_INT_ELT (x
, i
);
3747 if (TARGET_SUPPORTS_WIDE_INT
== 0 && mode
== VOIDmode
)
3749 hwi
= CONST_DOUBLE_LOW (x
) ^ CONST_DOUBLE_HIGH (x
);
3753 h
^= real_hash (CONST_DOUBLE_REAL_VALUE (x
));
3757 h
^= fixed_hash (CONST_FIXED_VALUE (x
));
3761 h
^= htab_hash_string (XSTR (x
, 0));
3765 h
= h
* 251 + CODE_LABEL_NUMBER (label_ref_label (x
));
3769 case UNSPEC_VOLATILE
:
3770 h
= h
* 251 + XINT (x
, 1);
3780 /* Compute a hash value for X, which should be a constant. */
3783 const_rtx_hash (rtx x
)
3786 subrtx_iterator::array_type array
;
3787 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
3788 h
= h
* 509 + const_rtx_hash_1 (*iter
);
3793 /* Create and return a new rtx constant pool. */
3795 static struct rtx_constant_pool
*
3796 create_constant_pool (void)
3798 struct rtx_constant_pool
*pool
;
3800 pool
= ggc_alloc
<rtx_constant_pool
> ();
3801 pool
->const_rtx_htab
= hash_table
<const_rtx_desc_hasher
>::create_ggc (31);
3808 /* Initialize constant pool hashing for a new function. */
3811 init_varasm_status (void)
3813 crtl
->varasm
.pool
= create_constant_pool ();
3814 crtl
->varasm
.deferred_constants
= 0;
3817 /* Given a MINUS expression, simplify it if both sides
3818 include the same symbol. */
3821 simplify_subtraction (rtx x
)
3823 rtx r
= simplify_rtx (x
);
3827 /* Given a constant rtx X, make (or find) a memory constant for its value
3828 and return a MEM rtx to refer to it in memory. IN_MODE is the mode
3832 force_const_mem (machine_mode in_mode
, rtx x
)
3834 class constant_descriptor_rtx
*desc
, tmp
;
3835 struct rtx_constant_pool
*pool
;
3840 constant_descriptor_rtx
**slot
;
3841 fixed_size_mode mode
;
3843 /* We can't force variable-sized objects to memory. */
3844 if (!is_a
<fixed_size_mode
> (in_mode
, &mode
))
3847 /* If we're not allowed to drop X into the constant pool, don't. */
3848 if (targetm
.cannot_force_const_mem (mode
, x
))
3851 /* Record that this function has used a constant pool entry. */
3852 crtl
->uses_const_pool
= 1;
3854 /* Decide which pool to use. */
3855 pool
= (targetm
.use_blocks_for_constant_p (mode
, x
)
3856 ? shared_constant_pool
3857 : crtl
->varasm
.pool
);
3859 /* Lookup the value in the hashtable. */
3862 hash
= const_rtx_hash (x
);
3863 slot
= pool
->const_rtx_htab
->find_slot_with_hash (&tmp
, hash
, INSERT
);
3866 /* If the constant was already present, return its memory. */
3868 return copy_rtx (desc
->mem
);
3870 /* Otherwise, create a new descriptor. */
3871 desc
= ggc_alloc
<constant_descriptor_rtx
> ();
3874 /* Align the location counter as required by EXP's data type. */
3875 machine_mode align_mode
= (mode
== VOIDmode
? word_mode
: mode
);
3876 align
= targetm
.static_rtx_alignment (align_mode
);
3878 pool
->offset
+= (align
/ BITS_PER_UNIT
) - 1;
3879 pool
->offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3882 desc
->constant
= copy_rtx (tmp
.constant
);
3883 desc
->offset
= pool
->offset
;
3886 desc
->align
= align
;
3887 desc
->labelno
= const_labelno
;
3890 pool
->offset
+= GET_MODE_SIZE (mode
);
3892 pool
->last
->next
= desc
;
3894 pool
->first
= pool
->last
= desc
;
3897 /* Create a string containing the label name, in LABEL. */
3898 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3901 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3902 the constants pool. */
3903 if (use_object_blocks_p () && targetm
.use_blocks_for_constant_p (mode
, x
))
3905 section
*sect
= targetm
.asm_out
.select_rtx_section (mode
, x
, align
);
3906 symbol
= create_block_symbol (ggc_strdup (label
),
3907 get_block_for_section (sect
), -1);
3910 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3912 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3913 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3914 SET_SYMBOL_REF_CONSTANT (symbol
, desc
);
3916 /* Construct the MEM. */
3917 desc
->mem
= def
= gen_const_mem (mode
, symbol
);
3918 set_mem_align (def
, align
);
3920 /* If we're dropping a label to the constant pool, make sure we
3922 if (GET_CODE (x
) == LABEL_REF
)
3923 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3925 return copy_rtx (def
);
3928 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3931 get_pool_constant (const_rtx addr
)
3933 return SYMBOL_REF_CONSTANT (addr
)->constant
;
3936 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3937 and whether it has been output or not. */
3940 get_pool_constant_mark (rtx addr
, bool *pmarked
)
3942 class constant_descriptor_rtx
*desc
;
3944 desc
= SYMBOL_REF_CONSTANT (addr
);
3945 *pmarked
= (desc
->mark
!= 0);
3946 return desc
->constant
;
3949 /* Similar, return the mode. */
3952 get_pool_mode (const_rtx addr
)
3954 return SYMBOL_REF_CONSTANT (addr
)->mode
;
3957 /* Return TRUE if and only if the constant pool has no entries. Note
3958 that even entries we might end up choosing not to emit are counted
3959 here, so there is the potential for missed optimizations. */
3962 constant_pool_empty_p (void)
3964 return crtl
->varasm
.pool
->first
== NULL
;
3967 /* Worker function for output_constant_pool_1. Emit assembly for X
3968 in MODE with known alignment ALIGN. */
3971 output_constant_pool_2 (fixed_size_mode mode
, rtx x
, unsigned int align
)
3973 switch (GET_MODE_CLASS (mode
))
3976 case MODE_DECIMAL_FLOAT
:
3978 gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x
));
3979 assemble_real (*CONST_DOUBLE_REAL_VALUE (x
),
3980 as_a
<scalar_float_mode
> (mode
), align
, false);
3985 case MODE_PARTIAL_INT
:
3990 assemble_integer (x
, GET_MODE_SIZE (mode
), align
, 1);
3993 case MODE_VECTOR_BOOL
:
3995 gcc_assert (GET_CODE (x
) == CONST_VECTOR
);
3997 /* Pick the smallest integer mode that contains at least one
3998 whole element. Often this is byte_mode and contains more
3999 than one element. */
4000 unsigned int nelts
= GET_MODE_NUNITS (mode
);
4001 unsigned int elt_bits
= GET_MODE_BITSIZE (mode
) / nelts
;
4002 unsigned int int_bits
= MAX (elt_bits
, BITS_PER_UNIT
);
4003 scalar_int_mode int_mode
= int_mode_for_size (int_bits
, 0).require ();
4005 /* Build the constant up one integer at a time. */
4006 unsigned int elts_per_int
= int_bits
/ elt_bits
;
4007 for (unsigned int i
= 0; i
< nelts
; i
+= elts_per_int
)
4009 unsigned HOST_WIDE_INT value
= 0;
4010 unsigned int limit
= MIN (nelts
- i
, elts_per_int
);
4011 for (unsigned int j
= 0; j
< limit
; ++j
)
4012 if (INTVAL (CONST_VECTOR_ELT (x
, i
+ j
)) != 0)
4013 value
|= 1 << (j
* elt_bits
);
4014 output_constant_pool_2 (int_mode
, gen_int_mode (value
, int_mode
),
4015 i
!= 0 ? MIN (align
, int_bits
) : align
);
4019 case MODE_VECTOR_FLOAT
:
4020 case MODE_VECTOR_INT
:
4021 case MODE_VECTOR_FRACT
:
4022 case MODE_VECTOR_UFRACT
:
4023 case MODE_VECTOR_ACCUM
:
4024 case MODE_VECTOR_UACCUM
:
4027 scalar_mode submode
= GET_MODE_INNER (mode
);
4028 unsigned int subalign
= MIN (align
, GET_MODE_BITSIZE (submode
));
4030 gcc_assert (GET_CODE (x
) == CONST_VECTOR
);
4031 units
= GET_MODE_NUNITS (mode
);
4033 for (i
= 0; i
< units
; i
++)
4035 rtx elt
= CONST_VECTOR_ELT (x
, i
);
4036 output_constant_pool_2 (submode
, elt
, i
? subalign
: align
);
4046 /* Worker function for output_constant_pool. Emit constant DESC,
4047 giving it ALIGN bits of alignment. */
4050 output_constant_pool_1 (class constant_descriptor_rtx
*desc
,
4057 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
4058 whose CODE_LABEL has been deleted. This can occur if a jump table
4059 is eliminated by optimization. If so, write a constant of zero
4060 instead. Note that this can also happen by turning the
4061 CODE_LABEL into a NOTE. */
4062 /* ??? This seems completely and utterly wrong. Certainly it's
4063 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
4064 functioning even with rtx_insn::deleted and friends. */
4067 switch (GET_CODE (tmp
))
4070 if (GET_CODE (XEXP (tmp
, 0)) != PLUS
4071 || GET_CODE (XEXP (XEXP (tmp
, 0), 0)) != LABEL_REF
)
4073 tmp
= XEXP (XEXP (tmp
, 0), 0);
4078 rtx_insn
*insn
= label_ref_label (tmp
);
4079 gcc_assert (!insn
->deleted ());
4080 gcc_assert (!NOTE_P (insn
)
4081 || NOTE_KIND (insn
) != NOTE_INSN_DELETED
);
4089 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4090 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, desc
->mode
,
4091 align
, desc
->labelno
, done
);
4094 assemble_align (align
);
4096 /* Output the label. */
4097 targetm
.asm_out
.internal_label (asm_out_file
, "LC", desc
->labelno
);
4100 Pass actual alignment value while emitting string constant to asm code
4101 as function 'output_constant_pool_1' explicitly passes the alignment as 1
4102 assuming that the data is already aligned which prevents the generation
4103 of fix-up table entries. */
4104 output_constant_pool_2 (desc
->mode
, x
, desc
->align
);
4106 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
4107 sections have proper size. */
4108 if (align
> GET_MODE_BITSIZE (desc
->mode
)
4110 && (in_section
->common
.flags
& SECTION_MERGE
))
4111 assemble_align (align
);
4113 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4119 /* Recompute the offsets of entries in POOL, and the overall size of
4120 POOL. Do this after calling mark_constant_pool to ensure that we
4121 are computing the offset values for the pool which we will actually
4125 recompute_pool_offsets (struct rtx_constant_pool
*pool
)
4127 class constant_descriptor_rtx
*desc
;
4130 for (desc
= pool
->first
; desc
; desc
= desc
->next
)
4133 /* Recalculate offset. */
4134 unsigned int align
= desc
->align
;
4135 pool
->offset
+= (align
/ BITS_PER_UNIT
) - 1;
4136 pool
->offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
4137 desc
->offset
= pool
->offset
;
4138 pool
->offset
+= GET_MODE_SIZE (desc
->mode
);
4142 /* Mark all constants that are referenced by SYMBOL_REFs in X.
4143 Emit referenced deferred strings. */
4146 mark_constants_in_pattern (rtx insn
)
4148 subrtx_iterator::array_type array
;
4149 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), ALL
)
4151 const_rtx x
= *iter
;
4152 if (GET_CODE (x
) == SYMBOL_REF
)
4154 if (CONSTANT_POOL_ADDRESS_P (x
))
4156 class constant_descriptor_rtx
*desc
= SYMBOL_REF_CONSTANT (x
);
4157 if (desc
->mark
== 0)
4160 iter
.substitute (desc
->constant
);
4163 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
4165 tree decl
= SYMBOL_REF_DECL (x
);
4166 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
4168 n_deferred_constants
--;
4169 output_constant_def_contents (CONST_CAST_RTX (x
));
4176 /* Look through appropriate parts of INSN, marking all entries in the
4177 constant pool which are actually being used. Entries that are only
4178 referenced by other constants are also marked as used. Emit
4179 deferred strings that are used. */
4182 mark_constants (rtx_insn
*insn
)
4187 /* Insns may appear inside a SEQUENCE. Only check the patterns of
4188 insns, not any notes that may be attached. We don't want to mark
4189 a constant just because it happens to appear in a REG_EQUIV note. */
4190 if (rtx_sequence
*seq
= dyn_cast
<rtx_sequence
*> (PATTERN (insn
)))
4192 int i
, n
= seq
->len ();
4193 for (i
= 0; i
< n
; ++i
)
4195 rtx subinsn
= seq
->element (i
);
4196 if (INSN_P (subinsn
))
4197 mark_constants_in_pattern (subinsn
);
4201 mark_constants_in_pattern (insn
);
4204 /* Look through the instructions for this function, and mark all the
4205 entries in POOL which are actually being used. Emit deferred constants
4206 which have indeed been used. */
4209 mark_constant_pool (void)
4213 if (!crtl
->uses_const_pool
&& n_deferred_constants
== 0)
4216 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4217 mark_constants (insn
);
4220 /* Write all the constants in POOL. */
4223 output_constant_pool_contents (struct rtx_constant_pool
*pool
)
4225 class constant_descriptor_rtx
*desc
;
4227 for (desc
= pool
->first
; desc
; desc
= desc
->next
)
4230 /* If the constant is part of an object_block, make sure that
4231 the constant has been positioned within its block, but do not
4232 write out its definition yet. output_object_blocks will do
4234 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc
->sym
)
4235 && SYMBOL_REF_BLOCK (desc
->sym
))
4236 place_block_symbol (desc
->sym
);
4239 switch_to_section (targetm
.asm_out
.select_rtx_section
4240 (desc
->mode
, desc
->constant
, desc
->align
));
4241 output_constant_pool_1 (desc
, desc
->align
);
4246 /* Mark all constants that are used in the current function, then write
4247 out the function's private constant pool. */
4250 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED
,
4251 tree fndecl ATTRIBUTE_UNUSED
)
4253 struct rtx_constant_pool
*pool
= crtl
->varasm
.pool
;
4255 /* It is possible for gcc to call force_const_mem and then to later
4256 discard the instructions which refer to the constant. In such a
4257 case we do not need to output the constant. */
4258 mark_constant_pool ();
4260 /* Having marked the constant pool entries we'll actually emit, we
4261 now need to rebuild the offset information, which may have become
4263 recompute_pool_offsets (pool
);
4265 #ifdef ASM_OUTPUT_POOL_PROLOGUE
4266 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4269 output_constant_pool_contents (pool
);
4271 #ifdef ASM_OUTPUT_POOL_EPILOGUE
4272 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4276 /* Write the contents of the shared constant pool. */
4279 output_shared_constant_pool (void)
4281 output_constant_pool_contents (shared_constant_pool
);
4284 /* Determine what kind of relocations EXP may need. */
4287 compute_reloc_for_constant (tree exp
)
4289 int reloc
= 0, reloc2
;
4292 switch (TREE_CODE (exp
))
4296 /* Go inside any operations that get_inner_reference can handle and see
4297 if what's inside is a constant: no need to do anything here for
4298 addresses of variables or functions. */
4299 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4300 tem
= TREE_OPERAND (tem
, 0))
4303 if (TREE_CODE (tem
) == MEM_REF
4304 && TREE_CODE (TREE_OPERAND (tem
, 0)) == ADDR_EXPR
)
4306 reloc
= compute_reloc_for_constant (TREE_OPERAND (tem
, 0));
4310 if (!targetm
.binds_local_p (tem
))
4317 case POINTER_PLUS_EXPR
:
4318 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4319 reloc
|= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4323 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4324 reloc2
= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4325 /* The difference of two local labels is computable at link time. */
4326 if (reloc
== 1 && reloc2
== 1)
4333 case VIEW_CONVERT_EXPR
:
4334 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4339 unsigned HOST_WIDE_INT idx
;
4340 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4342 reloc
|= compute_reloc_for_constant (tem
);
4352 /* Find all the constants whose addresses are referenced inside of EXP,
4353 and make sure assembler code with a label has been output for each one.
4354 Indicate whether an ADDR_EXPR has been encountered. */
4357 output_addressed_constants (tree exp
)
4361 switch (TREE_CODE (exp
))
4365 /* Go inside any operations that get_inner_reference can handle and see
4366 if what's inside is a constant: no need to do anything here for
4367 addresses of variables or functions. */
4368 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4369 tem
= TREE_OPERAND (tem
, 0))
4372 /* If we have an initialized CONST_DECL, retrieve the initializer. */
4373 if (TREE_CODE (tem
) == CONST_DECL
&& DECL_INITIAL (tem
))
4374 tem
= DECL_INITIAL (tem
);
4376 if (CONSTANT_CLASS_P (tem
) || TREE_CODE (tem
) == CONSTRUCTOR
)
4377 output_constant_def (tem
, 0);
4379 if (TREE_CODE (tem
) == MEM_REF
)
4380 output_addressed_constants (TREE_OPERAND (tem
, 0));
4384 case POINTER_PLUS_EXPR
:
4386 output_addressed_constants (TREE_OPERAND (exp
, 1));
4390 case VIEW_CONVERT_EXPR
:
4391 output_addressed_constants (TREE_OPERAND (exp
, 0));
4396 unsigned HOST_WIDE_INT idx
;
4397 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4399 output_addressed_constants (tem
);
4408 /* Whether a constructor CTOR is a valid static constant initializer if all
4409 its elements are. This used to be internal to initializer_constant_valid_p
4410 and has been exposed to let other functions like categorize_ctor_elements
4411 evaluate the property while walking a constructor for other purposes. */
4414 constructor_static_from_elts_p (const_tree ctor
)
4416 return (TREE_CONSTANT (ctor
)
4417 && (TREE_CODE (TREE_TYPE (ctor
)) == UNION_TYPE
4418 || TREE_CODE (TREE_TYPE (ctor
)) == RECORD_TYPE
4419 || TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
));
4422 static tree
initializer_constant_valid_p_1 (tree value
, tree endtype
,
4425 /* A subroutine of initializer_constant_valid_p. VALUE is a MINUS_EXPR,
4426 PLUS_EXPR or POINTER_PLUS_EXPR. This looks for cases of VALUE
4427 which are valid when ENDTYPE is an integer of any size; in
4428 particular, this does not accept a pointer minus a constant. This
4429 returns null_pointer_node if the VALUE is an absolute constant
4430 which can be used to initialize a static variable. Otherwise it
4434 narrowing_initializer_constant_valid_p (tree value
, tree endtype
, tree
*cache
)
4438 if (!INTEGRAL_TYPE_P (endtype
))
4441 op0
= TREE_OPERAND (value
, 0);
4442 op1
= TREE_OPERAND (value
, 1);
4444 /* Like STRIP_NOPS except allow the operand mode to widen. This
4445 works around a feature of fold that simplifies (int)(p1 - p2) to
4446 ((int)p1 - (int)p2) under the theory that the narrower operation
4449 while (CONVERT_EXPR_P (op0
)
4450 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4452 tree inner
= TREE_OPERAND (op0
, 0);
4453 if (inner
== error_mark_node
4454 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4455 || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op0
)))
4456 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner
)))))
4461 while (CONVERT_EXPR_P (op1
)
4462 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
4464 tree inner
= TREE_OPERAND (op1
, 0);
4465 if (inner
== error_mark_node
4466 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4467 || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op1
)))
4468 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner
)))))
4473 op0
= initializer_constant_valid_p_1 (op0
, endtype
, cache
);
4477 op1
= initializer_constant_valid_p_1 (op1
, endtype
,
4478 cache
? cache
+ 2 : NULL
);
4479 /* Both initializers must be known. */
4483 && (op0
== null_pointer_node
4484 || TREE_CODE (value
) == MINUS_EXPR
))
4485 return null_pointer_node
;
4487 /* Support differences between labels. */
4488 if (TREE_CODE (op0
) == LABEL_DECL
4489 && TREE_CODE (op1
) == LABEL_DECL
)
4490 return null_pointer_node
;
4492 if (TREE_CODE (op0
) == STRING_CST
4493 && TREE_CODE (op1
) == STRING_CST
4494 && operand_equal_p (op0
, op1
, 1))
4495 return null_pointer_node
;
4501 /* Helper function of initializer_constant_valid_p.
4502 Return nonzero if VALUE is a valid constant-valued expression
4503 for use in initializing a static variable; one that can be an
4504 element of a "constant" initializer.
4506 Return null_pointer_node if the value is absolute;
4507 if it is relocatable, return the variable that determines the relocation.
4508 We assume that VALUE has been folded as much as possible;
4509 therefore, we do not need to check for such things as
4510 arithmetic-combinations of integers.
4512 Use CACHE (pointer to 2 tree values) for caching if non-NULL. */
4515 initializer_constant_valid_p_1 (tree value
, tree endtype
, tree
*cache
)
4519 switch (TREE_CODE (value
))
4522 if (constructor_static_from_elts_p (value
))
4524 unsigned HOST_WIDE_INT idx
;
4526 bool absolute
= true;
4528 if (cache
&& cache
[0] == value
)
4530 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4533 reloc
= initializer_constant_valid_p_1 (elt
, TREE_TYPE (elt
),
4536 /* An absolute value is required with reverse SSO. */
4537 || (reloc
!= null_pointer_node
4538 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (value
))
4539 && !AGGREGATE_TYPE_P (TREE_TYPE (elt
))))
4544 cache
[1] = NULL_TREE
;
4548 if (reloc
!= null_pointer_node
)
4551 /* For a non-absolute relocation, there is no single
4552 variable that can be "the variable that determines the
4557 cache
[1] = absolute
? null_pointer_node
: error_mark_node
;
4559 return absolute
? null_pointer_node
: error_mark_node
;
4562 return TREE_STATIC (value
) ? null_pointer_node
: NULL_TREE
;
4570 return null_pointer_node
;
4575 tree op0
= staticp (TREE_OPERAND (value
, 0));
4578 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out
4579 to be a constant, this is old-skool offsetof-like nonsense. */
4580 if (TREE_CODE (op0
) == INDIRECT_REF
4581 && TREE_CONSTANT (TREE_OPERAND (op0
, 0)))
4582 return null_pointer_node
;
4583 /* Taking the address of a nested function involves a trampoline,
4584 unless we don't need or want one. */
4585 if (TREE_CODE (op0
) == FUNCTION_DECL
4586 && DECL_STATIC_CHAIN (op0
)
4587 && !TREE_NO_TRAMPOLINE (value
))
4589 /* "&{...}" requires a temporary to hold the constructed
4591 if (TREE_CODE (op0
) == CONSTRUCTOR
)
4597 case NON_LVALUE_EXPR
:
4598 return initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4601 case VIEW_CONVERT_EXPR
:
4603 tree src
= TREE_OPERAND (value
, 0);
4604 tree src_type
= TREE_TYPE (src
);
4605 tree dest_type
= TREE_TYPE (value
);
4607 /* Allow view-conversions from aggregate to non-aggregate type only
4608 if the bit pattern is fully preserved afterwards; otherwise, the
4609 RTL expander won't be able to apply a subsequent transformation
4610 to the underlying constructor. */
4611 if (AGGREGATE_TYPE_P (src_type
) && !AGGREGATE_TYPE_P (dest_type
))
4613 if (TYPE_MODE (endtype
) == TYPE_MODE (dest_type
))
4614 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4619 /* Allow all other kinds of view-conversion. */
4620 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4625 tree src
= TREE_OPERAND (value
, 0);
4626 tree src_type
= TREE_TYPE (src
);
4627 tree dest_type
= TREE_TYPE (value
);
4629 /* Allow conversions between pointer types, floating-point
4630 types, and offset types. */
4631 if ((POINTER_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
))
4632 || (FLOAT_TYPE_P (dest_type
) && FLOAT_TYPE_P (src_type
))
4633 || (TREE_CODE (dest_type
) == OFFSET_TYPE
4634 && TREE_CODE (src_type
) == OFFSET_TYPE
))
4635 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4637 /* Allow length-preserving conversions between integer types. */
4638 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
)
4639 && (TYPE_PRECISION (dest_type
) == TYPE_PRECISION (src_type
)))
4640 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4642 /* Allow conversions between other integer types only if
4643 explicit value. Don't allow sign-extension to a type larger
4644 than word and pointer, there aren't relocations that would
4645 allow to sign extend it to a wider type. */
4646 if (INTEGRAL_TYPE_P (dest_type
)
4647 && INTEGRAL_TYPE_P (src_type
)
4648 && (TYPE_UNSIGNED (src_type
)
4649 || TYPE_PRECISION (dest_type
) <= TYPE_PRECISION (src_type
)
4650 || TYPE_PRECISION (dest_type
) <= BITS_PER_WORD
4651 || TYPE_PRECISION (dest_type
) <= POINTER_SIZE
))
4653 tree inner
= initializer_constant_valid_p_1 (src
, endtype
, cache
);
4654 if (inner
== null_pointer_node
)
4655 return null_pointer_node
;
4659 /* Allow (int) &foo provided int is as wide as a pointer. */
4660 if (INTEGRAL_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
)
4661 && (TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
)))
4662 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4664 /* Likewise conversions from int to pointers, but also allow
4665 conversions from 0. */
4666 if ((POINTER_TYPE_P (dest_type
)
4667 || TREE_CODE (dest_type
) == OFFSET_TYPE
)
4668 && INTEGRAL_TYPE_P (src_type
))
4670 if (TREE_CODE (src
) == INTEGER_CST
4671 && TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
))
4672 return null_pointer_node
;
4673 if (integer_zerop (src
))
4674 return null_pointer_node
;
4675 else if (TYPE_PRECISION (dest_type
) <= TYPE_PRECISION (src_type
))
4676 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4679 /* Allow conversions to struct or union types if the value
4681 if (TREE_CODE (dest_type
) == RECORD_TYPE
4682 || TREE_CODE (dest_type
) == UNION_TYPE
)
4683 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4687 case POINTER_PLUS_EXPR
:
4689 /* Any valid floating-point constants will have been folded by now;
4690 with -frounding-math we hit this with addition of two constants. */
4691 if (TREE_CODE (endtype
) == REAL_TYPE
)
4693 if (cache
&& cache
[0] == value
)
4695 if (! INTEGRAL_TYPE_P (endtype
)
4696 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4698 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4700 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4703 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4704 endtype
, ncache
+ 2);
4705 /* If either term is absolute, use the other term's relocation. */
4706 if (valid0
== null_pointer_node
)
4708 else if (valid1
== null_pointer_node
)
4710 /* Support narrowing pointer differences. */
4712 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4716 /* Support narrowing pointer differences. */
4717 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4725 case POINTER_DIFF_EXPR
:
4727 if (TREE_CODE (endtype
) == REAL_TYPE
)
4729 if (cache
&& cache
[0] == value
)
4731 if (! INTEGRAL_TYPE_P (endtype
)
4732 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4734 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4736 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4739 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4740 endtype
, ncache
+ 2);
4741 /* Win if second argument is absolute. */
4742 if (valid1
== null_pointer_node
)
4744 /* Win if both arguments have the same relocation.
4745 Then the value is absolute. */
4746 else if (valid0
== valid1
&& valid0
!= 0)
4747 ret
= null_pointer_node
;
4748 /* Since GCC guarantees that string constants are unique in the
4749 generated code, a subtraction between two copies of the same
4750 constant string is absolute. */
4751 else if (valid0
&& TREE_CODE (valid0
) == STRING_CST
4752 && valid1
&& TREE_CODE (valid1
) == STRING_CST
4753 && operand_equal_p (valid0
, valid1
, 1))
4754 ret
= null_pointer_node
;
4755 /* Support narrowing differences. */
4757 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4761 /* Support narrowing differences. */
4762 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4777 /* Return nonzero if VALUE is a valid constant-valued expression
4778 for use in initializing a static variable; one that can be an
4779 element of a "constant" initializer.
4781 Return null_pointer_node if the value is absolute;
4782 if it is relocatable, return the variable that determines the relocation.
4783 We assume that VALUE has been folded as much as possible;
4784 therefore, we do not need to check for such things as
4785 arithmetic-combinations of integers. */
4787 initializer_constant_valid_p (tree value
, tree endtype
, bool reverse
)
4789 tree reloc
= initializer_constant_valid_p_1 (value
, endtype
, NULL
);
4791 /* An absolute value is required with reverse storage order. */
4793 && reloc
!= null_pointer_node
4795 && !AGGREGATE_TYPE_P (endtype
)
4796 && !VECTOR_TYPE_P (endtype
))
4802 /* Return true if VALUE is a valid constant-valued expression
4803 for use in initializing a static bit-field; one that can be
4804 an element of a "constant" initializer. */
4807 initializer_constant_valid_for_bitfield_p (tree value
)
4809 /* For bitfields we support integer constants or possibly nested aggregates
4811 switch (TREE_CODE (value
))
4815 unsigned HOST_WIDE_INT idx
;
4818 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4819 if (!initializer_constant_valid_for_bitfield_p (elt
))
4828 case VIEW_CONVERT_EXPR
:
4829 case NON_LVALUE_EXPR
:
4831 initializer_constant_valid_for_bitfield_p (TREE_OPERAND (value
, 0));
4840 /* Check if a STRING_CST fits into the field.
4841 Tolerate only the case when the NUL termination
4842 does not fit into the field. */
4845 check_string_literal (tree string
, unsigned HOST_WIDE_INT size
)
4847 tree type
= TREE_TYPE (string
);
4848 tree eltype
= TREE_TYPE (type
);
4849 unsigned HOST_WIDE_INT elts
= tree_to_uhwi (TYPE_SIZE_UNIT (eltype
));
4850 unsigned HOST_WIDE_INT mem_size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
4851 int len
= TREE_STRING_LENGTH (string
);
4853 if (elts
!= 1 && elts
!= 2 && elts
!= 4)
4855 if (len
< 0 || len
% elts
!= 0)
4857 if (size
< (unsigned)len
)
4859 if (mem_size
!= size
)
4864 /* output_constructor outer state of relevance in recursive calls, typically
4865 for nested aggregate bitfields. */
4867 struct oc_outer_state
{
4868 unsigned int bit_offset
; /* current position in ... */
4869 int byte
; /* ... the outer byte buffer. */
4872 static unsigned HOST_WIDE_INT
4873 output_constructor (tree
, unsigned HOST_WIDE_INT
, unsigned int, bool,
4876 /* Output assembler code for constant EXP, with no label.
4877 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4878 Assumes output_addressed_constants has been done on EXP already.
4880 Generate at least SIZE bytes of assembler data, padding at the end
4881 with zeros if necessary. SIZE must always be specified. The returned
4882 value is the actual number of bytes of assembler data generated, which
4883 may be bigger than SIZE if the object contains a variable length field.
4885 SIZE is important for structure constructors,
4886 since trailing members may have been omitted from the constructor.
4887 It is also important for initialization of arrays from string constants
4888 since the full length of the string constant might not be wanted.
4889 It is also needed for initialization of unions, where the initializer's
4890 type is just one member, and that may not be as long as the union.
4892 There a case in which we would fail to output exactly SIZE bytes:
4893 for a structure constructor that wants to produce more than SIZE bytes.
4894 But such constructors will never be generated for any possible input.
4896 ALIGN is the alignment of the data in bits.
4898 If REVERSE is true, EXP is output in reverse storage order. */
4900 static unsigned HOST_WIDE_INT
4901 output_constant (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
,
4902 bool reverse
, bool merge_strings
)
4904 enum tree_code code
;
4905 unsigned HOST_WIDE_INT thissize
;
4908 if (size
== 0 || flag_syntax_only
)
4911 /* See if we're trying to initialize a pointer in a non-default mode
4912 to the address of some declaration somewhere. If the target says
4913 the mode is valid for pointers, assume the target has a way of
4915 if (TREE_CODE (exp
) == NOP_EXPR
4916 && POINTER_TYPE_P (TREE_TYPE (exp
))
4917 && targetm
.addr_space
.valid_pointer_mode
4918 (SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
)),
4919 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4921 tree saved_type
= TREE_TYPE (exp
);
4923 /* Peel off any intermediate conversions-to-pointer for valid
4925 while (TREE_CODE (exp
) == NOP_EXPR
4926 && POINTER_TYPE_P (TREE_TYPE (exp
))
4927 && targetm
.addr_space
.valid_pointer_mode
4928 (SCALAR_INT_TYPE_MODE (TREE_TYPE (exp
)),
4929 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4930 exp
= TREE_OPERAND (exp
, 0);
4932 /* If what we're left with is the address of something, we can
4933 convert the address to the final type and output it that
4935 if (TREE_CODE (exp
) == ADDR_EXPR
)
4936 exp
= build1 (ADDR_EXPR
, saved_type
, TREE_OPERAND (exp
, 0));
4937 /* Likewise for constant ints. */
4938 else if (TREE_CODE (exp
) == INTEGER_CST
)
4939 exp
= fold_convert (saved_type
, exp
);
4943 /* Eliminate any conversions since we'll be outputting the underlying
4945 while (CONVERT_EXPR_P (exp
)
4946 || TREE_CODE (exp
) == NON_LVALUE_EXPR
4947 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
4949 HOST_WIDE_INT type_size
= int_size_in_bytes (TREE_TYPE (exp
));
4950 HOST_WIDE_INT op_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4952 /* Make sure eliminating the conversion is really a no-op, except with
4953 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4954 union types to allow for Ada unchecked unions. */
4955 if (type_size
> op_size
4956 && TREE_CODE (exp
) != VIEW_CONVERT_EXPR
4957 && TREE_CODE (TREE_TYPE (exp
)) != UNION_TYPE
)
4958 /* Keep the conversion. */
4961 exp
= TREE_OPERAND (exp
, 0);
4964 code
= TREE_CODE (TREE_TYPE (exp
));
4965 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
4967 /* Allow a constructor with no elements for any data type.
4968 This means to fill the space with zeros. */
4969 if (TREE_CODE (exp
) == CONSTRUCTOR
4970 && vec_safe_is_empty (CONSTRUCTOR_ELTS (exp
)))
4972 assemble_zeros (size
);
4976 if (TREE_CODE (exp
) == FDESC_EXPR
)
4978 #ifdef ASM_OUTPUT_FDESC
4979 HOST_WIDE_INT part
= tree_to_shwi (TREE_OPERAND (exp
, 1));
4980 tree decl
= TREE_OPERAND (exp
, 0);
4981 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
4988 /* Now output the underlying data. If we've handling the padding, return.
4989 Otherwise, break and ensure SIZE is the size written. */
4996 case REFERENCE_TYPE
:
4998 case FIXED_POINT_TYPE
:
5000 cst
= expand_expr (exp
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
5002 cst
= flip_storage_order (TYPE_MODE (TREE_TYPE (exp
)), cst
);
5003 if (!assemble_integer (cst
, MIN (size
, thissize
), align
, 0))
5004 error ("initializer for integer/fixed-point value is too complicated");
5008 if (TREE_CODE (exp
) != REAL_CST
)
5009 error ("initializer for floating value is not a floating constant");
5011 assemble_real (TREE_REAL_CST (exp
),
5012 SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (exp
)),
5017 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
,
5019 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
5020 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)),
5026 switch (TREE_CODE (exp
))
5029 return output_constructor (exp
, size
, align
, reverse
, NULL
);
5031 thissize
= (unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
);
5034 || TREE_STRING_POINTER (exp
) [thissize
- 1] != '\0'))
5036 gcc_checking_assert (check_string_literal (exp
, size
));
5037 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
5041 scalar_mode inner
= SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
5042 unsigned int nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
5043 int elt_size
= GET_MODE_SIZE (inner
);
5044 output_constant (VECTOR_CST_ELT (exp
, 0), elt_size
, align
,
5046 thissize
= elt_size
;
5047 /* Static constants must have a fixed size. */
5048 unsigned int nunits
= VECTOR_CST_NELTS (exp
).to_constant ();
5049 for (unsigned int i
= 1; i
< nunits
; i
++)
5051 output_constant (VECTOR_CST_ELT (exp
, i
), elt_size
, nalign
,
5053 thissize
+= elt_size
;
5064 gcc_assert (TREE_CODE (exp
) == CONSTRUCTOR
);
5065 return output_constructor (exp
, size
, align
, reverse
, NULL
);
5074 if (size
> thissize
)
5075 assemble_zeros (size
- thissize
);
5080 /* Subroutine of output_constructor, used for computing the size of
5081 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
5082 type with an unspecified upper bound. */
5084 static unsigned HOST_WIDE_INT
5085 array_size_for_constructor (tree val
)
5088 unsigned HOST_WIDE_INT cnt
;
5089 tree index
, value
, tmp
;
5092 /* This code used to attempt to handle string constants that are not
5093 arrays of single-bytes, but nothing else does, so there's no point in
5095 if (TREE_CODE (val
) == STRING_CST
)
5096 return TREE_STRING_LENGTH (val
);
5098 max_index
= NULL_TREE
;
5099 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val
), cnt
, index
, value
)
5101 if (TREE_CODE (index
) == RANGE_EXPR
)
5102 index
= TREE_OPERAND (index
, 1);
5103 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
5107 if (max_index
== NULL_TREE
)
5110 /* Compute the total number of array elements. */
5111 tmp
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)));
5112 i
= wi::to_offset (max_index
) - wi::to_offset (tmp
) + 1;
5114 /* Multiply by the array element unit size to find number of bytes. */
5115 i
*= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
5117 gcc_assert (wi::fits_uhwi_p (i
));
5118 return i
.to_uhwi ();
5121 /* Other datastructures + helpers for output_constructor. */
5123 /* output_constructor local state to support interaction with helpers. */
5125 struct oc_local_state
{
5127 /* Received arguments. */
5128 tree exp
; /* Constructor expression. */
5129 tree type
; /* Type of constructor expression. */
5130 unsigned HOST_WIDE_INT size
; /* # bytes to output - pad if necessary. */
5131 unsigned int align
; /* Known initial alignment. */
5132 tree min_index
; /* Lower bound if specified for an array. */
5134 /* Output processing state. */
5135 HOST_WIDE_INT total_bytes
; /* # bytes output so far / current position. */
5136 int byte
; /* Part of a bitfield byte yet to be output. */
5137 int last_relative_index
; /* Implicit or explicit index of the last
5138 array element output within a bitfield. */
5139 bool byte_buffer_in_use
; /* Whether BYTE is in use. */
5140 bool reverse
; /* Whether reverse storage order is in use. */
5142 /* Current element. */
5143 tree field
; /* Current field decl in a record. */
5144 tree val
; /* Current element value. */
5145 tree index
; /* Current element index. */
5149 /* Helper for output_constructor. From the current LOCAL state, output a
5150 RANGE_EXPR element. */
5153 output_constructor_array_range (oc_local_state
*local
)
5155 unsigned HOST_WIDE_INT fieldsize
5156 = int_size_in_bytes (TREE_TYPE (local
->type
));
5158 HOST_WIDE_INT lo_index
5159 = tree_to_shwi (TREE_OPERAND (local
->index
, 0));
5160 HOST_WIDE_INT hi_index
5161 = tree_to_shwi (TREE_OPERAND (local
->index
, 1));
5162 HOST_WIDE_INT index
;
5165 = min_align (local
->align
, fieldsize
* BITS_PER_UNIT
);
5167 for (index
= lo_index
; index
<= hi_index
; index
++)
5169 /* Output the element's initial value. */
5170 if (local
->val
== NULL_TREE
)
5171 assemble_zeros (fieldsize
);
5173 fieldsize
= output_constant (local
->val
, fieldsize
, align2
,
5174 local
->reverse
, false);
5176 /* Count its size. */
5177 local
->total_bytes
+= fieldsize
;
5181 /* Helper for output_constructor. From the current LOCAL state, output a
5182 field element that is not true bitfield or part of an outer one. */
5185 output_constructor_regular_field (oc_local_state
*local
)
5187 /* Field size and position. Since this structure is static, we know the
5188 positions are constant. */
5189 unsigned HOST_WIDE_INT fieldsize
;
5190 HOST_WIDE_INT fieldpos
;
5192 unsigned int align2
;
5194 /* Output any buffered-up bit-fields preceding this element. */
5195 if (local
->byte_buffer_in_use
)
5197 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5198 local
->total_bytes
++;
5199 local
->byte_buffer_in_use
= false;
5202 if (local
->index
!= NULL_TREE
)
5204 /* Perform the index calculation in modulo arithmetic but
5205 sign-extend the result because Ada has negative DECL_FIELD_OFFSETs
5206 but we are using an unsigned sizetype. */
5207 unsigned prec
= TYPE_PRECISION (sizetype
);
5208 offset_int idx
= wi::sext (wi::to_offset (local
->index
)
5209 - wi::to_offset (local
->min_index
), prec
);
5210 fieldpos
= (idx
* wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (local
->val
))))
5213 else if (local
->field
!= NULL_TREE
)
5214 fieldpos
= int_byte_position (local
->field
);
5218 /* Advance to offset of this element.
5219 Note no alignment needed in an array, since that is guaranteed
5220 if each element has the proper size. */
5221 if (local
->field
!= NULL_TREE
|| local
->index
!= NULL_TREE
)
5223 if (fieldpos
> local
->total_bytes
)
5225 assemble_zeros (fieldpos
- local
->total_bytes
);
5226 local
->total_bytes
= fieldpos
;
5229 /* Must not go backwards. */
5230 gcc_assert (fieldpos
== local
->total_bytes
);
5233 /* Find the alignment of this element. */
5234 align2
= min_align (local
->align
, BITS_PER_UNIT
* fieldpos
);
5236 /* Determine size this element should occupy. */
5241 /* If this is an array with an unspecified upper bound,
5242 the initializer determines the size. */
5243 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
5244 but we cannot do this until the deprecated support for
5245 initializing zero-length array members is removed. */
5246 if (TREE_CODE (TREE_TYPE (local
->field
)) == ARRAY_TYPE
5247 && (!TYPE_DOMAIN (TREE_TYPE (local
->field
))
5248 || !TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (local
->field
)))))
5250 fieldsize
= array_size_for_constructor (local
->val
);
5251 /* Given a non-empty initialization, this field had better
5252 be last. Given a flexible array member, the next field
5253 on the chain is a TYPE_DECL of the enclosing struct. */
5254 const_tree next
= DECL_CHAIN (local
->field
);
5255 gcc_assert (!fieldsize
|| !next
|| TREE_CODE (next
) != FIELD_DECL
);
5256 tree size
= TYPE_SIZE_UNIT (TREE_TYPE (local
->val
));
5257 gcc_checking_assert (compare_tree_int (size
, fieldsize
) == 0);
5260 fieldsize
= tree_to_uhwi (DECL_SIZE_UNIT (local
->field
));
5263 fieldsize
= int_size_in_bytes (TREE_TYPE (local
->type
));
5265 /* Output the element's initial value. */
5266 if (local
->val
== NULL_TREE
)
5267 assemble_zeros (fieldsize
);
5269 fieldsize
= output_constant (local
->val
, fieldsize
, align2
,
5270 local
->reverse
, false);
5272 /* Count its size. */
5273 local
->total_bytes
+= fieldsize
;
5276 /* Helper for output_constructor. From the LOCAL state, output an element
5277 that is a true bitfield or part of an outer one. BIT_OFFSET is the offset
5278 from the start of a possibly ongoing outer byte buffer. */
5281 output_constructor_bitfield (oc_local_state
*local
, unsigned int bit_offset
)
5283 /* Bit size of this element. */
5284 HOST_WIDE_INT ebitsize
5286 ? tree_to_uhwi (DECL_SIZE (local
->field
))
5287 : tree_to_uhwi (TYPE_SIZE (TREE_TYPE (local
->type
))));
5289 /* Relative index of this element if this is an array component. */
5290 HOST_WIDE_INT relative_index
5293 ? (tree_to_shwi (local
->index
)
5294 - tree_to_shwi (local
->min_index
))
5295 : local
->last_relative_index
+ 1)
5298 /* Bit position of this element from the start of the containing
5300 HOST_WIDE_INT constructor_relative_ebitpos
5302 ? int_bit_position (local
->field
)
5303 : ebitsize
* relative_index
);
5305 /* Bit position of this element from the start of a possibly ongoing
5306 outer byte buffer. */
5307 HOST_WIDE_INT byte_relative_ebitpos
5308 = bit_offset
+ constructor_relative_ebitpos
;
5310 /* From the start of a possibly ongoing outer byte buffer, offsets to
5311 the first bit of this element and to the first bit past the end of
5313 HOST_WIDE_INT next_offset
= byte_relative_ebitpos
;
5314 HOST_WIDE_INT end_offset
= byte_relative_ebitpos
+ ebitsize
;
5316 local
->last_relative_index
= relative_index
;
5318 if (local
->val
== NULL_TREE
)
5319 local
->val
= integer_zero_node
;
5321 while (TREE_CODE (local
->val
) == VIEW_CONVERT_EXPR
5322 || TREE_CODE (local
->val
) == NON_LVALUE_EXPR
)
5323 local
->val
= TREE_OPERAND (local
->val
, 0);
5325 if (TREE_CODE (local
->val
) != INTEGER_CST
5326 && TREE_CODE (local
->val
) != CONSTRUCTOR
)
5328 error ("invalid initial value for member %qE", DECL_NAME (local
->field
));
5332 /* If this field does not start in this (or next) byte, skip some bytes. */
5333 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
5335 /* Output remnant of any bit field in previous bytes. */
5336 if (local
->byte_buffer_in_use
)
5338 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5339 local
->total_bytes
++;
5340 local
->byte_buffer_in_use
= false;
5343 /* If still not at proper byte, advance to there. */
5344 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
5346 gcc_assert (next_offset
/ BITS_PER_UNIT
>= local
->total_bytes
);
5347 assemble_zeros (next_offset
/ BITS_PER_UNIT
- local
->total_bytes
);
5348 local
->total_bytes
= next_offset
/ BITS_PER_UNIT
;
5352 /* Set up the buffer if necessary. */
5353 if (!local
->byte_buffer_in_use
)
5357 local
->byte_buffer_in_use
= true;
5360 /* If this is nested constructor, recurse passing the bit offset and the
5361 pending data, then retrieve the new pending data afterwards. */
5362 if (TREE_CODE (local
->val
) == CONSTRUCTOR
)
5364 oc_outer_state temp_state
;
5365 temp_state
.bit_offset
= next_offset
% BITS_PER_UNIT
;
5366 temp_state
.byte
= local
->byte
;
5368 += output_constructor (local
->val
, 0, 0, local
->reverse
, &temp_state
);
5369 local
->byte
= temp_state
.byte
;
5373 /* Otherwise, we must split the element into pieces that fall within
5374 separate bytes, and combine each byte with previous or following
5376 while (next_offset
< end_offset
)
5380 unsigned HOST_WIDE_INT value
;
5381 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
5382 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
5384 /* Advance from byte to byte within this element when necessary. */
5385 while (next_byte
!= local
->total_bytes
)
5387 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5388 local
->total_bytes
++;
5392 /* Number of bits we can process at once (all part of the same byte). */
5393 this_time
= MIN (end_offset
- next_offset
, BITS_PER_UNIT
- next_bit
);
5394 if (local
->reverse
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5396 /* For big-endian data, take the most significant bits (of the
5397 bits that are significant) first and put them into bytes from
5398 the most significant end. */
5399 shift
= end_offset
- next_offset
- this_time
;
5401 /* Don't try to take a bunch of bits that cross
5402 the word boundary in the INTEGER_CST. We can
5403 only select bits from one element. */
5404 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5405 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5407 const int end
= shift
+ this_time
- 1;
5408 shift
= end
& -HOST_BITS_PER_WIDE_INT
;
5409 this_time
= end
- shift
+ 1;
5412 /* Now get the bits we want to insert. */
5413 value
= wi::extract_uhwi (wi::to_widest (local
->val
),
5416 /* Get the result. This works only when:
5417 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5418 local
->byte
|= value
<< (BITS_PER_UNIT
- this_time
- next_bit
);
5422 /* On little-endian machines, take the least significant bits of
5423 the value first and pack them starting at the least significant
5424 bits of the bytes. */
5425 shift
= next_offset
- byte_relative_ebitpos
;
5427 /* Don't try to take a bunch of bits that cross
5428 the word boundary in the INTEGER_CST. We can
5429 only select bits from one element. */
5430 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5431 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5433 = HOST_BITS_PER_WIDE_INT
- (shift
& (HOST_BITS_PER_WIDE_INT
- 1));
5435 /* Now get the bits we want to insert. */
5436 value
= wi::extract_uhwi (wi::to_widest (local
->val
),
5439 /* Get the result. This works only when:
5440 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5441 local
->byte
|= value
<< next_bit
;
5444 next_offset
+= this_time
;
5445 local
->byte_buffer_in_use
= true;
5449 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
5450 Generate at least SIZE bytes, padding if necessary. OUTER designates the
5451 caller output state of relevance in recursive invocations. */
5453 static unsigned HOST_WIDE_INT
5454 output_constructor (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
,
5455 bool reverse
, oc_outer_state
*outer
)
5457 unsigned HOST_WIDE_INT cnt
;
5458 constructor_elt
*ce
;
5459 oc_local_state local
;
5461 /* Setup our local state to communicate with helpers. */
5463 local
.type
= TREE_TYPE (exp
);
5465 local
.align
= align
;
5466 if (TREE_CODE (local
.type
) == ARRAY_TYPE
&& TYPE_DOMAIN (local
.type
))
5467 local
.min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (local
.type
));
5469 local
.min_index
= integer_zero_node
;
5471 local
.total_bytes
= 0;
5472 local
.byte_buffer_in_use
= outer
!= NULL
;
5473 local
.byte
= outer
? outer
->byte
: 0;
5474 local
.last_relative_index
= -1;
5475 /* The storage order is specified for every aggregate type. */
5476 if (AGGREGATE_TYPE_P (local
.type
))
5477 local
.reverse
= TYPE_REVERSE_STORAGE_ORDER (local
.type
);
5479 local
.reverse
= reverse
;
5481 gcc_assert (HOST_BITS_PER_WIDE_INT
>= BITS_PER_UNIT
);
5483 /* As CE goes through the elements of the constant, FIELD goes through the
5484 structure fields if the constant is a structure. If the constant is a
5485 union, we override this by getting the field from the TREE_LIST element.
5486 But the constant could also be an array. Then FIELD is zero.
5488 There is always a maximum of one element in the chain LINK for unions
5489 (even if the initializer in a source program incorrectly contains
5492 if (TREE_CODE (local
.type
) == RECORD_TYPE
)
5493 local
.field
= TYPE_FIELDS (local
.type
);
5495 local
.field
= NULL_TREE
;
5498 vec_safe_iterate (CONSTRUCTOR_ELTS (exp
), cnt
, &ce
);
5499 cnt
++, local
.field
= local
.field
? DECL_CHAIN (local
.field
) : 0)
5501 local
.val
= ce
->value
;
5502 local
.index
= NULL_TREE
;
5504 /* The element in a union constructor specifies the proper field
5506 if (RECORD_OR_UNION_TYPE_P (local
.type
) && ce
->index
!= NULL_TREE
)
5507 local
.field
= ce
->index
;
5509 else if (TREE_CODE (local
.type
) == ARRAY_TYPE
)
5510 local
.index
= ce
->index
;
5512 if (local
.field
&& flag_verbose_asm
)
5513 fprintf (asm_out_file
, "%s %s:\n",
5515 DECL_NAME (local
.field
)
5516 ? IDENTIFIER_POINTER (DECL_NAME (local
.field
))
5519 /* Eliminate the marker that makes a cast not be an lvalue. */
5520 if (local
.val
!= NULL_TREE
)
5521 STRIP_NOPS (local
.val
);
5523 /* Output the current element, using the appropriate helper ... */
5525 /* For an array slice not part of an outer bitfield. */
5527 && local
.index
!= NULL_TREE
5528 && TREE_CODE (local
.index
) == RANGE_EXPR
)
5529 output_constructor_array_range (&local
);
5531 /* For a field that is neither a true bitfield nor part of an outer one,
5532 known to be at least byte aligned and multiple-of-bytes long. */
5534 && (local
.field
== NULL_TREE
5535 || !CONSTRUCTOR_BITFIELD_P (local
.field
)))
5536 output_constructor_regular_field (&local
);
5538 /* For a true bitfield or part of an outer one. Only INTEGER_CSTs are
5539 supported for scalar fields, so we may need to convert first. */
5542 if (TREE_CODE (local
.val
) == REAL_CST
)
5544 = fold_unary (VIEW_CONVERT_EXPR
,
5545 build_nonstandard_integer_type
5546 (TYPE_PRECISION (TREE_TYPE (local
.val
)), 0),
5548 output_constructor_bitfield (&local
, outer
? outer
->bit_offset
: 0);
5552 /* If we are not at toplevel, save the pending data for our caller.
5553 Otherwise output the pending data and padding zeros as needed. */
5555 outer
->byte
= local
.byte
;
5558 if (local
.byte_buffer_in_use
)
5560 assemble_integer (GEN_INT (local
.byte
), 1, BITS_PER_UNIT
, 1);
5561 local
.total_bytes
++;
5564 if ((unsigned HOST_WIDE_INT
)local
.total_bytes
< local
.size
)
5566 assemble_zeros (local
.size
- local
.total_bytes
);
5567 local
.total_bytes
= local
.size
;
5571 return local
.total_bytes
;
5574 /* Mark DECL as weak. */
5577 mark_weak (tree decl
)
5579 if (DECL_WEAK (decl
))
5582 struct symtab_node
*n
= symtab_node::get (decl
);
5583 if (n
&& n
->refuse_visibility_changes
)
5584 error ("%+qD declared weak after being used", decl
);
5585 DECL_WEAK (decl
) = 1;
5587 if (DECL_RTL_SET_P (decl
)
5588 && MEM_P (DECL_RTL (decl
))
5589 && XEXP (DECL_RTL (decl
), 0)
5590 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
5591 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
5594 /* Merge weak status between NEWDECL and OLDDECL. */
5597 merge_weak (tree newdecl
, tree olddecl
)
5599 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
5601 if (DECL_WEAK (newdecl
) && TARGET_SUPPORTS_WEAK
)
5604 /* We put the NEWDECL on the weak_decls list at some point
5605 and OLDDECL as well. Keep just OLDDECL on the list. */
5606 for (pwd
= &weak_decls
; *pwd
; pwd
= &TREE_CHAIN (*pwd
))
5607 if (TREE_VALUE (*pwd
) == newdecl
)
5609 *pwd
= TREE_CHAIN (*pwd
);
5616 if (DECL_WEAK (newdecl
))
5620 /* NEWDECL is weak, but OLDDECL is not. */
5622 /* If we already output the OLDDECL, we're in trouble; we can't
5623 go back and make it weak. This should never happen in
5624 unit-at-a-time compilation. */
5625 gcc_assert (!TREE_ASM_WRITTEN (olddecl
));
5627 /* If we've already generated rtl referencing OLDDECL, we may
5628 have done so in a way that will not function properly with
5629 a weak symbol. Again in unit-at-a-time this should be
5631 gcc_assert (!TREE_USED (olddecl
)
5632 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)));
5634 /* PR 49899: You cannot convert a static function into a weak, public function. */
5635 if (! TREE_PUBLIC (olddecl
) && TREE_PUBLIC (newdecl
))
5636 error ("weak declaration of %q+D being applied to a already "
5637 "existing, static definition", newdecl
);
5639 if (TARGET_SUPPORTS_WEAK
)
5641 /* We put the NEWDECL on the weak_decls list at some point.
5642 Replace it with the OLDDECL. */
5643 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
5644 if (TREE_VALUE (wd
) == newdecl
)
5646 TREE_VALUE (wd
) = olddecl
;
5649 /* We may not find the entry on the list. If NEWDECL is a
5650 weak alias, then we will have already called
5651 globalize_decl to remove the entry; in that case, we do
5652 not need to do anything. */
5655 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
5656 mark_weak (olddecl
);
5659 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
5660 weak. Just update NEWDECL to indicate that it's weak too. */
5661 mark_weak (newdecl
);
5664 /* Declare DECL to be a weak symbol. */
5667 declare_weak (tree decl
)
5669 gcc_assert (TREE_CODE (decl
) != FUNCTION_DECL
|| !TREE_ASM_WRITTEN (decl
));
5670 if (! TREE_PUBLIC (decl
))
5672 error ("weak declaration of %q+D must be public", decl
);
5675 else if (!TARGET_SUPPORTS_WEAK
)
5676 warning (0, "weak declaration of %q+D not supported", decl
);
5679 if (!lookup_attribute ("weak", DECL_ATTRIBUTES (decl
)))
5680 DECL_ATTRIBUTES (decl
)
5681 = tree_cons (get_identifier ("weak"), NULL
, DECL_ATTRIBUTES (decl
));
5685 weak_finish_1 (tree decl
)
5687 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
5688 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5691 if (! TREE_USED (decl
))
5694 #ifdef ASM_WEAKEN_DECL
5695 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
5697 #ifdef ASM_WEAKEN_LABEL
5698 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5700 #ifdef ASM_OUTPUT_WEAK_ALIAS
5702 static bool warn_once
= 0;
5705 warning (0, "only weak aliases are supported in this configuration");
5715 /* Fiven an assembly name, find the decl it is associated with. */
5717 find_decl (tree target
)
5719 symtab_node
*node
= symtab_node::get_for_asmname (target
);
5725 /* This TREE_LIST contains weakref targets. */
5727 static GTY(()) tree weakref_targets
;
5729 /* Emit any pending weak declarations. */
5736 for (t
= weakref_targets
; t
; t
= TREE_CHAIN (t
))
5738 tree alias_decl
= TREE_PURPOSE (t
);
5739 tree target
= ultimate_transparent_alias_target (&TREE_VALUE (t
));
5741 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl
))
5742 || TREE_SYMBOL_REFERENCED (target
))
5743 /* Remove alias_decl from the weak list, but leave entries for
5744 the target alone. */
5746 #ifndef ASM_OUTPUT_WEAKREF
5747 else if (! TREE_SYMBOL_REFERENCED (target
))
5749 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
5750 defined, otherwise we and weak_finish_1 would use
5751 different macros. */
5752 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
5753 ASM_WEAKEN_LABEL (asm_out_file
, IDENTIFIER_POINTER (target
));
5755 tree decl
= find_decl (target
);
5759 decl
= build_decl (DECL_SOURCE_LOCATION (alias_decl
),
5760 TREE_CODE (alias_decl
), target
,
5761 TREE_TYPE (alias_decl
));
5763 DECL_EXTERNAL (decl
) = 1;
5764 TREE_PUBLIC (decl
) = 1;
5765 DECL_ARTIFICIAL (decl
) = 1;
5766 TREE_NOTHROW (decl
) = TREE_NOTHROW (alias_decl
);
5767 TREE_USED (decl
) = 1;
5770 weak_finish_1 (decl
);
5779 /* Remove the alias and the target from the pending weak list
5780 so that we do not emit any .weak directives for the former,
5781 nor multiple .weak directives for the latter. */
5782 for (p
= &weak_decls
; (t2
= *p
) ; )
5784 if (TREE_VALUE (t2
) == alias_decl
5785 || target
== DECL_ASSEMBLER_NAME (TREE_VALUE (t2
)))
5786 *p
= TREE_CHAIN (t2
);
5788 p
= &TREE_CHAIN (t2
);
5791 /* Remove other weakrefs to the same target, to speed things up. */
5792 for (p
= &TREE_CHAIN (t
); (t2
= *p
) ; )
5794 if (target
== ultimate_transparent_alias_target (&TREE_VALUE (t2
)))
5795 *p
= TREE_CHAIN (t2
);
5797 p
= &TREE_CHAIN (t2
);
5802 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
5804 tree decl
= TREE_VALUE (t
);
5806 weak_finish_1 (decl
);
5810 /* Emit the assembly bits to indicate that DECL is globally visible. */
5813 globalize_decl (tree decl
)
5816 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5817 if (DECL_WEAK (decl
))
5819 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
5822 #ifdef ASM_WEAKEN_DECL
5823 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
5825 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5828 /* Remove this function from the pending weak list so that
5829 we do not emit multiple .weak directives for it. */
5830 for (p
= &weak_decls
; (t
= *p
) ; )
5832 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5833 *p
= TREE_CHAIN (t
);
5835 p
= &TREE_CHAIN (t
);
5838 /* Remove weakrefs to the same target from the pending weakref
5839 list, for the same reason. */
5840 for (p
= &weakref_targets
; (t
= *p
) ; )
5842 if (DECL_ASSEMBLER_NAME (decl
)
5843 == ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5844 *p
= TREE_CHAIN (t
);
5846 p
= &TREE_CHAIN (t
);
5853 targetm
.asm_out
.globalize_decl_name (asm_out_file
, decl
);
5856 vec
<alias_pair
, va_gc
> *alias_pairs
;
5858 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
5859 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
5860 tree node is DECL to have the value of the tree node TARGET. */
5863 do_assemble_alias (tree decl
, tree target
)
5867 /* Emulated TLS had better not get this var. */
5868 gcc_assert (!(!targetm
.have_tls
5870 && DECL_THREAD_LOCAL_P (decl
)));
5872 if (TREE_ASM_WRITTEN (decl
))
5875 id
= DECL_ASSEMBLER_NAME (decl
);
5876 ultimate_transparent_alias_target (&id
);
5877 ultimate_transparent_alias_target (&target
);
5879 /* We must force creation of DECL_RTL for debug info generation, even though
5880 we don't use it here. */
5881 make_decl_rtl (decl
);
5883 TREE_ASM_WRITTEN (decl
) = 1;
5884 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
5885 TREE_ASM_WRITTEN (id
) = 1;
5887 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5889 if (!TREE_SYMBOL_REFERENCED (target
))
5890 weakref_targets
= tree_cons (decl
, target
, weakref_targets
);
5892 #ifdef ASM_OUTPUT_WEAKREF
5893 ASM_OUTPUT_WEAKREF (asm_out_file
, decl
,
5894 IDENTIFIER_POINTER (id
),
5895 IDENTIFIER_POINTER (target
));
5897 if (!TARGET_SUPPORTS_WEAK
)
5899 error_at (DECL_SOURCE_LOCATION (decl
),
5900 "weakref is not supported in this configuration");
5907 #ifdef ASM_OUTPUT_DEF
5908 tree orig_decl
= decl
;
5910 /* Make name accessible from other files, if appropriate. */
5912 if (TREE_PUBLIC (decl
) || TREE_PUBLIC (orig_decl
))
5914 globalize_decl (decl
);
5915 maybe_assemble_visibility (decl
);
5917 if (TREE_CODE (decl
) == FUNCTION_DECL
5918 && cgraph_node::get (decl
)->ifunc_resolver
)
5920 #if defined (ASM_OUTPUT_TYPE_DIRECTIVE)
5921 if (targetm
.has_ifunc_p ())
5922 ASM_OUTPUT_TYPE_DIRECTIVE
5923 (asm_out_file
, IDENTIFIER_POINTER (id
),
5927 error_at (DECL_SOURCE_LOCATION (decl
),
5928 "%qs is not supported on this target", "ifunc");
5931 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
5932 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
5934 ASM_OUTPUT_DEF (asm_out_file
,
5935 IDENTIFIER_POINTER (id
),
5936 IDENTIFIER_POINTER (target
));
5938 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5943 name
= IDENTIFIER_POINTER (id
);
5944 # ifdef ASM_WEAKEN_DECL
5945 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
5947 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
5949 /* Remove this function from the pending weak list so that
5950 we do not emit multiple .weak directives for it. */
5951 for (p
= &weak_decls
; (t
= *p
) ; )
5952 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
))
5953 || id
== DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5954 *p
= TREE_CHAIN (t
);
5956 p
= &TREE_CHAIN (t
);
5958 /* Remove weakrefs to the same target from the pending weakref
5959 list, for the same reason. */
5960 for (p
= &weakref_targets
; (t
= *p
) ; )
5962 if (id
== ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5963 *p
= TREE_CHAIN (t
);
5965 p
= &TREE_CHAIN (t
);
5971 /* Output .symver directive. */
5974 do_assemble_symver (tree decl
, tree target
)
5976 tree id
= DECL_ASSEMBLER_NAME (decl
);
5977 ultimate_transparent_alias_target (&id
);
5978 ultimate_transparent_alias_target (&target
);
5979 #ifdef ASM_OUTPUT_SYMVER_DIRECTIVE
5980 ASM_OUTPUT_SYMVER_DIRECTIVE (asm_out_file
,
5981 IDENTIFIER_POINTER (target
),
5982 IDENTIFIER_POINTER (id
));
5984 error ("symver is only supported on ELF platforms");
5988 /* Emit an assembler directive to make the symbol for DECL an alias to
5989 the symbol for TARGET. */
5992 assemble_alias (tree decl
, tree target
)
5996 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5998 tree alias
= DECL_ASSEMBLER_NAME (decl
);
6000 ultimate_transparent_alias_target (&target
);
6002 if (alias
== target
)
6003 error ("%qs symbol %q+D ultimately targets itself", "weakref", decl
);
6004 if (TREE_PUBLIC (decl
))
6005 error ("%qs symbol %q+D must have static linkage", "weakref", decl
);
6009 #if !defined (ASM_OUTPUT_DEF)
6010 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
6011 error_at (DECL_SOURCE_LOCATION (decl
),
6012 "alias definitions not supported in this configuration");
6013 TREE_ASM_WRITTEN (decl
) = 1;
6016 if (!DECL_WEAK (decl
))
6018 /* NB: ifunc_resolver isn't set when an error is detected. */
6019 if (TREE_CODE (decl
) == FUNCTION_DECL
6020 && lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
6021 error_at (DECL_SOURCE_LOCATION (decl
),
6022 "%qs is not supported in this configuration", "ifunc");
6024 error_at (DECL_SOURCE_LOCATION (decl
),
6025 "only weak aliases are supported in this configuration");
6026 TREE_ASM_WRITTEN (decl
) = 1;
6032 TREE_USED (decl
) = 1;
6034 /* Allow aliases to aliases. */
6035 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6036 cgraph_node::get_create (decl
)->alias
= true;
6038 varpool_node::get_create (decl
)->alias
= true;
6040 /* If the target has already been emitted, we don't have to queue the
6041 alias. This saves a tad of memory. */
6042 if (symtab
->global_info_ready
)
6043 target_decl
= find_decl (target
);
6046 if ((target_decl
&& TREE_ASM_WRITTEN (target_decl
))
6047 || symtab
->state
>= EXPANSION
)
6048 do_assemble_alias (decl
, target
);
6051 alias_pair p
= {decl
, target
};
6052 vec_safe_push (alias_pairs
, p
);
6056 /* Record and output a table of translations from original function
6057 to its transaction aware clone. Note that tm_pure functions are
6058 considered to be their own clone. */
6060 struct tm_clone_hasher
: ggc_cache_ptr_hash
<tree_map
>
6062 static hashval_t
hash (tree_map
*m
) { return tree_map_hash (m
); }
6063 static bool equal (tree_map
*a
, tree_map
*b
) { return tree_map_eq (a
, b
); }
6066 keep_cache_entry (tree_map
*&e
)
6068 return ggc_marked_p (e
->base
.from
);
6072 static GTY((cache
)) hash_table
<tm_clone_hasher
> *tm_clone_hash
;
6075 record_tm_clone_pair (tree o
, tree n
)
6077 struct tree_map
**slot
, *h
;
6079 if (tm_clone_hash
== NULL
)
6080 tm_clone_hash
= hash_table
<tm_clone_hasher
>::create_ggc (32);
6082 h
= ggc_alloc
<tree_map
> ();
6083 h
->hash
= htab_hash_pointer (o
);
6087 slot
= tm_clone_hash
->find_slot_with_hash (h
, h
->hash
, INSERT
);
6092 get_tm_clone_pair (tree o
)
6096 struct tree_map
*h
, in
;
6099 in
.hash
= htab_hash_pointer (o
);
6100 h
= tm_clone_hash
->find_with_hash (&in
, in
.hash
);
6107 struct tm_alias_pair
6115 /* Dump the actual pairs to the .tm_clone_table section. */
6118 dump_tm_clone_pairs (vec
<tm_alias_pair
> tm_alias_pairs
)
6122 bool switched
= false;
6124 FOR_EACH_VEC_ELT (tm_alias_pairs
, i
, p
)
6128 struct cgraph_node
*src_n
= cgraph_node::get (src
);
6129 struct cgraph_node
*dst_n
= cgraph_node::get (dst
);
6131 /* The function ipa_tm_create_version() marks the clone as needed if
6132 the original function was needed. But we also mark the clone as
6133 needed if we ever called the clone indirectly through
6134 TM_GETTMCLONE. If neither of these are true, we didn't generate
6135 a clone, and we didn't call it indirectly... no sense keeping it
6136 in the clone table. */
6137 if (!dst_n
|| !dst_n
->definition
)
6140 /* This covers the case where we have optimized the original
6141 function away, and only access the transactional clone. */
6142 if (!src_n
|| !src_n
->definition
)
6147 switch_to_section (targetm
.asm_out
.tm_clone_table_section ());
6148 assemble_align (POINTER_SIZE
);
6152 assemble_integer (XEXP (DECL_RTL (src
), 0),
6153 POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
6154 assemble_integer (XEXP (DECL_RTL (dst
), 0),
6155 POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
6159 /* Provide a default for the tm_clone_table section. */
6162 default_clone_table_section (void)
6164 return get_named_section (NULL
, ".tm_clone_table", 3);
6167 /* Helper comparison function for qsorting by the DECL_UID stored in
6168 alias_pair->emitted_diags. */
6171 tm_alias_pair_cmp (const void *x
, const void *y
)
6173 const tm_alias_pair
*p1
= (const tm_alias_pair
*) x
;
6174 const tm_alias_pair
*p2
= (const tm_alias_pair
*) y
;
6175 if (p1
->uid
< p2
->uid
)
6177 if (p1
->uid
> p2
->uid
)
6183 finish_tm_clone_pairs (void)
6185 vec
<tm_alias_pair
> tm_alias_pairs
= vNULL
;
6187 if (tm_clone_hash
== NULL
)
6190 /* We need a determenistic order for the .tm_clone_table, otherwise
6191 we will get bootstrap comparison failures, so dump the hash table
6192 to a vector, sort it, and dump the vector. */
6194 /* Dump the hashtable to a vector. */
6196 hash_table
<tm_clone_hasher
>::iterator iter
;
6197 FOR_EACH_HASH_TABLE_ELEMENT (*tm_clone_hash
, map
, tree_map
*, iter
)
6199 tm_alias_pair p
= {DECL_UID (map
->base
.from
), map
->base
.from
, map
->to
};
6200 tm_alias_pairs
.safe_push (p
);
6203 tm_alias_pairs
.qsort (tm_alias_pair_cmp
);
6206 dump_tm_clone_pairs (tm_alias_pairs
);
6208 tm_clone_hash
->empty ();
6209 tm_clone_hash
= NULL
;
6210 tm_alias_pairs
.release ();
6214 /* Emit an assembler directive to set symbol for DECL visibility to
6215 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
6218 default_assemble_visibility (tree decl ATTRIBUTE_UNUSED
,
6219 int vis ATTRIBUTE_UNUSED
)
6221 #ifdef HAVE_GAS_HIDDEN
6222 static const char * const visibility_types
[] = {
6223 NULL
, "protected", "hidden", "internal"
6226 const char *name
, *type
;
6229 id
= DECL_ASSEMBLER_NAME (decl
);
6230 ultimate_transparent_alias_target (&id
);
6231 name
= IDENTIFIER_POINTER (id
);
6233 type
= visibility_types
[vis
];
6235 fprintf (asm_out_file
, "\t.%s\t", type
);
6236 assemble_name (asm_out_file
, name
);
6237 fprintf (asm_out_file
, "\n");
6239 if (!DECL_ARTIFICIAL (decl
))
6240 warning (OPT_Wattributes
, "visibility attribute not supported "
6241 "in this configuration; ignored");
6245 /* A helper function to call assemble_visibility when needed for a decl. */
6248 maybe_assemble_visibility (tree decl
)
6250 enum symbol_visibility vis
= DECL_VISIBILITY (decl
);
6251 if (vis
!= VISIBILITY_DEFAULT
)
6253 targetm
.asm_out
.assemble_visibility (decl
, vis
);
6260 /* Returns 1 if the target configuration supports defining public symbols
6261 so that one of them will be chosen at link time instead of generating a
6262 multiply-defined symbol error, whether through the use of weak symbols or
6263 a target-specific mechanism for having duplicates discarded. */
6266 supports_one_only (void)
6268 if (SUPPORTS_ONE_ONLY
)
6270 return TARGET_SUPPORTS_WEAK
;
6273 /* Set up DECL as a public symbol that can be defined in multiple
6274 translation units without generating a linker error. */
6277 make_decl_one_only (tree decl
, tree comdat_group
)
6279 struct symtab_node
*symbol
;
6280 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
6282 TREE_PUBLIC (decl
) = 1;
6285 symbol
= varpool_node::get_create (decl
);
6287 symbol
= cgraph_node::get_create (decl
);
6289 if (SUPPORTS_ONE_ONLY
)
6291 #ifdef MAKE_DECL_ONE_ONLY
6292 MAKE_DECL_ONE_ONLY (decl
);
6294 symbol
->set_comdat_group (comdat_group
);
6296 else if (VAR_P (decl
)
6297 && (DECL_INITIAL (decl
) == 0
6298 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
6299 DECL_COMMON (decl
) = 1;
6302 gcc_assert (TARGET_SUPPORTS_WEAK
);
6303 DECL_WEAK (decl
) = 1;
6308 init_varasm_once (void)
6310 section_htab
= hash_table
<section_hasher
>::create_ggc (31);
6311 object_block_htab
= hash_table
<object_block_hasher
>::create_ggc (31);
6312 const_desc_htab
= hash_table
<tree_descriptor_hasher
>::create_ggc (1009);
6314 shared_constant_pool
= create_constant_pool ();
6316 #ifdef TEXT_SECTION_ASM_OP
6317 text_section
= get_unnamed_section (SECTION_CODE
, output_section_asm_op
,
6318 TEXT_SECTION_ASM_OP
);
6321 #ifdef DATA_SECTION_ASM_OP
6322 data_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
6323 DATA_SECTION_ASM_OP
);
6326 #ifdef SDATA_SECTION_ASM_OP
6327 sdata_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
6328 SDATA_SECTION_ASM_OP
);
6331 #ifdef READONLY_DATA_SECTION_ASM_OP
6332 readonly_data_section
= get_unnamed_section (0, output_section_asm_op
,
6333 READONLY_DATA_SECTION_ASM_OP
);
6336 #ifdef CTORS_SECTION_ASM_OP
6337 ctors_section
= get_unnamed_section (0, output_section_asm_op
,
6338 CTORS_SECTION_ASM_OP
);
6341 #ifdef DTORS_SECTION_ASM_OP
6342 dtors_section
= get_unnamed_section (0, output_section_asm_op
,
6343 DTORS_SECTION_ASM_OP
);
6346 #ifdef BSS_SECTION_ASM_OP
6347 bss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
6348 output_section_asm_op
,
6349 BSS_SECTION_ASM_OP
);
6352 #ifdef SBSS_SECTION_ASM_OP
6353 sbss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
6354 output_section_asm_op
,
6355 SBSS_SECTION_ASM_OP
);
6358 tls_comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6359 | SECTION_COMMON
, emit_tls_common
);
6360 lcomm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6361 | SECTION_COMMON
, emit_local
);
6362 comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6363 | SECTION_COMMON
, emit_common
);
6365 #if defined ASM_OUTPUT_ALIGNED_BSS
6366 bss_noswitch_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
,
6370 targetm
.asm_out
.init_sections ();
6372 if (readonly_data_section
== NULL
)
6373 readonly_data_section
= text_section
;
6375 #ifdef ASM_OUTPUT_EXTERNAL
6376 pending_assemble_externals_set
= new hash_set
<tree
>;
6381 decl_default_tls_model (const_tree decl
)
6383 enum tls_model kind
;
6386 is_local
= targetm
.binds_local_p (decl
);
6390 kind
= TLS_MODEL_LOCAL_EXEC
;
6392 kind
= TLS_MODEL_INITIAL_EXEC
;
6395 /* Local dynamic is inefficient when we're not combining the
6396 parts of the address. */
6397 else if (optimize
&& is_local
)
6398 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
6400 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6401 if (kind
< flag_tls_default
)
6402 kind
= flag_tls_default
;
6407 /* Select a set of attributes for section NAME based on the properties
6408 of DECL and whether or not RELOC indicates that DECL's initializer
6409 might contain runtime relocations.
6411 We make the section read-only and executable for a function decl,
6412 read-only for a const data decl, and writable for a non-const data decl. */
6415 default_section_type_flags (tree decl
, const char *name
, int reloc
)
6419 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6420 flags
= SECTION_CODE
;
6423 enum section_category category
6424 = categorize_decl_for_section (decl
, reloc
);
6425 if (decl_readonly_section_1 (category
))
6427 else if (category
== SECCAT_DATA_REL_RO
6428 || category
== SECCAT_DATA_REL_RO_LOCAL
)
6429 flags
= SECTION_WRITE
| SECTION_RELRO
;
6431 flags
= SECTION_WRITE
;
6435 flags
= SECTION_WRITE
;
6436 if (strcmp (name
, ".data.rel.ro") == 0
6437 || strcmp (name
, ".data.rel.ro.local") == 0)
6438 flags
|= SECTION_RELRO
;
6441 if (decl
&& DECL_P (decl
) && DECL_COMDAT_GROUP (decl
))
6442 flags
|= SECTION_LINKONCE
;
6444 if (strcmp (name
, ".vtable_map_vars") == 0)
6445 flags
|= SECTION_LINKONCE
;
6447 if (decl
&& VAR_P (decl
) && DECL_THREAD_LOCAL_P (decl
))
6448 flags
|= SECTION_TLS
| SECTION_WRITE
;
6450 if (strcmp (name
, ".bss") == 0
6451 || strncmp (name
, ".bss.", 5) == 0
6452 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
6453 || strcmp (name
, ".persistent.bss") == 0
6454 || strcmp (name
, ".sbss") == 0
6455 || strncmp (name
, ".sbss.", 6) == 0
6456 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
6457 flags
|= SECTION_BSS
;
6459 if (strcmp (name
, ".tdata") == 0
6460 || strncmp (name
, ".tdata.", 7) == 0
6461 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0)
6462 flags
|= SECTION_TLS
;
6464 if (strcmp (name
, ".tbss") == 0
6465 || strncmp (name
, ".tbss.", 6) == 0
6466 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
6467 flags
|= SECTION_TLS
| SECTION_BSS
;
6469 if (strcmp (name
, ".noinit") == 0)
6470 flags
|= SECTION_WRITE
| SECTION_BSS
| SECTION_NOTYPE
;
6472 /* Various sections have special ELF types that the assembler will
6473 assign by default based on the name. They are neither SHT_PROGBITS
6474 nor SHT_NOBITS, so when changing sections we don't want to print a
6475 section type (@progbits or @nobits). Rather than duplicating the
6476 assembler's knowledge of what those special name patterns are, just
6477 let the assembler choose the type if we don't know a specific
6478 reason to set it to something other than the default. SHT_PROGBITS
6479 is the default for sections whose name is not specially known to
6480 the assembler, so it does no harm to leave the choice to the
6481 assembler when @progbits is the best thing we know to use. If
6482 someone is silly enough to emit code or TLS variables to one of
6483 these sections, then don't handle them specially.
6485 default_elf_asm_named_section (below) handles the BSS, TLS, ENTSIZE, and
6486 LINKONCE cases when NOTYPE is not set, so leave those to its logic. */
6487 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
| SECTION_ENTSIZE
))
6488 && !(HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
)))
6489 flags
|= SECTION_NOTYPE
;
6494 /* Return true if the target supports some form of global BSS,
6495 either through bss_noswitch_section, or by selecting a BSS
6496 section in TARGET_ASM_SELECT_SECTION. */
6499 have_global_bss_p (void)
6501 return bss_noswitch_section
|| targetm
.have_switchable_bss_sections
;
6504 /* Output assembly to switch to section NAME with attribute FLAGS.
6505 Four variants for common object file formats. */
6508 default_no_named_section (const char *name ATTRIBUTE_UNUSED
,
6509 unsigned int flags ATTRIBUTE_UNUSED
,
6510 tree decl ATTRIBUTE_UNUSED
)
6512 /* Some object formats don't support named sections at all. The
6513 front-end should already have flagged this as an error. */
6517 #ifndef TLS_SECTION_ASM_FLAG
6518 #define TLS_SECTION_ASM_FLAG 'T'
6522 default_elf_asm_named_section (const char *name
, unsigned int flags
,
6525 char flagchars
[11], *f
= flagchars
;
6526 unsigned int numeric_value
= 0;
6528 /* If we have already declared this section, we can use an
6529 abbreviated form to switch back to it -- unless this section is
6530 part of a COMDAT groups, in which case GAS requires the full
6531 declaration every time. */
6532 if (!(HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6533 && (flags
& SECTION_DECLARED
))
6535 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
6539 /* If we have a machine specific flag, then use the numeric value to pass
6541 if (targetm
.asm_out
.elf_flags_numeric (flags
, &numeric_value
))
6542 snprintf (f
, sizeof (flagchars
), "0x%08x", numeric_value
);
6545 if (!(flags
& SECTION_DEBUG
))
6547 #if HAVE_GAS_SECTION_EXCLUDE
6548 if (flags
& SECTION_EXCLUDE
)
6551 if (flags
& SECTION_WRITE
)
6553 if (flags
& SECTION_CODE
)
6555 if (flags
& SECTION_SMALL
)
6557 if (flags
& SECTION_MERGE
)
6559 if (flags
& SECTION_STRINGS
)
6561 if (flags
& SECTION_TLS
)
6562 *f
++ = TLS_SECTION_ASM_FLAG
;
6563 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6565 #ifdef MACH_DEP_SECTION_ASM_FLAG
6566 if (flags
& SECTION_MACH_DEP
)
6567 *f
++ = MACH_DEP_SECTION_ASM_FLAG
;
6572 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
6574 /* default_section_type_flags (above) knows which flags need special
6575 handling here, and sets NOTYPE when none of these apply so that the
6576 assembler's logic for default types can apply to user-chosen
6578 if (!(flags
& SECTION_NOTYPE
))
6583 if (flags
& SECTION_BSS
)
6589 /* On platforms that use "@" as the assembly comment character,
6591 if (strcmp (ASM_COMMENT_START
, "@") == 0)
6593 fprintf (asm_out_file
, format
, type
);
6595 if (flags
& SECTION_ENTSIZE
)
6596 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
6597 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6599 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6600 fprintf (asm_out_file
, ",%s,comdat", IDENTIFIER_POINTER (decl
));
6602 fprintf (asm_out_file
, ",%s,comdat",
6603 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl
)));
6607 putc ('\n', asm_out_file
);
6611 default_coff_asm_named_section (const char *name
, unsigned int flags
,
6612 tree decl ATTRIBUTE_UNUSED
)
6614 char flagchars
[8], *f
= flagchars
;
6616 if (flags
& SECTION_WRITE
)
6618 if (flags
& SECTION_CODE
)
6622 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
6626 default_pe_asm_named_section (const char *name
, unsigned int flags
,
6629 default_coff_asm_named_section (name
, flags
, decl
);
6631 if (flags
& SECTION_LINKONCE
)
6633 /* Functions may have been compiled at various levels of
6634 optimization so we can't use `same_size' here.
6635 Instead, have the linker pick one. */
6636 fprintf (asm_out_file
, "\t.linkonce %s\n",
6637 (flags
& SECTION_CODE
? "discard" : "same_size"));
6641 /* The lame default section selector. */
6644 default_select_section (tree decl
, int reloc
,
6645 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6649 if (decl_readonly_section (decl
, reloc
))
6650 return readonly_data_section
;
6652 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6654 if (! ((flag_pic
&& reloc
)
6655 || !TREE_READONLY (decl
)
6656 || TREE_SIDE_EFFECTS (decl
)
6657 || !TREE_CONSTANT (decl
)))
6658 return readonly_data_section
;
6660 else if (TREE_CODE (decl
) == STRING_CST
)
6661 return readonly_data_section
;
6662 else if (! (flag_pic
&& reloc
))
6663 return readonly_data_section
;
6665 return data_section
;
6668 enum section_category
6669 categorize_decl_for_section (const_tree decl
, int reloc
)
6671 enum section_category ret
;
6673 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6675 else if (TREE_CODE (decl
) == STRING_CST
)
6677 if ((flag_sanitize
& SANITIZE_ADDRESS
)
6678 && asan_protect_global (CONST_CAST_TREE (decl
)))
6679 /* or !flag_merge_constants */
6680 return SECCAT_RODATA
;
6682 return SECCAT_RODATA_MERGE_STR
;
6684 else if (VAR_P (decl
))
6686 tree d
= CONST_CAST_TREE (decl
);
6687 if (bss_initializer_p (decl
))
6689 else if (! TREE_READONLY (decl
)
6690 || TREE_SIDE_EFFECTS (decl
)
6691 || (DECL_INITIAL (decl
)
6692 && ! TREE_CONSTANT (DECL_INITIAL (decl
))))
6694 /* Here the reloc_rw_mask is not testing whether the section should
6695 be read-only or not, but whether the dynamic link will have to
6696 do something. If so, we wish to segregate the data in order to
6697 minimize cache misses inside the dynamic linker. */
6698 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6699 ret
= reloc
== 1 ? SECCAT_DATA_REL_LOCAL
: SECCAT_DATA_REL
;
6703 else if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6704 ret
= reloc
== 1 ? SECCAT_DATA_REL_RO_LOCAL
: SECCAT_DATA_REL_RO
;
6705 else if (reloc
|| flag_merge_constants
< 2
6706 || ((flag_sanitize
& SANITIZE_ADDRESS
)
6707 /* PR 81697: for architectures that use section anchors we
6708 need to ignore DECL_RTL_SET_P (decl) for string constants
6709 inside this asan_protect_global call because otherwise
6710 we'll wrongly put them into SECCAT_RODATA_MERGE_CONST
6711 section, set DECL_RTL (decl) later on and add DECL to
6712 protected globals via successive asan_protect_global
6713 calls. In this scenario we'll end up with wrong
6714 alignment of these strings at runtime and possible ASan
6716 && asan_protect_global (d
, use_object_blocks_p ()
6717 && use_blocks_for_decl_p (d
))))
6718 /* C and C++ don't allow different variables to share the same
6719 location. -fmerge-all-constants allows even that (at the
6720 expense of not conforming). */
6721 ret
= SECCAT_RODATA
;
6722 else if (DECL_INITIAL (decl
)
6723 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
6724 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
6726 ret
= SECCAT_RODATA_MERGE_CONST
;
6728 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6730 if ((reloc
& targetm
.asm_out
.reloc_rw_mask ())
6731 || TREE_SIDE_EFFECTS (decl
)
6732 || ! TREE_CONSTANT (decl
))
6735 ret
= SECCAT_RODATA
;
6738 ret
= SECCAT_RODATA
;
6740 /* There are no read-only thread-local sections. */
6741 if (VAR_P (decl
) && DECL_THREAD_LOCAL_P (decl
))
6743 /* Note that this would be *just* SECCAT_BSS, except that there's
6744 no concept of a read-only thread-local-data section. */
6745 if (ret
== SECCAT_BSS
6746 || DECL_INITIAL (decl
) == NULL
6747 || (flag_zero_initialized_in_bss
6748 && initializer_zerop (DECL_INITIAL (decl
))))
6754 /* If the target uses small data sections, select it. */
6755 else if (targetm
.in_small_data_p (decl
))
6757 if (ret
== SECCAT_BSS
)
6759 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
6760 ret
= SECCAT_SRODATA
;
6769 decl_readonly_section_1 (enum section_category category
)
6774 case SECCAT_RODATA_MERGE_STR
:
6775 case SECCAT_RODATA_MERGE_STR_INIT
:
6776 case SECCAT_RODATA_MERGE_CONST
:
6777 case SECCAT_SRODATA
:
6785 decl_readonly_section (const_tree decl
, int reloc
)
6787 return decl_readonly_section_1 (categorize_decl_for_section (decl
, reloc
));
6790 /* Select a section based on the above categorization. */
6793 default_elf_select_section (tree decl
, int reloc
,
6794 unsigned HOST_WIDE_INT align
)
6798 switch (categorize_decl_for_section (decl
, reloc
))
6801 /* We're not supposed to be called on FUNCTION_DECLs. */
6804 return readonly_data_section
;
6805 case SECCAT_RODATA_MERGE_STR
:
6806 return mergeable_string_section (decl
, align
, 0);
6807 case SECCAT_RODATA_MERGE_STR_INIT
:
6808 return mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
6809 case SECCAT_RODATA_MERGE_CONST
:
6810 return mergeable_constant_section (DECL_MODE (decl
), align
, 0);
6811 case SECCAT_SRODATA
:
6815 return data_section
;
6816 case SECCAT_DATA_REL
:
6817 sname
= ".data.rel";
6819 case SECCAT_DATA_REL_LOCAL
:
6820 sname
= ".data.rel.local";
6822 case SECCAT_DATA_REL_RO
:
6823 sname
= ".data.rel.ro";
6825 case SECCAT_DATA_REL_RO_LOCAL
:
6826 sname
= ".data.rel.ro.local";
6836 && lookup_attribute ("noinit", DECL_ATTRIBUTES (decl
)) != NULL_TREE
)
6856 return get_named_section (decl
, sname
, reloc
);
6859 /* Construct a unique section name based on the decl name and the
6860 categorization performed above. */
6863 default_unique_section (tree decl
, int reloc
)
6865 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
6866 bool one_only
= DECL_ONE_ONLY (decl
) && !HAVE_COMDAT_GROUP
;
6867 const char *prefix
, *name
, *linkonce
;
6871 switch (categorize_decl_for_section (decl
, reloc
))
6874 prefix
= one_only
? ".t" : ".text";
6877 case SECCAT_RODATA_MERGE_STR
:
6878 case SECCAT_RODATA_MERGE_STR_INIT
:
6879 case SECCAT_RODATA_MERGE_CONST
:
6880 prefix
= one_only
? ".r" : ".rodata";
6882 case SECCAT_SRODATA
:
6883 prefix
= one_only
? ".s2" : ".sdata2";
6886 prefix
= one_only
? ".d" : ".data";
6888 case SECCAT_DATA_REL
:
6889 prefix
= one_only
? ".d.rel" : ".data.rel";
6891 case SECCAT_DATA_REL_LOCAL
:
6892 prefix
= one_only
? ".d.rel.local" : ".data.rel.local";
6894 case SECCAT_DATA_REL_RO
:
6895 prefix
= one_only
? ".d.rel.ro" : ".data.rel.ro";
6897 case SECCAT_DATA_REL_RO_LOCAL
:
6898 prefix
= one_only
? ".d.rel.ro.local" : ".data.rel.ro.local";
6901 prefix
= one_only
? ".s" : ".sdata";
6904 prefix
= one_only
? ".b" : ".bss";
6907 prefix
= one_only
? ".sb" : ".sbss";
6910 prefix
= one_only
? ".td" : ".tdata";
6913 prefix
= one_only
? ".tb" : ".tbss";
6919 id
= DECL_ASSEMBLER_NAME (decl
);
6920 ultimate_transparent_alias_target (&id
);
6921 name
= IDENTIFIER_POINTER (id
);
6922 name
= targetm
.strip_name_encoding (name
);
6924 /* If we're using one_only, then there needs to be a .gnu.linkonce
6925 prefix to the section name. */
6926 linkonce
= one_only
? ".gnu.linkonce" : "";
6928 string
= ACONCAT ((linkonce
, prefix
, ".", name
, NULL
));
6930 set_decl_section_name (decl
, string
);
6933 /* Subroutine of compute_reloc_for_rtx for leaf rtxes. */
6936 compute_reloc_for_rtx_1 (const_rtx x
)
6938 switch (GET_CODE (x
))
6941 return SYMBOL_REF_LOCAL_P (x
) ? 1 : 2;
6949 /* Like compute_reloc_for_constant, except for an RTX. The return value
6950 is a mask for which bit 1 indicates a global relocation, and bit 0
6951 indicates a local relocation. */
6954 compute_reloc_for_rtx (const_rtx x
)
6956 switch (GET_CODE (x
))
6960 return compute_reloc_for_rtx_1 (x
);
6965 subrtx_iterator::array_type array
;
6966 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
6967 reloc
|= compute_reloc_for_rtx_1 (*iter
);
6977 default_select_rtx_section (machine_mode mode ATTRIBUTE_UNUSED
,
6979 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6981 if (compute_reloc_for_rtx (x
) & targetm
.asm_out
.reloc_rw_mask ())
6982 return data_section
;
6984 return readonly_data_section
;
6988 default_elf_select_rtx_section (machine_mode mode
, rtx x
,
6989 unsigned HOST_WIDE_INT align
)
6991 int reloc
= compute_reloc_for_rtx (x
);
6993 /* ??? Handle small data here somehow. */
6995 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6998 return get_named_section (NULL
, ".data.rel.ro.local", 1);
7000 return get_named_section (NULL
, ".data.rel.ro", 3);
7003 return mergeable_constant_section (mode
, align
, 0);
7006 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
7009 default_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
7014 /* Careful not to prod global register variables. */
7017 symbol
= XEXP (rtl
, 0);
7018 if (GET_CODE (symbol
) != SYMBOL_REF
)
7021 flags
= SYMBOL_REF_FLAGS (symbol
) & SYMBOL_FLAG_HAS_BLOCK_INFO
;
7022 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7023 flags
|= SYMBOL_FLAG_FUNCTION
;
7024 if (targetm
.binds_local_p (decl
))
7025 flags
|= SYMBOL_FLAG_LOCAL
;
7026 if (VAR_P (decl
) && DECL_THREAD_LOCAL_P (decl
))
7027 flags
|= DECL_TLS_MODEL (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
7028 else if (targetm
.in_small_data_p (decl
))
7029 flags
|= SYMBOL_FLAG_SMALL
;
7030 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
7031 being PUBLIC, the thing *must* be defined in this translation unit.
7032 Prevent this buglet from being propagated into rtl code as well. */
7033 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
7034 flags
|= SYMBOL_FLAG_EXTERNAL
;
7036 SYMBOL_REF_FLAGS (symbol
) = flags
;
7039 /* By default, we do nothing for encode_section_info, so we need not
7040 do anything but discard the '*' marker. */
7043 default_strip_name_encoding (const char *str
)
7045 return str
+ (*str
== '*');
7048 #ifdef ASM_OUTPUT_DEF
7049 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
7050 anchor relative to ".", the current section position. */
7053 default_asm_output_anchor (rtx symbol
)
7057 sprintf (buffer
, "*. + " HOST_WIDE_INT_PRINT_DEC
,
7058 SYMBOL_REF_BLOCK_OFFSET (symbol
));
7059 ASM_OUTPUT_DEF (asm_out_file
, XSTR (symbol
, 0), buffer
);
7063 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
7066 default_use_anchors_for_symbol_p (const_rtx symbol
)
7069 section
*sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
7071 /* This function should only be called with non-zero SYMBOL_REF_BLOCK,
7072 furthermore get_block_for_section should not create object blocks
7073 for mergeable sections. */
7074 gcc_checking_assert (sect
&& !(sect
->common
.flags
& SECTION_MERGE
));
7076 /* Don't use anchors for small data sections. The small data register
7077 acts as an anchor for such sections. */
7078 if (sect
->common
.flags
& SECTION_SMALL
)
7081 decl
= SYMBOL_REF_DECL (symbol
);
7082 if (decl
&& DECL_P (decl
))
7084 /* Don't use section anchors for decls that might be defined or
7085 usurped by other modules. */
7086 if (TREE_PUBLIC (decl
) && !decl_binds_to_current_def_p (decl
))
7089 /* Don't use section anchors for decls that will be placed in a
7090 small data section. */
7091 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
7092 one above. The problem is that we only use SECTION_SMALL for
7093 sections that should be marked as small in the section directive. */
7094 if (targetm
.in_small_data_p (decl
))
7097 /* Don't use section anchors for decls that won't fit inside a single
7098 anchor range to reduce the amount of instructions required to refer
7099 to the entire declaration. */
7100 if (DECL_SIZE_UNIT (decl
) == NULL_TREE
7101 || !tree_fits_uhwi_p (DECL_SIZE_UNIT (decl
))
7102 || (tree_to_uhwi (DECL_SIZE_UNIT (decl
))
7103 >= (unsigned HOST_WIDE_INT
) targetm
.max_anchor_offset
))
7110 /* Return true when RESOLUTION indicate that symbol will be bound to the
7111 definition provided by current .o file. */
7114 resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution
)
7116 return (resolution
== LDPR_PREVAILING_DEF
7117 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
7118 || resolution
== LDPR_PREVAILING_DEF_IRONLY
);
7121 /* Return true when RESOLUTION indicate that symbol will be bound locally
7122 within current executable or DSO. */
7125 resolution_local_p (enum ld_plugin_symbol_resolution resolution
)
7127 return (resolution
== LDPR_PREVAILING_DEF
7128 || resolution
== LDPR_PREVAILING_DEF_IRONLY
7129 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
7130 || resolution
== LDPR_PREEMPTED_REG
7131 || resolution
== LDPR_PREEMPTED_IR
7132 || resolution
== LDPR_RESOLVED_IR
7133 || resolution
== LDPR_RESOLVED_EXEC
);
7136 /* COMMON_LOCAL_P is true means that the linker can guarantee that an
7137 uninitialized common symbol in the executable will still be defined
7138 (through COPY relocation) in the executable. */
7141 default_binds_local_p_3 (const_tree exp
, bool shlib
, bool weak_dominate
,
7142 bool extern_protected_data
, bool common_local_p
)
7144 /* A non-decl is an entry in the constant pool. */
7148 /* Weakrefs may not bind locally, even though the weakref itself is always
7149 static and therefore local. Similarly, the resolver for ifunc functions
7150 might resolve to a non-local function.
7151 FIXME: We can resolve the weakref case more curefuly by looking at the
7153 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp
))
7154 || (TREE_CODE (exp
) == FUNCTION_DECL
7155 && cgraph_node::get (exp
)
7156 && cgraph_node::get (exp
)->ifunc_resolver
))
7159 /* Static variables are always local. */
7160 if (! TREE_PUBLIC (exp
))
7163 /* With resolution file in hand, take look into resolutions.
7164 We can't just return true for resolved_locally symbols,
7165 because dynamic linking might overwrite symbols
7166 in shared libraries. */
7167 bool resolved_locally
= false;
7169 bool uninited_common
= (DECL_COMMON (exp
)
7170 && (DECL_INITIAL (exp
) == NULL
7172 && DECL_INITIAL (exp
) == error_mark_node
)));
7174 /* A non-external variable is defined locally only if it isn't
7175 uninitialized COMMON variable or common_local_p is true. */
7176 bool defined_locally
= (!DECL_EXTERNAL (exp
)
7177 && (!uninited_common
|| common_local_p
));
7178 if (symtab_node
*node
= symtab_node::get (exp
))
7180 if (node
->in_other_partition
)
7181 defined_locally
= true;
7182 if (node
->can_be_discarded_p ())
7184 else if (resolution_to_local_definition_p (node
->resolution
))
7185 defined_locally
= resolved_locally
= true;
7186 else if (resolution_local_p (node
->resolution
))
7187 resolved_locally
= true;
7189 if (defined_locally
&& weak_dominate
&& !shlib
)
7190 resolved_locally
= true;
7192 /* Undefined weak symbols are never defined locally. */
7193 if (DECL_WEAK (exp
) && !defined_locally
)
7196 /* A symbol is local if the user has said explicitly that it will be,
7197 or if we have a definition for the symbol. We cannot infer visibility
7198 for undefined symbols. */
7199 if (DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
7200 && (TREE_CODE (exp
) == FUNCTION_DECL
7201 || !extern_protected_data
7202 || DECL_VISIBILITY (exp
) != VISIBILITY_PROTECTED
)
7203 && (DECL_VISIBILITY_SPECIFIED (exp
) || defined_locally
))
7206 /* If PIC, then assume that any global name can be overridden by
7207 symbols resolved from other modules. */
7211 /* Variables defined outside this object might not be local. */
7212 if (DECL_EXTERNAL (exp
) && !resolved_locally
)
7215 /* Non-dominant weak symbols are not defined locally. */
7216 if (DECL_WEAK (exp
) && !resolved_locally
)
7219 /* Uninitialized COMMON variable may be unified with symbols
7220 resolved from other modules. */
7221 if (uninited_common
&& !resolved_locally
)
7224 /* Otherwise we're left with initialized (or non-common) global data
7225 which is of necessity defined locally. */
7229 /* Assume ELF-ish defaults, since that's pretty much the most liberal
7230 wrt cross-module name binding. */
7233 default_binds_local_p (const_tree exp
)
7235 return default_binds_local_p_3 (exp
, flag_shlib
!= 0, true, false, false);
7238 /* Similar to default_binds_local_p, but common symbol may be local and
7239 extern protected data is non-local. */
7242 default_binds_local_p_2 (const_tree exp
)
7244 return default_binds_local_p_3 (exp
, flag_shlib
!= 0, true, true,
7249 default_binds_local_p_1 (const_tree exp
, int shlib
)
7251 return default_binds_local_p_3 (exp
, shlib
!= 0, false, false, false);
7254 /* Return true when references to DECL must bind to current definition in
7257 The condition is usually equivalent to whether the function binds to the
7258 current module (shared library or executable), that is to binds_local_p.
7259 We use this fact to avoid need for another target hook and implement
7260 the logic using binds_local_p and just special cases where
7261 decl_binds_to_current_def_p is stronger than binds_local_p. In particular
7262 the weak definitions (that can be overwritten at linktime by other
7263 definition from different object file) and when resolution info is available
7264 we simply use the knowledge passed to us by linker plugin. */
7266 decl_binds_to_current_def_p (const_tree decl
)
7268 gcc_assert (DECL_P (decl
));
7269 if (!targetm
.binds_local_p (decl
))
7271 if (!TREE_PUBLIC (decl
))
7274 /* When resolution is available, just use it. */
7275 if (symtab_node
*node
= symtab_node::get (decl
))
7277 if (node
->resolution
!= LDPR_UNKNOWN
7278 && !node
->can_be_discarded_p ())
7279 return resolution_to_local_definition_p (node
->resolution
);
7282 /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
7283 binds locally but still can be overwritten), DECL_COMMON (can be merged
7284 with a non-common definition somewhere in the same module) or
7286 This rely on fact that binds_local_p behave as decl_replaceable_p
7287 for all other declaration types. */
7288 if (DECL_WEAK (decl
))
7290 if (DECL_COMMON (decl
)
7291 && (DECL_INITIAL (decl
) == NULL
7292 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
7294 if (DECL_EXTERNAL (decl
))
7299 /* A replaceable function or variable is one which may be replaced
7300 at link-time with an entirely different definition, provided that the
7301 replacement has the same type. For example, functions declared
7302 with __attribute__((weak)) on most systems are replaceable.
7304 COMDAT functions are not replaceable, since all definitions of the
7305 function must be equivalent. It is important that COMDAT functions
7306 not be treated as replaceable so that use of C++ template
7307 instantiations is not penalized. */
7310 decl_replaceable_p (tree decl
)
7312 gcc_assert (DECL_P (decl
));
7313 if (!TREE_PUBLIC (decl
) || DECL_COMDAT (decl
))
7315 if (!flag_semantic_interposition
7316 && !DECL_WEAK (decl
))
7318 return !decl_binds_to_current_def_p (decl
);
7321 /* Default function to output code that will globalize a label. A
7322 target must define GLOBAL_ASM_OP or provide its own function to
7323 globalize a label. */
7324 #ifdef GLOBAL_ASM_OP
7326 default_globalize_label (FILE * stream
, const char *name
)
7328 fputs (GLOBAL_ASM_OP
, stream
);
7329 assemble_name (stream
, name
);
7330 putc ('\n', stream
);
7332 #endif /* GLOBAL_ASM_OP */
7334 /* Default function to output code that will globalize a declaration. */
7336 default_globalize_decl_name (FILE * stream
, tree decl
)
7338 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
7339 targetm
.asm_out
.globalize_label (stream
, name
);
7342 /* Default function to output a label for unwind information. The
7343 default is to do nothing. A target that needs nonlocal labels for
7344 unwind information must provide its own function to do this. */
7346 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED
,
7347 tree decl ATTRIBUTE_UNUSED
,
7348 int for_eh ATTRIBUTE_UNUSED
,
7349 int empty ATTRIBUTE_UNUSED
)
7353 /* Default function to output a label to divide up the exception table.
7354 The default is to do nothing. A target that needs/wants to divide
7355 up the table must provide it's own function to do this. */
7357 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED
)
7361 /* This is how to output an internal numbered label where PREFIX is
7362 the class of label and LABELNO is the number within the class. */
7365 default_generate_internal_label (char *buf
, const char *prefix
,
7366 unsigned long labelno
)
7368 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
7371 /* This is how to output an internal numbered label where PREFIX is
7372 the class of label and LABELNO is the number within the class. */
7375 default_internal_label (FILE *stream
, const char *prefix
,
7376 unsigned long labelno
)
7378 char *const buf
= (char *) alloca (40 + strlen (prefix
));
7379 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
7380 ASM_OUTPUT_INTERNAL_LABEL (stream
, buf
);
7384 /* The default implementation of ASM_DECLARE_CONSTANT_NAME. */
7387 default_asm_declare_constant_name (FILE *file
, const char *name
,
7388 const_tree exp ATTRIBUTE_UNUSED
,
7389 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
7391 assemble_label (file
, name
);
7394 /* This is the default behavior at the beginning of a file. It's
7395 controlled by two other target-hook toggles. */
7397 default_file_start (void)
7399 if (targetm
.asm_file_start_app_off
7400 && !(flag_verbose_asm
|| flag_debug_asm
|| flag_dump_rtl_in_asm
))
7401 fputs (ASM_APP_OFF
, asm_out_file
);
7403 if (targetm
.asm_file_start_file_directive
)
7405 /* LTO produced units have no meaningful main_input_filename. */
7407 output_file_directive (asm_out_file
, "<artificial>");
7409 output_file_directive (asm_out_file
, main_input_filename
);
7413 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
7414 which emits a special section directive used to indicate whether or
7415 not this object file needs an executable stack. This is primarily
7416 a GNU extension to ELF but could be used on other targets. */
7418 int trampolines_created
;
7421 file_end_indicate_exec_stack (void)
7423 unsigned int flags
= SECTION_DEBUG
;
7424 if (trampolines_created
)
7425 flags
|= SECTION_CODE
;
7427 switch_to_section (get_section (".note.GNU-stack", flags
, NULL
));
7430 /* Emit a special section directive to indicate that this object file
7431 was compiled with -fsplit-stack. This is used to let the linker
7432 detect calls between split-stack code and non-split-stack code, so
7433 that it can modify the split-stack code to allocate a sufficiently
7434 large stack. We emit another special section if there are any
7435 functions in this file which have the no_split_stack attribute, to
7436 prevent the linker from warning about being unable to convert the
7437 functions if they call non-split-stack code. */
7440 file_end_indicate_split_stack (void)
7442 if (flag_split_stack
)
7444 switch_to_section (get_section (".note.GNU-split-stack", SECTION_DEBUG
,
7446 if (saw_no_split_stack
)
7447 switch_to_section (get_section (".note.GNU-no-split-stack",
7448 SECTION_DEBUG
, NULL
));
7452 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
7453 a get_unnamed_section callback. */
7456 output_section_asm_op (const void *directive
)
7458 fprintf (asm_out_file
, "%s\n", (const char *) directive
);
7461 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
7462 the current section is NEW_SECTION. */
7465 switch_to_section (section
*new_section
)
7467 if (in_section
== new_section
)
7470 if (new_section
->common
.flags
& SECTION_FORGET
)
7473 in_section
= new_section
;
7475 switch (SECTION_STYLE (new_section
))
7478 targetm
.asm_out
.named_section (new_section
->named
.name
,
7479 new_section
->named
.common
.flags
,
7480 new_section
->named
.decl
);
7483 case SECTION_UNNAMED
:
7484 new_section
->unnamed
.callback (new_section
->unnamed
.data
);
7487 case SECTION_NOSWITCH
:
7492 new_section
->common
.flags
|= SECTION_DECLARED
;
7495 /* If block symbol SYMBOL has not yet been assigned an offset, place
7496 it at the end of its block. */
7499 place_block_symbol (rtx symbol
)
7501 unsigned HOST_WIDE_INT size
, mask
, offset
;
7502 class constant_descriptor_rtx
*desc
;
7503 unsigned int alignment
;
7504 struct object_block
*block
;
7507 gcc_assert (SYMBOL_REF_BLOCK (symbol
));
7508 if (SYMBOL_REF_BLOCK_OFFSET (symbol
) >= 0)
7511 /* Work out the symbol's size and alignment. */
7512 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7514 desc
= SYMBOL_REF_CONSTANT (symbol
);
7515 alignment
= desc
->align
;
7516 size
= GET_MODE_SIZE (desc
->mode
);
7518 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7520 decl
= SYMBOL_REF_DECL (symbol
);
7521 gcc_checking_assert (DECL_IN_CONSTANT_POOL (decl
));
7522 alignment
= DECL_ALIGN (decl
);
7523 size
= get_constant_size (DECL_INITIAL (decl
));
7524 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7525 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7526 && asan_protect_global (DECL_INITIAL (decl
)))
7528 size
+= asan_red_zone_size (size
);
7529 alignment
= MAX (alignment
,
7530 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
7535 struct symtab_node
*snode
;
7536 decl
= SYMBOL_REF_DECL (symbol
);
7538 snode
= symtab_node::get (decl
);
7541 rtx target
= DECL_RTL (snode
->ultimate_alias_target ()->decl
);
7543 gcc_assert (MEM_P (target
)
7544 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
7545 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (target
, 0)));
7546 target
= XEXP (target
, 0);
7547 place_block_symbol (target
);
7548 SYMBOL_REF_BLOCK_OFFSET (symbol
) = SYMBOL_REF_BLOCK_OFFSET (target
);
7551 alignment
= get_variable_align (decl
);
7552 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7553 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7554 && asan_protect_global (decl
))
7556 size
+= asan_red_zone_size (size
);
7557 alignment
= MAX (alignment
,
7558 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
7562 /* Calculate the object's offset from the start of the block. */
7563 block
= SYMBOL_REF_BLOCK (symbol
);
7564 mask
= alignment
/ BITS_PER_UNIT
- 1;
7565 offset
= (block
->size
+ mask
) & ~mask
;
7566 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
7568 /* Record the block's new alignment and size. */
7569 block
->alignment
= MAX (block
->alignment
, alignment
);
7570 block
->size
= offset
+ size
;
7572 vec_safe_push (block
->objects
, symbol
);
7575 /* Return the anchor that should be used to address byte offset OFFSET
7576 from the first object in BLOCK. MODEL is the TLS model used
7580 get_section_anchor (struct object_block
*block
, HOST_WIDE_INT offset
,
7581 enum tls_model model
)
7584 unsigned int begin
, middle
, end
;
7585 unsigned HOST_WIDE_INT min_offset
, max_offset
, range
, bias
, delta
;
7588 /* Work out the anchor's offset. Use an offset of 0 for the first
7589 anchor so that we don't pessimize the case where we take the address
7590 of a variable at the beginning of the block. This is particularly
7591 useful when a block has only one variable assigned to it.
7593 We try to place anchors RANGE bytes apart, so there can then be
7594 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
7595 a ptr_mode offset. With some target settings, the lowest such
7596 anchor might be out of range for the lowest ptr_mode offset;
7597 likewise the highest anchor for the highest offset. Use anchors
7598 at the extreme ends of the ptr_mode range in such cases.
7600 All arithmetic uses unsigned integers in order to avoid
7602 max_offset
= (unsigned HOST_WIDE_INT
) targetm
.max_anchor_offset
;
7603 min_offset
= (unsigned HOST_WIDE_INT
) targetm
.min_anchor_offset
;
7604 range
= max_offset
- min_offset
+ 1;
7609 bias
= HOST_WIDE_INT_1U
<< (GET_MODE_BITSIZE (ptr_mode
) - 1);
7612 delta
= -(unsigned HOST_WIDE_INT
) offset
+ max_offset
;
7613 delta
-= delta
% range
;
7616 offset
= (HOST_WIDE_INT
) (-delta
);
7620 delta
= (unsigned HOST_WIDE_INT
) offset
- min_offset
;
7621 delta
-= delta
% range
;
7622 if (delta
> bias
- 1)
7624 offset
= (HOST_WIDE_INT
) delta
;
7628 /* Do a binary search to see if there's already an anchor we can use.
7629 Set BEGIN to the new anchor's index if not. */
7631 end
= vec_safe_length (block
->anchors
);
7632 while (begin
!= end
)
7634 middle
= (end
+ begin
) / 2;
7635 anchor
= (*block
->anchors
)[middle
];
7636 if (SYMBOL_REF_BLOCK_OFFSET (anchor
) > offset
)
7638 else if (SYMBOL_REF_BLOCK_OFFSET (anchor
) < offset
)
7640 else if (SYMBOL_REF_TLS_MODEL (anchor
) > model
)
7642 else if (SYMBOL_REF_TLS_MODEL (anchor
) < model
)
7648 /* Create a new anchor with a unique label. */
7649 ASM_GENERATE_INTERNAL_LABEL (label
, "LANCHOR", anchor_labelno
++);
7650 anchor
= create_block_symbol (ggc_strdup (label
), block
, offset
);
7651 SYMBOL_REF_FLAGS (anchor
) |= SYMBOL_FLAG_LOCAL
| SYMBOL_FLAG_ANCHOR
;
7652 SYMBOL_REF_FLAGS (anchor
) |= model
<< SYMBOL_FLAG_TLS_SHIFT
;
7654 /* Insert it at index BEGIN. */
7655 vec_safe_insert (block
->anchors
, begin
, anchor
);
7659 /* Output the objects in BLOCK. */
7662 output_object_block (struct object_block
*block
)
7664 class constant_descriptor_rtx
*desc
;
7666 HOST_WIDE_INT offset
;
7670 if (!block
->objects
)
7673 /* Switch to the section and make sure that the first byte is
7674 suitably aligned. */
7675 /* Special case VTV comdat sections similar to assemble_variable. */
7676 if (SECTION_STYLE (block
->sect
) == SECTION_NAMED
7677 && block
->sect
->named
.name
7678 && (strcmp (block
->sect
->named
.name
, ".vtable_map_vars") == 0))
7679 handle_vtv_comdat_section (block
->sect
, block
->sect
->named
.decl
);
7681 switch_to_section (block
->sect
);
7683 gcc_checking_assert (!(block
->sect
->common
.flags
& SECTION_MERGE
));
7684 assemble_align (block
->alignment
);
7686 /* Define the values of all anchors relative to the current section
7688 FOR_EACH_VEC_SAFE_ELT (block
->anchors
, i
, symbol
)
7689 targetm
.asm_out
.output_anchor (symbol
);
7691 /* Output the objects themselves. */
7693 FOR_EACH_VEC_ELT (*block
->objects
, i
, symbol
)
7695 /* Move to the object's offset, padding with zeros if necessary. */
7696 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol
) - offset
);
7697 offset
= SYMBOL_REF_BLOCK_OFFSET (symbol
);
7698 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7700 desc
= SYMBOL_REF_CONSTANT (symbol
);
7701 /* Pass 1 for align as we have already laid out everything in the block.
7702 So aligning shouldn't be necessary. */
7703 output_constant_pool_1 (desc
, 1);
7704 offset
+= GET_MODE_SIZE (desc
->mode
);
7706 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7709 decl
= SYMBOL_REF_DECL (symbol
);
7710 assemble_constant_contents (DECL_INITIAL (decl
), XSTR (symbol
, 0),
7711 DECL_ALIGN (decl
), false);
7713 size
= get_constant_size (DECL_INITIAL (decl
));
7715 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7716 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7717 && asan_protect_global (DECL_INITIAL (decl
)))
7719 size
= asan_red_zone_size (size
);
7720 assemble_zeros (size
);
7727 decl
= SYMBOL_REF_DECL (symbol
);
7728 assemble_variable_contents (decl
, XSTR (symbol
, 0), false, false);
7729 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7731 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7732 && asan_protect_global (decl
))
7734 size
= asan_red_zone_size (size
);
7735 assemble_zeros (size
);
7742 /* A callback for qsort to compare object_blocks. */
7745 output_object_block_compare (const void *x
, const void *y
)
7747 object_block
*p1
= *(object_block
* const*)x
;
7748 object_block
*p2
= *(object_block
* const*)y
;
7750 if (p1
->sect
->common
.flags
& SECTION_NAMED
7751 && !(p2
->sect
->common
.flags
& SECTION_NAMED
))
7754 if (!(p1
->sect
->common
.flags
& SECTION_NAMED
)
7755 && p2
->sect
->common
.flags
& SECTION_NAMED
)
7758 if (p1
->sect
->common
.flags
& SECTION_NAMED
7759 && p2
->sect
->common
.flags
& SECTION_NAMED
)
7760 return strcmp (p1
->sect
->named
.name
, p2
->sect
->named
.name
);
7762 unsigned f1
= p1
->sect
->common
.flags
;
7763 unsigned f2
= p2
->sect
->common
.flags
;
7766 return f1
< f2
? -1 : 1;
7769 /* Output the definitions of all object_blocks. */
7772 output_object_blocks (void)
7774 vec
<object_block
*, va_heap
> v
;
7775 v
.create (object_block_htab
->elements ());
7777 hash_table
<object_block_hasher
>::iterator hi
;
7779 FOR_EACH_HASH_TABLE_ELEMENT (*object_block_htab
, obj
, object_block
*, hi
)
7782 /* Sort them in order to output them in a deterministic manner,
7783 otherwise we may get .rodata sections in different orders with
7785 v
.qsort (output_object_block_compare
);
7787 FOR_EACH_VEC_ELT (v
, i
, obj
)
7788 output_object_block (obj
);
7793 /* This function provides a possible implementation of the
7794 TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered
7795 by -frecord-gcc-switches it creates a new mergeable, string section in the
7796 assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which
7797 contains the switches in ASCII format.
7799 FIXME: This code does not correctly handle double quote characters
7800 that appear inside strings, (it strips them rather than preserving them).
7801 FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL
7802 characters - instead it treats them as sub-string separators. Since
7803 we want to emit NUL strings terminators into the object file we have to use
7807 elf_record_gcc_switches (print_switch_type type
, const char * name
)
7811 case SWITCH_TYPE_PASSED
:
7812 ASM_OUTPUT_ASCII (asm_out_file
, name
, strlen (name
));
7813 ASM_OUTPUT_SKIP (asm_out_file
, HOST_WIDE_INT_1U
);
7816 case SWITCH_TYPE_DESCRIPTIVE
:
7819 /* Distinguish between invocations where name is NULL. */
7820 static bool started
= false;
7826 sec
= get_section (targetm
.asm_out
.record_gcc_switches_section
,
7830 | (SECTION_ENTSIZE
& 1),
7832 switch_to_section (sec
);
7841 /* The return value is currently ignored by the caller, but must be 0.
7842 For -fverbose-asm the return value would be the number of characters
7843 emitted into the assembler file. */
7847 /* Emit text to declare externally defined symbols. It is needed to
7848 properly support non-default visibility. */
7850 default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED
,
7852 const char *name ATTRIBUTE_UNUSED
)
7854 /* We output the name if and only if TREE_SYMBOL_REFERENCED is
7855 set in order to avoid putting out names that are never really
7856 used. Always output visibility specified in the source. */
7857 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
7858 && (DECL_VISIBILITY_SPECIFIED (decl
)
7859 || targetm
.binds_local_p (decl
)))
7860 maybe_assemble_visibility (decl
);
7863 /* The default hook for TARGET_ASM_OUTPUT_SOURCE_FILENAME. */
7866 default_asm_output_source_filename (FILE *file
, const char *name
)
7868 #ifdef ASM_OUTPUT_SOURCE_FILENAME
7869 ASM_OUTPUT_SOURCE_FILENAME (file
, name
);
7871 fprintf (file
, "\t.file\t");
7872 output_quoted_string (file
, name
);
7877 /* Output a file name in the form wanted by System V. */
7880 output_file_directive (FILE *asm_file
, const char *input_name
)
7885 if (input_name
== NULL
)
7886 input_name
= "<stdin>";
7888 input_name
= remap_debug_filename (input_name
);
7890 len
= strlen (input_name
);
7891 na
= input_name
+ len
;
7893 /* NA gets INPUT_NAME sans directory names. */
7894 while (na
> input_name
)
7896 if (IS_DIR_SEPARATOR (na
[-1]))
7901 targetm
.asm_out
.output_source_filename (asm_file
, na
);
7904 /* Create a DEBUG_EXPR_DECL / DEBUG_EXPR pair from RTL expression
7907 make_debug_expr_from_rtl (const_rtx exp
)
7909 tree ddecl
= make_node (DEBUG_EXPR_DECL
), type
;
7910 machine_mode mode
= GET_MODE (exp
);
7913 DECL_ARTIFICIAL (ddecl
) = 1;
7914 if (REG_P (exp
) && REG_EXPR (exp
))
7915 type
= TREE_TYPE (REG_EXPR (exp
));
7916 else if (MEM_P (exp
) && MEM_EXPR (exp
))
7917 type
= TREE_TYPE (MEM_EXPR (exp
));
7920 if (type
&& TYPE_MODE (type
) == mode
)
7921 TREE_TYPE (ddecl
) = type
;
7923 TREE_TYPE (ddecl
) = lang_hooks
.types
.type_for_mode (mode
, 1);
7924 SET_DECL_MODE (ddecl
, mode
);
7925 dval
= gen_rtx_DEBUG_EXPR (mode
);
7926 DEBUG_EXPR_TREE_DECL (dval
) = ddecl
;
7927 SET_DECL_RTL (ddecl
, dval
);
7931 #ifdef ELF_ASCII_ESCAPES
7932 /* Default ASM_OUTPUT_LIMITED_STRING for ELF targets. */
7935 default_elf_asm_output_limited_string (FILE *f
, const char *s
)
7940 fputs (STRING_ASM_OP
, f
);
7945 escape
= ELF_ASCII_ESCAPES
[c
];
7953 putc ('0'+((c
>>6)&7), f
);
7954 putc ('0'+((c
>>3)&7), f
);
7955 putc ('0'+(c
&7), f
);
7968 /* Default ASM_OUTPUT_ASCII for ELF targets. */
7971 default_elf_asm_output_ascii (FILE *f
, const char *s
, unsigned int len
)
7973 const char *limit
= s
+ len
;
7974 const char *last_null
= NULL
;
7975 unsigned bytes_in_chunk
= 0;
7979 for (; s
< limit
; s
++)
7983 if (bytes_in_chunk
>= 60)
7992 for (p
= s
; p
< limit
&& *p
!= '\0'; p
++)
7999 if (p
< limit
&& (p
- s
) <= (long) ELF_STRING_LIMIT
)
8001 if (bytes_in_chunk
> 0)
8008 default_elf_asm_output_limited_string (f
, s
);
8013 if (bytes_in_chunk
== 0)
8014 fputs (ASCII_DATA_ASM_OP
"\"", f
);
8017 escape
= ELF_ASCII_ESCAPES
[c
];
8026 putc ('0'+((c
>>6)&7), f
);
8027 putc ('0'+((c
>>3)&7), f
);
8028 putc ('0'+(c
&7), f
);
8029 bytes_in_chunk
+= 4;
8034 bytes_in_chunk
+= 2;
8041 if (bytes_in_chunk
> 0)
8049 static GTY(()) section
*elf_init_array_section
;
8050 static GTY(()) section
*elf_fini_array_section
;
8053 get_elf_initfini_array_priority_section (int priority
,
8057 if (priority
!= DEFAULT_INIT_PRIORITY
)
8060 sprintf (buf
, "%s.%.5u",
8061 constructor_p
? ".init_array" : ".fini_array",
8063 sec
= get_section (buf
, SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
8069 if (elf_init_array_section
== NULL
)
8070 elf_init_array_section
8071 = get_section (".init_array",
8072 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
8073 sec
= elf_init_array_section
;
8077 if (elf_fini_array_section
== NULL
)
8078 elf_fini_array_section
8079 = get_section (".fini_array",
8080 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
8081 sec
= elf_fini_array_section
;
8087 /* Use .init_array section for constructors. */
8090 default_elf_init_array_asm_out_constructor (rtx symbol
, int priority
)
8092 section
*sec
= get_elf_initfini_array_priority_section (priority
,
8094 assemble_addr_to_section (symbol
, sec
);
8097 /* Use .fini_array section for destructors. */
8100 default_elf_fini_array_asm_out_destructor (rtx symbol
, int priority
)
8102 section
*sec
= get_elf_initfini_array_priority_section (priority
,
8104 assemble_addr_to_section (symbol
, sec
);
8107 /* Default TARGET_ASM_OUTPUT_IDENT hook.
8109 This is a bit of a cheat. The real default is a no-op, but this
8110 hook is the default for all targets with a .ident directive. */
8113 default_asm_output_ident_directive (const char *ident_str
)
8115 const char *ident_asm_op
= "\t.ident\t";
8117 /* If we are still in the front end, do not write out the string
8118 to asm_out_file. Instead, add a fake top-level asm statement.
8119 This allows the front ends to use this hook without actually
8120 writing to asm_out_file, to handle #ident or Pragma Ident. */
8121 if (symtab
->state
== PARSING
)
8123 char *buf
= ACONCAT ((ident_asm_op
, "\"", ident_str
, "\"\n", NULL
));
8124 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
8127 fprintf (asm_out_file
, "%s\"%s\"\n", ident_asm_op
, ident_str
);
8131 /* This function ensures that vtable_map variables are not only
8132 in the comdat section, but that each variable has its own unique
8133 comdat name. Without this the variables end up in the same section
8134 with a single comdat name.
8136 FIXME: resolve_unique_section needs to deal better with
8137 decls with both DECL_SECTION_NAME and DECL_ONE_ONLY. Once
8138 that is fixed, this if-else statement can be replaced with
8139 a single call to "switch_to_section (sect)". */
8142 handle_vtv_comdat_section (section
*sect
, const_tree decl ATTRIBUTE_UNUSED
)
8144 #if defined (OBJECT_FORMAT_ELF)
8145 targetm
.asm_out
.named_section (sect
->named
.name
,
8146 sect
->named
.common
.flags
8151 /* Neither OBJECT_FORMAT_PE, nor OBJECT_FORMAT_COFF is set here.
8152 Therefore the following check is used.
8153 In case a the target is PE or COFF a comdat group section
8154 is created, e.g. .vtable_map_vars$foo. The linker places
8155 everything in .vtable_map_vars at the end.
8157 A fix could be made in
8158 gcc/config/i386/winnt.c: i386_pe_unique_section. */
8163 if (TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
)
8164 name
= ACONCAT ((sect
->named
.name
, "$",
8165 IDENTIFIER_POINTER (DECL_NAME (decl
)), NULL
));
8167 name
= ACONCAT ((sect
->named
.name
, "$",
8168 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (DECL_NAME (decl
))),
8171 targetm
.asm_out
.named_section (name
,
8172 sect
->named
.common
.flags
8178 switch_to_section (sect
);
8182 #include "gt-varasm.h"