1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987-2016 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"
37 #include "stringpool.h"
41 #include "diagnostic-core.h"
42 #include "fold-const.h"
43 #include "stor-layout.h"
50 #include "langhooks.h"
52 #include "common/common-target.h"
56 #ifdef XCOFF_DEBUGGING_INFO
57 #include "xcoffout.h" /* Needed for external data declarations. */
60 /* The (assembler) name of the first globally-visible object output. */
61 extern GTY(()) const char *first_global_object_name
;
62 extern GTY(()) const char *weak_global_object_name
;
64 const char *first_global_object_name
;
65 const char *weak_global_object_name
;
68 struct constant_descriptor_rtx
;
69 struct rtx_constant_pool
;
71 #define n_deferred_constants (crtl->varasm.deferred_constants)
73 /* Number for making the label on the next
74 constant that is stored in memory. */
76 static GTY(()) int const_labelno
;
78 /* Carry information from ASM_DECLARE_OBJECT_NAME
79 to ASM_FINISH_DECLARE_OBJECT. */
81 int size_directive_output
;
83 /* The last decl for which assemble_variable was called,
84 if it did ASM_DECLARE_OBJECT_NAME.
85 If the last call to assemble_variable didn't do that,
88 tree last_assemble_variable_decl
;
90 /* The following global variable indicates if the first basic block
91 in a function belongs to the cold partition or not. */
93 bool first_function_block_is_cold
;
95 /* Whether we saw any functions with no_split_stack. */
97 static bool saw_no_split_stack
;
99 static const char *strip_reg_name (const char *);
100 static int contains_pointers_p (tree
);
101 #ifdef ASM_OUTPUT_EXTERNAL
102 static bool incorporeal_function_p (tree
);
104 static void decode_addr_const (tree
, struct addr_const
*);
105 static hashval_t
const_hash_1 (const tree
);
106 static int compare_constant (const tree
, const tree
);
107 static void output_constant_def_contents (rtx
);
108 static void output_addressed_constants (tree
);
109 static unsigned HOST_WIDE_INT
output_constant (tree
, unsigned HOST_WIDE_INT
,
111 static void globalize_decl (tree
);
112 static bool decl_readonly_section_1 (enum section_category
);
113 #ifdef BSS_SECTION_ASM_OP
114 #ifdef ASM_OUTPUT_ALIGNED_BSS
115 static void asm_output_aligned_bss (FILE *, tree
, const char *,
116 unsigned HOST_WIDE_INT
, int)
119 #endif /* BSS_SECTION_ASM_OP */
120 static void mark_weak (tree
);
121 static void output_constant_pool (const char *, tree
);
122 static void handle_vtv_comdat_section (section
*, const_tree
);
124 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
125 section
*text_section
;
126 section
*data_section
;
127 section
*readonly_data_section
;
128 section
*sdata_section
;
129 section
*ctors_section
;
130 section
*dtors_section
;
131 section
*bss_section
;
132 section
*sbss_section
;
134 /* Various forms of common section. All are guaranteed to be nonnull. */
135 section
*tls_comm_section
;
136 section
*comm_section
;
137 section
*lcomm_section
;
139 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
141 section
*bss_noswitch_section
;
143 /* The section that holds the main exception table, when known. The section
144 is set either by the target's init_sections hook or by the first call to
145 switch_to_exception_section. */
146 section
*exception_section
;
148 /* The section that holds the DWARF2 frame unwind information, when known.
149 The section is set either by the target's init_sections hook or by the
150 first call to switch_to_eh_frame_section. */
151 section
*eh_frame_section
;
153 /* asm_out_file's current section. This is NULL if no section has yet
154 been selected or if we lose track of what the current section is. */
157 /* True if code for the current function is currently being directed
158 at the cold section. */
159 bool in_cold_section_p
;
161 /* The following global holds the "function name" for the code in the
162 cold section of a function, if hot/cold function splitting is enabled
163 and there was actually code that went into the cold section. A
164 pseudo function name is needed for the cold section of code for some
165 debugging tools that perform symbolization. */
166 tree cold_function_name
= NULL_TREE
;
168 /* A linked list of all the unnamed sections. */
169 static GTY(()) section
*unnamed_sections
;
171 /* Return a nonzero value if DECL has a section attribute. */
172 #define IN_NAMED_SECTION(DECL) \
173 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
174 && DECL_SECTION_NAME (DECL) != NULL)
176 struct section_hasher
: ggc_ptr_hash
<section
>
178 typedef const char *compare_type
;
180 static hashval_t
hash (section
*);
181 static bool equal (section
*, const char *);
184 /* Hash table of named sections. */
185 static GTY(()) hash_table
<section_hasher
> *section_htab
;
187 struct object_block_hasher
: ggc_ptr_hash
<object_block
>
189 typedef const section
*compare_type
;
191 static hashval_t
hash (object_block
*);
192 static bool equal (object_block
*, const section
*);
195 /* A table of object_blocks, indexed by section. */
196 static GTY(()) hash_table
<object_block_hasher
> *object_block_htab
;
198 /* The next number to use for internal anchor labels. */
199 static GTY(()) int anchor_labelno
;
201 /* A pool of constants that can be shared between functions. */
202 static GTY(()) struct rtx_constant_pool
*shared_constant_pool
;
204 /* Helper routines for maintaining section_htab. */
207 section_hasher::equal (section
*old
, const char *new_name
)
209 return strcmp (old
->named
.name
, new_name
) == 0;
213 section_hasher::hash (section
*old
)
215 return htab_hash_string (old
->named
.name
);
218 /* Return a hash value for section SECT. */
221 hash_section (section
*sect
)
223 if (sect
->common
.flags
& SECTION_NAMED
)
224 return htab_hash_string (sect
->named
.name
);
225 return sect
->common
.flags
;
228 /* Helper routines for maintaining object_block_htab. */
231 object_block_hasher::equal (object_block
*old
, const section
*new_section
)
233 return old
->sect
== new_section
;
237 object_block_hasher::hash (object_block
*old
)
239 return hash_section (old
->sect
);
242 /* Return a new unnamed section with the given fields. */
245 get_unnamed_section (unsigned int flags
, void (*callback
) (const void *),
250 sect
= ggc_alloc
<section
> ();
251 sect
->unnamed
.common
.flags
= flags
| SECTION_UNNAMED
;
252 sect
->unnamed
.callback
= callback
;
253 sect
->unnamed
.data
= data
;
254 sect
->unnamed
.next
= unnamed_sections
;
256 unnamed_sections
= sect
;
260 /* Return a SECTION_NOSWITCH section with the given fields. */
263 get_noswitch_section (unsigned int flags
, noswitch_section_callback callback
)
267 sect
= ggc_alloc
<section
> ();
268 sect
->noswitch
.common
.flags
= flags
| SECTION_NOSWITCH
;
269 sect
->noswitch
.callback
= callback
;
274 /* Return the named section structure associated with NAME. Create
275 a new section with the given fields if no such structure exists. */
278 get_section (const char *name
, unsigned int flags
, tree decl
)
280 section
*sect
, **slot
;
282 slot
= section_htab
->find_slot_with_hash (name
, htab_hash_string (name
),
284 flags
|= SECTION_NAMED
;
287 sect
= ggc_alloc
<section
> ();
288 sect
->named
.common
.flags
= flags
;
289 sect
->named
.name
= ggc_strdup (name
);
290 sect
->named
.decl
= decl
;
296 if ((sect
->common
.flags
& ~SECTION_DECLARED
) != flags
297 && ((sect
->common
.flags
| flags
) & SECTION_OVERRIDE
) == 0)
299 /* It is fine if one of the section flags is
300 SECTION_WRITE | SECTION_RELRO and the other has none of these
301 flags (i.e. read-only) in named sections and either the
302 section hasn't been declared yet or has been declared as writable.
303 In that case just make sure the resulting flags are
304 SECTION_WRITE | SECTION_RELRO, ie. writable only because of
306 if (((sect
->common
.flags
^ flags
) & (SECTION_WRITE
| SECTION_RELRO
))
307 == (SECTION_WRITE
| SECTION_RELRO
)
308 && (sect
->common
.flags
309 & ~(SECTION_DECLARED
| SECTION_WRITE
| SECTION_RELRO
))
310 == (flags
& ~(SECTION_WRITE
| SECTION_RELRO
))
311 && ((sect
->common
.flags
& SECTION_DECLARED
) == 0
312 || (sect
->common
.flags
& SECTION_WRITE
)))
314 sect
->common
.flags
|= (SECTION_WRITE
| SECTION_RELRO
);
317 /* Sanity check user variables for flag changes. */
318 if (sect
->named
.decl
!= NULL
319 && DECL_P (sect
->named
.decl
)
320 && decl
!= sect
->named
.decl
)
322 if (decl
!= NULL
&& DECL_P (decl
))
323 error ("%+D causes a section type conflict with %D",
324 decl
, sect
->named
.decl
);
326 error ("section type conflict with %D", sect
->named
.decl
);
327 inform (DECL_SOURCE_LOCATION (sect
->named
.decl
),
328 "%qD was declared here", sect
->named
.decl
);
330 else if (decl
!= NULL
&& DECL_P (decl
))
331 error ("%+D causes a section type conflict", decl
);
333 error ("section type conflict");
334 /* Make sure we don't error about one section multiple times. */
335 sect
->common
.flags
|= SECTION_OVERRIDE
;
341 /* Return true if the current compilation mode benefits from having
342 objects grouped into blocks. */
345 use_object_blocks_p (void)
347 return flag_section_anchors
;
350 /* Return the object_block structure for section SECT. Create a new
351 structure if we haven't created one already. Return null if SECT
354 static struct object_block
*
355 get_block_for_section (section
*sect
)
357 struct object_block
*block
;
363 = object_block_htab
->find_slot_with_hash (sect
, hash_section (sect
),
368 block
= ggc_cleared_alloc
<object_block
> ();
375 /* Create a symbol with label LABEL and place it at byte offset
376 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
377 is not yet known. LABEL must be a garbage-collected string. */
380 create_block_symbol (const char *label
, struct object_block
*block
,
381 HOST_WIDE_INT offset
)
386 /* Create the extended SYMBOL_REF. */
387 size
= RTX_HDR_SIZE
+ sizeof (struct block_symbol
);
388 symbol
= (rtx
) ggc_internal_alloc (size
);
390 /* Initialize the normal SYMBOL_REF fields. */
391 memset (symbol
, 0, size
);
392 PUT_CODE (symbol
, SYMBOL_REF
);
393 PUT_MODE (symbol
, Pmode
);
394 XSTR (symbol
, 0) = label
;
395 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_HAS_BLOCK_INFO
;
397 /* Initialize the block_symbol stuff. */
398 SYMBOL_REF_BLOCK (symbol
) = block
;
399 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
404 /* Return a section with a particular name and with whatever SECTION_*
405 flags section_type_flags deems appropriate. The name of the section
406 is taken from NAME if nonnull, otherwise it is taken from DECL's
407 DECL_SECTION_NAME. DECL is the decl associated with the section
408 (see the section comment for details) and RELOC is as for
409 section_type_flags. */
412 get_named_section (tree decl
, const char *name
, int reloc
)
418 gcc_assert (decl
&& DECL_P (decl
) && DECL_SECTION_NAME (decl
));
419 name
= DECL_SECTION_NAME (decl
);
422 flags
= targetm
.section_type_flags (decl
, name
, reloc
);
423 return get_section (name
, flags
, decl
);
426 /* Worker for resolve_unique_section. */
429 set_implicit_section (struct symtab_node
*n
, void *data ATTRIBUTE_UNUSED
)
431 n
->implicit_section
= true;
435 /* If required, set DECL_SECTION_NAME to a unique name. */
438 resolve_unique_section (tree decl
, int reloc ATTRIBUTE_UNUSED
,
439 int flag_function_or_data_sections
)
441 if (DECL_SECTION_NAME (decl
) == NULL
442 && targetm_common
.have_named_sections
443 && (flag_function_or_data_sections
444 || DECL_COMDAT_GROUP (decl
)))
446 targetm
.asm_out
.unique_section (decl
, reloc
);
447 if (DECL_SECTION_NAME (decl
))
448 symtab_node::get (decl
)->call_for_symbol_and_aliases
449 (set_implicit_section
, NULL
, true);
453 #ifdef BSS_SECTION_ASM_OP
455 #ifdef ASM_OUTPUT_ALIGNED_BSS
457 /* Utility function for targets to use in implementing
458 ASM_OUTPUT_ALIGNED_BSS.
459 ??? It is believed that this function will work in most cases so such
460 support is localized here. */
463 asm_output_aligned_bss (FILE *file
, tree decl ATTRIBUTE_UNUSED
,
464 const char *name
, unsigned HOST_WIDE_INT size
,
467 switch_to_section (bss_section
);
468 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
469 #ifdef ASM_DECLARE_OBJECT_NAME
470 last_assemble_variable_decl
= decl
;
471 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
473 /* Standard thing is just output label for the object. */
474 ASM_OUTPUT_LABEL (file
, name
);
475 #endif /* ASM_DECLARE_OBJECT_NAME */
476 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
481 #endif /* BSS_SECTION_ASM_OP */
483 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
484 /* Return the hot section for function DECL. Return text_section for
488 hot_function_section (tree decl
)
490 if (decl
!= NULL_TREE
491 && DECL_SECTION_NAME (decl
) != NULL
492 && targetm_common
.have_named_sections
)
493 return get_named_section (decl
, NULL
, 0);
499 /* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL)
502 When DECL_SECTION_NAME is non-NULL and it is implicit section and
503 NAMED_SECTION_SUFFIX is non-NULL, then produce section called
504 concatenate the name with NAMED_SECTION_SUFFIX.
505 Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */
508 get_named_text_section (tree decl
,
509 const char *text_section_name
,
510 const char *named_section_suffix
)
512 if (decl
&& DECL_SECTION_NAME (decl
))
514 if (named_section_suffix
)
516 const char *dsn
= DECL_SECTION_NAME (decl
);
517 const char *stripped_name
;
520 name
= (char *) alloca (strlen (dsn
) + 1);
524 stripped_name
= targetm
.strip_name_encoding (name
);
526 buffer
= ACONCAT ((stripped_name
, named_section_suffix
, NULL
));
527 return get_named_section (decl
, buffer
, 0);
529 else if (symtab_node::get (decl
)->implicit_section
)
533 /* Do not try to split gnu_linkonce functions. This gets somewhat
535 if (DECL_COMDAT_GROUP (decl
) && !HAVE_COMDAT_GROUP
)
537 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
538 name
= targetm
.strip_name_encoding (name
);
539 return get_named_section (decl
, ACONCAT ((text_section_name
, ".",
545 return get_named_section (decl
, text_section_name
, 0);
548 /* Choose named function section based on its frequency. */
551 default_function_section (tree decl
, enum node_frequency freq
,
552 bool startup
, bool exit
)
554 #if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG
555 /* Old GNU linkers have buggy --gc-section support, which sometimes
556 results in .gcc_except_table* sections being garbage collected. */
558 && symtab_node::get (decl
)->implicit_section
)
562 if (!flag_reorder_functions
563 || !targetm_common
.have_named_sections
)
565 /* Startup code should go to startup subsection unless it is
566 unlikely executed (this happens especially with function splitting
567 where we can split away unnecessary parts of static constructors. */
568 if (startup
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
570 /* If we do have a profile or(and) LTO phase is executed, we do not need
571 these ELF section. */
572 if (!in_lto_p
|| !flag_profile_values
)
573 return get_named_text_section (decl
, ".text.startup", NULL
);
578 /* Similarly for exit. */
579 if (exit
&& freq
!= NODE_FREQUENCY_UNLIKELY_EXECUTED
)
580 return get_named_text_section (decl
, ".text.exit", NULL
);
582 /* Group cold functions together, similarly for hot code. */
585 case NODE_FREQUENCY_UNLIKELY_EXECUTED
:
586 return get_named_text_section (decl
, ".text.unlikely", NULL
);
587 case NODE_FREQUENCY_HOT
:
588 /* If we do have a profile or(and) LTO phase is executed, we do not need
589 these ELF section. */
590 if (!in_lto_p
|| !flag_profile_values
)
591 return get_named_text_section (decl
, ".text.hot", NULL
);
597 /* Return the section for function DECL.
599 If DECL is NULL_TREE, return the text section. We can be passed
600 NULL_TREE under some circumstances by dbxout.c at least.
602 If FORCE_COLD is true, return cold function section ignoring
603 the frequency info of cgraph_node. */
606 function_section_1 (tree decl
, bool force_cold
)
608 section
*section
= NULL
;
609 enum node_frequency freq
= NODE_FREQUENCY_NORMAL
;
610 bool startup
= false, exit
= false;
614 struct cgraph_node
*node
= cgraph_node::get (decl
);
618 freq
= node
->frequency
;
619 startup
= node
->only_called_at_startup
;
620 exit
= node
->only_called_at_exit
;
624 freq
= NODE_FREQUENCY_UNLIKELY_EXECUTED
;
626 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
627 if (decl
!= NULL_TREE
628 && DECL_SECTION_NAME (decl
) != NULL
)
630 if (targetm
.asm_out
.function_section
)
631 section
= targetm
.asm_out
.function_section (decl
, freq
,
635 return get_named_section (decl
, NULL
, 0);
638 return targetm
.asm_out
.select_section
639 (decl
, freq
== NODE_FREQUENCY_UNLIKELY_EXECUTED
,
640 symtab_node::get (decl
)->definition_alignment ());
642 if (targetm
.asm_out
.function_section
)
643 section
= targetm
.asm_out
.function_section (decl
, freq
, startup
, exit
);
646 return hot_function_section (decl
);
650 /* Return the section for function DECL.
652 If DECL is NULL_TREE, return the text section. We can be passed
653 NULL_TREE under some circumstances by dbxout.c at least. */
656 function_section (tree decl
)
658 /* Handle cases where function splitting code decides
659 to put function entry point into unlikely executed section
660 despite the fact that the function itself is not cold
661 (i.e. it is called rarely but contains a hot loop that is
662 better to live in hot subsection for the code locality). */
663 return function_section_1 (decl
,
664 first_function_block_is_cold
);
667 /* Return the section for the current function, take IN_COLD_SECTION_P
671 current_function_section (void)
673 return function_section_1 (current_function_decl
, in_cold_section_p
);
676 /* Tell assembler to switch to unlikely-to-be-executed text section. */
679 unlikely_text_section (void)
681 return function_section_1 (current_function_decl
, true);
684 /* When called within a function context, return true if the function
685 has been assigned a cold text section and if SECT is that section.
686 When called outside a function context, return true if SECT is the
687 default cold section. */
690 unlikely_text_section_p (section
*sect
)
692 return sect
== function_section_1 (current_function_decl
, true);
695 /* Return the read-only data section associated with function DECL. */
698 default_function_rodata_section (tree decl
)
700 if (decl
!= NULL_TREE
&& DECL_SECTION_NAME (decl
))
702 const char *name
= DECL_SECTION_NAME (decl
);
704 if (DECL_COMDAT_GROUP (decl
) && HAVE_COMDAT_GROUP
)
710 dot
= strchr (name
+ 1, '.');
713 len
= strlen (dot
) + 8;
714 rname
= (char *) alloca (len
);
716 strcpy (rname
, ".rodata");
718 return get_section (rname
, SECTION_LINKONCE
, decl
);
720 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
721 else if (DECL_COMDAT_GROUP (decl
)
722 && strncmp (name
, ".gnu.linkonce.t.", 16) == 0)
724 size_t len
= strlen (name
) + 1;
725 char *rname
= (char *) alloca (len
);
727 memcpy (rname
, name
, len
);
729 return get_section (rname
, SECTION_LINKONCE
, decl
);
731 /* For .text.foo we want to use .rodata.foo. */
732 else if (flag_function_sections
&& flag_data_sections
733 && strncmp (name
, ".text.", 6) == 0)
735 size_t len
= strlen (name
) + 1;
736 char *rname
= (char *) alloca (len
+ 2);
738 memcpy (rname
, ".rodata", 7);
739 memcpy (rname
+ 7, name
+ 5, len
- 5);
740 return get_section (rname
, 0, decl
);
744 return readonly_data_section
;
747 /* Return the read-only data section associated with function DECL
748 for targets where that section should be always the single
749 readonly data section. */
752 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED
)
754 return readonly_data_section
;
757 /* A subroutine of mergeable_string_section and mergeable_constant_section. */
760 function_mergeable_rodata_prefix (void)
762 section
*s
= targetm
.asm_out
.function_rodata_section (current_function_decl
);
763 if (SECTION_STYLE (s
) == SECTION_NAMED
)
764 return s
->named
.name
;
766 return targetm
.asm_out
.mergeable_rodata_prefix
;
769 /* Return the section to use for string merging. */
772 mergeable_string_section (tree decl ATTRIBUTE_UNUSED
,
773 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
774 unsigned int flags ATTRIBUTE_UNUSED
)
778 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
779 && TREE_CODE (decl
) == STRING_CST
780 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
782 && (len
= int_size_in_bytes (TREE_TYPE (decl
))) > 0
783 && TREE_STRING_LENGTH (decl
) >= len
)
786 unsigned int modesize
;
790 const char *prefix
= function_mergeable_rodata_prefix ();
791 char *name
= (char *) alloca (strlen (prefix
) + 30);
793 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
794 modesize
= GET_MODE_BITSIZE (mode
);
795 if (modesize
>= 8 && modesize
<= 256
796 && (modesize
& (modesize
- 1)) == 0)
798 if (align
< modesize
)
801 str
= TREE_STRING_POINTER (decl
);
802 unit
= GET_MODE_SIZE (mode
);
804 /* Check for embedded NUL characters. */
805 for (i
= 0; i
< len
; i
+= unit
)
807 for (j
= 0; j
< unit
; j
++)
808 if (str
[i
+ j
] != '\0')
815 sprintf (name
, "%s.str%d.%d", prefix
,
816 modesize
/ 8, (int) (align
/ 8));
817 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
818 return get_section (name
, flags
, NULL
);
823 return readonly_data_section
;
826 /* Return the section to use for constant merging. */
829 mergeable_constant_section (machine_mode mode ATTRIBUTE_UNUSED
,
830 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
831 unsigned int flags ATTRIBUTE_UNUSED
)
833 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
835 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
841 && (align
& (align
- 1)) == 0)
843 const char *prefix
= function_mergeable_rodata_prefix ();
844 char *name
= (char *) alloca (strlen (prefix
) + 30);
846 sprintf (name
, "%s.cst%d", prefix
, (int) (align
/ 8));
847 flags
|= (align
/ 8) | SECTION_MERGE
;
848 return get_section (name
, flags
, NULL
);
850 return readonly_data_section
;
853 /* Given NAME, a putative register name, discard any customary prefixes. */
856 strip_reg_name (const char *name
)
858 #ifdef REGISTER_PREFIX
859 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
860 name
+= strlen (REGISTER_PREFIX
);
862 if (name
[0] == '%' || name
[0] == '#')
867 /* The user has asked for a DECL to have a particular name. Set (or
868 change) it in such a way that we don't prefix an underscore to
871 set_user_assembler_name (tree decl
, const char *name
)
873 char *starred
= (char *) alloca (strlen (name
) + 2);
875 strcpy (starred
+ 1, name
);
876 symtab
->change_decl_assembler_name (decl
, get_identifier (starred
));
877 SET_DECL_RTL (decl
, NULL_RTX
);
880 /* Decode an `asm' spec for a declaration as a register name.
881 Return the register number, or -1 if nothing specified,
882 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
883 or -3 if ASMSPEC is `cc' and is not recognized,
884 or -4 if ASMSPEC is `memory' and is not recognized.
885 Accept an exact spelling or a decimal number.
886 Prefixes such as % are optional. */
889 decode_reg_name_and_count (const char *asmspec
, int *pnregs
)
891 /* Presume just one register is clobbered. */
898 /* Get rid of confusing prefixes. */
899 asmspec
= strip_reg_name (asmspec
);
901 /* Allow a decimal number as a "register name". */
902 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
903 if (! ISDIGIT (asmspec
[i
]))
905 if (asmspec
[0] != 0 && i
< 0)
908 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0 && reg_names
[i
][0])
914 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
916 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
919 #ifdef OVERLAPPING_REGISTER_NAMES
923 const char *const name
;
926 } table
[] = OVERLAPPING_REGISTER_NAMES
;
928 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
930 && ! strcmp (asmspec
, table
[i
].name
))
932 *pnregs
= table
[i
].nregs
;
933 return table
[i
].number
;
936 #endif /* OVERLAPPING_REGISTER_NAMES */
938 #ifdef ADDITIONAL_REGISTER_NAMES
940 static const struct { const char *const name
; const int number
; } table
[]
941 = ADDITIONAL_REGISTER_NAMES
;
943 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
945 && ! strcmp (asmspec
, table
[i
].name
)
946 && reg_names
[table
[i
].number
][0])
947 return table
[i
].number
;
949 #endif /* ADDITIONAL_REGISTER_NAMES */
951 if (!strcmp (asmspec
, "memory"))
954 if (!strcmp (asmspec
, "cc"))
964 decode_reg_name (const char *name
)
967 return decode_reg_name_and_count (name
, &count
);
971 /* Return true if DECL's initializer is suitable for a BSS section. */
974 bss_initializer_p (const_tree decl
)
976 return (DECL_INITIAL (decl
) == NULL
977 /* In LTO we have no errors in program; error_mark_node is used
978 to mark offlined constructors. */
979 || (DECL_INITIAL (decl
) == error_mark_node
981 || (flag_zero_initialized_in_bss
982 /* Leave constant zeroes in .rodata so they
984 && !TREE_READONLY (decl
)
985 && initializer_zerop (DECL_INITIAL (decl
))));
988 /* Compute the alignment of variable specified by DECL.
989 DONT_OUTPUT_DATA is from assemble_variable. */
992 align_variable (tree decl
, bool dont_output_data
)
994 unsigned int align
= DECL_ALIGN (decl
);
996 /* In the case for initialing an array whose length isn't specified,
997 where we have not yet been able to do the layout,
998 figure out the proper alignment now. */
999 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1000 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1001 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1003 /* Some object file formats have a maximum alignment which they support.
1004 In particular, a.out format supports a maximum alignment of 4. */
1005 if (align
> MAX_OFILE_ALIGNMENT
)
1007 error ("alignment of %q+D is greater than maximum object "
1008 "file alignment %d", decl
,
1009 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1010 align
= MAX_OFILE_ALIGNMENT
;
1013 if (! DECL_USER_ALIGN (decl
))
1015 #ifdef DATA_ABI_ALIGNMENT
1016 unsigned int data_abi_align
1017 = DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
1018 /* For backwards compatibility, don't assume the ABI alignment for
1020 if (! DECL_THREAD_LOCAL_P (decl
) || data_abi_align
<= BITS_PER_WORD
)
1021 align
= data_abi_align
;
1024 /* On some machines, it is good to increase alignment sometimes.
1025 But as DECL_ALIGN is used both for actually emitting the variable
1026 and for code accessing the variable as guaranteed alignment, we
1027 can only increase the alignment if it is a performance optimization
1028 if the references to it must bind to the current definition. */
1029 if (decl_binds_to_current_def_p (decl
)
1030 && !DECL_VIRTUAL_P (decl
))
1032 #ifdef DATA_ALIGNMENT
1033 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1034 /* Don't increase alignment too much for TLS variables - TLS space
1036 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
1039 if (DECL_INITIAL (decl
) != 0
1040 /* In LTO we have no errors in program; error_mark_node is used
1041 to mark offlined constructors. */
1042 && (in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
))
1044 unsigned int const_align
1045 = CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1046 /* Don't increase alignment too much for TLS variables - TLS
1047 space is too precious. */
1048 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1049 align
= const_align
;
1054 /* Reset the alignment in case we have made it tighter, so we can benefit
1055 from it in get_pointer_alignment. */
1056 SET_DECL_ALIGN (decl
, align
);
1059 /* Return DECL_ALIGN (decl), possibly increased for optimization purposes
1060 beyond what align_variable returned. */
1063 get_variable_align (tree decl
)
1065 unsigned int align
= DECL_ALIGN (decl
);
1067 /* For user aligned vars or static vars align_variable already did
1069 if (DECL_USER_ALIGN (decl
) || !TREE_PUBLIC (decl
))
1072 #ifdef DATA_ABI_ALIGNMENT
1073 if (DECL_THREAD_LOCAL_P (decl
))
1074 align
= DATA_ABI_ALIGNMENT (TREE_TYPE (decl
), align
);
1077 /* For decls that bind to the current definition, align_variable
1078 did also everything, except for not assuming ABI required alignment
1079 of TLS variables. For other vars, increase the alignment here
1080 as an optimization. */
1081 if (!decl_binds_to_current_def_p (decl
))
1083 /* On some machines, it is good to increase alignment sometimes. */
1084 #ifdef DATA_ALIGNMENT
1085 unsigned int data_align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1086 /* Don't increase alignment too much for TLS variables - TLS space
1088 if (! DECL_THREAD_LOCAL_P (decl
) || data_align
<= BITS_PER_WORD
)
1091 if (DECL_INITIAL (decl
) != 0
1092 /* In LTO we have no errors in program; error_mark_node is used
1093 to mark offlined constructors. */
1094 && (in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
))
1096 unsigned int const_align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
),
1098 /* Don't increase alignment too much for TLS variables - TLS space
1100 if (! DECL_THREAD_LOCAL_P (decl
) || const_align
<= BITS_PER_WORD
)
1101 align
= const_align
;
1108 /* Return the section into which the given VAR_DECL or CONST_DECL
1109 should be placed. PREFER_NOSWITCH_P is true if a noswitch
1110 section should be used wherever possible. */
1113 get_variable_section (tree decl
, bool prefer_noswitch_p
)
1115 addr_space_t as
= ADDR_SPACE_GENERIC
;
1117 varpool_node
*vnode
= varpool_node::get (decl
);
1120 vnode
= vnode
->ultimate_alias_target ();
1124 if (TREE_TYPE (decl
) != error_mark_node
)
1125 as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1127 /* We need the constructor to figure out reloc flag. */
1129 vnode
->get_constructor ();
1131 if (DECL_COMMON (decl
))
1133 /* If the decl has been given an explicit section name, or it resides
1134 in a non-generic address space, then it isn't common, and shouldn't
1135 be handled as such. */
1136 gcc_assert (DECL_SECTION_NAME (decl
) == NULL
1137 && ADDR_SPACE_GENERIC_P (as
));
1138 if (DECL_THREAD_LOCAL_P (decl
))
1139 return tls_comm_section
;
1140 else if (TREE_PUBLIC (decl
) && bss_initializer_p (decl
))
1141 return comm_section
;
1144 if (DECL_INITIAL (decl
) == error_mark_node
)
1145 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1146 else if (DECL_INITIAL (decl
))
1147 reloc
= compute_reloc_for_constant (DECL_INITIAL (decl
));
1151 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1152 if (IN_NAMED_SECTION (decl
))
1154 section
*sect
= get_named_section (decl
, NULL
, reloc
);
1156 if ((sect
->common
.flags
& SECTION_BSS
) && !bss_initializer_p (decl
))
1158 error_at (DECL_SOURCE_LOCATION (decl
),
1159 "only zero initializers are allowed in section %qs",
1161 DECL_INITIAL (decl
) = error_mark_node
;
1166 if (ADDR_SPACE_GENERIC_P (as
)
1167 && !DECL_THREAD_LOCAL_P (decl
)
1168 && !(prefer_noswitch_p
&& targetm
.have_switchable_bss_sections
)
1169 && bss_initializer_p (decl
))
1171 if (!TREE_PUBLIC (decl
)
1172 && !((flag_sanitize
& SANITIZE_ADDRESS
)
1173 && asan_protect_global (decl
)))
1174 return lcomm_section
;
1175 if (bss_noswitch_section
)
1176 return bss_noswitch_section
;
1179 return targetm
.asm_out
.select_section (decl
, reloc
,
1180 get_variable_align (decl
));
1183 /* Return the block into which object_block DECL should be placed. */
1185 static struct object_block
*
1186 get_block_for_decl (tree decl
)
1190 if (TREE_CODE (decl
) == VAR_DECL
)
1192 /* The object must be defined in this translation unit. */
1193 if (DECL_EXTERNAL (decl
))
1196 /* There's no point using object blocks for something that is
1197 isolated by definition. */
1198 if (DECL_COMDAT_GROUP (decl
))
1202 /* We can only calculate block offsets if the decl has a known
1204 if (DECL_SIZE_UNIT (decl
) == NULL
)
1206 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (decl
)))
1209 /* Find out which section should contain DECL. We cannot put it into
1210 an object block if it requires a standalone definition. */
1211 if (TREE_CODE (decl
) == VAR_DECL
)
1212 align_variable (decl
, 0);
1213 sect
= get_variable_section (decl
, true);
1214 if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
1217 return get_block_for_section (sect
);
1220 /* Make sure block symbol SYMBOL is in block BLOCK. */
1223 change_symbol_block (rtx symbol
, struct object_block
*block
)
1225 if (block
!= SYMBOL_REF_BLOCK (symbol
))
1227 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol
) < 0);
1228 SYMBOL_REF_BLOCK (symbol
) = block
;
1232 /* Return true if it is possible to put DECL in an object_block. */
1235 use_blocks_for_decl_p (tree decl
)
1237 struct symtab_node
*snode
;
1239 /* Only data DECLs can be placed into object blocks. */
1240 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != CONST_DECL
)
1243 /* Detect decls created by dw2_force_const_mem. Such decls are
1244 special because DECL_INITIAL doesn't specify the decl's true value.
1245 dw2_output_indirect_constants will instead call assemble_variable
1246 with dont_output_data set to 1 and then print the contents itself. */
1247 if (DECL_INITIAL (decl
) == decl
)
1250 /* If this decl is an alias, then we don't want to emit a
1252 if (TREE_CODE (decl
) == VAR_DECL
1253 && (snode
= symtab_node::get (decl
)) != NULL
1257 return targetm
.use_blocks_for_decl_p (decl
);
1260 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
1261 until we find an identifier that is not itself a transparent alias.
1262 Modify the alias passed to it by reference (and all aliases on the
1263 way to the ultimate target), such that they do not have to be
1264 followed again, and return the ultimate target of the alias
1268 ultimate_transparent_alias_target (tree
*alias
)
1270 tree target
= *alias
;
1272 if (IDENTIFIER_TRANSPARENT_ALIAS (target
))
1274 gcc_assert (TREE_CHAIN (target
));
1275 target
= ultimate_transparent_alias_target (&TREE_CHAIN (target
));
1276 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
1277 && ! TREE_CHAIN (target
));
1284 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
1285 have static storage duration. In other words, it should not be an
1286 automatic variable, including PARM_DECLs.
1288 There is, however, one exception: this function handles variables
1289 explicitly placed in a particular register by the user.
1291 This is never called for PARM_DECL nodes. */
1294 make_decl_rtl (tree decl
)
1296 const char *name
= 0;
1301 /* Check that we are not being given an automatic variable. */
1302 gcc_assert (TREE_CODE (decl
) != PARM_DECL
1303 && TREE_CODE (decl
) != RESULT_DECL
);
1305 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1306 gcc_assert (TREE_CODE (decl
) != VAR_DECL
1307 || TREE_STATIC (decl
)
1308 || TREE_PUBLIC (decl
)
1309 || DECL_EXTERNAL (decl
)
1310 || DECL_REGISTER (decl
));
1312 /* And that we were not given a type or a label. */
1313 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
1314 && TREE_CODE (decl
) != LABEL_DECL
);
1316 /* For a duplicate declaration, we can be called twice on the
1317 same DECL node. Don't discard the RTL already made. */
1318 if (DECL_RTL_SET_P (decl
))
1320 /* If the old RTL had the wrong mode, fix the mode. */
1321 x
= DECL_RTL (decl
);
1322 if (GET_MODE (x
) != DECL_MODE (decl
))
1323 SET_DECL_RTL (decl
, adjust_address_nv (x
, DECL_MODE (decl
), 0));
1325 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1328 /* ??? Another way to do this would be to maintain a hashed
1329 table of such critters. Instead of adding stuff to a DECL
1330 to give certain attributes to it, we could use an external
1331 hash map from DECL to set of attributes. */
1333 /* Let the target reassign the RTL if it wants.
1334 This is necessary, for example, when one machine specific
1335 decl attribute overrides another. */
1336 targetm
.encode_section_info (decl
, DECL_RTL (decl
), false);
1338 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1339 on the new decl information. */
1341 && GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
1342 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x
, 0)))
1343 change_symbol_block (XEXP (x
, 0), get_block_for_decl (decl
));
1348 /* If this variable belongs to the global constant pool, retrieve the
1349 pre-computed RTL or recompute it in LTO mode. */
1350 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_IN_CONSTANT_POOL (decl
))
1352 SET_DECL_RTL (decl
, output_constant_def (DECL_INITIAL (decl
), 1));
1356 id
= DECL_ASSEMBLER_NAME (decl
);
1357 if (TREE_CODE (decl
) == FUNCTION_DECL
1358 && cgraph_node::get (decl
)
1359 && cgraph_node::get (decl
)->instrumentation_clone
)
1360 ultimate_transparent_alias_target (&id
);
1361 name
= IDENTIFIER_POINTER (id
);
1363 if (name
[0] != '*' && TREE_CODE (decl
) != FUNCTION_DECL
1364 && DECL_REGISTER (decl
))
1366 error ("register name not specified for %q+D", decl
);
1368 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
1370 const char *asmspec
= name
+1;
1371 machine_mode mode
= DECL_MODE (decl
);
1372 reg_number
= decode_reg_name (asmspec
);
1373 /* First detect errors in declaring global registers. */
1374 if (reg_number
== -1)
1375 error ("register name not specified for %q+D", decl
);
1376 else if (reg_number
< 0)
1377 error ("invalid register name for %q+D", decl
);
1378 else if (mode
== BLKmode
)
1379 error ("data type of %q+D isn%'t suitable for a register",
1381 else if (!in_hard_reg_set_p (accessible_reg_set
, mode
, reg_number
))
1382 error ("the register specified for %q+D cannot be accessed"
1383 " by the current target", decl
);
1384 else if (!in_hard_reg_set_p (operand_reg_set
, mode
, reg_number
))
1385 error ("the register specified for %q+D is not general enough"
1386 " to be used as a register variable", decl
);
1387 else if (!HARD_REGNO_MODE_OK (reg_number
, mode
))
1388 error ("register specified for %q+D isn%'t suitable for data type",
1390 /* Now handle properly declared static register variables. */
1395 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
1397 DECL_INITIAL (decl
) = 0;
1398 error ("global register variable has initial value");
1400 if (TREE_THIS_VOLATILE (decl
))
1401 warning (OPT_Wvolatile_register_var
,
1402 "optimization may eliminate reads and/or "
1403 "writes to register variables");
1405 /* If the user specified one of the eliminables registers here,
1406 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1407 confused with that register and be eliminated. This usage is
1408 somewhat suspect... */
1410 SET_DECL_RTL (decl
, gen_raw_REG (mode
, reg_number
));
1411 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
1412 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
1414 if (TREE_STATIC (decl
))
1416 /* Make this register global, so not usable for anything
1418 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1419 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1420 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
1422 nregs
= hard_regno_nregs
[reg_number
][mode
];
1424 globalize_reg (decl
, reg_number
+ --nregs
);
1427 /* As a register variable, it has no section. */
1430 /* Avoid internal errors from invalid register
1432 SET_DECL_ASSEMBLER_NAME (decl
, NULL_TREE
);
1433 DECL_HARD_REGISTER (decl
) = 0;
1434 /* Also avoid SSA inconsistencies by pretending this is an external
1436 DECL_EXTERNAL (decl
) = 1;
1439 /* Now handle ordinary static variables and functions (in memory).
1440 Also handle vars declared register invalidly. */
1441 else if (name
[0] == '*')
1443 #ifdef REGISTER_PREFIX
1444 if (strlen (REGISTER_PREFIX
) != 0)
1446 reg_number
= decode_reg_name (name
);
1447 if (reg_number
>= 0 || reg_number
== -3)
1448 error ("register name given for non-register variable %q+D", decl
);
1453 /* Specifying a section attribute on a variable forces it into a
1454 non-.bss section, and thus it cannot be common. */
1455 /* FIXME: In general this code should not be necessary because
1456 visibility pass is doing the same work. But notice_global_symbol
1457 is called early and it needs to make DECL_RTL to get the name.
1458 we take care of recomputing the DECL_RTL after visibility is changed. */
1459 if (TREE_CODE (decl
) == VAR_DECL
1460 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
1461 && DECL_SECTION_NAME (decl
) != NULL
1462 && DECL_INITIAL (decl
) == NULL_TREE
1463 && DECL_COMMON (decl
))
1464 DECL_COMMON (decl
) = 0;
1466 /* Variables can't be both common and weak. */
1467 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_WEAK (decl
))
1468 DECL_COMMON (decl
) = 0;
1470 if (use_object_blocks_p () && use_blocks_for_decl_p (decl
))
1471 x
= create_block_symbol (name
, get_block_for_decl (decl
), -1);
1474 machine_mode address_mode
= Pmode
;
1475 if (TREE_TYPE (decl
) != error_mark_node
)
1477 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (decl
));
1478 address_mode
= targetm
.addr_space
.address_mode (as
);
1480 x
= gen_rtx_SYMBOL_REF (address_mode
, name
);
1482 SYMBOL_REF_WEAK (x
) = DECL_WEAK (decl
);
1483 SET_SYMBOL_REF_DECL (x
, decl
);
1485 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
1486 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1487 set_mem_attributes (x
, decl
, 1);
1488 SET_DECL_RTL (decl
, x
);
1490 /* Optionally set flags or add text to the name to record information
1491 such as that it is a function name.
1492 If the name is changed, the macro ASM_OUTPUT_LABELREF
1493 will have to know how to strip this information. */
1494 targetm
.encode_section_info (decl
, DECL_RTL (decl
), true);
1497 /* Like make_decl_rtl, but inhibit creation of new alias sets when
1498 calling make_decl_rtl. Also, reset DECL_RTL before returning the
1502 make_decl_rtl_for_debug (tree decl
)
1504 unsigned int save_aliasing_flag
;
1507 if (DECL_RTL_SET_P (decl
))
1508 return DECL_RTL (decl
);
1510 /* Kludge alert! Somewhere down the call chain, make_decl_rtl will
1511 call new_alias_set. If running with -fcompare-debug, sometimes
1512 we do not want to create alias sets that will throw the alias
1513 numbers off in the comparison dumps. So... clearing
1514 flag_strict_aliasing will keep new_alias_set() from creating a
1516 save_aliasing_flag
= flag_strict_aliasing
;
1517 flag_strict_aliasing
= 0;
1519 rtl
= DECL_RTL (decl
);
1520 /* Reset DECL_RTL back, as various parts of the compiler expects
1521 DECL_RTL set meaning it is actually going to be output. */
1522 SET_DECL_RTL (decl
, NULL
);
1524 flag_strict_aliasing
= save_aliasing_flag
;
1528 /* Output a string of literal assembler code
1529 for an `asm' keyword used between functions. */
1532 assemble_asm (tree string
)
1537 if (TREE_CODE (string
) == ADDR_EXPR
)
1538 string
= TREE_OPERAND (string
, 0);
1540 p
= TREE_STRING_POINTER (string
);
1541 fprintf (asm_out_file
, "%s%s\n", p
[0] == '\t' ? "" : "\t", p
);
1544 /* Write the address of the entity given by SYMBOL to SEC. */
1546 assemble_addr_to_section (rtx symbol
, section
*sec
)
1548 switch_to_section (sec
);
1549 assemble_align (POINTER_SIZE
);
1550 assemble_integer (symbol
, POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
1553 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1554 not) section for PRIORITY. */
1556 get_cdtor_priority_section (int priority
, bool constructor_p
)
1560 /* ??? This only works reliably with the GNU linker. */
1561 sprintf (buf
, "%s.%.5u",
1562 constructor_p
? ".ctors" : ".dtors",
1563 /* Invert the numbering so the linker puts us in the proper
1564 order; constructors are run from right to left, and the
1565 linker sorts in increasing order. */
1566 MAX_INIT_PRIORITY
- priority
);
1567 return get_section (buf
, SECTION_WRITE
, NULL
);
1571 default_named_section_asm_out_destructor (rtx symbol
, int priority
)
1575 if (priority
!= DEFAULT_INIT_PRIORITY
)
1576 sec
= get_cdtor_priority_section (priority
,
1577 /*constructor_p=*/false);
1579 sec
= get_section (".dtors", SECTION_WRITE
, NULL
);
1581 assemble_addr_to_section (symbol
, sec
);
1584 #ifdef DTORS_SECTION_ASM_OP
1586 default_dtor_section_asm_out_destructor (rtx symbol
,
1587 int priority ATTRIBUTE_UNUSED
)
1589 assemble_addr_to_section (symbol
, dtors_section
);
1594 default_named_section_asm_out_constructor (rtx symbol
, int priority
)
1598 if (priority
!= DEFAULT_INIT_PRIORITY
)
1599 sec
= get_cdtor_priority_section (priority
,
1600 /*constructor_p=*/true);
1602 sec
= get_section (".ctors", SECTION_WRITE
, NULL
);
1604 assemble_addr_to_section (symbol
, sec
);
1607 #ifdef CTORS_SECTION_ASM_OP
1609 default_ctor_section_asm_out_constructor (rtx symbol
,
1610 int priority ATTRIBUTE_UNUSED
)
1612 assemble_addr_to_section (symbol
, ctors_section
);
1616 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1617 a nonzero value if the constant pool should be output before the
1618 start of the function, or a zero value if the pool should output
1619 after the end of the function. The default is to put it before the
1622 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1623 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1626 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1627 to be output to assembler.
1628 Set first_global_object_name and weak_global_object_name as appropriate. */
1631 notice_global_symbol (tree decl
)
1633 const char **t
= &first_global_object_name
;
1635 if (first_global_object_name
1636 || !TREE_PUBLIC (decl
)
1637 || DECL_EXTERNAL (decl
)
1638 || !DECL_NAME (decl
)
1639 || (TREE_CODE (decl
) == VAR_DECL
&& DECL_HARD_REGISTER (decl
))
1640 || (TREE_CODE (decl
) != FUNCTION_DECL
1641 && (TREE_CODE (decl
) != VAR_DECL
1642 || (DECL_COMMON (decl
)
1643 && (DECL_INITIAL (decl
) == 0
1644 || DECL_INITIAL (decl
) == error_mark_node
)))))
1647 /* We win when global object is found, but it is useful to know about weak
1648 symbol as well so we can produce nicer unique names. */
1649 if (DECL_WEAK (decl
) || DECL_ONE_ONLY (decl
) || flag_shlib
)
1650 t
= &weak_global_object_name
;
1654 tree id
= DECL_ASSEMBLER_NAME (decl
);
1655 ultimate_transparent_alias_target (&id
);
1656 *t
= ggc_strdup (targetm
.strip_name_encoding (IDENTIFIER_POINTER (id
)));
1660 /* If not using flag_reorder_blocks_and_partition, decide early whether the
1661 current function goes into the cold section, so that targets can use
1662 current_function_section during RTL expansion. DECL describes the
1666 decide_function_section (tree decl
)
1668 first_function_block_is_cold
= false;
1670 if (flag_reorder_blocks_and_partition
)
1671 /* We will decide in assemble_start_function. */
1674 if (DECL_SECTION_NAME (decl
))
1676 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1677 /* Calls to function_section rely on first_function_block_is_cold
1679 first_function_block_is_cold
= (node
1681 == NODE_FREQUENCY_UNLIKELY_EXECUTED
);
1684 in_cold_section_p
= first_function_block_is_cold
;
1687 /* Get the function's name, as described by its RTL. This may be
1688 different from the DECL_NAME name used in the source file. */
1690 get_fnname_from_decl (tree decl
)
1692 rtx x
= DECL_RTL (decl
);
1693 gcc_assert (MEM_P (x
));
1695 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
1699 /* Output assembler code for the constant pool of a function and associated
1700 with defining the name of the function. DECL describes the function.
1701 NAME is the function's name. For the constant pool, we use the current
1702 constant pool data. */
1705 assemble_start_function (tree decl
, const char *fnname
)
1708 char tmp_label
[100];
1709 bool hot_label_written
= false;
1711 if (flag_reorder_blocks_and_partition
)
1713 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTB", const_labelno
);
1714 crtl
->subsections
.hot_section_label
= ggc_strdup (tmp_label
);
1715 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDB", const_labelno
);
1716 crtl
->subsections
.cold_section_label
= ggc_strdup (tmp_label
);
1717 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LHOTE", const_labelno
);
1718 crtl
->subsections
.hot_section_end_label
= ggc_strdup (tmp_label
);
1719 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "LCOLDE", const_labelno
);
1720 crtl
->subsections
.cold_section_end_label
= ggc_strdup (tmp_label
);
1722 cold_function_name
= NULL_TREE
;
1726 crtl
->subsections
.hot_section_label
= NULL
;
1727 crtl
->subsections
.cold_section_label
= NULL
;
1728 crtl
->subsections
.hot_section_end_label
= NULL
;
1729 crtl
->subsections
.cold_section_end_label
= NULL
;
1732 /* The following code does not need preprocessing in the assembler. */
1736 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1737 output_constant_pool (fnname
, decl
);
1739 align
= symtab_node::get (decl
)->definition_alignment ();
1741 /* Make sure the not and cold text (code) sections are properly
1742 aligned. This is necessary here in the case where the function
1743 has both hot and cold sections, because we don't want to re-set
1744 the alignment when the section switch happens mid-function. */
1746 if (flag_reorder_blocks_and_partition
)
1748 first_function_block_is_cold
= false;
1750 switch_to_section (unlikely_text_section ());
1751 assemble_align (align
);
1752 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_label
);
1754 /* When the function starts with a cold section, we need to explicitly
1755 align the hot section and write out the hot section label.
1756 But if the current function is a thunk, we do not have a CFG. */
1758 && BB_PARTITION (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
) == BB_COLD_PARTITION
)
1760 switch_to_section (text_section
);
1761 assemble_align (align
);
1762 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1763 hot_label_written
= true;
1764 first_function_block_is_cold
= true;
1766 in_cold_section_p
= first_function_block_is_cold
;
1770 /* Switch to the correct text section for the start of the function. */
1772 switch_to_section (function_section (decl
));
1773 if (flag_reorder_blocks_and_partition
1774 && !hot_label_written
)
1775 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_label
);
1777 /* Tell assembler to move to target machine's alignment for functions. */
1778 align
= floor_log2 (align
/ BITS_PER_UNIT
);
1781 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1784 /* Handle a user-specified function alignment.
1785 Note that we still need to align to DECL_ALIGN, as above,
1786 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1787 if (! DECL_USER_ALIGN (decl
)
1788 && align_functions_log
> align
1789 && optimize_function_for_speed_p (cfun
))
1791 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1792 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1793 align_functions_log
, align_functions
- 1);
1795 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1799 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1800 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1803 if (!DECL_IGNORED_P (decl
))
1804 (*debug_hooks
->begin_function
) (decl
);
1806 /* Make function name accessible from other files, if appropriate. */
1808 if (TREE_PUBLIC (decl
)
1809 || (cgraph_node::get (decl
)->instrumentation_clone
1810 && cgraph_node::get (decl
)->instrumented_version
1811 && TREE_PUBLIC (cgraph_node::get (decl
)->instrumented_version
->decl
)))
1813 notice_global_symbol (decl
);
1815 globalize_decl (decl
);
1817 maybe_assemble_visibility (decl
);
1820 if (DECL_PRESERVE_P (decl
))
1821 targetm
.asm_out
.mark_decl_preserved (fnname
);
1823 /* Do any machine/system dependent processing of the function name. */
1824 #ifdef ASM_DECLARE_FUNCTION_NAME
1825 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1827 /* Standard thing is just output label for the function. */
1828 ASM_OUTPUT_FUNCTION_LABEL (asm_out_file
, fnname
, current_function_decl
);
1829 #endif /* ASM_DECLARE_FUNCTION_NAME */
1831 if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl
)))
1832 saw_no_split_stack
= true;
1835 /* Output assembler code associated with defining the size of the
1836 function. DECL describes the function. NAME is the function's name. */
1839 assemble_end_function (tree decl
, const char *fnname ATTRIBUTE_UNUSED
)
1841 #ifdef ASM_DECLARE_FUNCTION_SIZE
1842 /* We could have switched section in the middle of the function. */
1843 if (flag_reorder_blocks_and_partition
)
1844 switch_to_section (function_section (decl
));
1845 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1847 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1849 output_constant_pool (fnname
, decl
);
1850 switch_to_section (function_section (decl
)); /* need to switch back */
1852 /* Output labels for end of hot/cold text sections (to be used by
1854 if (flag_reorder_blocks_and_partition
)
1856 section
*save_text_section
;
1858 save_text_section
= in_section
;
1859 switch_to_section (unlikely_text_section ());
1860 #ifdef ASM_DECLARE_COLD_FUNCTION_SIZE
1861 if (cold_function_name
!= NULL_TREE
)
1862 ASM_DECLARE_COLD_FUNCTION_SIZE (asm_out_file
,
1863 IDENTIFIER_POINTER (cold_function_name
),
1866 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.cold_section_end_label
);
1867 if (first_function_block_is_cold
)
1868 switch_to_section (text_section
);
1870 switch_to_section (function_section (decl
));
1871 ASM_OUTPUT_LABEL (asm_out_file
, crtl
->subsections
.hot_section_end_label
);
1872 switch_to_section (save_text_section
);
1876 /* Assemble code to leave SIZE bytes of zeros. */
1879 assemble_zeros (unsigned HOST_WIDE_INT size
)
1881 /* Do no output if -fsyntax-only. */
1882 if (flag_syntax_only
)
1885 #ifdef ASM_NO_SKIP_IN_TEXT
1886 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1887 so we must output 0s explicitly in the text section. */
1888 if (ASM_NO_SKIP_IN_TEXT
&& (in_section
->common
.flags
& SECTION_CODE
) != 0)
1890 unsigned HOST_WIDE_INT i
;
1891 for (i
= 0; i
< size
; i
++)
1892 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1897 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1900 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1903 assemble_align (int align
)
1905 if (align
> BITS_PER_UNIT
)
1907 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1911 /* Assemble a string constant with the specified C string as contents. */
1914 assemble_string (const char *p
, int size
)
1919 /* If the string is very long, split it up. */
1923 int thissize
= size
- pos
;
1924 if (thissize
> maximum
)
1927 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1935 /* A noswitch_section_callback for lcomm_section. */
1938 emit_local (tree decl ATTRIBUTE_UNUSED
,
1939 const char *name ATTRIBUTE_UNUSED
,
1940 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1941 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1943 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1944 unsigned int align
= symtab_node::get (decl
)->definition_alignment ();
1945 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, decl
, name
,
1948 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1949 unsigned int align
= symtab_node::get (decl
)->definition_alignment ();
1950 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, align
);
1953 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1958 /* A noswitch_section_callback for bss_noswitch_section. */
1960 #if defined ASM_OUTPUT_ALIGNED_BSS
1962 emit_bss (tree decl ATTRIBUTE_UNUSED
,
1963 const char *name ATTRIBUTE_UNUSED
,
1964 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1965 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1967 ASM_OUTPUT_ALIGNED_BSS (asm_out_file
, decl
, name
, size
,
1968 get_variable_align (decl
));
1973 /* A noswitch_section_callback for comm_section. */
1976 emit_common (tree decl ATTRIBUTE_UNUSED
,
1977 const char *name ATTRIBUTE_UNUSED
,
1978 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1979 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1981 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1982 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, decl
, name
,
1983 size
, get_variable_align (decl
));
1985 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1986 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, name
, size
,
1987 get_variable_align (decl
));
1990 ASM_OUTPUT_COMMON (asm_out_file
, name
, size
, rounded
);
1995 /* A noswitch_section_callback for tls_comm_section. */
1998 emit_tls_common (tree decl ATTRIBUTE_UNUSED
,
1999 const char *name ATTRIBUTE_UNUSED
,
2000 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
2001 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
2003 #ifdef ASM_OUTPUT_TLS_COMMON
2004 ASM_OUTPUT_TLS_COMMON (asm_out_file
, decl
, name
, size
);
2007 sorry ("thread-local COMMON data not implemented");
2012 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
2013 NAME is the name of DECL's SYMBOL_REF. */
2016 assemble_noswitch_variable (tree decl
, const char *name
, section
*sect
,
2019 unsigned HOST_WIDE_INT size
, rounded
;
2021 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2024 if ((flag_sanitize
& SANITIZE_ADDRESS
) && asan_protect_global (decl
))
2025 size
+= asan_red_zone_size (size
);
2027 /* Don't allocate zero bytes of common,
2028 since that means "undefined external" in the linker. */
2032 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2033 so that each uninitialized object starts on such a boundary. */
2034 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
2035 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2036 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2038 if (!sect
->noswitch
.callback (decl
, name
, size
, rounded
)
2039 && (unsigned HOST_WIDE_INT
) (align
/ BITS_PER_UNIT
) > rounded
)
2040 error ("requested alignment for %q+D is greater than "
2041 "implemented alignment of %wu", decl
, rounded
);
2044 /* A subroutine of assemble_variable. Output the label and contents of
2045 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
2046 is as for assemble_variable. */
2049 assemble_variable_contents (tree decl
, const char *name
,
2050 bool dont_output_data
)
2052 /* Do any machine/system dependent processing of the object. */
2053 #ifdef ASM_DECLARE_OBJECT_NAME
2054 last_assemble_variable_decl
= decl
;
2055 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
2057 /* Standard thing is just output label for the object. */
2058 ASM_OUTPUT_LABEL (asm_out_file
, name
);
2059 #endif /* ASM_DECLARE_OBJECT_NAME */
2061 if (!dont_output_data
)
2063 /* Caller is supposed to use varpool_get_constructor when it wants
2064 to output the body. */
2065 gcc_assert (!in_lto_p
|| DECL_INITIAL (decl
) != error_mark_node
);
2066 if (DECL_INITIAL (decl
)
2067 && DECL_INITIAL (decl
) != error_mark_node
2068 && !initializer_zerop (DECL_INITIAL (decl
)))
2069 /* Output the actual data. */
2070 output_constant (DECL_INITIAL (decl
),
2071 tree_to_uhwi (DECL_SIZE_UNIT (decl
)),
2072 get_variable_align (decl
),
2075 /* Leave space for it. */
2076 assemble_zeros (tree_to_uhwi (DECL_SIZE_UNIT (decl
)));
2077 targetm
.asm_out
.decl_end ();
2081 /* Write out assembly for the variable DECL, which is not defined in
2082 the current translation unit. */
2084 assemble_undefined_decl (tree decl
)
2086 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
2087 targetm
.asm_out
.assemble_undefined_decl (asm_out_file
, name
, decl
);
2090 /* Assemble everything that is needed for a variable or function declaration.
2091 Not used for automatic variables, and not used for function definitions.
2092 Should not be called for variables of incomplete structure type.
2094 TOP_LEVEL is nonzero if this variable has file scope.
2095 AT_END is nonzero if this is the special handling, at end of compilation,
2096 to define things that have had only tentative definitions.
2097 DONT_OUTPUT_DATA if nonzero means don't actually output the
2098 initial value (that will be done by the caller). */
2101 assemble_variable (tree decl
, int top_level ATTRIBUTE_UNUSED
,
2102 int at_end ATTRIBUTE_UNUSED
, int dont_output_data
)
2105 rtx decl_rtl
, symbol
;
2108 bool asan_protected
= false;
2110 /* This function is supposed to handle VARIABLES. Ensure we have one. */
2111 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2113 /* Emulated TLS had better not get this far. */
2114 gcc_checking_assert (targetm
.have_tls
|| !DECL_THREAD_LOCAL_P (decl
));
2116 last_assemble_variable_decl
= 0;
2118 /* Normally no need to say anything here for external references,
2119 since assemble_external is called by the language-specific code
2120 when a declaration is first seen. */
2122 if (DECL_EXTERNAL (decl
))
2125 /* Do nothing for global register variables. */
2126 if (DECL_RTL_SET_P (decl
) && REG_P (DECL_RTL (decl
)))
2128 TREE_ASM_WRITTEN (decl
) = 1;
2132 /* If type was incomplete when the variable was declared,
2133 see if it is complete now. */
2135 if (DECL_SIZE (decl
) == 0)
2136 layout_decl (decl
, 0);
2138 /* Still incomplete => don't allocate it; treat the tentative defn
2139 (which is what it must have been) as an `extern' reference. */
2141 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
2143 error ("storage size of %q+D isn%'t known", decl
);
2144 TREE_ASM_WRITTEN (decl
) = 1;
2148 /* The first declaration of a variable that comes through this function
2149 decides whether it is global (in C, has external linkage)
2150 or local (in C, has internal linkage). So do nothing more
2151 if this function has already run. */
2153 if (TREE_ASM_WRITTEN (decl
))
2156 /* Make sure targetm.encode_section_info is invoked before we set
2158 decl_rtl
= DECL_RTL (decl
);
2160 TREE_ASM_WRITTEN (decl
) = 1;
2162 /* Do no output if -fsyntax-only. */
2163 if (flag_syntax_only
)
2166 if (! dont_output_data
2167 && ! valid_constant_size_p (DECL_SIZE_UNIT (decl
)))
2169 error ("size of variable %q+D is too large", decl
);
2173 gcc_assert (MEM_P (decl_rtl
));
2174 gcc_assert (GET_CODE (XEXP (decl_rtl
, 0)) == SYMBOL_REF
);
2175 symbol
= XEXP (decl_rtl
, 0);
2177 /* If this symbol belongs to the tree constant pool, output the constant
2178 if it hasn't already been written. */
2179 if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
2181 tree decl
= SYMBOL_REF_DECL (symbol
);
2182 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
2183 output_constant_def_contents (symbol
);
2189 name
= XSTR (symbol
, 0);
2190 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
2191 notice_global_symbol (decl
);
2193 /* Compute the alignment of this data. */
2195 align_variable (decl
, dont_output_data
);
2197 if ((flag_sanitize
& SANITIZE_ADDRESS
)
2198 && asan_protect_global (decl
))
2200 asan_protected
= true;
2201 SET_DECL_ALIGN (decl
, MAX (DECL_ALIGN (decl
),
2202 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
));
2205 set_mem_align (decl_rtl
, DECL_ALIGN (decl
));
2207 align
= get_variable_align (decl
);
2209 if (TREE_PUBLIC (decl
))
2210 maybe_assemble_visibility (decl
);
2212 if (DECL_PRESERVE_P (decl
))
2213 targetm
.asm_out
.mark_decl_preserved (name
);
2215 /* First make the assembler name(s) global if appropriate. */
2216 sect
= get_variable_section (decl
, false);
2217 if (TREE_PUBLIC (decl
)
2218 && (sect
->common
.flags
& SECTION_COMMON
) == 0)
2219 globalize_decl (decl
);
2221 /* Output any data that we will need to use the address of. */
2222 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
2223 output_addressed_constants (DECL_INITIAL (decl
));
2225 /* dbxout.c needs to know this. */
2226 if (sect
&& (sect
->common
.flags
& SECTION_CODE
) != 0)
2227 DECL_IN_TEXT_SECTION (decl
) = 1;
2229 /* If the decl is part of an object_block, make sure that the decl
2230 has been positioned within its block, but do not write out its
2231 definition yet. output_object_blocks will do that later. */
2232 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
2234 gcc_assert (!dont_output_data
);
2235 place_block_symbol (symbol
);
2237 else if (SECTION_STYLE (sect
) == SECTION_NOSWITCH
)
2238 assemble_noswitch_variable (decl
, name
, sect
, align
);
2241 /* Special-case handling of vtv comdat sections. */
2242 if (sect
->named
.name
2243 && (strcmp (sect
->named
.name
, ".vtable_map_vars") == 0))
2244 handle_vtv_comdat_section (sect
, decl
);
2246 switch_to_section (sect
);
2247 if (align
> BITS_PER_UNIT
)
2248 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2249 assemble_variable_contents (decl
, name
, dont_output_data
);
2252 unsigned HOST_WIDE_INT
int size
2253 = tree_to_uhwi (DECL_SIZE_UNIT (decl
));
2254 assemble_zeros (asan_red_zone_size (size
));
2260 /* Given a function declaration (FN_DECL), this function assembles the
2261 function into the .preinit_array section. */
2264 assemble_vtv_preinit_initializer (tree fn_decl
)
2267 unsigned flags
= SECTION_WRITE
;
2268 rtx symbol
= XEXP (DECL_RTL (fn_decl
), 0);
2270 flags
|= SECTION_NOTYPE
;
2271 sect
= get_section (".preinit_array", flags
, fn_decl
);
2272 switch_to_section (sect
);
2273 assemble_addr_to_section (symbol
, sect
);
2276 /* Return 1 if type TYPE contains any pointers. */
2279 contains_pointers_p (tree type
)
2281 switch (TREE_CODE (type
))
2284 case REFERENCE_TYPE
:
2285 /* I'm not sure whether OFFSET_TYPE needs this treatment,
2286 so I'll play safe and return 1. */
2292 case QUAL_UNION_TYPE
:
2295 /* For a type that has fields, see if the fields have pointers. */
2296 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
2297 if (TREE_CODE (fields
) == FIELD_DECL
2298 && contains_pointers_p (TREE_TYPE (fields
)))
2304 /* An array type contains pointers if its element type does. */
2305 return contains_pointers_p (TREE_TYPE (type
));
2312 /* We delay assemble_external processing until
2313 the compilation unit is finalized. This is the best we can do for
2314 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2315 it all the way to final. See PR 17982 for further discussion. */
2316 static GTY(()) tree pending_assemble_externals
;
2318 #ifdef ASM_OUTPUT_EXTERNAL
2319 /* Some targets delay some output to final using TARGET_ASM_FILE_END.
2320 As a result, assemble_external can be called after the list of externals
2321 is processed and the pointer set destroyed. */
2322 static bool pending_assemble_externals_processed
;
2324 /* Avoid O(external_decls**2) lookups in the pending_assemble_externals
2325 TREE_LIST in assemble_external. */
2326 static hash_set
<tree
> *pending_assemble_externals_set
;
2328 /* True if DECL is a function decl for which no out-of-line copy exists.
2329 It is assumed that DECL's assembler name has been set. */
2332 incorporeal_function_p (tree decl
)
2334 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
2338 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
2339 && (DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
2340 || DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA_WITH_ALIGN
))
2343 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2344 /* Atomic or sync builtins which have survived this far will be
2345 resolved externally and therefore are not incorporeal. */
2346 if (strncmp (name
, "__builtin_", 10) == 0)
2352 /* Actually do the tests to determine if this is necessary, and invoke
2353 ASM_OUTPUT_EXTERNAL. */
2355 assemble_external_real (tree decl
)
2357 rtx rtl
= DECL_RTL (decl
);
2359 if (MEM_P (rtl
) && GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
2360 && !SYMBOL_REF_USED (XEXP (rtl
, 0))
2361 && !incorporeal_function_p (decl
))
2363 /* Some systems do require some output. */
2364 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
2365 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
2371 process_pending_assemble_externals (void)
2373 #ifdef ASM_OUTPUT_EXTERNAL
2375 for (list
= pending_assemble_externals
; list
; list
= TREE_CHAIN (list
))
2376 assemble_external_real (TREE_VALUE (list
));
2378 pending_assemble_externals
= 0;
2379 pending_assemble_externals_processed
= true;
2380 delete pending_assemble_externals_set
;
2384 /* This TREE_LIST contains any weak symbol declarations waiting
2386 static GTY(()) tree weak_decls
;
2388 /* Output something to declare an external symbol to the assembler,
2389 and qualifiers such as weakness. (Most assemblers don't need
2390 extern declaration, so we normally output nothing.) Do nothing if
2391 DECL is not external. */
2394 assemble_external (tree decl ATTRIBUTE_UNUSED
)
2396 /* Make sure that the ASM_OUT_FILE is open.
2397 If it's not, we should not be calling this function. */
2398 gcc_assert (asm_out_file
);
2400 /* In a perfect world, the following condition would be true.
2401 Sadly, the Java and Go front ends emit assembly *from the front end*,
2402 bypassing the call graph. See PR52739. Fix before GCC 4.8. */
2404 /* This function should only be called if we are expanding, or have
2406 Ideally, only final.c would be calling this function, but it is
2407 not clear whether that would break things somehow. See PR 17982
2408 for further discussion. */
2409 gcc_assert (state
== EXPANSION
2410 || state
== FINISHED
);
2413 if (!DECL_P (decl
) || !DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
))
2416 /* We want to output annotation for weak and external symbols at
2417 very last to check if they are references or not. */
2419 if (TARGET_SUPPORTS_WEAK
2421 /* TREE_STATIC is a weird and abused creature which is not
2422 generally the right test for whether an entity has been
2423 locally emitted, inlined or otherwise not-really-extern, but
2424 for declarations that can be weak, it happens to be
2426 && !TREE_STATIC (decl
)
2427 && lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
2428 && value_member (decl
, weak_decls
) == NULL_TREE
)
2429 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
2431 #ifdef ASM_OUTPUT_EXTERNAL
2432 if (pending_assemble_externals_processed
)
2434 assemble_external_real (decl
);
2438 if (! pending_assemble_externals_set
->add (decl
))
2439 pending_assemble_externals
= tree_cons (NULL
, decl
,
2440 pending_assemble_externals
);
2444 /* Similar, for calling a library function FUN. */
2447 assemble_external_libcall (rtx fun
)
2449 /* Declare library function name external when first used, if nec. */
2450 if (! SYMBOL_REF_USED (fun
))
2452 SYMBOL_REF_USED (fun
) = 1;
2453 targetm
.asm_out
.external_libcall (fun
);
2457 /* Assemble a label named NAME. */
2460 assemble_label (FILE *file
, const char *name
)
2462 ASM_OUTPUT_LABEL (file
, name
);
2465 /* Set the symbol_referenced flag for ID. */
2467 mark_referenced (tree id
)
2469 TREE_SYMBOL_REFERENCED (id
) = 1;
2472 /* Set the symbol_referenced flag for DECL and notify callgraph. */
2474 mark_decl_referenced (tree decl
)
2476 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2478 /* Extern inline functions don't become needed when referenced.
2479 If we know a method will be emitted in other TU and no new
2480 functions can be marked reachable, just use the external
2482 struct cgraph_node
*node
= cgraph_node::get_create (decl
);
2483 if (!DECL_EXTERNAL (decl
)
2484 && !node
->definition
)
2485 node
->mark_force_output ();
2487 else if (TREE_CODE (decl
) == VAR_DECL
)
2489 varpool_node
*node
= varpool_node::get_create (decl
);
2490 /* C++ frontend use mark_decl_references to force COMDAT variables
2491 to be output that might appear dead otherwise. */
2492 node
->force_output
= true;
2494 /* else do nothing - we can get various sorts of CST nodes here,
2495 which do not need to be marked. */
2499 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2500 starts with a *, the rest of NAME is output verbatim. Otherwise
2501 NAME is transformed in a target-specific way (usually by the
2502 addition of an underscore). */
2505 assemble_name_raw (FILE *file
, const char *name
)
2508 fputs (&name
[1], file
);
2510 ASM_OUTPUT_LABELREF (file
, name
);
2513 /* Like assemble_name_raw, but should be used when NAME might refer to
2514 an entity that is also represented as a tree (like a function or
2515 variable). If NAME does refer to such an entity, that entity will
2516 be marked as referenced. */
2519 assemble_name (FILE *file
, const char *name
)
2521 const char *real_name
;
2524 real_name
= targetm
.strip_name_encoding (name
);
2526 id
= maybe_get_identifier (real_name
);
2531 mark_referenced (id
);
2532 ultimate_transparent_alias_target (&id
);
2534 name
= IDENTIFIER_POINTER (id
);
2535 gcc_assert (! TREE_CHAIN (id
));
2538 assemble_name_raw (file
, name
);
2541 /* Allocate SIZE bytes writable static space with a gensym name
2542 and return an RTX to refer to its address. */
2545 assemble_static_space (unsigned HOST_WIDE_INT size
)
2548 const char *namestring
;
2551 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
2553 namestring
= ggc_strdup (name
);
2555 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
2556 SYMBOL_REF_FLAGS (x
) = SYMBOL_FLAG_LOCAL
;
2558 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2559 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
2562 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2563 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
2566 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2567 so that each uninitialized object starts on such a boundary. */
2568 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2569 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2570 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
2571 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2572 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2573 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
2580 /* Assemble the static constant template for function entry trampolines.
2581 This is done at most once per compilation.
2582 Returns an RTX for the address of the template. */
2584 static GTY(()) rtx initial_trampoline
;
2587 assemble_trampoline_template (void)
2594 gcc_assert (targetm
.asm_out
.trampoline_template
!= NULL
);
2596 if (initial_trampoline
)
2597 return initial_trampoline
;
2599 /* By default, put trampoline templates in read-only data section. */
2601 #ifdef TRAMPOLINE_SECTION
2602 switch_to_section (TRAMPOLINE_SECTION
);
2604 switch_to_section (readonly_data_section
);
2607 /* Write the assembler code to define one. */
2608 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
2610 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
2612 targetm
.asm_out
.internal_label (asm_out_file
, "LTRAMP", 0);
2613 targetm
.asm_out
.trampoline_template (asm_out_file
);
2615 /* Record the rtl to refer to it. */
2616 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
2617 name
= ggc_strdup (label
);
2618 symbol
= gen_rtx_SYMBOL_REF (Pmode
, name
);
2619 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2621 initial_trampoline
= gen_const_mem (BLKmode
, symbol
);
2622 set_mem_align (initial_trampoline
, TRAMPOLINE_ALIGNMENT
);
2623 set_mem_size (initial_trampoline
, TRAMPOLINE_SIZE
);
2625 return initial_trampoline
;
2628 /* A and B are either alignments or offsets. Return the minimum alignment
2629 that may be assumed after adding the two together. */
2631 static inline unsigned
2632 min_align (unsigned int a
, unsigned int b
)
2634 return (a
| b
) & -(a
| b
);
2637 /* Return the assembler directive for creating a given kind of integer
2638 object. SIZE is the number of bytes in the object and ALIGNED_P
2639 indicates whether it is known to be aligned. Return NULL if the
2640 assembly dialect has no such directive.
2642 The returned string should be printed at the start of a new line and
2643 be followed immediately by the object's initial value. */
2646 integer_asm_op (int size
, int aligned_p
)
2648 struct asm_int_op
*ops
;
2651 ops
= &targetm
.asm_out
.aligned_op
;
2653 ops
= &targetm
.asm_out
.unaligned_op
;
2658 return targetm
.asm_out
.byte_op
;
2672 /* Use directive OP to assemble an integer object X. Print OP at the
2673 start of the line, followed immediately by the value of X. */
2676 assemble_integer_with_op (const char *op
, rtx x
)
2678 fputs (op
, asm_out_file
);
2679 output_addr_const (asm_out_file
, x
);
2680 fputc ('\n', asm_out_file
);
2683 /* The default implementation of the asm_out.integer target hook. */
2686 default_assemble_integer (rtx x ATTRIBUTE_UNUSED
,
2687 unsigned int size ATTRIBUTE_UNUSED
,
2688 int aligned_p ATTRIBUTE_UNUSED
)
2690 const char *op
= integer_asm_op (size
, aligned_p
);
2691 /* Avoid GAS bugs for large values. Specifically negative values whose
2692 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2693 if (size
> UNITS_PER_WORD
&& size
> POINTER_SIZE_UNITS
)
2695 return op
&& (assemble_integer_with_op (op
, x
), true);
2698 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2699 the alignment of the integer in bits. Return 1 if we were able to output
2700 the constant, otherwise 0. We must be able to output the constant,
2701 if FORCE is nonzero. */
2704 assemble_integer (rtx x
, unsigned int size
, unsigned int align
, int force
)
2708 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
2710 /* See if the target hook can handle this kind of object. */
2711 if (targetm
.asm_out
.integer (x
, size
, aligned_p
))
2714 /* If the object is a multi-byte one, try splitting it up. Split
2715 it into words it if is multi-word, otherwise split it into bytes. */
2718 machine_mode omode
, imode
;
2719 unsigned int subalign
;
2720 unsigned int subsize
, i
;
2721 enum mode_class mclass
;
2723 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
2724 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
2725 if (GET_CODE (x
) == CONST_FIXED
)
2726 mclass
= GET_MODE_CLASS (GET_MODE (x
));
2730 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, mclass
, 0);
2731 imode
= mode_for_size (size
* BITS_PER_UNIT
, mclass
, 0);
2733 for (i
= 0; i
< size
; i
+= subsize
)
2735 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
2736 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
2742 /* If we've printed some of it, but not all of it, there's no going
2747 gcc_assert (!force
);
2752 /* Assemble the floating-point constant D into an object of size MODE. ALIGN
2753 is the alignment of the constant in bits. If REVERSE is true, D is output
2754 in reverse storage order. */
2757 assemble_real (REAL_VALUE_TYPE d
, machine_mode mode
, unsigned int align
,
2760 long data
[4] = {0, 0, 0, 0};
2761 int bitsize
, nelts
, nunits
, units_per
;
2764 /* This is hairy. We have a quantity of known size. real_to_target
2765 will put it into an array of *host* longs, 32 bits per element
2766 (even if long is more than 32 bits). We need to determine the
2767 number of array elements that are occupied (nelts) and the number
2768 of *target* min-addressable units that will be occupied in the
2769 object file (nunits). We cannot assume that 32 divides the
2770 mode's bitsize (size * BITS_PER_UNIT) evenly.
2772 size * BITS_PER_UNIT is used here to make sure that padding bits
2773 (which might appear at either end of the value; real_to_target
2774 will include the padding bits in its output array) are included. */
2776 nunits
= GET_MODE_SIZE (mode
);
2777 bitsize
= nunits
* BITS_PER_UNIT
;
2778 nelts
= CEIL (bitsize
, 32);
2779 units_per
= 32 / BITS_PER_UNIT
;
2781 real_to_target (data
, &d
, mode
);
2783 /* Put out the first word with the specified alignment. */
2785 elt
= flip_storage_order (SImode
, gen_int_mode (data
[nelts
- 1], SImode
));
2787 elt
= GEN_INT (data
[0]);
2788 assemble_integer (elt
, MIN (nunits
, units_per
), align
, 1);
2789 nunits
-= units_per
;
2791 /* Subsequent words need only 32-bit alignment. */
2792 align
= min_align (align
, 32);
2794 for (int i
= 1; i
< nelts
; i
++)
2797 elt
= flip_storage_order (SImode
,
2798 gen_int_mode (data
[nelts
- 1 - i
], SImode
));
2800 elt
= GEN_INT (data
[i
]);
2801 assemble_integer (elt
, MIN (nunits
, units_per
), align
, 1);
2802 nunits
-= units_per
;
2806 /* Given an expression EXP with a constant value,
2807 reduce it to the sum of an assembler symbol and an integer.
2808 Store them both in the structure *VALUE.
2809 EXP must be reducible. */
2813 HOST_WIDE_INT offset
;
2817 decode_addr_const (tree exp
, struct addr_const
*value
)
2819 tree target
= TREE_OPERAND (exp
, 0);
2825 if (TREE_CODE (target
) == COMPONENT_REF
2826 && tree_fits_shwi_p (byte_position (TREE_OPERAND (target
, 1))))
2828 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2829 target
= TREE_OPERAND (target
, 0);
2831 else if (TREE_CODE (target
) == ARRAY_REF
2832 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2834 offset
+= (tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (target
)))
2835 * tree_to_shwi (TREE_OPERAND (target
, 1)));
2836 target
= TREE_OPERAND (target
, 0);
2838 else if (TREE_CODE (target
) == MEM_REF
2839 && TREE_CODE (TREE_OPERAND (target
, 0)) == ADDR_EXPR
)
2841 offset
+= mem_ref_offset (target
).to_short_addr ();
2842 target
= TREE_OPERAND (TREE_OPERAND (target
, 0), 0);
2844 else if (TREE_CODE (target
) == INDIRECT_REF
2845 && TREE_CODE (TREE_OPERAND (target
, 0)) == NOP_EXPR
2846 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target
, 0), 0))
2848 target
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target
, 0), 0), 0);
2853 switch (TREE_CODE (target
))
2857 x
= DECL_RTL (target
);
2861 x
= gen_rtx_MEM (FUNCTION_MODE
,
2862 gen_rtx_LABEL_REF (Pmode
, force_label_rtx (target
)));
2871 x
= output_constant_def (target
, 1);
2878 gcc_assert (MEM_P (x
));
2882 value
->offset
= offset
;
2885 static GTY(()) hash_table
<tree_descriptor_hasher
> *const_desc_htab
;
2887 static void maybe_output_constant_def_contents (struct constant_descriptor_tree
*, int);
2889 /* Constant pool accessor function. */
2891 hash_table
<tree_descriptor_hasher
> *
2892 constant_pool_htab (void)
2894 return const_desc_htab
;
2897 /* Compute a hash code for a constant expression. */
2900 tree_descriptor_hasher::hash (constant_descriptor_tree
*ptr
)
2906 const_hash_1 (const tree exp
)
2911 enum tree_code code
= TREE_CODE (exp
);
2913 /* Either set P and LEN to the address and len of something to hash and
2914 exit the switch or return a value. */
2919 p
= (char *) &TREE_INT_CST_ELT (exp
, 0);
2920 len
= TREE_INT_CST_NUNITS (exp
) * sizeof (HOST_WIDE_INT
);
2924 return real_hash (TREE_REAL_CST_PTR (exp
));
2927 return fixed_hash (TREE_FIXED_CST_PTR (exp
));
2930 p
= TREE_STRING_POINTER (exp
);
2931 len
= TREE_STRING_LENGTH (exp
);
2935 return (const_hash_1 (TREE_REALPART (exp
)) * 5
2936 + const_hash_1 (TREE_IMAGPART (exp
)));
2942 hi
= 7 + VECTOR_CST_NELTS (exp
);
2944 for (i
= 0; i
< VECTOR_CST_NELTS (exp
); ++i
)
2945 hi
= hi
* 563 + const_hash_1 (VECTOR_CST_ELT (exp
, i
));
2952 unsigned HOST_WIDE_INT idx
;
2955 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
2957 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, value
)
2959 hi
= hi
* 603 + const_hash_1 (value
);
2967 struct addr_const value
;
2969 decode_addr_const (exp
, &value
);
2970 switch (GET_CODE (value
.base
))
2973 /* Don't hash the address of the SYMBOL_REF;
2974 only use the offset and the symbol name. */
2976 p
= XSTR (value
.base
, 0);
2977 for (i
= 0; p
[i
] != 0; i
++)
2978 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2983 + CODE_LABEL_NUMBER (LABEL_REF_LABEL (value
.base
)) * 13);
2993 case POINTER_PLUS_EXPR
:
2995 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
2996 + const_hash_1 (TREE_OPERAND (exp
, 1)));
2999 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
3002 /* A language specific constant. Just hash the code. */
3006 /* Compute hashing function. */
3008 for (i
= 0; i
< len
; i
++)
3009 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
3014 /* Wrapper of compare_constant, for the htab interface. */
3016 tree_descriptor_hasher::equal (constant_descriptor_tree
*c1
,
3017 constant_descriptor_tree
*c2
)
3019 if (c1
->hash
!= c2
->hash
)
3021 return compare_constant (c1
->value
, c2
->value
);
3024 /* Compare t1 and t2, and return 1 only if they are known to result in
3025 the same bit pattern on output. */
3028 compare_constant (const tree t1
, const tree t2
)
3030 enum tree_code typecode
;
3032 if (t1
== NULL_TREE
)
3033 return t2
== NULL_TREE
;
3034 if (t2
== NULL_TREE
)
3037 if (TREE_CODE (t1
) != TREE_CODE (t2
))
3040 switch (TREE_CODE (t1
))
3043 /* Integer constants are the same only if the same width of type. */
3044 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3046 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
3048 return tree_int_cst_equal (t1
, t2
);
3051 /* Real constants are the same only if the same width of type. */
3052 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3055 return real_identical (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3058 /* Fixed constants are the same only if the same width of type. */
3059 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
3062 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
), TREE_FIXED_CST (t2
));
3065 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
3068 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3069 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3070 TREE_STRING_LENGTH (t1
)));
3073 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
3074 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
3080 if (VECTOR_CST_NELTS (t1
) != VECTOR_CST_NELTS (t2
))
3083 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
3084 if (!compare_constant (VECTOR_CST_ELT (t1
, i
),
3085 VECTOR_CST_ELT (t2
, i
)))
3093 vec
<constructor_elt
, va_gc
> *v1
, *v2
;
3094 unsigned HOST_WIDE_INT idx
;
3096 typecode
= TREE_CODE (TREE_TYPE (t1
));
3097 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
3100 if (typecode
== ARRAY_TYPE
)
3102 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
3103 /* For arrays, check that mode, size and storage order match. */
3104 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
3106 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
))
3107 || TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t1
))
3108 != TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t2
)))
3113 /* For record and union constructors, require exact type
3115 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
3119 v1
= CONSTRUCTOR_ELTS (t1
);
3120 v2
= CONSTRUCTOR_ELTS (t2
);
3121 if (vec_safe_length (v1
) != vec_safe_length (v2
))
3124 for (idx
= 0; idx
< vec_safe_length (v1
); ++idx
)
3126 constructor_elt
*c1
= &(*v1
)[idx
];
3127 constructor_elt
*c2
= &(*v2
)[idx
];
3129 /* Check that each value is the same... */
3130 if (!compare_constant (c1
->value
, c2
->value
))
3132 /* ... and that they apply to the same fields! */
3133 if (typecode
== ARRAY_TYPE
)
3135 if (!compare_constant (c1
->index
, c2
->index
))
3140 if (c1
->index
!= c2
->index
)
3151 struct addr_const value1
, value2
;
3155 decode_addr_const (t1
, &value1
);
3156 decode_addr_const (t2
, &value2
);
3158 if (value1
.offset
!= value2
.offset
)
3161 code
= GET_CODE (value1
.base
);
3162 if (code
!= GET_CODE (value2
.base
))
3168 ret
= (strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
3172 ret
= (CODE_LABEL_NUMBER (LABEL_REF_LABEL (value1
.base
))
3173 == CODE_LABEL_NUMBER (LABEL_REF_LABEL (value2
.base
)));
3183 case POINTER_PLUS_EXPR
:
3186 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3187 && compare_constant (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3190 case VIEW_CONVERT_EXPR
:
3191 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3200 /* Return the section into which constant EXP should be placed. */
3203 get_constant_section (tree exp
, unsigned int align
)
3205 return targetm
.asm_out
.select_section (exp
,
3206 compute_reloc_for_constant (exp
),
3210 /* Return the size of constant EXP in bytes. */
3212 static HOST_WIDE_INT
3213 get_constant_size (tree exp
)
3217 size
= int_size_in_bytes (TREE_TYPE (exp
));
3218 if (TREE_CODE (exp
) == STRING_CST
)
3219 size
= MAX (TREE_STRING_LENGTH (exp
), size
);
3223 /* Subroutine of output_constant_def:
3224 No constant equal to EXP is known to have been output.
3225 Make a constant descriptor to enter EXP in the hash table.
3226 Assign the label number and construct RTL to refer to the
3227 constant's location in memory.
3228 Caller is responsible for updating the hash table. */
3230 static struct constant_descriptor_tree
*
3231 build_constant_desc (tree exp
)
3233 struct constant_descriptor_tree
*desc
;
3239 desc
= ggc_alloc
<constant_descriptor_tree
> ();
3242 /* Create a string containing the label name, in LABEL. */
3243 labelno
= const_labelno
++;
3244 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
3246 /* Construct the VAR_DECL associated with the constant. */
3247 decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
, get_identifier (label
),
3249 DECL_ARTIFICIAL (decl
) = 1;
3250 DECL_IGNORED_P (decl
) = 1;
3251 TREE_READONLY (decl
) = 1;
3252 TREE_STATIC (decl
) = 1;
3253 TREE_ADDRESSABLE (decl
) = 1;
3254 /* We don't set the RTL yet as this would cause varpool to assume that the
3255 variable is referenced. Moreover, it would just be dropped in LTO mode.
3256 Instead we set the flag that will be recognized in make_decl_rtl. */
3257 DECL_IN_CONSTANT_POOL (decl
) = 1;
3258 DECL_INITIAL (decl
) = desc
->value
;
3259 /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most
3260 architectures so use DATA_ALIGNMENT as well, except for strings. */
3261 if (TREE_CODE (exp
) == STRING_CST
)
3263 SET_DECL_ALIGN (decl
, CONSTANT_ALIGNMENT (exp
, DECL_ALIGN (decl
)));
3266 align_variable (decl
, 0);
3268 /* Now construct the SYMBOL_REF and the MEM. */
3269 if (use_object_blocks_p ())
3271 int align
= (TREE_CODE (decl
) == CONST_DECL
3272 || (TREE_CODE (decl
) == VAR_DECL
3273 && DECL_IN_CONSTANT_POOL (decl
))
3275 : symtab_node::get (decl
)->definition_alignment ());
3276 section
*sect
= get_constant_section (exp
, align
);
3277 symbol
= create_block_symbol (ggc_strdup (label
),
3278 get_block_for_section (sect
), -1);
3281 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3282 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3283 SET_SYMBOL_REF_DECL (symbol
, decl
);
3284 TREE_CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3286 rtl
= gen_const_mem (TYPE_MODE (TREE_TYPE (exp
)), symbol
);
3287 set_mem_attributes (rtl
, exp
, 1);
3288 set_mem_alias_set (rtl
, 0);
3290 /* We cannot share RTX'es in pool entries.
3291 Mark this piece of RTL as required for unsharing. */
3292 RTX_FLAG (rtl
, used
) = 1;
3294 /* Set flags or add text to the name to record information, such as
3295 that it is a local symbol. If the name is changed, the macro
3296 ASM_OUTPUT_LABELREF will have to know how to strip this
3297 information. This call might invalidate our local variable
3298 SYMBOL; we can't use it afterward. */
3299 targetm
.encode_section_info (exp
, rtl
, true);
3306 /* Return an rtx representing a reference to constant data in memory
3307 for the constant expression EXP.
3309 If assembler code for such a constant has already been output,
3310 return an rtx to refer to it.
3311 Otherwise, output such a constant in memory
3312 and generate an rtx for it.
3314 If DEFER is nonzero, this constant can be deferred and output only
3315 if referenced in the function after all optimizations.
3317 `const_desc_table' records which constants already have label strings. */
3320 output_constant_def (tree exp
, int defer
)
3322 struct constant_descriptor_tree
*desc
;
3323 struct constant_descriptor_tree key
;
3325 /* Look up EXP in the table of constant descriptors. If we didn't find
3326 it, create a new one. */
3328 key
.hash
= const_hash_1 (exp
);
3329 constant_descriptor_tree
**loc
3330 = const_desc_htab
->find_slot_with_hash (&key
, key
.hash
, INSERT
);
3335 desc
= build_constant_desc (exp
);
3336 desc
->hash
= key
.hash
;
3340 maybe_output_constant_def_contents (desc
, defer
);
3344 /* Subroutine of output_constant_def: Decide whether or not we need to
3345 output the constant DESC now, and if so, do it. */
3347 maybe_output_constant_def_contents (struct constant_descriptor_tree
*desc
,
3350 rtx symbol
= XEXP (desc
->rtl
, 0);
3351 tree exp
= desc
->value
;
3353 if (flag_syntax_only
)
3356 if (TREE_ASM_WRITTEN (exp
))
3357 /* Already output; don't do it again. */
3360 /* We can always defer constants as long as the context allows
3364 /* Increment n_deferred_constants if it exists. It needs to be at
3365 least as large as the number of constants actually referred to
3366 by the function. If it's too small we'll stop looking too early
3367 and fail to emit constants; if it's too large we'll only look
3368 through the entire function when we could have stopped earlier. */
3370 n_deferred_constants
++;
3374 output_constant_def_contents (symbol
);
3377 /* Subroutine of output_constant_def_contents. Output the definition
3378 of constant EXP, which is pointed to by label LABEL. ALIGN is the
3379 constant's alignment in bits. */
3382 assemble_constant_contents (tree exp
, const char *label
, unsigned int align
)
3386 size
= get_constant_size (exp
);
3388 /* Do any machine/system dependent processing of the constant. */
3389 targetm
.asm_out
.declare_constant_name (asm_out_file
, label
, exp
, size
);
3391 /* Output the value of EXP. */
3392 output_constant (exp
, size
, align
, false);
3394 targetm
.asm_out
.decl_end ();
3397 /* We must output the constant data referred to by SYMBOL; do so. */
3400 output_constant_def_contents (rtx symbol
)
3402 tree decl
= SYMBOL_REF_DECL (symbol
);
3403 tree exp
= DECL_INITIAL (decl
);
3404 bool asan_protected
= false;
3406 /* Make sure any other constants whose addresses appear in EXP
3407 are assigned label numbers. */
3408 output_addressed_constants (exp
);
3410 /* We are no longer deferring this constant. */
3411 TREE_ASM_WRITTEN (decl
) = TREE_ASM_WRITTEN (exp
) = 1;
3413 if ((flag_sanitize
& SANITIZE_ADDRESS
)
3414 && TREE_CODE (exp
) == STRING_CST
3415 && asan_protect_global (exp
))
3417 asan_protected
= true;
3418 SET_DECL_ALIGN (decl
, MAX (DECL_ALIGN (decl
),
3419 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
));
3422 /* If the constant is part of an object block, make sure that the
3423 decl has been positioned within its block, but do not write out
3424 its definition yet. output_object_blocks will do that later. */
3425 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol
) && SYMBOL_REF_BLOCK (symbol
))
3426 place_block_symbol (symbol
);
3429 int align
= (TREE_CODE (decl
) == CONST_DECL
3430 || (TREE_CODE (decl
) == VAR_DECL
3431 && DECL_IN_CONSTANT_POOL (decl
))
3433 : symtab_node::get (decl
)->definition_alignment ());
3434 switch_to_section (get_constant_section (exp
, align
));
3435 if (align
> BITS_PER_UNIT
)
3436 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3437 assemble_constant_contents (exp
, XSTR (symbol
, 0), align
);
3440 HOST_WIDE_INT size
= get_constant_size (exp
);
3441 assemble_zeros (asan_red_zone_size (size
));
3446 /* Look up EXP in the table of constant descriptors. Return the rtl
3447 if it has been emitted, else null. */
3450 lookup_constant_def (tree exp
)
3452 struct constant_descriptor_tree key
;
3455 key
.hash
= const_hash_1 (exp
);
3456 constant_descriptor_tree
*desc
3457 = const_desc_htab
->find_with_hash (&key
, key
.hash
);
3459 return (desc
? desc
->rtl
: NULL_RTX
);
3462 /* Return a tree representing a reference to constant data in memory
3463 for the constant expression EXP.
3465 This is the counterpart of output_constant_def at the Tree level. */
3468 tree_output_constant_def (tree exp
)
3470 struct constant_descriptor_tree
*desc
, key
;
3473 /* Look up EXP in the table of constant descriptors. If we didn't find
3474 it, create a new one. */
3476 key
.hash
= const_hash_1 (exp
);
3477 constant_descriptor_tree
**loc
3478 = const_desc_htab
->find_slot_with_hash (&key
, key
.hash
, INSERT
);
3483 desc
= build_constant_desc (exp
);
3484 desc
->hash
= key
.hash
;
3488 decl
= SYMBOL_REF_DECL (XEXP (desc
->rtl
, 0));
3489 varpool_node::finalize_decl (decl
);
3493 struct GTY((chain_next ("%h.next"), for_user
)) constant_descriptor_rtx
{
3494 struct constant_descriptor_rtx
*next
;
3498 HOST_WIDE_INT offset
;
3506 struct const_rtx_desc_hasher
: ggc_ptr_hash
<constant_descriptor_rtx
>
3508 static hashval_t
hash (constant_descriptor_rtx
*);
3509 static bool equal (constant_descriptor_rtx
*, constant_descriptor_rtx
*);
3512 /* Used in the hash tables to avoid outputting the same constant
3513 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3514 are output once per function, not once per file. */
3515 /* ??? Only a few targets need per-function constant pools. Most
3516 can use one per-file pool. Should add a targetm bit to tell the
3519 struct GTY(()) rtx_constant_pool
{
3520 /* Pointers to first and last constant in pool, as ordered by offset. */
3521 struct constant_descriptor_rtx
*first
;
3522 struct constant_descriptor_rtx
*last
;
3524 /* Hash facility for making memory-constants from constant rtl-expressions.
3525 It is used on RISC machines where immediate integer arguments and
3526 constant addresses are restricted so that such constants must be stored
3528 hash_table
<const_rtx_desc_hasher
> *const_rtx_htab
;
3530 /* Current offset in constant pool (does not include any
3531 machine-specific header). */
3532 HOST_WIDE_INT offset
;
3535 /* Hash and compare functions for const_rtx_htab. */
3538 const_rtx_desc_hasher::hash (constant_descriptor_rtx
*desc
)
3544 const_rtx_desc_hasher::equal (constant_descriptor_rtx
*x
,
3545 constant_descriptor_rtx
*y
)
3547 if (x
->mode
!= y
->mode
)
3549 return rtx_equal_p (x
->constant
, y
->constant
);
3552 /* Hash one component of a constant. */
3555 const_rtx_hash_1 (const_rtx x
)
3557 unsigned HOST_WIDE_INT hwi
;
3563 code
= GET_CODE (x
);
3564 mode
= GET_MODE (x
);
3565 h
= (hashval_t
) code
* 1048573 + mode
;
3574 int shift
= sizeof (hashval_t
) * CHAR_BIT
;
3575 const int n
= sizeof (HOST_WIDE_INT
) / sizeof (hashval_t
);
3577 h
^= (hashval_t
) hwi
;
3578 for (i
= 1; i
< n
; ++i
)
3581 h
^= (hashval_t
) hwi
;
3586 case CONST_WIDE_INT
:
3587 hwi
= GET_MODE_PRECISION (mode
);
3589 for (i
= 0; i
< CONST_WIDE_INT_NUNITS (x
); i
++)
3590 hwi
^= CONST_WIDE_INT_ELT (x
, i
);
3595 if (TARGET_SUPPORTS_WIDE_INT
== 0 && mode
== VOIDmode
)
3597 hwi
= CONST_DOUBLE_LOW (x
) ^ CONST_DOUBLE_HIGH (x
);
3601 h
^= real_hash (CONST_DOUBLE_REAL_VALUE (x
));
3605 h
^= fixed_hash (CONST_FIXED_VALUE (x
));
3609 h
^= htab_hash_string (XSTR (x
, 0));
3613 h
= h
* 251 + CODE_LABEL_NUMBER (LABEL_REF_LABEL (x
));
3617 case UNSPEC_VOLATILE
:
3618 h
= h
* 251 + XINT (x
, 1);
3628 /* Compute a hash value for X, which should be a constant. */
3631 const_rtx_hash (rtx x
)
3634 subrtx_iterator::array_type array
;
3635 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
3636 h
= h
* 509 + const_rtx_hash_1 (*iter
);
3641 /* Create and return a new rtx constant pool. */
3643 static struct rtx_constant_pool
*
3644 create_constant_pool (void)
3646 struct rtx_constant_pool
*pool
;
3648 pool
= ggc_alloc
<rtx_constant_pool
> ();
3649 pool
->const_rtx_htab
= hash_table
<const_rtx_desc_hasher
>::create_ggc (31);
3656 /* Initialize constant pool hashing for a new function. */
3659 init_varasm_status (void)
3661 crtl
->varasm
.pool
= create_constant_pool ();
3662 crtl
->varasm
.deferred_constants
= 0;
3665 /* Given a MINUS expression, simplify it if both sides
3666 include the same symbol. */
3669 simplify_subtraction (rtx x
)
3671 rtx r
= simplify_rtx (x
);
3675 /* Given a constant rtx X, make (or find) a memory constant for its value
3676 and return a MEM rtx to refer to it in memory. */
3679 force_const_mem (machine_mode mode
, rtx x
)
3681 struct constant_descriptor_rtx
*desc
, tmp
;
3682 struct rtx_constant_pool
*pool
;
3687 constant_descriptor_rtx
**slot
;
3689 /* If we're not allowed to drop X into the constant pool, don't. */
3690 if (targetm
.cannot_force_const_mem (mode
, x
))
3693 /* Record that this function has used a constant pool entry. */
3694 crtl
->uses_const_pool
= 1;
3696 /* Decide which pool to use. */
3697 pool
= (targetm
.use_blocks_for_constant_p (mode
, x
)
3698 ? shared_constant_pool
3699 : crtl
->varasm
.pool
);
3701 /* Lookup the value in the hashtable. */
3704 hash
= const_rtx_hash (x
);
3705 slot
= pool
->const_rtx_htab
->find_slot_with_hash (&tmp
, hash
, INSERT
);
3708 /* If the constant was already present, return its memory. */
3710 return copy_rtx (desc
->mem
);
3712 /* Otherwise, create a new descriptor. */
3713 desc
= ggc_alloc
<constant_descriptor_rtx
> ();
3716 /* Align the location counter as required by EXP's data type. */
3717 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3719 tree type
= lang_hooks
.types
.type_for_mode (mode
, 0);
3720 if (type
!= NULL_TREE
)
3721 align
= CONSTANT_ALIGNMENT (make_tree (type
, x
), align
);
3723 pool
->offset
+= (align
/ BITS_PER_UNIT
) - 1;
3724 pool
->offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3727 desc
->constant
= copy_rtx (tmp
.constant
);
3728 desc
->offset
= pool
->offset
;
3731 desc
->align
= align
;
3732 desc
->labelno
= const_labelno
;
3735 pool
->offset
+= GET_MODE_SIZE (mode
);
3737 pool
->last
->next
= desc
;
3739 pool
->first
= pool
->last
= desc
;
3742 /* Create a string containing the label name, in LABEL. */
3743 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3746 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3747 the constants pool. */
3748 if (use_object_blocks_p () && targetm
.use_blocks_for_constant_p (mode
, x
))
3750 section
*sect
= targetm
.asm_out
.select_rtx_section (mode
, x
, align
);
3751 symbol
= create_block_symbol (ggc_strdup (label
),
3752 get_block_for_section (sect
), -1);
3755 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3757 SYMBOL_REF_FLAGS (symbol
) |= SYMBOL_FLAG_LOCAL
;
3758 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3759 SET_SYMBOL_REF_CONSTANT (symbol
, desc
);
3761 /* Construct the MEM. */
3762 desc
->mem
= def
= gen_const_mem (mode
, symbol
);
3763 set_mem_attributes (def
, lang_hooks
.types
.type_for_mode (mode
, 0), 1);
3764 set_mem_align (def
, align
);
3766 /* If we're dropping a label to the constant pool, make sure we
3768 if (GET_CODE (x
) == LABEL_REF
)
3769 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3771 return copy_rtx (def
);
3774 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3777 get_pool_constant (const_rtx addr
)
3779 return SYMBOL_REF_CONSTANT (addr
)->constant
;
3782 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3783 and whether it has been output or not. */
3786 get_pool_constant_mark (rtx addr
, bool *pmarked
)
3788 struct constant_descriptor_rtx
*desc
;
3790 desc
= SYMBOL_REF_CONSTANT (addr
);
3791 *pmarked
= (desc
->mark
!= 0);
3792 return desc
->constant
;
3795 /* Similar, return the mode. */
3798 get_pool_mode (const_rtx addr
)
3800 return SYMBOL_REF_CONSTANT (addr
)->mode
;
3803 /* Return the size of the constant pool. */
3806 get_pool_size (void)
3808 return crtl
->varasm
.pool
->offset
;
3811 /* Worker function for output_constant_pool_1. Emit assembly for X
3812 in MODE with known alignment ALIGN. */
3815 output_constant_pool_2 (machine_mode mode
, rtx x
, unsigned int align
)
3817 switch (GET_MODE_CLASS (mode
))
3820 case MODE_DECIMAL_FLOAT
:
3822 gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x
));
3823 assemble_real (*CONST_DOUBLE_REAL_VALUE (x
), mode
, align
, false);
3828 case MODE_PARTIAL_INT
:
3833 case MODE_POINTER_BOUNDS
:
3834 assemble_integer (x
, GET_MODE_SIZE (mode
), align
, 1);
3837 case MODE_VECTOR_FLOAT
:
3838 case MODE_VECTOR_INT
:
3839 case MODE_VECTOR_FRACT
:
3840 case MODE_VECTOR_UFRACT
:
3841 case MODE_VECTOR_ACCUM
:
3842 case MODE_VECTOR_UACCUM
:
3845 machine_mode submode
= GET_MODE_INNER (mode
);
3846 unsigned int subalign
= MIN (align
, GET_MODE_BITSIZE (submode
));
3848 gcc_assert (GET_CODE (x
) == CONST_VECTOR
);
3849 units
= CONST_VECTOR_NUNITS (x
);
3851 for (i
= 0; i
< units
; i
++)
3853 rtx elt
= CONST_VECTOR_ELT (x
, i
);
3854 output_constant_pool_2 (submode
, elt
, i
? subalign
: align
);
3864 /* Worker function for output_constant_pool. Emit constant DESC,
3865 giving it ALIGN bits of alignment. */
3868 output_constant_pool_1 (struct constant_descriptor_rtx
*desc
,
3875 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3876 whose CODE_LABEL has been deleted. This can occur if a jump table
3877 is eliminated by optimization. If so, write a constant of zero
3878 instead. Note that this can also happen by turning the
3879 CODE_LABEL into a NOTE. */
3880 /* ??? This seems completely and utterly wrong. Certainly it's
3881 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3882 functioning even with rtx_insn::deleted and friends. */
3885 switch (GET_CODE (tmp
))
3888 if (GET_CODE (XEXP (tmp
, 0)) != PLUS
3889 || GET_CODE (XEXP (XEXP (tmp
, 0), 0)) != LABEL_REF
)
3891 tmp
= XEXP (XEXP (tmp
, 0), 0);
3895 tmp
= LABEL_REF_LABEL (tmp
);
3896 gcc_assert (!as_a
<rtx_insn
*> (tmp
)->deleted ());
3897 gcc_assert (!NOTE_P (tmp
)
3898 || NOTE_KIND (tmp
) != NOTE_INSN_DELETED
);
3905 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3906 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, desc
->mode
,
3907 align
, desc
->labelno
, done
);
3910 assemble_align (align
);
3912 /* Output the label. */
3913 targetm
.asm_out
.internal_label (asm_out_file
, "LC", desc
->labelno
);
3916 Pass actual alignment value while emitting string constant to asm code
3917 as function 'output_constant_pool_1' explicitly passes the alignment as 1
3918 assuming that the data is already aligned which prevents the generation
3919 of fix-up table entries. */
3920 output_constant_pool_2 (desc
->mode
, x
, desc
->align
);
3922 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3923 sections have proper size. */
3924 if (align
> GET_MODE_BITSIZE (desc
->mode
)
3926 && (in_section
->common
.flags
& SECTION_MERGE
))
3927 assemble_align (align
);
3929 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3935 /* Mark all constants that are referenced by SYMBOL_REFs in X.
3936 Emit referenced deferred strings. */
3939 mark_constants_in_pattern (rtx insn
)
3941 subrtx_iterator::array_type array
;
3942 FOR_EACH_SUBRTX (iter
, array
, PATTERN (insn
), ALL
)
3944 const_rtx x
= *iter
;
3945 if (GET_CODE (x
) == SYMBOL_REF
)
3947 if (CONSTANT_POOL_ADDRESS_P (x
))
3949 struct constant_descriptor_rtx
*desc
= SYMBOL_REF_CONSTANT (x
);
3950 if (desc
->mark
== 0)
3953 iter
.substitute (desc
->constant
);
3956 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
3958 tree decl
= SYMBOL_REF_DECL (x
);
3959 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl
)))
3961 n_deferred_constants
--;
3962 output_constant_def_contents (CONST_CAST_RTX (x
));
3969 /* Look through appropriate parts of INSN, marking all entries in the
3970 constant pool which are actually being used. Entries that are only
3971 referenced by other constants are also marked as used. Emit
3972 deferred strings that are used. */
3975 mark_constants (rtx_insn
*insn
)
3980 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3981 insns, not any notes that may be attached. We don't want to mark
3982 a constant just because it happens to appear in a REG_EQUIV note. */
3983 if (rtx_sequence
*seq
= dyn_cast
<rtx_sequence
*> (PATTERN (insn
)))
3985 int i
, n
= seq
->len ();
3986 for (i
= 0; i
< n
; ++i
)
3988 rtx subinsn
= seq
->element (i
);
3989 if (INSN_P (subinsn
))
3990 mark_constants_in_pattern (subinsn
);
3994 mark_constants_in_pattern (insn
);
3997 /* Look through the instructions for this function, and mark all the
3998 entries in POOL which are actually being used. Emit deferred constants
3999 which have indeed been used. */
4002 mark_constant_pool (void)
4006 if (!crtl
->uses_const_pool
&& n_deferred_constants
== 0)
4009 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4010 mark_constants (insn
);
4013 /* Write all the constants in POOL. */
4016 output_constant_pool_contents (struct rtx_constant_pool
*pool
)
4018 struct constant_descriptor_rtx
*desc
;
4020 for (desc
= pool
->first
; desc
; desc
= desc
->next
)
4023 /* If the constant is part of an object_block, make sure that
4024 the constant has been positioned within its block, but do not
4025 write out its definition yet. output_object_blocks will do
4027 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc
->sym
)
4028 && SYMBOL_REF_BLOCK (desc
->sym
))
4029 place_block_symbol (desc
->sym
);
4032 switch_to_section (targetm
.asm_out
.select_rtx_section
4033 (desc
->mode
, desc
->constant
, desc
->align
));
4034 output_constant_pool_1 (desc
, desc
->align
);
4039 /* Mark all constants that are used in the current function, then write
4040 out the function's private constant pool. */
4043 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED
,
4044 tree fndecl ATTRIBUTE_UNUSED
)
4046 struct rtx_constant_pool
*pool
= crtl
->varasm
.pool
;
4048 /* It is possible for gcc to call force_const_mem and then to later
4049 discard the instructions which refer to the constant. In such a
4050 case we do not need to output the constant. */
4051 mark_constant_pool ();
4053 #ifdef ASM_OUTPUT_POOL_PROLOGUE
4054 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4057 output_constant_pool_contents (pool
);
4059 #ifdef ASM_OUTPUT_POOL_EPILOGUE
4060 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
4064 /* Write the contents of the shared constant pool. */
4067 output_shared_constant_pool (void)
4069 output_constant_pool_contents (shared_constant_pool
);
4072 /* Determine what kind of relocations EXP may need. */
4075 compute_reloc_for_constant (tree exp
)
4077 int reloc
= 0, reloc2
;
4080 switch (TREE_CODE (exp
))
4084 /* Go inside any operations that get_inner_reference can handle and see
4085 if what's inside is a constant: no need to do anything here for
4086 addresses of variables or functions. */
4087 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4088 tem
= TREE_OPERAND (tem
, 0))
4091 if (TREE_CODE (tem
) == MEM_REF
4092 && TREE_CODE (TREE_OPERAND (tem
, 0)) == ADDR_EXPR
)
4094 reloc
= compute_reloc_for_constant (TREE_OPERAND (tem
, 0));
4098 if (!targetm
.binds_local_p (tem
))
4105 case POINTER_PLUS_EXPR
:
4106 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4107 reloc
|= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4111 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4112 reloc2
= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
4113 /* The difference of two local labels is computable at link time. */
4114 if (reloc
== 1 && reloc2
== 1)
4121 case VIEW_CONVERT_EXPR
:
4122 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
4127 unsigned HOST_WIDE_INT idx
;
4128 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4130 reloc
|= compute_reloc_for_constant (tem
);
4140 /* Find all the constants whose addresses are referenced inside of EXP,
4141 and make sure assembler code with a label has been output for each one.
4142 Indicate whether an ADDR_EXPR has been encountered. */
4145 output_addressed_constants (tree exp
)
4149 switch (TREE_CODE (exp
))
4153 /* Go inside any operations that get_inner_reference can handle and see
4154 if what's inside is a constant: no need to do anything here for
4155 addresses of variables or functions. */
4156 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4157 tem
= TREE_OPERAND (tem
, 0))
4160 /* If we have an initialized CONST_DECL, retrieve the initializer. */
4161 if (TREE_CODE (tem
) == CONST_DECL
&& DECL_INITIAL (tem
))
4162 tem
= DECL_INITIAL (tem
);
4164 if (CONSTANT_CLASS_P (tem
) || TREE_CODE (tem
) == CONSTRUCTOR
)
4165 output_constant_def (tem
, 0);
4167 if (TREE_CODE (tem
) == MEM_REF
)
4168 output_addressed_constants (TREE_OPERAND (tem
, 0));
4172 case POINTER_PLUS_EXPR
:
4174 output_addressed_constants (TREE_OPERAND (exp
, 1));
4178 case VIEW_CONVERT_EXPR
:
4179 output_addressed_constants (TREE_OPERAND (exp
, 0));
4184 unsigned HOST_WIDE_INT idx
;
4185 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp
), idx
, tem
)
4187 output_addressed_constants (tem
);
4196 /* Whether a constructor CTOR is a valid static constant initializer if all
4197 its elements are. This used to be internal to initializer_constant_valid_p
4198 and has been exposed to let other functions like categorize_ctor_elements
4199 evaluate the property while walking a constructor for other purposes. */
4202 constructor_static_from_elts_p (const_tree ctor
)
4204 return (TREE_CONSTANT (ctor
)
4205 && (TREE_CODE (TREE_TYPE (ctor
)) == UNION_TYPE
4206 || TREE_CODE (TREE_TYPE (ctor
)) == RECORD_TYPE
4207 || TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
));
4210 static tree
initializer_constant_valid_p_1 (tree value
, tree endtype
,
4213 /* A subroutine of initializer_constant_valid_p. VALUE is a MINUS_EXPR,
4214 PLUS_EXPR or POINTER_PLUS_EXPR. This looks for cases of VALUE
4215 which are valid when ENDTYPE is an integer of any size; in
4216 particular, this does not accept a pointer minus a constant. This
4217 returns null_pointer_node if the VALUE is an absolute constant
4218 which can be used to initialize a static variable. Otherwise it
4222 narrowing_initializer_constant_valid_p (tree value
, tree endtype
, tree
*cache
)
4226 if (!INTEGRAL_TYPE_P (endtype
))
4229 op0
= TREE_OPERAND (value
, 0);
4230 op1
= TREE_OPERAND (value
, 1);
4232 /* Like STRIP_NOPS except allow the operand mode to widen. This
4233 works around a feature of fold that simplifies (int)(p1 - p2) to
4234 ((int)p1 - (int)p2) under the theory that the narrower operation
4237 while (CONVERT_EXPR_P (op0
)
4238 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4240 tree inner
= TREE_OPERAND (op0
, 0);
4241 if (inner
== error_mark_node
4242 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4243 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
4244 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4249 while (CONVERT_EXPR_P (op1
)
4250 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
4252 tree inner
= TREE_OPERAND (op1
, 0);
4253 if (inner
== error_mark_node
4254 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4255 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
4256 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4261 op0
= initializer_constant_valid_p_1 (op0
, endtype
, cache
);
4265 op1
= initializer_constant_valid_p_1 (op1
, endtype
,
4266 cache
? cache
+ 2 : NULL
);
4267 /* Both initializers must be known. */
4271 && (op0
== null_pointer_node
4272 || TREE_CODE (value
) == MINUS_EXPR
))
4273 return null_pointer_node
;
4275 /* Support differences between labels. */
4276 if (TREE_CODE (op0
) == LABEL_DECL
4277 && TREE_CODE (op1
) == LABEL_DECL
)
4278 return null_pointer_node
;
4280 if (TREE_CODE (op0
) == STRING_CST
4281 && TREE_CODE (op1
) == STRING_CST
4282 && operand_equal_p (op0
, op1
, 1))
4283 return null_pointer_node
;
4289 /* Helper function of initializer_constant_valid_p.
4290 Return nonzero if VALUE is a valid constant-valued expression
4291 for use in initializing a static variable; one that can be an
4292 element of a "constant" initializer.
4294 Return null_pointer_node if the value is absolute;
4295 if it is relocatable, return the variable that determines the relocation.
4296 We assume that VALUE has been folded as much as possible;
4297 therefore, we do not need to check for such things as
4298 arithmetic-combinations of integers.
4300 Use CACHE (pointer to 2 tree values) for caching if non-NULL. */
4303 initializer_constant_valid_p_1 (tree value
, tree endtype
, tree
*cache
)
4307 switch (TREE_CODE (value
))
4310 if (constructor_static_from_elts_p (value
))
4312 unsigned HOST_WIDE_INT idx
;
4314 bool absolute
= true;
4316 if (cache
&& cache
[0] == value
)
4318 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4321 reloc
= initializer_constant_valid_p_1 (elt
, TREE_TYPE (elt
),
4324 /* An absolute value is required with reverse SSO. */
4325 || (reloc
!= null_pointer_node
4326 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (value
))
4327 && !AGGREGATE_TYPE_P (TREE_TYPE (elt
))))
4332 cache
[1] = NULL_TREE
;
4336 if (reloc
!= null_pointer_node
)
4339 /* For a non-absolute relocation, there is no single
4340 variable that can be "the variable that determines the
4345 cache
[1] = absolute
? null_pointer_node
: error_mark_node
;
4347 return absolute
? null_pointer_node
: error_mark_node
;
4350 return TREE_STATIC (value
) ? null_pointer_node
: NULL_TREE
;
4358 return null_pointer_node
;
4363 tree op0
= staticp (TREE_OPERAND (value
, 0));
4366 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out
4367 to be a constant, this is old-skool offsetof-like nonsense. */
4368 if (TREE_CODE (op0
) == INDIRECT_REF
4369 && TREE_CONSTANT (TREE_OPERAND (op0
, 0)))
4370 return null_pointer_node
;
4371 /* Taking the address of a nested function involves a trampoline,
4372 unless we don't need or want one. */
4373 if (TREE_CODE (op0
) == FUNCTION_DECL
4374 && DECL_STATIC_CHAIN (op0
)
4375 && !TREE_NO_TRAMPOLINE (value
))
4377 /* "&{...}" requires a temporary to hold the constructed
4379 if (TREE_CODE (op0
) == CONSTRUCTOR
)
4385 case NON_LVALUE_EXPR
:
4386 return initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4389 case VIEW_CONVERT_EXPR
:
4391 tree src
= TREE_OPERAND (value
, 0);
4392 tree src_type
= TREE_TYPE (src
);
4393 tree dest_type
= TREE_TYPE (value
);
4395 /* Allow view-conversions from aggregate to non-aggregate type only
4396 if the bit pattern is fully preserved afterwards; otherwise, the
4397 RTL expander won't be able to apply a subsequent transformation
4398 to the underlying constructor. */
4399 if (AGGREGATE_TYPE_P (src_type
) && !AGGREGATE_TYPE_P (dest_type
))
4401 if (TYPE_MODE (endtype
) == TYPE_MODE (dest_type
))
4402 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4407 /* Allow all other kinds of view-conversion. */
4408 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4413 tree src
= TREE_OPERAND (value
, 0);
4414 tree src_type
= TREE_TYPE (src
);
4415 tree dest_type
= TREE_TYPE (value
);
4417 /* Allow conversions between pointer types, floating-point
4418 types, and offset types. */
4419 if ((POINTER_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
))
4420 || (FLOAT_TYPE_P (dest_type
) && FLOAT_TYPE_P (src_type
))
4421 || (TREE_CODE (dest_type
) == OFFSET_TYPE
4422 && TREE_CODE (src_type
) == OFFSET_TYPE
))
4423 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4425 /* Allow length-preserving conversions between integer types. */
4426 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
)
4427 && (TYPE_PRECISION (dest_type
) == TYPE_PRECISION (src_type
)))
4428 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4430 /* Allow conversions between other integer types only if
4432 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
))
4434 tree inner
= initializer_constant_valid_p_1 (src
, endtype
, cache
);
4435 if (inner
== null_pointer_node
)
4436 return null_pointer_node
;
4440 /* Allow (int) &foo provided int is as wide as a pointer. */
4441 if (INTEGRAL_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
)
4442 && (TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
)))
4443 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4445 /* Likewise conversions from int to pointers, but also allow
4446 conversions from 0. */
4447 if ((POINTER_TYPE_P (dest_type
)
4448 || TREE_CODE (dest_type
) == OFFSET_TYPE
)
4449 && INTEGRAL_TYPE_P (src_type
))
4451 if (TREE_CODE (src
) == INTEGER_CST
4452 && TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
))
4453 return null_pointer_node
;
4454 if (integer_zerop (src
))
4455 return null_pointer_node
;
4456 else if (TYPE_PRECISION (dest_type
) <= TYPE_PRECISION (src_type
))
4457 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4460 /* Allow conversions to struct or union types if the value
4462 if (TREE_CODE (dest_type
) == RECORD_TYPE
4463 || TREE_CODE (dest_type
) == UNION_TYPE
)
4464 return initializer_constant_valid_p_1 (src
, endtype
, cache
);
4468 case POINTER_PLUS_EXPR
:
4470 /* Any valid floating-point constants will have been folded by now;
4471 with -frounding-math we hit this with addition of two constants. */
4472 if (TREE_CODE (endtype
) == REAL_TYPE
)
4474 if (cache
&& cache
[0] == value
)
4476 if (! INTEGRAL_TYPE_P (endtype
)
4477 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4479 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4481 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4484 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4485 endtype
, ncache
+ 2);
4486 /* If either term is absolute, use the other term's relocation. */
4487 if (valid0
== null_pointer_node
)
4489 else if (valid1
== null_pointer_node
)
4491 /* Support narrowing pointer differences. */
4493 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4497 /* Support narrowing pointer differences. */
4498 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4507 if (TREE_CODE (endtype
) == REAL_TYPE
)
4509 if (cache
&& cache
[0] == value
)
4511 if (! INTEGRAL_TYPE_P (endtype
)
4512 || TYPE_PRECISION (endtype
) >= TYPE_PRECISION (TREE_TYPE (value
)))
4514 tree ncache
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
4516 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 0),
4519 = initializer_constant_valid_p_1 (TREE_OPERAND (value
, 1),
4520 endtype
, ncache
+ 2);
4521 /* Win if second argument is absolute. */
4522 if (valid1
== null_pointer_node
)
4524 /* Win if both arguments have the same relocation.
4525 Then the value is absolute. */
4526 else if (valid0
== valid1
&& valid0
!= 0)
4527 ret
= null_pointer_node
;
4528 /* Since GCC guarantees that string constants are unique in the
4529 generated code, a subtraction between two copies of the same
4530 constant string is absolute. */
4531 else if (valid0
&& TREE_CODE (valid0
) == STRING_CST
4532 && valid1
&& TREE_CODE (valid1
) == STRING_CST
4533 && operand_equal_p (valid0
, valid1
, 1))
4534 ret
= null_pointer_node
;
4535 /* Support narrowing differences. */
4537 ret
= narrowing_initializer_constant_valid_p (value
, endtype
,
4541 /* Support narrowing differences. */
4542 ret
= narrowing_initializer_constant_valid_p (value
, endtype
, NULL
);
4557 /* Return nonzero if VALUE is a valid constant-valued expression
4558 for use in initializing a static variable; one that can be an
4559 element of a "constant" initializer.
4561 Return null_pointer_node if the value is absolute;
4562 if it is relocatable, return the variable that determines the relocation.
4563 We assume that VALUE has been folded as much as possible;
4564 therefore, we do not need to check for such things as
4565 arithmetic-combinations of integers. */
4567 initializer_constant_valid_p (tree value
, tree endtype
, bool reverse
)
4569 tree reloc
= initializer_constant_valid_p_1 (value
, endtype
, NULL
);
4571 /* An absolute value is required with reverse storage order. */
4573 && reloc
!= null_pointer_node
4575 && !AGGREGATE_TYPE_P (endtype
)
4576 && !VECTOR_TYPE_P (endtype
))
4582 /* Return true if VALUE is a valid constant-valued expression
4583 for use in initializing a static bit-field; one that can be
4584 an element of a "constant" initializer. */
4587 initializer_constant_valid_for_bitfield_p (tree value
)
4589 /* For bitfields we support integer constants or possibly nested aggregates
4591 switch (TREE_CODE (value
))
4595 unsigned HOST_WIDE_INT idx
;
4598 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value
), idx
, elt
)
4599 if (!initializer_constant_valid_for_bitfield_p (elt
))
4608 case VIEW_CONVERT_EXPR
:
4609 case NON_LVALUE_EXPR
:
4611 initializer_constant_valid_for_bitfield_p (TREE_OPERAND (value
, 0));
4620 /* output_constructor outer state of relevance in recursive calls, typically
4621 for nested aggregate bitfields. */
4623 struct oc_outer_state
{
4624 unsigned int bit_offset
; /* current position in ... */
4625 int byte
; /* ... the outer byte buffer. */
4628 static unsigned HOST_WIDE_INT
4629 output_constructor (tree
, unsigned HOST_WIDE_INT
, unsigned int, bool,
4632 /* Output assembler code for constant EXP, with no label.
4633 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4634 Assumes output_addressed_constants has been done on EXP already.
4636 Generate at least SIZE bytes of assembler data, padding at the end
4637 with zeros if necessary. SIZE must always be specified. The returned
4638 value is the actual number of bytes of assembler data generated, which
4639 may be bigger than SIZE if the object contains a variable length field.
4641 SIZE is important for structure constructors,
4642 since trailing members may have been omitted from the constructor.
4643 It is also important for initialization of arrays from string constants
4644 since the full length of the string constant might not be wanted.
4645 It is also needed for initialization of unions, where the initializer's
4646 type is just one member, and that may not be as long as the union.
4648 There a case in which we would fail to output exactly SIZE bytes:
4649 for a structure constructor that wants to produce more than SIZE bytes.
4650 But such constructors will never be generated for any possible input.
4652 ALIGN is the alignment of the data in bits.
4654 If REVERSE is true, EXP is output in reverse storage order. */
4656 static unsigned HOST_WIDE_INT
4657 output_constant (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
,
4660 enum tree_code code
;
4661 unsigned HOST_WIDE_INT thissize
;
4664 if (size
== 0 || flag_syntax_only
)
4667 /* See if we're trying to initialize a pointer in a non-default mode
4668 to the address of some declaration somewhere. If the target says
4669 the mode is valid for pointers, assume the target has a way of
4671 if (TREE_CODE (exp
) == NOP_EXPR
4672 && POINTER_TYPE_P (TREE_TYPE (exp
))
4673 && targetm
.addr_space
.valid_pointer_mode
4674 (TYPE_MODE (TREE_TYPE (exp
)),
4675 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4677 tree saved_type
= TREE_TYPE (exp
);
4679 /* Peel off any intermediate conversions-to-pointer for valid
4681 while (TREE_CODE (exp
) == NOP_EXPR
4682 && POINTER_TYPE_P (TREE_TYPE (exp
))
4683 && targetm
.addr_space
.valid_pointer_mode
4684 (TYPE_MODE (TREE_TYPE (exp
)),
4685 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp
)))))
4686 exp
= TREE_OPERAND (exp
, 0);
4688 /* If what we're left with is the address of something, we can
4689 convert the address to the final type and output it that
4691 if (TREE_CODE (exp
) == ADDR_EXPR
)
4692 exp
= build1 (ADDR_EXPR
, saved_type
, TREE_OPERAND (exp
, 0));
4693 /* Likewise for constant ints. */
4694 else if (TREE_CODE (exp
) == INTEGER_CST
)
4695 exp
= fold_convert (saved_type
, exp
);
4699 /* Eliminate any conversions since we'll be outputting the underlying
4701 while (CONVERT_EXPR_P (exp
)
4702 || TREE_CODE (exp
) == NON_LVALUE_EXPR
4703 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
4705 HOST_WIDE_INT type_size
= int_size_in_bytes (TREE_TYPE (exp
));
4706 HOST_WIDE_INT op_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp
, 0)));
4708 /* Make sure eliminating the conversion is really a no-op, except with
4709 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4710 union types to allow for Ada unchecked unions. */
4711 if (type_size
> op_size
4712 && TREE_CODE (exp
) != VIEW_CONVERT_EXPR
4713 && TREE_CODE (TREE_TYPE (exp
)) != UNION_TYPE
)
4714 /* Keep the conversion. */
4717 exp
= TREE_OPERAND (exp
, 0);
4720 code
= TREE_CODE (TREE_TYPE (exp
));
4721 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
4723 /* Allow a constructor with no elements for any data type.
4724 This means to fill the space with zeros. */
4725 if (TREE_CODE (exp
) == CONSTRUCTOR
4726 && vec_safe_is_empty (CONSTRUCTOR_ELTS (exp
)))
4728 assemble_zeros (size
);
4732 if (TREE_CODE (exp
) == FDESC_EXPR
)
4734 #ifdef ASM_OUTPUT_FDESC
4735 HOST_WIDE_INT part
= tree_to_shwi (TREE_OPERAND (exp
, 1));
4736 tree decl
= TREE_OPERAND (exp
, 0);
4737 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
4744 /* Now output the underlying data. If we've handling the padding, return.
4745 Otherwise, break and ensure SIZE is the size written. */
4752 case REFERENCE_TYPE
:
4754 case FIXED_POINT_TYPE
:
4755 case POINTER_BOUNDS_TYPE
:
4757 cst
= expand_expr (exp
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
4759 cst
= flip_storage_order (TYPE_MODE (TREE_TYPE (exp
)), cst
);
4760 if (!assemble_integer (cst
, MIN (size
, thissize
), align
, 0))
4761 error ("initializer for integer/fixed-point value is too complicated");
4765 if (TREE_CODE (exp
) != REAL_CST
)
4766 error ("initializer for floating value is not a floating constant");
4768 assemble_real (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)),
4773 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
, reverse
);
4774 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
4775 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)),
4781 switch (TREE_CODE (exp
))
4784 return output_constructor (exp
, size
, align
, reverse
, NULL
);
4787 = MIN ((unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
), size
);
4788 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
4792 machine_mode inner
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
4793 unsigned int nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
4794 int elt_size
= GET_MODE_SIZE (inner
);
4795 output_constant (VECTOR_CST_ELT (exp
, 0), elt_size
, align
,
4797 thissize
= elt_size
;
4798 for (unsigned int i
= 1; i
< VECTOR_CST_NELTS (exp
); i
++)
4800 output_constant (VECTOR_CST_ELT (exp
, i
), elt_size
, nalign
,
4802 thissize
+= elt_size
;
4813 gcc_assert (TREE_CODE (exp
) == CONSTRUCTOR
);
4814 return output_constructor (exp
, size
, align
, reverse
, NULL
);
4823 if (size
> thissize
)
4824 assemble_zeros (size
- thissize
);
4829 /* Subroutine of output_constructor, used for computing the size of
4830 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4831 type with an unspecified upper bound. */
4833 static unsigned HOST_WIDE_INT
4834 array_size_for_constructor (tree val
)
4837 unsigned HOST_WIDE_INT cnt
;
4838 tree index
, value
, tmp
;
4841 /* This code used to attempt to handle string constants that are not
4842 arrays of single-bytes, but nothing else does, so there's no point in
4844 if (TREE_CODE (val
) == STRING_CST
)
4845 return TREE_STRING_LENGTH (val
);
4847 max_index
= NULL_TREE
;
4848 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val
), cnt
, index
, value
)
4850 if (TREE_CODE (index
) == RANGE_EXPR
)
4851 index
= TREE_OPERAND (index
, 1);
4852 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4856 if (max_index
== NULL_TREE
)
4859 /* Compute the total number of array elements. */
4860 tmp
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)));
4861 i
= wi::to_offset (max_index
) - wi::to_offset (tmp
) + 1;
4863 /* Multiply by the array element unit size to find number of bytes. */
4864 i
*= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4866 gcc_assert (wi::fits_uhwi_p (i
));
4867 return i
.to_uhwi ();
4870 /* Other datastructures + helpers for output_constructor. */
4872 /* output_constructor local state to support interaction with helpers. */
4874 struct oc_local_state
{
4876 /* Received arguments. */
4877 tree exp
; /* Constructor expression. */
4878 tree type
; /* Type of constructor expression. */
4879 unsigned HOST_WIDE_INT size
; /* # bytes to output - pad if necessary. */
4880 unsigned int align
; /* Known initial alignment. */
4881 tree min_index
; /* Lower bound if specified for an array. */
4883 /* Output processing state. */
4884 HOST_WIDE_INT total_bytes
; /* # bytes output so far / current position. */
4885 int byte
; /* Part of a bitfield byte yet to be output. */
4886 int last_relative_index
; /* Implicit or explicit index of the last
4887 array element output within a bitfield. */
4888 bool byte_buffer_in_use
; /* Whether BYTE is in use. */
4889 bool reverse
; /* Whether reverse storage order is in use. */
4891 /* Current element. */
4892 tree field
; /* Current field decl in a record. */
4893 tree val
; /* Current element value. */
4894 tree index
; /* Current element index. */
4898 /* Helper for output_constructor. From the current LOCAL state, output a
4899 RANGE_EXPR element. */
4902 output_constructor_array_range (oc_local_state
*local
)
4904 unsigned HOST_WIDE_INT fieldsize
4905 = int_size_in_bytes (TREE_TYPE (local
->type
));
4907 HOST_WIDE_INT lo_index
4908 = tree_to_shwi (TREE_OPERAND (local
->index
, 0));
4909 HOST_WIDE_INT hi_index
4910 = tree_to_shwi (TREE_OPERAND (local
->index
, 1));
4911 HOST_WIDE_INT index
;
4914 = min_align (local
->align
, fieldsize
* BITS_PER_UNIT
);
4916 for (index
= lo_index
; index
<= hi_index
; index
++)
4918 /* Output the element's initial value. */
4919 if (local
->val
== NULL_TREE
)
4920 assemble_zeros (fieldsize
);
4923 = output_constant (local
->val
, fieldsize
, align2
, local
->reverse
);
4925 /* Count its size. */
4926 local
->total_bytes
+= fieldsize
;
4930 /* Helper for output_constructor. From the current LOCAL state, output a
4931 field element that is not true bitfield or part of an outer one. */
4934 output_constructor_regular_field (oc_local_state
*local
)
4936 /* Field size and position. Since this structure is static, we know the
4937 positions are constant. */
4938 unsigned HOST_WIDE_INT fieldsize
;
4939 HOST_WIDE_INT fieldpos
;
4941 unsigned int align2
;
4943 /* Output any buffered-up bit-fields preceding this element. */
4944 if (local
->byte_buffer_in_use
)
4946 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
4947 local
->total_bytes
++;
4948 local
->byte_buffer_in_use
= false;
4951 if (local
->index
!= NULL_TREE
)
4953 /* Perform the index calculation in modulo arithmetic but
4954 sign-extend the result because Ada has negative DECL_FIELD_OFFSETs
4955 but we are using an unsigned sizetype. */
4956 unsigned prec
= TYPE_PRECISION (sizetype
);
4957 offset_int idx
= wi::sext (wi::to_offset (local
->index
)
4958 - wi::to_offset (local
->min_index
), prec
);
4959 fieldpos
= (idx
* wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (local
->val
))))
4962 else if (local
->field
!= NULL_TREE
)
4963 fieldpos
= int_byte_position (local
->field
);
4967 /* Advance to offset of this element.
4968 Note no alignment needed in an array, since that is guaranteed
4969 if each element has the proper size. */
4970 if (local
->field
!= NULL_TREE
|| local
->index
!= NULL_TREE
)
4972 if (fieldpos
> local
->total_bytes
)
4974 assemble_zeros (fieldpos
- local
->total_bytes
);
4975 local
->total_bytes
= fieldpos
;
4978 /* Must not go backwards. */
4979 gcc_assert (fieldpos
== local
->total_bytes
);
4982 /* Find the alignment of this element. */
4983 align2
= min_align (local
->align
, BITS_PER_UNIT
* fieldpos
);
4985 /* Determine size this element should occupy. */
4990 /* If this is an array with an unspecified upper bound,
4991 the initializer determines the size. */
4992 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4993 but we cannot do this until the deprecated support for
4994 initializing zero-length array members is removed. */
4995 if (TREE_CODE (TREE_TYPE (local
->field
)) == ARRAY_TYPE
4996 && (!TYPE_DOMAIN (TREE_TYPE (local
->field
))
4997 || !TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (local
->field
)))))
4999 fieldsize
= array_size_for_constructor (local
->val
);
5000 /* Given a non-empty initialization, this field had better
5001 be last. Given a flexible array member, the next field
5002 on the chain is a TYPE_DECL of the enclosing struct. */
5003 const_tree next
= DECL_CHAIN (local
->field
);
5004 gcc_assert (!fieldsize
|| !next
|| TREE_CODE (next
) != FIELD_DECL
);
5007 fieldsize
= tree_to_uhwi (DECL_SIZE_UNIT (local
->field
));
5010 fieldsize
= int_size_in_bytes (TREE_TYPE (local
->type
));
5012 /* Output the element's initial value. */
5013 if (local
->val
== NULL_TREE
)
5014 assemble_zeros (fieldsize
);
5017 = output_constant (local
->val
, fieldsize
, align2
, local
->reverse
);
5019 /* Count its size. */
5020 local
->total_bytes
+= fieldsize
;
5023 /* Helper for output_constructor. From the LOCAL state, output an element
5024 that is a true bitfield or part of an outer one. BIT_OFFSET is the offset
5025 from the start of a possibly ongoing outer byte buffer. */
5028 output_constructor_bitfield (oc_local_state
*local
, unsigned int bit_offset
)
5030 /* Bit size of this element. */
5031 HOST_WIDE_INT ebitsize
5033 ? tree_to_uhwi (DECL_SIZE (local
->field
))
5034 : tree_to_uhwi (TYPE_SIZE (TREE_TYPE (local
->type
))));
5036 /* Relative index of this element if this is an array component. */
5037 HOST_WIDE_INT relative_index
5040 ? (tree_to_shwi (local
->index
)
5041 - tree_to_shwi (local
->min_index
))
5042 : local
->last_relative_index
+ 1)
5045 /* Bit position of this element from the start of the containing
5047 HOST_WIDE_INT constructor_relative_ebitpos
5049 ? int_bit_position (local
->field
)
5050 : ebitsize
* relative_index
);
5052 /* Bit position of this element from the start of a possibly ongoing
5053 outer byte buffer. */
5054 HOST_WIDE_INT byte_relative_ebitpos
5055 = bit_offset
+ constructor_relative_ebitpos
;
5057 /* From the start of a possibly ongoing outer byte buffer, offsets to
5058 the first bit of this element and to the first bit past the end of
5060 HOST_WIDE_INT next_offset
= byte_relative_ebitpos
;
5061 HOST_WIDE_INT end_offset
= byte_relative_ebitpos
+ ebitsize
;
5063 local
->last_relative_index
= relative_index
;
5065 if (local
->val
== NULL_TREE
)
5066 local
->val
= integer_zero_node
;
5068 while (TREE_CODE (local
->val
) == VIEW_CONVERT_EXPR
5069 || TREE_CODE (local
->val
) == NON_LVALUE_EXPR
)
5070 local
->val
= TREE_OPERAND (local
->val
, 0);
5072 if (TREE_CODE (local
->val
) != INTEGER_CST
5073 && TREE_CODE (local
->val
) != CONSTRUCTOR
)
5075 error ("invalid initial value for member %qE", DECL_NAME (local
->field
));
5079 /* If this field does not start in this (or next) byte, skip some bytes. */
5080 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
5082 /* Output remnant of any bit field in previous bytes. */
5083 if (local
->byte_buffer_in_use
)
5085 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5086 local
->total_bytes
++;
5087 local
->byte_buffer_in_use
= false;
5090 /* If still not at proper byte, advance to there. */
5091 if (next_offset
/ BITS_PER_UNIT
!= local
->total_bytes
)
5093 gcc_assert (next_offset
/ BITS_PER_UNIT
>= local
->total_bytes
);
5094 assemble_zeros (next_offset
/ BITS_PER_UNIT
- local
->total_bytes
);
5095 local
->total_bytes
= next_offset
/ BITS_PER_UNIT
;
5099 /* Set up the buffer if necessary. */
5100 if (!local
->byte_buffer_in_use
)
5104 local
->byte_buffer_in_use
= true;
5107 /* If this is nested constructor, recurse passing the bit offset and the
5108 pending data, then retrieve the new pending data afterwards. */
5109 if (TREE_CODE (local
->val
) == CONSTRUCTOR
)
5111 oc_outer_state temp_state
;
5112 temp_state
.bit_offset
= next_offset
% BITS_PER_UNIT
;
5113 temp_state
.byte
= local
->byte
;
5115 += output_constructor (local
->val
, 0, 0, local
->reverse
, &temp_state
);
5116 local
->byte
= temp_state
.byte
;
5120 /* Otherwise, we must split the element into pieces that fall within
5121 separate bytes, and combine each byte with previous or following
5123 while (next_offset
< end_offset
)
5127 HOST_WIDE_INT value
;
5128 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
5129 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
5131 /* Advance from byte to byte within this element when necessary. */
5132 while (next_byte
!= local
->total_bytes
)
5134 assemble_integer (GEN_INT (local
->byte
), 1, BITS_PER_UNIT
, 1);
5135 local
->total_bytes
++;
5139 /* Number of bits we can process at once (all part of the same byte). */
5140 this_time
= MIN (end_offset
- next_offset
, BITS_PER_UNIT
- next_bit
);
5141 if (local
->reverse
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5143 /* For big-endian data, take the most significant bits (of the
5144 bits that are significant) first and put them into bytes from
5145 the most significant end. */
5146 shift
= end_offset
- next_offset
- this_time
;
5148 /* Don't try to take a bunch of bits that cross
5149 the word boundary in the INTEGER_CST. We can
5150 only select bits from one element. */
5151 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5152 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5154 const int end
= shift
+ this_time
- 1;
5155 shift
= end
& -HOST_BITS_PER_WIDE_INT
;
5156 this_time
= end
- shift
+ 1;
5159 /* Now get the bits from the appropriate constant word. */
5160 value
= TREE_INT_CST_ELT (local
->val
, shift
/ HOST_BITS_PER_WIDE_INT
);
5161 shift
= shift
& (HOST_BITS_PER_WIDE_INT
- 1);
5163 /* Get the result. This works only when:
5164 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5165 local
->byte
|= (((value
>> shift
)
5166 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
5167 << (BITS_PER_UNIT
- this_time
- next_bit
));
5171 /* On little-endian machines, take the least significant bits of
5172 the value first and pack them starting at the least significant
5173 bits of the bytes. */
5174 shift
= next_offset
- byte_relative_ebitpos
;
5176 /* Don't try to take a bunch of bits that cross
5177 the word boundary in the INTEGER_CST. We can
5178 only select bits from one element. */
5179 if ((shift
/ HOST_BITS_PER_WIDE_INT
)
5180 != ((shift
+ this_time
- 1) / HOST_BITS_PER_WIDE_INT
))
5182 = HOST_BITS_PER_WIDE_INT
- (shift
& (HOST_BITS_PER_WIDE_INT
- 1));
5184 /* Now get the bits from the appropriate constant word. */
5185 value
= TREE_INT_CST_ELT (local
->val
, shift
/ HOST_BITS_PER_WIDE_INT
);
5186 shift
= shift
& (HOST_BITS_PER_WIDE_INT
- 1);
5188 /* Get the result. This works only when:
5189 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
5190 local
->byte
|= (((value
>> shift
)
5191 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
5195 next_offset
+= this_time
;
5196 local
->byte_buffer_in_use
= true;
5200 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
5201 Generate at least SIZE bytes, padding if necessary. OUTER designates the
5202 caller output state of relevance in recursive invocations. */
5204 static unsigned HOST_WIDE_INT
5205 output_constructor (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
,
5206 bool reverse
, oc_outer_state
*outer
)
5208 unsigned HOST_WIDE_INT cnt
;
5209 constructor_elt
*ce
;
5210 oc_local_state local
;
5212 /* Setup our local state to communicate with helpers. */
5214 local
.type
= TREE_TYPE (exp
);
5216 local
.align
= align
;
5217 if (TREE_CODE (local
.type
) == ARRAY_TYPE
&& TYPE_DOMAIN (local
.type
))
5218 local
.min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (local
.type
));
5220 local
.min_index
= integer_zero_node
;
5222 local
.total_bytes
= 0;
5223 local
.byte_buffer_in_use
= outer
!= NULL
;
5224 local
.byte
= outer
? outer
->byte
: 0;
5225 local
.last_relative_index
= -1;
5226 /* The storage order is specified for every aggregate type. */
5227 if (AGGREGATE_TYPE_P (local
.type
))
5228 local
.reverse
= TYPE_REVERSE_STORAGE_ORDER (local
.type
);
5230 local
.reverse
= reverse
;
5232 gcc_assert (HOST_BITS_PER_WIDE_INT
>= BITS_PER_UNIT
);
5234 /* As CE goes through the elements of the constant, FIELD goes through the
5235 structure fields if the constant is a structure. If the constant is a
5236 union, we override this by getting the field from the TREE_LIST element.
5237 But the constant could also be an array. Then FIELD is zero.
5239 There is always a maximum of one element in the chain LINK for unions
5240 (even if the initializer in a source program incorrectly contains
5243 if (TREE_CODE (local
.type
) == RECORD_TYPE
)
5244 local
.field
= TYPE_FIELDS (local
.type
);
5246 local
.field
= NULL_TREE
;
5249 vec_safe_iterate (CONSTRUCTOR_ELTS (exp
), cnt
, &ce
);
5250 cnt
++, local
.field
= local
.field
? DECL_CHAIN (local
.field
) : 0)
5252 local
.val
= ce
->value
;
5253 local
.index
= NULL_TREE
;
5255 /* The element in a union constructor specifies the proper field
5257 if (RECORD_OR_UNION_TYPE_P (local
.type
) && ce
->index
!= NULL_TREE
)
5258 local
.field
= ce
->index
;
5260 else if (TREE_CODE (local
.type
) == ARRAY_TYPE
)
5261 local
.index
= ce
->index
;
5263 if (local
.field
&& flag_verbose_asm
)
5264 fprintf (asm_out_file
, "%s %s:\n",
5266 DECL_NAME (local
.field
)
5267 ? IDENTIFIER_POINTER (DECL_NAME (local
.field
))
5270 /* Eliminate the marker that makes a cast not be an lvalue. */
5271 if (local
.val
!= NULL_TREE
)
5272 STRIP_NOPS (local
.val
);
5274 /* Output the current element, using the appropriate helper ... */
5276 /* For an array slice not part of an outer bitfield. */
5278 && local
.index
!= NULL_TREE
5279 && TREE_CODE (local
.index
) == RANGE_EXPR
)
5280 output_constructor_array_range (&local
);
5282 /* For a field that is neither a true bitfield nor part of an outer one,
5283 known to be at least byte aligned and multiple-of-bytes long. */
5285 && (local
.field
== NULL_TREE
5286 || !CONSTRUCTOR_BITFIELD_P (local
.field
)))
5287 output_constructor_regular_field (&local
);
5289 /* For a true bitfield or part of an outer one. Only INTEGER_CSTs are
5290 supported for scalar fields, so we may need to convert first. */
5293 if (TREE_CODE (local
.val
) == REAL_CST
)
5295 = fold_unary (VIEW_CONVERT_EXPR
,
5296 build_nonstandard_integer_type
5297 (TYPE_PRECISION (TREE_TYPE (local
.val
)), 0),
5299 output_constructor_bitfield (&local
, outer
? outer
->bit_offset
: 0);
5303 /* If we are not at toplevel, save the pending data for our caller.
5304 Otherwise output the pending data and padding zeros as needed. */
5306 outer
->byte
= local
.byte
;
5309 if (local
.byte_buffer_in_use
)
5311 assemble_integer (GEN_INT (local
.byte
), 1, BITS_PER_UNIT
, 1);
5312 local
.total_bytes
++;
5315 if ((unsigned HOST_WIDE_INT
)local
.total_bytes
< local
.size
)
5317 assemble_zeros (local
.size
- local
.total_bytes
);
5318 local
.total_bytes
= local
.size
;
5322 return local
.total_bytes
;
5325 /* Mark DECL as weak. */
5328 mark_weak (tree decl
)
5330 if (DECL_WEAK (decl
))
5333 struct symtab_node
*n
= symtab_node::get (decl
);
5334 if (n
&& n
->refuse_visibility_changes
)
5335 error ("%+D declared weak after being used", decl
);
5336 DECL_WEAK (decl
) = 1;
5338 if (DECL_RTL_SET_P (decl
)
5339 && MEM_P (DECL_RTL (decl
))
5340 && XEXP (DECL_RTL (decl
), 0)
5341 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
5342 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
5345 /* Merge weak status between NEWDECL and OLDDECL. */
5348 merge_weak (tree newdecl
, tree olddecl
)
5350 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
5352 if (DECL_WEAK (newdecl
) && TARGET_SUPPORTS_WEAK
)
5355 /* We put the NEWDECL on the weak_decls list at some point
5356 and OLDDECL as well. Keep just OLDDECL on the list. */
5357 for (pwd
= &weak_decls
; *pwd
; pwd
= &TREE_CHAIN (*pwd
))
5358 if (TREE_VALUE (*pwd
) == newdecl
)
5360 *pwd
= TREE_CHAIN (*pwd
);
5367 if (DECL_WEAK (newdecl
))
5371 /* NEWDECL is weak, but OLDDECL is not. */
5373 /* If we already output the OLDDECL, we're in trouble; we can't
5374 go back and make it weak. This should never happen in
5375 unit-at-a-time compilation. */
5376 gcc_assert (!TREE_ASM_WRITTEN (olddecl
));
5378 /* If we've already generated rtl referencing OLDDECL, we may
5379 have done so in a way that will not function properly with
5380 a weak symbol. Again in unit-at-a-time this should be
5382 gcc_assert (!TREE_USED (olddecl
)
5383 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)));
5385 /* PR 49899: You cannot convert a static function into a weak, public function. */
5386 if (! TREE_PUBLIC (olddecl
) && TREE_PUBLIC (newdecl
))
5387 error ("weak declaration of %q+D being applied to a already "
5388 "existing, static definition", newdecl
);
5390 if (TARGET_SUPPORTS_WEAK
)
5392 /* We put the NEWDECL on the weak_decls list at some point.
5393 Replace it with the OLDDECL. */
5394 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
5395 if (TREE_VALUE (wd
) == newdecl
)
5397 TREE_VALUE (wd
) = olddecl
;
5400 /* We may not find the entry on the list. If NEWDECL is a
5401 weak alias, then we will have already called
5402 globalize_decl to remove the entry; in that case, we do
5403 not need to do anything. */
5406 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
5407 mark_weak (olddecl
);
5410 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
5411 weak. Just update NEWDECL to indicate that it's weak too. */
5412 mark_weak (newdecl
);
5415 /* Declare DECL to be a weak symbol. */
5418 declare_weak (tree decl
)
5420 gcc_assert (TREE_CODE (decl
) != FUNCTION_DECL
|| !TREE_ASM_WRITTEN (decl
));
5421 if (! TREE_PUBLIC (decl
))
5423 error ("weak declaration of %q+D must be public", decl
);
5426 else if (!TARGET_SUPPORTS_WEAK
)
5427 warning (0, "weak declaration of %q+D not supported", decl
);
5430 if (!lookup_attribute ("weak", DECL_ATTRIBUTES (decl
)))
5431 DECL_ATTRIBUTES (decl
)
5432 = tree_cons (get_identifier ("weak"), NULL
, DECL_ATTRIBUTES (decl
));
5436 weak_finish_1 (tree decl
)
5438 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
5439 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5442 if (! TREE_USED (decl
))
5445 #ifdef ASM_WEAKEN_DECL
5446 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
5448 #ifdef ASM_WEAKEN_LABEL
5449 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5451 #ifdef ASM_OUTPUT_WEAK_ALIAS
5453 static bool warn_once
= 0;
5456 warning (0, "only weak aliases are supported in this configuration");
5466 /* Fiven an assembly name, find the decl it is associated with. */
5468 find_decl (tree target
)
5470 symtab_node
*node
= symtab_node::get_for_asmname (target
);
5476 /* This TREE_LIST contains weakref targets. */
5478 static GTY(()) tree weakref_targets
;
5480 /* Emit any pending weak declarations. */
5487 for (t
= weakref_targets
; t
; t
= TREE_CHAIN (t
))
5489 tree alias_decl
= TREE_PURPOSE (t
);
5490 tree target
= ultimate_transparent_alias_target (&TREE_VALUE (t
));
5492 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl
)))
5493 /* Remove alias_decl from the weak list, but leave entries for
5494 the target alone. */
5496 #ifndef ASM_OUTPUT_WEAKREF
5497 else if (! TREE_SYMBOL_REFERENCED (target
))
5499 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
5500 defined, otherwise we and weak_finish_1 would use
5501 different macros. */
5502 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
5503 ASM_WEAKEN_LABEL (asm_out_file
, IDENTIFIER_POINTER (target
));
5505 tree decl
= find_decl (target
);
5509 decl
= build_decl (DECL_SOURCE_LOCATION (alias_decl
),
5510 TREE_CODE (alias_decl
), target
,
5511 TREE_TYPE (alias_decl
));
5513 DECL_EXTERNAL (decl
) = 1;
5514 TREE_PUBLIC (decl
) = 1;
5515 DECL_ARTIFICIAL (decl
) = 1;
5516 TREE_NOTHROW (decl
) = TREE_NOTHROW (alias_decl
);
5517 TREE_USED (decl
) = 1;
5520 weak_finish_1 (decl
);
5529 /* Remove the alias and the target from the pending weak list
5530 so that we do not emit any .weak directives for the former,
5531 nor multiple .weak directives for the latter. */
5532 for (p
= &weak_decls
; (t2
= *p
) ; )
5534 if (TREE_VALUE (t2
) == alias_decl
5535 || target
== DECL_ASSEMBLER_NAME (TREE_VALUE (t2
)))
5536 *p
= TREE_CHAIN (t2
);
5538 p
= &TREE_CHAIN (t2
);
5541 /* Remove other weakrefs to the same target, to speed things up. */
5542 for (p
= &TREE_CHAIN (t
); (t2
= *p
) ; )
5544 if (target
== ultimate_transparent_alias_target (&TREE_VALUE (t2
)))
5545 *p
= TREE_CHAIN (t2
);
5547 p
= &TREE_CHAIN (t2
);
5552 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
5554 tree decl
= TREE_VALUE (t
);
5556 weak_finish_1 (decl
);
5560 /* Emit the assembly bits to indicate that DECL is globally visible. */
5563 globalize_decl (tree decl
)
5566 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5567 if (DECL_WEAK (decl
))
5569 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
5572 #ifdef ASM_WEAKEN_DECL
5573 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
5575 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5578 /* Remove this function from the pending weak list so that
5579 we do not emit multiple .weak directives for it. */
5580 for (p
= &weak_decls
; (t
= *p
) ; )
5582 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5583 *p
= TREE_CHAIN (t
);
5585 p
= &TREE_CHAIN (t
);
5588 /* Remove weakrefs to the same target from the pending weakref
5589 list, for the same reason. */
5590 for (p
= &weakref_targets
; (t
= *p
) ; )
5592 if (DECL_ASSEMBLER_NAME (decl
)
5593 == ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5594 *p
= TREE_CHAIN (t
);
5596 p
= &TREE_CHAIN (t
);
5603 targetm
.asm_out
.globalize_decl_name (asm_out_file
, decl
);
5606 vec
<alias_pair
, va_gc
> *alias_pairs
;
5608 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
5609 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
5610 tree node is DECL to have the value of the tree node TARGET. */
5613 do_assemble_alias (tree decl
, tree target
)
5617 /* Emulated TLS had better not get this var. */
5618 gcc_assert (!(!targetm
.have_tls
5619 && TREE_CODE (decl
) == VAR_DECL
5620 && DECL_THREAD_LOCAL_P (decl
)));
5622 if (TREE_ASM_WRITTEN (decl
))
5625 id
= DECL_ASSEMBLER_NAME (decl
);
5626 ultimate_transparent_alias_target (&id
);
5627 ultimate_transparent_alias_target (&target
);
5629 /* We must force creation of DECL_RTL for debug info generation, even though
5630 we don't use it here. */
5631 make_decl_rtl (decl
);
5633 TREE_ASM_WRITTEN (decl
) = 1;
5634 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
5635 TREE_ASM_WRITTEN (id
) = 1;
5637 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5639 if (!TREE_SYMBOL_REFERENCED (target
))
5640 weakref_targets
= tree_cons (decl
, target
, weakref_targets
);
5642 #ifdef ASM_OUTPUT_WEAKREF
5643 ASM_OUTPUT_WEAKREF (asm_out_file
, decl
,
5644 IDENTIFIER_POINTER (id
),
5645 IDENTIFIER_POINTER (target
));
5647 if (!TARGET_SUPPORTS_WEAK
)
5649 error_at (DECL_SOURCE_LOCATION (decl
),
5650 "weakref is not supported in this configuration");
5657 #ifdef ASM_OUTPUT_DEF
5658 tree orig_decl
= decl
;
5660 if (TREE_CODE (decl
) == FUNCTION_DECL
5661 && cgraph_node::get (decl
)->instrumentation_clone
5662 && cgraph_node::get (decl
)->instrumented_version
)
5663 orig_decl
= cgraph_node::get (decl
)->instrumented_version
->decl
;
5665 /* Make name accessible from other files, if appropriate. */
5667 if (TREE_PUBLIC (decl
) || TREE_PUBLIC (orig_decl
))
5669 globalize_decl (decl
);
5670 maybe_assemble_visibility (decl
);
5672 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
5674 #if defined (ASM_OUTPUT_TYPE_DIRECTIVE)
5675 if (targetm
.has_ifunc_p ())
5676 ASM_OUTPUT_TYPE_DIRECTIVE
5677 (asm_out_file
, IDENTIFIER_POINTER (id
),
5681 error_at (DECL_SOURCE_LOCATION (decl
),
5682 "ifunc is not supported on this target");
5685 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
5686 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
5688 ASM_OUTPUT_DEF (asm_out_file
,
5689 IDENTIFIER_POINTER (id
),
5690 IDENTIFIER_POINTER (target
));
5692 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5697 name
= IDENTIFIER_POINTER (id
);
5698 # ifdef ASM_WEAKEN_DECL
5699 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
5701 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
5703 /* Remove this function from the pending weak list so that
5704 we do not emit multiple .weak directives for it. */
5705 for (p
= &weak_decls
; (t
= *p
) ; )
5706 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
))
5707 || id
== DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5708 *p
= TREE_CHAIN (t
);
5710 p
= &TREE_CHAIN (t
);
5712 /* Remove weakrefs to the same target from the pending weakref
5713 list, for the same reason. */
5714 for (p
= &weakref_targets
; (t
= *p
) ; )
5716 if (id
== ultimate_transparent_alias_target (&TREE_VALUE (t
)))
5717 *p
= TREE_CHAIN (t
);
5719 p
= &TREE_CHAIN (t
);
5725 /* Emit an assembler directive to make the symbol for DECL an alias to
5726 the symbol for TARGET. */
5729 assemble_alias (tree decl
, tree target
)
5733 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
5735 tree alias
= DECL_ASSEMBLER_NAME (decl
);
5737 ultimate_transparent_alias_target (&target
);
5739 if (alias
== target
)
5740 error ("weakref %q+D ultimately targets itself", decl
);
5741 if (TREE_PUBLIC (decl
))
5742 error ("weakref %q+D must have static linkage", decl
);
5746 #if !defined (ASM_OUTPUT_DEF)
5747 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
5748 error_at (DECL_SOURCE_LOCATION (decl
),
5749 "alias definitions not supported in this configuration");
5750 TREE_ASM_WRITTEN (decl
) = 1;
5753 if (!DECL_WEAK (decl
))
5755 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
)))
5756 error_at (DECL_SOURCE_LOCATION (decl
),
5757 "ifunc is not supported in this configuration");
5759 error_at (DECL_SOURCE_LOCATION (decl
),
5760 "only weak aliases are supported in this configuration");
5761 TREE_ASM_WRITTEN (decl
) = 1;
5767 TREE_USED (decl
) = 1;
5769 /* Allow aliases to aliases. */
5770 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5771 cgraph_node::get_create (decl
)->alias
= true;
5773 varpool_node::get_create (decl
)->alias
= true;
5775 /* If the target has already been emitted, we don't have to queue the
5776 alias. This saves a tad of memory. */
5777 if (symtab
->global_info_ready
)
5778 target_decl
= find_decl (target
);
5781 if ((target_decl
&& TREE_ASM_WRITTEN (target_decl
))
5782 || symtab
->state
>= EXPANSION
)
5783 do_assemble_alias (decl
, target
);
5786 alias_pair p
= {decl
, target
};
5787 vec_safe_push (alias_pairs
, p
);
5791 /* Record and output a table of translations from original function
5792 to its transaction aware clone. Note that tm_pure functions are
5793 considered to be their own clone. */
5795 struct tm_clone_hasher
: ggc_cache_ptr_hash
<tree_map
>
5797 static hashval_t
hash (tree_map
*m
) { return tree_map_hash (m
); }
5798 static bool equal (tree_map
*a
, tree_map
*b
) { return tree_map_eq (a
, b
); }
5801 keep_cache_entry (tree_map
*&e
)
5803 return ggc_marked_p (e
->base
.from
);
5807 static GTY((cache
)) hash_table
<tm_clone_hasher
> *tm_clone_hash
;
5810 record_tm_clone_pair (tree o
, tree n
)
5812 struct tree_map
**slot
, *h
;
5814 if (tm_clone_hash
== NULL
)
5815 tm_clone_hash
= hash_table
<tm_clone_hasher
>::create_ggc (32);
5817 h
= ggc_alloc
<tree_map
> ();
5818 h
->hash
= htab_hash_pointer (o
);
5822 slot
= tm_clone_hash
->find_slot_with_hash (h
, h
->hash
, INSERT
);
5827 get_tm_clone_pair (tree o
)
5831 struct tree_map
*h
, in
;
5834 in
.hash
= htab_hash_pointer (o
);
5835 h
= tm_clone_hash
->find_with_hash (&in
, in
.hash
);
5842 struct tm_alias_pair
5850 /* Dump the actual pairs to the .tm_clone_table section. */
5853 dump_tm_clone_pairs (vec
<tm_alias_pair
> tm_alias_pairs
)
5857 bool switched
= false;
5859 FOR_EACH_VEC_ELT (tm_alias_pairs
, i
, p
)
5863 struct cgraph_node
*src_n
= cgraph_node::get (src
);
5864 struct cgraph_node
*dst_n
= cgraph_node::get (dst
);
5866 /* The function ipa_tm_create_version() marks the clone as needed if
5867 the original function was needed. But we also mark the clone as
5868 needed if we ever called the clone indirectly through
5869 TM_GETTMCLONE. If neither of these are true, we didn't generate
5870 a clone, and we didn't call it indirectly... no sense keeping it
5871 in the clone table. */
5872 if (!dst_n
|| !dst_n
->definition
)
5875 /* This covers the case where we have optimized the original
5876 function away, and only access the transactional clone. */
5877 if (!src_n
|| !src_n
->definition
)
5882 switch_to_section (targetm
.asm_out
.tm_clone_table_section ());
5883 assemble_align (POINTER_SIZE
);
5887 assemble_integer (XEXP (DECL_RTL (src
), 0),
5888 POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
5889 assemble_integer (XEXP (DECL_RTL (dst
), 0),
5890 POINTER_SIZE_UNITS
, POINTER_SIZE
, 1);
5894 /* Provide a default for the tm_clone_table section. */
5897 default_clone_table_section (void)
5899 return get_named_section (NULL
, ".tm_clone_table", 3);
5902 /* Helper comparison function for qsorting by the DECL_UID stored in
5903 alias_pair->emitted_diags. */
5906 tm_alias_pair_cmp (const void *x
, const void *y
)
5908 const tm_alias_pair
*p1
= (const tm_alias_pair
*) x
;
5909 const tm_alias_pair
*p2
= (const tm_alias_pair
*) y
;
5910 if (p1
->uid
< p2
->uid
)
5912 if (p1
->uid
> p2
->uid
)
5918 finish_tm_clone_pairs (void)
5920 vec
<tm_alias_pair
> tm_alias_pairs
= vNULL
;
5922 if (tm_clone_hash
== NULL
)
5925 /* We need a determenistic order for the .tm_clone_table, otherwise
5926 we will get bootstrap comparison failures, so dump the hash table
5927 to a vector, sort it, and dump the vector. */
5929 /* Dump the hashtable to a vector. */
5931 hash_table
<tm_clone_hasher
>::iterator iter
;
5932 FOR_EACH_HASH_TABLE_ELEMENT (*tm_clone_hash
, map
, tree_map
*, iter
)
5934 tm_alias_pair p
= {DECL_UID (map
->base
.from
), map
->base
.from
, map
->to
};
5935 tm_alias_pairs
.safe_push (p
);
5938 tm_alias_pairs
.qsort (tm_alias_pair_cmp
);
5941 dump_tm_clone_pairs (tm_alias_pairs
);
5943 tm_clone_hash
->empty ();
5944 tm_clone_hash
= NULL
;
5945 tm_alias_pairs
.release ();
5949 /* Emit an assembler directive to set symbol for DECL visibility to
5950 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
5953 default_assemble_visibility (tree decl ATTRIBUTE_UNUSED
,
5954 int vis ATTRIBUTE_UNUSED
)
5956 #ifdef HAVE_GAS_HIDDEN
5957 static const char * const visibility_types
[] = {
5958 NULL
, "protected", "hidden", "internal"
5961 const char *name
, *type
;
5964 id
= DECL_ASSEMBLER_NAME (decl
);
5965 ultimate_transparent_alias_target (&id
);
5966 name
= IDENTIFIER_POINTER (id
);
5968 type
= visibility_types
[vis
];
5970 fprintf (asm_out_file
, "\t.%s\t", type
);
5971 assemble_name (asm_out_file
, name
);
5972 fprintf (asm_out_file
, "\n");
5974 if (!DECL_ARTIFICIAL (decl
))
5975 warning (OPT_Wattributes
, "visibility attribute not supported "
5976 "in this configuration; ignored");
5980 /* A helper function to call assemble_visibility when needed for a decl. */
5983 maybe_assemble_visibility (tree decl
)
5985 enum symbol_visibility vis
= DECL_VISIBILITY (decl
);
5987 if (TREE_CODE (decl
) == FUNCTION_DECL
5988 && cgraph_node::get (decl
)
5989 && cgraph_node::get (decl
)->instrumentation_clone
5990 && cgraph_node::get (decl
)->instrumented_version
)
5991 vis
= DECL_VISIBILITY (cgraph_node::get (decl
)->instrumented_version
->decl
);
5993 if (vis
!= VISIBILITY_DEFAULT
)
5995 targetm
.asm_out
.assemble_visibility (decl
, vis
);
6002 /* Returns 1 if the target configuration supports defining public symbols
6003 so that one of them will be chosen at link time instead of generating a
6004 multiply-defined symbol error, whether through the use of weak symbols or
6005 a target-specific mechanism for having duplicates discarded. */
6008 supports_one_only (void)
6010 if (SUPPORTS_ONE_ONLY
)
6012 return TARGET_SUPPORTS_WEAK
;
6015 /* Set up DECL as a public symbol that can be defined in multiple
6016 translation units without generating a linker error. */
6019 make_decl_one_only (tree decl
, tree comdat_group
)
6021 struct symtab_node
*symbol
;
6022 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6023 || TREE_CODE (decl
) == FUNCTION_DECL
);
6025 TREE_PUBLIC (decl
) = 1;
6027 if (TREE_CODE (decl
) == VAR_DECL
)
6028 symbol
= varpool_node::get_create (decl
);
6030 symbol
= cgraph_node::get_create (decl
);
6032 if (SUPPORTS_ONE_ONLY
)
6034 #ifdef MAKE_DECL_ONE_ONLY
6035 MAKE_DECL_ONE_ONLY (decl
);
6037 symbol
->set_comdat_group (comdat_group
);
6039 else if (TREE_CODE (decl
) == VAR_DECL
6040 && (DECL_INITIAL (decl
) == 0
6041 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
6042 DECL_COMMON (decl
) = 1;
6045 gcc_assert (TARGET_SUPPORTS_WEAK
);
6046 DECL_WEAK (decl
) = 1;
6051 init_varasm_once (void)
6053 section_htab
= hash_table
<section_hasher
>::create_ggc (31);
6054 object_block_htab
= hash_table
<object_block_hasher
>::create_ggc (31);
6055 const_desc_htab
= hash_table
<tree_descriptor_hasher
>::create_ggc (1009);
6057 shared_constant_pool
= create_constant_pool ();
6059 #ifdef TEXT_SECTION_ASM_OP
6060 text_section
= get_unnamed_section (SECTION_CODE
, output_section_asm_op
,
6061 TEXT_SECTION_ASM_OP
);
6064 #ifdef DATA_SECTION_ASM_OP
6065 data_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
6066 DATA_SECTION_ASM_OP
);
6069 #ifdef SDATA_SECTION_ASM_OP
6070 sdata_section
= get_unnamed_section (SECTION_WRITE
, output_section_asm_op
,
6071 SDATA_SECTION_ASM_OP
);
6074 #ifdef READONLY_DATA_SECTION_ASM_OP
6075 readonly_data_section
= get_unnamed_section (0, output_section_asm_op
,
6076 READONLY_DATA_SECTION_ASM_OP
);
6079 #ifdef CTORS_SECTION_ASM_OP
6080 ctors_section
= get_unnamed_section (0, output_section_asm_op
,
6081 CTORS_SECTION_ASM_OP
);
6084 #ifdef DTORS_SECTION_ASM_OP
6085 dtors_section
= get_unnamed_section (0, output_section_asm_op
,
6086 DTORS_SECTION_ASM_OP
);
6089 #ifdef BSS_SECTION_ASM_OP
6090 bss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
6091 output_section_asm_op
,
6092 BSS_SECTION_ASM_OP
);
6095 #ifdef SBSS_SECTION_ASM_OP
6096 sbss_section
= get_unnamed_section (SECTION_WRITE
| SECTION_BSS
,
6097 output_section_asm_op
,
6098 SBSS_SECTION_ASM_OP
);
6101 tls_comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6102 | SECTION_COMMON
, emit_tls_common
);
6103 lcomm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6104 | SECTION_COMMON
, emit_local
);
6105 comm_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
6106 | SECTION_COMMON
, emit_common
);
6108 #if defined ASM_OUTPUT_ALIGNED_BSS
6109 bss_noswitch_section
= get_noswitch_section (SECTION_WRITE
| SECTION_BSS
,
6113 targetm
.asm_out
.init_sections ();
6115 if (readonly_data_section
== NULL
)
6116 readonly_data_section
= text_section
;
6118 #ifdef ASM_OUTPUT_EXTERNAL
6119 pending_assemble_externals_set
= new hash_set
<tree
>;
6124 decl_default_tls_model (const_tree decl
)
6126 enum tls_model kind
;
6129 is_local
= targetm
.binds_local_p (decl
);
6133 kind
= TLS_MODEL_LOCAL_EXEC
;
6135 kind
= TLS_MODEL_INITIAL_EXEC
;
6138 /* Local dynamic is inefficient when we're not combining the
6139 parts of the address. */
6140 else if (optimize
&& is_local
)
6141 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
6143 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6144 if (kind
< flag_tls_default
)
6145 kind
= flag_tls_default
;
6150 /* Select a set of attributes for section NAME based on the properties
6151 of DECL and whether or not RELOC indicates that DECL's initializer
6152 might contain runtime relocations.
6154 We make the section read-only and executable for a function decl,
6155 read-only for a const data decl, and writable for a non-const data decl. */
6158 default_section_type_flags (tree decl
, const char *name
, int reloc
)
6162 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6163 flags
= SECTION_CODE
;
6166 enum section_category category
6167 = categorize_decl_for_section (decl
, reloc
);
6168 if (decl_readonly_section_1 (category
))
6170 else if (category
== SECCAT_DATA_REL_RO
6171 || category
== SECCAT_DATA_REL_RO_LOCAL
)
6172 flags
= SECTION_WRITE
| SECTION_RELRO
;
6174 flags
= SECTION_WRITE
;
6178 flags
= SECTION_WRITE
;
6179 if (strcmp (name
, ".data.rel.ro") == 0
6180 || strcmp (name
, ".data.rel.ro.local") == 0)
6181 flags
|= SECTION_RELRO
;
6184 if (decl
&& DECL_P (decl
) && DECL_COMDAT_GROUP (decl
))
6185 flags
|= SECTION_LINKONCE
;
6187 if (strcmp (name
, ".vtable_map_vars") == 0)
6188 flags
|= SECTION_LINKONCE
;
6190 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6191 flags
|= SECTION_TLS
| SECTION_WRITE
;
6193 if (strcmp (name
, ".bss") == 0
6194 || strncmp (name
, ".bss.", 5) == 0
6195 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
6196 || strcmp (name
, ".persistent.bss") == 0
6197 || strcmp (name
, ".sbss") == 0
6198 || strncmp (name
, ".sbss.", 6) == 0
6199 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
6200 flags
|= SECTION_BSS
;
6202 if (strcmp (name
, ".tdata") == 0
6203 || strncmp (name
, ".tdata.", 7) == 0
6204 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0)
6205 flags
|= SECTION_TLS
;
6207 if (strcmp (name
, ".tbss") == 0
6208 || strncmp (name
, ".tbss.", 6) == 0
6209 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
6210 flags
|= SECTION_TLS
| SECTION_BSS
;
6212 /* These three sections have special ELF types. They are neither
6213 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
6214 want to print a section type (@progbits or @nobits). If someone
6215 is silly enough to emit code or TLS variables to one of these
6216 sections, then don't handle them specially. */
6217 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
6218 && (strcmp (name
, ".init_array") == 0
6219 || strcmp (name
, ".fini_array") == 0
6220 || strcmp (name
, ".preinit_array") == 0))
6221 flags
|= SECTION_NOTYPE
;
6226 /* Return true if the target supports some form of global BSS,
6227 either through bss_noswitch_section, or by selecting a BSS
6228 section in TARGET_ASM_SELECT_SECTION. */
6231 have_global_bss_p (void)
6233 return bss_noswitch_section
|| targetm
.have_switchable_bss_sections
;
6236 /* Output assembly to switch to section NAME with attribute FLAGS.
6237 Four variants for common object file formats. */
6240 default_no_named_section (const char *name ATTRIBUTE_UNUSED
,
6241 unsigned int flags ATTRIBUTE_UNUSED
,
6242 tree decl ATTRIBUTE_UNUSED
)
6244 /* Some object formats don't support named sections at all. The
6245 front-end should already have flagged this as an error. */
6249 #ifndef TLS_SECTION_ASM_FLAG
6250 #define TLS_SECTION_ASM_FLAG 'T'
6254 default_elf_asm_named_section (const char *name
, unsigned int flags
,
6257 char flagchars
[11], *f
= flagchars
;
6259 /* If we have already declared this section, we can use an
6260 abbreviated form to switch back to it -- unless this section is
6261 part of a COMDAT groups, in which case GAS requires the full
6262 declaration every time. */
6263 if (!(HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6264 && (flags
& SECTION_DECLARED
))
6266 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
6270 if (!(flags
& SECTION_DEBUG
))
6272 #if defined (HAVE_GAS_SECTION_EXCLUDE) && HAVE_GAS_SECTION_EXCLUDE == 1
6273 if (flags
& SECTION_EXCLUDE
)
6276 if (flags
& SECTION_WRITE
)
6278 if (flags
& SECTION_CODE
)
6280 if (flags
& SECTION_SMALL
)
6282 if (flags
& SECTION_MERGE
)
6284 if (flags
& SECTION_STRINGS
)
6286 if (flags
& SECTION_TLS
)
6287 *f
++ = TLS_SECTION_ASM_FLAG
;
6288 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6290 #ifdef MACH_DEP_SECTION_ASM_FLAG
6291 if (flags
& SECTION_MACH_DEP
)
6292 *f
++ = MACH_DEP_SECTION_ASM_FLAG
;
6296 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
6298 if (!(flags
& SECTION_NOTYPE
))
6303 if (flags
& SECTION_BSS
)
6309 /* On platforms that use "@" as the assembly comment character,
6311 if (strcmp (ASM_COMMENT_START
, "@") == 0)
6313 fprintf (asm_out_file
, format
, type
);
6315 if (flags
& SECTION_ENTSIZE
)
6316 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
6317 if (HAVE_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
6319 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6320 fprintf (asm_out_file
, ",%s,comdat", IDENTIFIER_POINTER (decl
));
6322 fprintf (asm_out_file
, ",%s,comdat",
6323 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl
)));
6327 putc ('\n', asm_out_file
);
6331 default_coff_asm_named_section (const char *name
, unsigned int flags
,
6332 tree decl ATTRIBUTE_UNUSED
)
6334 char flagchars
[8], *f
= flagchars
;
6336 if (flags
& SECTION_WRITE
)
6338 if (flags
& SECTION_CODE
)
6342 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
6346 default_pe_asm_named_section (const char *name
, unsigned int flags
,
6349 default_coff_asm_named_section (name
, flags
, decl
);
6351 if (flags
& SECTION_LINKONCE
)
6353 /* Functions may have been compiled at various levels of
6354 optimization so we can't use `same_size' here.
6355 Instead, have the linker pick one. */
6356 fprintf (asm_out_file
, "\t.linkonce %s\n",
6357 (flags
& SECTION_CODE
? "discard" : "same_size"));
6361 /* The lame default section selector. */
6364 default_select_section (tree decl
, int reloc
,
6365 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6369 if (decl_readonly_section (decl
, reloc
))
6370 return readonly_data_section
;
6372 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6374 if (! ((flag_pic
&& reloc
)
6375 || !TREE_READONLY (decl
)
6376 || TREE_SIDE_EFFECTS (decl
)
6377 || !TREE_CONSTANT (decl
)))
6378 return readonly_data_section
;
6380 else if (TREE_CODE (decl
) == STRING_CST
)
6381 return readonly_data_section
;
6382 else if (! (flag_pic
&& reloc
))
6383 return readonly_data_section
;
6385 return data_section
;
6388 enum section_category
6389 categorize_decl_for_section (const_tree decl
, int reloc
)
6391 enum section_category ret
;
6393 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6395 else if (TREE_CODE (decl
) == STRING_CST
)
6397 if ((flag_sanitize
& SANITIZE_ADDRESS
)
6398 && asan_protect_global (CONST_CAST_TREE (decl
)))
6399 /* or !flag_merge_constants */
6400 return SECCAT_RODATA
;
6402 return SECCAT_RODATA_MERGE_STR
;
6404 else if (TREE_CODE (decl
) == VAR_DECL
)
6406 if (bss_initializer_p (decl
))
6408 else if (! TREE_READONLY (decl
)
6409 || TREE_SIDE_EFFECTS (decl
)
6410 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6412 /* Here the reloc_rw_mask is not testing whether the section should
6413 be read-only or not, but whether the dynamic link will have to
6414 do something. If so, we wish to segregate the data in order to
6415 minimize cache misses inside the dynamic linker. */
6416 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6417 ret
= reloc
== 1 ? SECCAT_DATA_REL_LOCAL
: SECCAT_DATA_REL
;
6421 else if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6422 ret
= reloc
== 1 ? SECCAT_DATA_REL_RO_LOCAL
: SECCAT_DATA_REL_RO
;
6423 else if (reloc
|| flag_merge_constants
< 2
6424 || ((flag_sanitize
& SANITIZE_ADDRESS
)
6425 && asan_protect_global (CONST_CAST_TREE (decl
))))
6426 /* C and C++ don't allow different variables to share the same
6427 location. -fmerge-all-constants allows even that (at the
6428 expense of not conforming). */
6429 ret
= SECCAT_RODATA
;
6430 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
6431 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
6433 ret
= SECCAT_RODATA_MERGE_CONST
;
6435 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
6437 if ((reloc
& targetm
.asm_out
.reloc_rw_mask ())
6438 || TREE_SIDE_EFFECTS (decl
)
6439 || ! TREE_CONSTANT (decl
))
6442 ret
= SECCAT_RODATA
;
6445 ret
= SECCAT_RODATA
;
6447 /* There are no read-only thread-local sections. */
6448 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6450 /* Note that this would be *just* SECCAT_BSS, except that there's
6451 no concept of a read-only thread-local-data section. */
6452 if (ret
== SECCAT_BSS
6453 || (flag_zero_initialized_in_bss
6454 && initializer_zerop (DECL_INITIAL (decl
))))
6460 /* If the target uses small data sections, select it. */
6461 else if (targetm
.in_small_data_p (decl
))
6463 if (ret
== SECCAT_BSS
)
6465 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
6466 ret
= SECCAT_SRODATA
;
6475 decl_readonly_section_1 (enum section_category category
)
6480 case SECCAT_RODATA_MERGE_STR
:
6481 case SECCAT_RODATA_MERGE_STR_INIT
:
6482 case SECCAT_RODATA_MERGE_CONST
:
6483 case SECCAT_SRODATA
:
6491 decl_readonly_section (const_tree decl
, int reloc
)
6493 return decl_readonly_section_1 (categorize_decl_for_section (decl
, reloc
));
6496 /* Select a section based on the above categorization. */
6499 default_elf_select_section (tree decl
, int reloc
,
6500 unsigned HOST_WIDE_INT align
)
6503 switch (categorize_decl_for_section (decl
, reloc
))
6506 /* We're not supposed to be called on FUNCTION_DECLs. */
6509 return readonly_data_section
;
6510 case SECCAT_RODATA_MERGE_STR
:
6511 return mergeable_string_section (decl
, align
, 0);
6512 case SECCAT_RODATA_MERGE_STR_INIT
:
6513 return mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
6514 case SECCAT_RODATA_MERGE_CONST
:
6515 return mergeable_constant_section (DECL_MODE (decl
), align
, 0);
6516 case SECCAT_SRODATA
:
6520 return data_section
;
6521 case SECCAT_DATA_REL
:
6522 sname
= ".data.rel";
6524 case SECCAT_DATA_REL_LOCAL
:
6525 sname
= ".data.rel.local";
6527 case SECCAT_DATA_REL_RO
:
6528 sname
= ".data.rel.ro";
6530 case SECCAT_DATA_REL_RO_LOCAL
:
6531 sname
= ".data.rel.ro.local";
6554 return get_named_section (decl
, sname
, reloc
);
6557 /* Construct a unique section name based on the decl name and the
6558 categorization performed above. */
6561 default_unique_section (tree decl
, int reloc
)
6563 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
6564 bool one_only
= DECL_ONE_ONLY (decl
) && !HAVE_COMDAT_GROUP
;
6565 const char *prefix
, *name
, *linkonce
;
6569 switch (categorize_decl_for_section (decl
, reloc
))
6572 prefix
= one_only
? ".t" : ".text";
6575 case SECCAT_RODATA_MERGE_STR
:
6576 case SECCAT_RODATA_MERGE_STR_INIT
:
6577 case SECCAT_RODATA_MERGE_CONST
:
6578 prefix
= one_only
? ".r" : ".rodata";
6580 case SECCAT_SRODATA
:
6581 prefix
= one_only
? ".s2" : ".sdata2";
6584 prefix
= one_only
? ".d" : ".data";
6586 case SECCAT_DATA_REL
:
6587 prefix
= one_only
? ".d.rel" : ".data.rel";
6589 case SECCAT_DATA_REL_LOCAL
:
6590 prefix
= one_only
? ".d.rel.local" : ".data.rel.local";
6592 case SECCAT_DATA_REL_RO
:
6593 prefix
= one_only
? ".d.rel.ro" : ".data.rel.ro";
6595 case SECCAT_DATA_REL_RO_LOCAL
:
6596 prefix
= one_only
? ".d.rel.ro.local" : ".data.rel.ro.local";
6599 prefix
= one_only
? ".s" : ".sdata";
6602 prefix
= one_only
? ".b" : ".bss";
6605 prefix
= one_only
? ".sb" : ".sbss";
6608 prefix
= one_only
? ".td" : ".tdata";
6611 prefix
= one_only
? ".tb" : ".tbss";
6617 id
= DECL_ASSEMBLER_NAME (decl
);
6618 ultimate_transparent_alias_target (&id
);
6619 name
= IDENTIFIER_POINTER (id
);
6620 name
= targetm
.strip_name_encoding (name
);
6622 /* If we're using one_only, then there needs to be a .gnu.linkonce
6623 prefix to the section name. */
6624 linkonce
= one_only
? ".gnu.linkonce" : "";
6626 string
= ACONCAT ((linkonce
, prefix
, ".", name
, NULL
));
6628 set_decl_section_name (decl
, string
);
6631 /* Subroutine of compute_reloc_for_rtx for leaf rtxes. */
6634 compute_reloc_for_rtx_1 (const_rtx x
)
6636 switch (GET_CODE (x
))
6639 return SYMBOL_REF_LOCAL_P (x
) ? 1 : 2;
6647 /* Like compute_reloc_for_constant, except for an RTX. The return value
6648 is a mask for which bit 1 indicates a global relocation, and bit 0
6649 indicates a local relocation. */
6652 compute_reloc_for_rtx (const_rtx x
)
6654 switch (GET_CODE (x
))
6658 return compute_reloc_for_rtx_1 (x
);
6663 subrtx_iterator::array_type array
;
6664 FOR_EACH_SUBRTX (iter
, array
, x
, ALL
)
6665 reloc
|= compute_reloc_for_rtx_1 (*iter
);
6675 default_select_rtx_section (machine_mode mode ATTRIBUTE_UNUSED
,
6677 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
6679 if (compute_reloc_for_rtx (x
) & targetm
.asm_out
.reloc_rw_mask ())
6680 return data_section
;
6682 return readonly_data_section
;
6686 default_elf_select_rtx_section (machine_mode mode
, rtx x
,
6687 unsigned HOST_WIDE_INT align
)
6689 int reloc
= compute_reloc_for_rtx (x
);
6691 /* ??? Handle small data here somehow. */
6693 if (reloc
& targetm
.asm_out
.reloc_rw_mask ())
6696 return get_named_section (NULL
, ".data.rel.ro.local", 1);
6698 return get_named_section (NULL
, ".data.rel.ro", 3);
6701 return mergeable_constant_section (mode
, align
, 0);
6704 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
6707 default_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
6712 /* Careful not to prod global register variables. */
6715 symbol
= XEXP (rtl
, 0);
6716 if (GET_CODE (symbol
) != SYMBOL_REF
)
6719 flags
= SYMBOL_REF_FLAGS (symbol
) & SYMBOL_FLAG_HAS_BLOCK_INFO
;
6720 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6721 flags
|= SYMBOL_FLAG_FUNCTION
;
6722 if (targetm
.binds_local_p (decl
))
6723 flags
|= SYMBOL_FLAG_LOCAL
;
6724 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (decl
))
6725 flags
|= DECL_TLS_MODEL (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
6726 else if (targetm
.in_small_data_p (decl
))
6727 flags
|= SYMBOL_FLAG_SMALL
;
6728 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
6729 being PUBLIC, the thing *must* be defined in this translation unit.
6730 Prevent this buglet from being propagated into rtl code as well. */
6731 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
6732 flags
|= SYMBOL_FLAG_EXTERNAL
;
6734 SYMBOL_REF_FLAGS (symbol
) = flags
;
6737 /* By default, we do nothing for encode_section_info, so we need not
6738 do anything but discard the '*' marker. */
6741 default_strip_name_encoding (const char *str
)
6743 return str
+ (*str
== '*');
6746 #ifdef ASM_OUTPUT_DEF
6747 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
6748 anchor relative to ".", the current section position. */
6751 default_asm_output_anchor (rtx symbol
)
6755 sprintf (buffer
, "*. + " HOST_WIDE_INT_PRINT_DEC
,
6756 SYMBOL_REF_BLOCK_OFFSET (symbol
));
6757 ASM_OUTPUT_DEF (asm_out_file
, XSTR (symbol
, 0), buffer
);
6761 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
6764 default_use_anchors_for_symbol_p (const_rtx symbol
)
6769 /* Don't use anchors for mergeable sections. The linker might move
6770 the objects around. */
6771 sect
= SYMBOL_REF_BLOCK (symbol
)->sect
;
6772 if (sect
->common
.flags
& SECTION_MERGE
)
6775 /* Don't use anchors for small data sections. The small data register
6776 acts as an anchor for such sections. */
6777 if (sect
->common
.flags
& SECTION_SMALL
)
6780 decl
= SYMBOL_REF_DECL (symbol
);
6781 if (decl
&& DECL_P (decl
))
6783 /* Don't use section anchors for decls that might be defined or
6784 usurped by other modules. */
6785 if (TREE_PUBLIC (decl
) && !decl_binds_to_current_def_p (decl
))
6788 /* Don't use section anchors for decls that will be placed in a
6789 small data section. */
6790 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
6791 one above. The problem is that we only use SECTION_SMALL for
6792 sections that should be marked as small in the section directive. */
6793 if (targetm
.in_small_data_p (decl
))
6799 /* Return true when RESOLUTION indicate that symbol will be bound to the
6800 definition provided by current .o file. */
6803 resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution
)
6805 return (resolution
== LDPR_PREVAILING_DEF
6806 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
6807 || resolution
== LDPR_PREVAILING_DEF_IRONLY
);
6810 /* Return true when RESOLUTION indicate that symbol will be bound locally
6811 within current executable or DSO. */
6814 resolution_local_p (enum ld_plugin_symbol_resolution resolution
)
6816 return (resolution
== LDPR_PREVAILING_DEF
6817 || resolution
== LDPR_PREVAILING_DEF_IRONLY
6818 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
6819 || resolution
== LDPR_PREEMPTED_REG
6820 || resolution
== LDPR_PREEMPTED_IR
6821 || resolution
== LDPR_RESOLVED_IR
6822 || resolution
== LDPR_RESOLVED_EXEC
);
6825 /* COMMON_LOCAL_P is true means that the linker can guarantee that an
6826 uninitialized common symbol in the executable will still be defined
6827 (through COPY relocation) in the executable. */
6830 default_binds_local_p_3 (const_tree exp
, bool shlib
, bool weak_dominate
,
6831 bool extern_protected_data
, bool common_local_p
)
6833 /* A non-decl is an entry in the constant pool. */
6837 /* Weakrefs may not bind locally, even though the weakref itself is always
6838 static and therefore local. Similarly, the resolver for ifunc functions
6839 might resolve to a non-local function.
6840 FIXME: We can resolve the weakref case more curefuly by looking at the
6842 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp
))
6843 || (TREE_CODE (exp
) == FUNCTION_DECL
6844 && lookup_attribute ("ifunc", DECL_ATTRIBUTES (exp
))))
6847 /* Static variables are always local. */
6848 if (! TREE_PUBLIC (exp
))
6851 /* With resolution file in hand, take look into resolutions.
6852 We can't just return true for resolved_locally symbols,
6853 because dynamic linking might overwrite symbols
6854 in shared libraries. */
6855 bool resolved_locally
= false;
6857 bool uninited_common
= (DECL_COMMON (exp
)
6858 && (DECL_INITIAL (exp
) == NULL
6860 && DECL_INITIAL (exp
) == error_mark_node
)));
6862 /* A non-external variable is defined locally only if it isn't
6863 uninitialized COMMON variable or common_local_p is true. */
6864 bool defined_locally
= (!DECL_EXTERNAL (exp
)
6865 && (!uninited_common
|| common_local_p
));
6866 if (symtab_node
*node
= symtab_node::get (exp
))
6868 if (node
->in_other_partition
)
6869 defined_locally
= true;
6870 if (node
->can_be_discarded_p ())
6872 else if (resolution_to_local_definition_p (node
->resolution
))
6873 defined_locally
= resolved_locally
= true;
6874 else if (resolution_local_p (node
->resolution
))
6875 resolved_locally
= true;
6877 if (defined_locally
&& weak_dominate
&& !shlib
)
6878 resolved_locally
= true;
6880 /* Undefined weak symbols are never defined locally. */
6881 if (DECL_WEAK (exp
) && !defined_locally
)
6884 /* A symbol is local if the user has said explicitly that it will be,
6885 or if we have a definition for the symbol. We cannot infer visibility
6886 for undefined symbols. */
6887 if (DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
6888 && (TREE_CODE (exp
) == FUNCTION_DECL
6889 || !extern_protected_data
6890 || DECL_VISIBILITY (exp
) != VISIBILITY_PROTECTED
)
6891 && (DECL_VISIBILITY_SPECIFIED (exp
) || defined_locally
))
6894 /* If PIC, then assume that any global name can be overridden by
6895 symbols resolved from other modules. */
6899 /* Variables defined outside this object might not be local. */
6900 if (DECL_EXTERNAL (exp
) && !resolved_locally
)
6903 /* Non-dominant weak symbols are not defined locally. */
6904 if (DECL_WEAK (exp
) && !resolved_locally
)
6907 /* Uninitialized COMMON variable may be unified with symbols
6908 resolved from other modules. */
6909 if (uninited_common
&& !resolved_locally
)
6912 /* Otherwise we're left with initialized (or non-common) global data
6913 which is of necessity defined locally. */
6917 /* Assume ELF-ish defaults, since that's pretty much the most liberal
6918 wrt cross-module name binding. */
6921 default_binds_local_p (const_tree exp
)
6923 return default_binds_local_p_3 (exp
, flag_shlib
!= 0, true, false, false);
6926 /* Similar to default_binds_local_p, but common symbol may be local and
6927 extern protected data is non-local. */
6930 default_binds_local_p_2 (const_tree exp
)
6932 return default_binds_local_p_3 (exp
, flag_shlib
!= 0, true, true,
6937 default_binds_local_p_1 (const_tree exp
, int shlib
)
6939 return default_binds_local_p_3 (exp
, shlib
!= 0, false, false, false);
6942 /* Return true when references to DECL must bind to current definition in
6945 The condition is usually equivalent to whether the function binds to the
6946 current module (shared library or executable), that is to binds_local_p.
6947 We use this fact to avoid need for another target hook and implement
6948 the logic using binds_local_p and just special cases where
6949 decl_binds_to_current_def_p is stronger than binds_local_p. In particular
6950 the weak definitions (that can be overwritten at linktime by other
6951 definition from different object file) and when resolution info is available
6952 we simply use the knowledge passed to us by linker plugin. */
6954 decl_binds_to_current_def_p (const_tree decl
)
6956 gcc_assert (DECL_P (decl
));
6957 if (!targetm
.binds_local_p (decl
))
6959 if (!TREE_PUBLIC (decl
))
6962 /* When resolution is available, just use it. */
6963 if (symtab_node
*node
= symtab_node::get (decl
))
6965 if (node
->resolution
!= LDPR_UNKNOWN
6966 && !node
->can_be_discarded_p ())
6967 return resolution_to_local_definition_p (node
->resolution
);
6970 /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
6971 binds locally but still can be overwritten), DECL_COMMON (can be merged
6972 with a non-common definition somewhere in the same module) or
6974 This rely on fact that binds_local_p behave as decl_replaceable_p
6975 for all other declaration types. */
6976 if (DECL_WEAK (decl
))
6978 if (DECL_COMMON (decl
)
6979 && (DECL_INITIAL (decl
) == NULL
6980 || (!in_lto_p
&& DECL_INITIAL (decl
) == error_mark_node
)))
6982 if (DECL_EXTERNAL (decl
))
6987 /* A replaceable function or variable is one which may be replaced
6988 at link-time with an entirely different definition, provided that the
6989 replacement has the same type. For example, functions declared
6990 with __attribute__((weak)) on most systems are replaceable.
6992 COMDAT functions are not replaceable, since all definitions of the
6993 function must be equivalent. It is important that COMDAT functions
6994 not be treated as replaceable so that use of C++ template
6995 instantiations is not penalized. */
6998 decl_replaceable_p (tree decl
)
7000 gcc_assert (DECL_P (decl
));
7001 if (!TREE_PUBLIC (decl
) || DECL_COMDAT (decl
))
7003 if (!flag_semantic_interposition
7004 && !DECL_WEAK (decl
))
7006 return !decl_binds_to_current_def_p (decl
);
7009 /* Default function to output code that will globalize a label. A
7010 target must define GLOBAL_ASM_OP or provide its own function to
7011 globalize a label. */
7012 #ifdef GLOBAL_ASM_OP
7014 default_globalize_label (FILE * stream
, const char *name
)
7016 fputs (GLOBAL_ASM_OP
, stream
);
7017 assemble_name (stream
, name
);
7018 putc ('\n', stream
);
7020 #endif /* GLOBAL_ASM_OP */
7022 /* Default function to output code that will globalize a declaration. */
7024 default_globalize_decl_name (FILE * stream
, tree decl
)
7026 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
7027 targetm
.asm_out
.globalize_label (stream
, name
);
7030 /* Default function to output a label for unwind information. The
7031 default is to do nothing. A target that needs nonlocal labels for
7032 unwind information must provide its own function to do this. */
7034 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED
,
7035 tree decl ATTRIBUTE_UNUSED
,
7036 int for_eh ATTRIBUTE_UNUSED
,
7037 int empty ATTRIBUTE_UNUSED
)
7041 /* Default function to output a label to divide up the exception table.
7042 The default is to do nothing. A target that needs/wants to divide
7043 up the table must provide it's own function to do this. */
7045 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED
)
7049 /* This is how to output an internal numbered label where PREFIX is
7050 the class of label and LABELNO is the number within the class. */
7053 default_generate_internal_label (char *buf
, const char *prefix
,
7054 unsigned long labelno
)
7056 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
7059 /* This is how to output an internal numbered label where PREFIX is
7060 the class of label and LABELNO is the number within the class. */
7063 default_internal_label (FILE *stream
, const char *prefix
,
7064 unsigned long labelno
)
7066 char *const buf
= (char *) alloca (40 + strlen (prefix
));
7067 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
7068 ASM_OUTPUT_INTERNAL_LABEL (stream
, buf
);
7072 /* The default implementation of ASM_DECLARE_CONSTANT_NAME. */
7075 default_asm_declare_constant_name (FILE *file
, const char *name
,
7076 const_tree exp ATTRIBUTE_UNUSED
,
7077 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
7079 assemble_label (file
, name
);
7082 /* This is the default behavior at the beginning of a file. It's
7083 controlled by two other target-hook toggles. */
7085 default_file_start (void)
7087 if (targetm
.asm_file_start_app_off
7088 && !(flag_verbose_asm
|| flag_debug_asm
|| flag_dump_rtl_in_asm
))
7089 fputs (ASM_APP_OFF
, asm_out_file
);
7091 if (targetm
.asm_file_start_file_directive
)
7093 /* LTO produced units have no meaningful main_input_filename. */
7095 output_file_directive (asm_out_file
, "<artificial>");
7097 output_file_directive (asm_out_file
, main_input_filename
);
7101 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
7102 which emits a special section directive used to indicate whether or
7103 not this object file needs an executable stack. This is primarily
7104 a GNU extension to ELF but could be used on other targets. */
7106 int trampolines_created
;
7109 file_end_indicate_exec_stack (void)
7111 unsigned int flags
= SECTION_DEBUG
;
7112 if (trampolines_created
)
7113 flags
|= SECTION_CODE
;
7115 switch_to_section (get_section (".note.GNU-stack", flags
, NULL
));
7118 /* Emit a special section directive to indicate that this object file
7119 was compiled with -fsplit-stack. This is used to let the linker
7120 detect calls between split-stack code and non-split-stack code, so
7121 that it can modify the split-stack code to allocate a sufficiently
7122 large stack. We emit another special section if there are any
7123 functions in this file which have the no_split_stack attribute, to
7124 prevent the linker from warning about being unable to convert the
7125 functions if they call non-split-stack code. */
7128 file_end_indicate_split_stack (void)
7130 if (flag_split_stack
)
7132 switch_to_section (get_section (".note.GNU-split-stack", SECTION_DEBUG
,
7134 if (saw_no_split_stack
)
7135 switch_to_section (get_section (".note.GNU-no-split-stack",
7136 SECTION_DEBUG
, NULL
));
7140 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
7141 a get_unnamed_section callback. */
7144 output_section_asm_op (const void *directive
)
7146 fprintf (asm_out_file
, "%s\n", (const char *) directive
);
7149 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
7150 the current section is NEW_SECTION. */
7153 switch_to_section (section
*new_section
)
7155 if (in_section
== new_section
)
7158 if (new_section
->common
.flags
& SECTION_FORGET
)
7161 in_section
= new_section
;
7163 switch (SECTION_STYLE (new_section
))
7166 targetm
.asm_out
.named_section (new_section
->named
.name
,
7167 new_section
->named
.common
.flags
,
7168 new_section
->named
.decl
);
7171 case SECTION_UNNAMED
:
7172 new_section
->unnamed
.callback (new_section
->unnamed
.data
);
7175 case SECTION_NOSWITCH
:
7180 new_section
->common
.flags
|= SECTION_DECLARED
;
7183 /* If block symbol SYMBOL has not yet been assigned an offset, place
7184 it at the end of its block. */
7187 place_block_symbol (rtx symbol
)
7189 unsigned HOST_WIDE_INT size
, mask
, offset
;
7190 struct constant_descriptor_rtx
*desc
;
7191 unsigned int alignment
;
7192 struct object_block
*block
;
7195 gcc_assert (SYMBOL_REF_BLOCK (symbol
));
7196 if (SYMBOL_REF_BLOCK_OFFSET (symbol
) >= 0)
7199 /* Work out the symbol's size and alignment. */
7200 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7202 desc
= SYMBOL_REF_CONSTANT (symbol
);
7203 alignment
= desc
->align
;
7204 size
= GET_MODE_SIZE (desc
->mode
);
7206 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7208 decl
= SYMBOL_REF_DECL (symbol
);
7209 gcc_checking_assert (DECL_IN_CONSTANT_POOL (decl
));
7210 alignment
= DECL_ALIGN (decl
);
7211 size
= get_constant_size (DECL_INITIAL (decl
));
7212 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7213 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7214 && asan_protect_global (DECL_INITIAL (decl
)))
7216 size
+= asan_red_zone_size (size
);
7217 alignment
= MAX (alignment
,
7218 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
7223 struct symtab_node
*snode
;
7224 decl
= SYMBOL_REF_DECL (symbol
);
7226 snode
= symtab_node::get (decl
);
7229 rtx target
= DECL_RTL (snode
->ultimate_alias_target ()->decl
);
7231 gcc_assert (MEM_P (target
)
7232 && GET_CODE (XEXP (target
, 0)) == SYMBOL_REF
7233 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (target
, 0)));
7234 target
= XEXP (target
, 0);
7235 place_block_symbol (target
);
7236 SYMBOL_REF_BLOCK_OFFSET (symbol
) = SYMBOL_REF_BLOCK_OFFSET (target
);
7239 alignment
= get_variable_align (decl
);
7240 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7241 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7242 && asan_protect_global (decl
))
7244 size
+= asan_red_zone_size (size
);
7245 alignment
= MAX (alignment
,
7246 ASAN_RED_ZONE_SIZE
* BITS_PER_UNIT
);
7250 /* Calculate the object's offset from the start of the block. */
7251 block
= SYMBOL_REF_BLOCK (symbol
);
7252 mask
= alignment
/ BITS_PER_UNIT
- 1;
7253 offset
= (block
->size
+ mask
) & ~mask
;
7254 SYMBOL_REF_BLOCK_OFFSET (symbol
) = offset
;
7256 /* Record the block's new alignment and size. */
7257 block
->alignment
= MAX (block
->alignment
, alignment
);
7258 block
->size
= offset
+ size
;
7260 vec_safe_push (block
->objects
, symbol
);
7263 /* Return the anchor that should be used to address byte offset OFFSET
7264 from the first object in BLOCK. MODEL is the TLS model used
7268 get_section_anchor (struct object_block
*block
, HOST_WIDE_INT offset
,
7269 enum tls_model model
)
7272 unsigned int begin
, middle
, end
;
7273 unsigned HOST_WIDE_INT min_offset
, max_offset
, range
, bias
, delta
;
7276 /* Work out the anchor's offset. Use an offset of 0 for the first
7277 anchor so that we don't pessimize the case where we take the address
7278 of a variable at the beginning of the block. This is particularly
7279 useful when a block has only one variable assigned to it.
7281 We try to place anchors RANGE bytes apart, so there can then be
7282 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
7283 a ptr_mode offset. With some target settings, the lowest such
7284 anchor might be out of range for the lowest ptr_mode offset;
7285 likewise the highest anchor for the highest offset. Use anchors
7286 at the extreme ends of the ptr_mode range in such cases.
7288 All arithmetic uses unsigned integers in order to avoid
7290 max_offset
= (unsigned HOST_WIDE_INT
) targetm
.max_anchor_offset
;
7291 min_offset
= (unsigned HOST_WIDE_INT
) targetm
.min_anchor_offset
;
7292 range
= max_offset
- min_offset
+ 1;
7297 bias
= HOST_WIDE_INT_1U
<< (GET_MODE_BITSIZE (ptr_mode
) - 1);
7300 delta
= -(unsigned HOST_WIDE_INT
) offset
+ max_offset
;
7301 delta
-= delta
% range
;
7304 offset
= (HOST_WIDE_INT
) (-delta
);
7308 delta
= (unsigned HOST_WIDE_INT
) offset
- min_offset
;
7309 delta
-= delta
% range
;
7310 if (delta
> bias
- 1)
7312 offset
= (HOST_WIDE_INT
) delta
;
7316 /* Do a binary search to see if there's already an anchor we can use.
7317 Set BEGIN to the new anchor's index if not. */
7319 end
= vec_safe_length (block
->anchors
);
7320 while (begin
!= end
)
7322 middle
= (end
+ begin
) / 2;
7323 anchor
= (*block
->anchors
)[middle
];
7324 if (SYMBOL_REF_BLOCK_OFFSET (anchor
) > offset
)
7326 else if (SYMBOL_REF_BLOCK_OFFSET (anchor
) < offset
)
7328 else if (SYMBOL_REF_TLS_MODEL (anchor
) > model
)
7330 else if (SYMBOL_REF_TLS_MODEL (anchor
) < model
)
7336 /* Create a new anchor with a unique label. */
7337 ASM_GENERATE_INTERNAL_LABEL (label
, "LANCHOR", anchor_labelno
++);
7338 anchor
= create_block_symbol (ggc_strdup (label
), block
, offset
);
7339 SYMBOL_REF_FLAGS (anchor
) |= SYMBOL_FLAG_LOCAL
| SYMBOL_FLAG_ANCHOR
;
7340 SYMBOL_REF_FLAGS (anchor
) |= model
<< SYMBOL_FLAG_TLS_SHIFT
;
7342 /* Insert it at index BEGIN. */
7343 vec_safe_insert (block
->anchors
, begin
, anchor
);
7347 /* Output the objects in BLOCK. */
7350 output_object_block (struct object_block
*block
)
7352 struct constant_descriptor_rtx
*desc
;
7354 HOST_WIDE_INT offset
;
7358 if (!block
->objects
)
7361 /* Switch to the section and make sure that the first byte is
7362 suitably aligned. */
7363 /* Special case VTV comdat sections similar to assemble_variable. */
7364 if (SECTION_STYLE (block
->sect
) == SECTION_NAMED
7365 && block
->sect
->named
.name
7366 && (strcmp (block
->sect
->named
.name
, ".vtable_map_vars") == 0))
7367 handle_vtv_comdat_section (block
->sect
, block
->sect
->named
.decl
);
7369 switch_to_section (block
->sect
);
7371 assemble_align (block
->alignment
);
7373 /* Define the values of all anchors relative to the current section
7375 FOR_EACH_VEC_SAFE_ELT (block
->anchors
, i
, symbol
)
7376 targetm
.asm_out
.output_anchor (symbol
);
7378 /* Output the objects themselves. */
7380 FOR_EACH_VEC_ELT (*block
->objects
, i
, symbol
)
7382 /* Move to the object's offset, padding with zeros if necessary. */
7383 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol
) - offset
);
7384 offset
= SYMBOL_REF_BLOCK_OFFSET (symbol
);
7385 if (CONSTANT_POOL_ADDRESS_P (symbol
))
7387 desc
= SYMBOL_REF_CONSTANT (symbol
);
7388 /* Pass 1 for align as we have already laid out everything in the block.
7389 So aligning shouldn't be necessary. */
7390 output_constant_pool_1 (desc
, 1);
7391 offset
+= GET_MODE_SIZE (desc
->mode
);
7393 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol
))
7396 decl
= SYMBOL_REF_DECL (symbol
);
7397 assemble_constant_contents
7398 (DECL_INITIAL (decl
), XSTR (symbol
, 0), DECL_ALIGN (decl
));
7400 size
= get_constant_size (DECL_INITIAL (decl
));
7402 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7403 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
7404 && asan_protect_global (DECL_INITIAL (decl
)))
7406 size
= asan_red_zone_size (size
);
7407 assemble_zeros (size
);
7414 decl
= SYMBOL_REF_DECL (symbol
);
7415 assemble_variable_contents (decl
, XSTR (symbol
, 0), false);
7416 size
= tree_to_uhwi (DECL_SIZE_UNIT (decl
));
7418 if ((flag_sanitize
& SANITIZE_ADDRESS
)
7419 && asan_protect_global (decl
))
7421 size
= asan_red_zone_size (size
);
7422 assemble_zeros (size
);
7429 /* A callback for qsort to compare object_blocks. */
7432 output_object_block_compare (const void *x
, const void *y
)
7434 object_block
*p1
= *(object_block
* const*)x
;
7435 object_block
*p2
= *(object_block
* const*)y
;
7437 if (p1
->sect
->common
.flags
& SECTION_NAMED
7438 && !(p2
->sect
->common
.flags
& SECTION_NAMED
))
7441 if (!(p1
->sect
->common
.flags
& SECTION_NAMED
)
7442 && p2
->sect
->common
.flags
& SECTION_NAMED
)
7445 if (p1
->sect
->common
.flags
& SECTION_NAMED
7446 && p2
->sect
->common
.flags
& SECTION_NAMED
)
7447 return strcmp (p1
->sect
->named
.name
, p2
->sect
->named
.name
);
7449 unsigned f1
= p1
->sect
->common
.flags
;
7450 unsigned f2
= p2
->sect
->common
.flags
;
7453 return f1
< f2
? -1 : 1;
7456 /* Output the definitions of all object_blocks. */
7459 output_object_blocks (void)
7461 vec
<object_block
*, va_heap
> v
;
7462 v
.create (object_block_htab
->elements ());
7464 hash_table
<object_block_hasher
>::iterator hi
;
7466 FOR_EACH_HASH_TABLE_ELEMENT (*object_block_htab
, obj
, object_block
*, hi
)
7469 /* Sort them in order to output them in a deterministic manner,
7470 otherwise we may get .rodata sections in different orders with
7472 v
.qsort (output_object_block_compare
);
7474 FOR_EACH_VEC_ELT (v
, i
, obj
)
7475 output_object_block (obj
);
7480 /* This function provides a possible implementation of the
7481 TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered
7482 by -frecord-gcc-switches it creates a new mergeable, string section in the
7483 assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which
7484 contains the switches in ASCII format.
7486 FIXME: This code does not correctly handle double quote characters
7487 that appear inside strings, (it strips them rather than preserving them).
7488 FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL
7489 characters - instead it treats them as sub-string separators. Since
7490 we want to emit NUL strings terminators into the object file we have to use
7494 elf_record_gcc_switches (print_switch_type type
, const char * name
)
7498 case SWITCH_TYPE_PASSED
:
7499 ASM_OUTPUT_ASCII (asm_out_file
, name
, strlen (name
));
7500 ASM_OUTPUT_SKIP (asm_out_file
, HOST_WIDE_INT_1U
);
7503 case SWITCH_TYPE_DESCRIPTIVE
:
7506 /* Distinguish between invocations where name is NULL. */
7507 static bool started
= false;
7513 sec
= get_section (targetm
.asm_out
.record_gcc_switches_section
,
7517 | (SECTION_ENTSIZE
& 1),
7519 switch_to_section (sec
);
7528 /* The return value is currently ignored by the caller, but must be 0.
7529 For -fverbose-asm the return value would be the number of characters
7530 emitted into the assembler file. */
7534 /* Emit text to declare externally defined symbols. It is needed to
7535 properly support non-default visibility. */
7537 default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED
,
7539 const char *name ATTRIBUTE_UNUSED
)
7541 /* We output the name if and only if TREE_SYMBOL_REFERENCED is
7542 set in order to avoid putting out names that are never really
7543 used. Always output visibility specified in the source. */
7544 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
7545 && (DECL_VISIBILITY_SPECIFIED (decl
)
7546 || targetm
.binds_local_p (decl
)))
7547 maybe_assemble_visibility (decl
);
7550 /* The default hook for TARGET_ASM_OUTPUT_SOURCE_FILENAME. */
7553 default_asm_output_source_filename (FILE *file
, const char *name
)
7555 #ifdef ASM_OUTPUT_SOURCE_FILENAME
7556 ASM_OUTPUT_SOURCE_FILENAME (file
, name
);
7558 fprintf (file
, "\t.file\t");
7559 output_quoted_string (file
, name
);
7564 /* Output a file name in the form wanted by System V. */
7567 output_file_directive (FILE *asm_file
, const char *input_name
)
7572 if (input_name
== NULL
)
7573 input_name
= "<stdin>";
7575 input_name
= remap_debug_filename (input_name
);
7577 len
= strlen (input_name
);
7578 na
= input_name
+ len
;
7580 /* NA gets INPUT_NAME sans directory names. */
7581 while (na
> input_name
)
7583 if (IS_DIR_SEPARATOR (na
[-1]))
7588 targetm
.asm_out
.output_source_filename (asm_file
, na
);
7591 /* Create a DEBUG_EXPR_DECL / DEBUG_EXPR pair from RTL expression
7594 make_debug_expr_from_rtl (const_rtx exp
)
7596 tree ddecl
= make_node (DEBUG_EXPR_DECL
), type
;
7597 machine_mode mode
= GET_MODE (exp
);
7600 DECL_ARTIFICIAL (ddecl
) = 1;
7601 if (REG_P (exp
) && REG_EXPR (exp
))
7602 type
= TREE_TYPE (REG_EXPR (exp
));
7603 else if (MEM_P (exp
) && MEM_EXPR (exp
))
7604 type
= TREE_TYPE (MEM_EXPR (exp
));
7607 if (type
&& TYPE_MODE (type
) == mode
)
7608 TREE_TYPE (ddecl
) = type
;
7610 TREE_TYPE (ddecl
) = lang_hooks
.types
.type_for_mode (mode
, 1);
7611 DECL_MODE (ddecl
) = mode
;
7612 dval
= gen_rtx_DEBUG_EXPR (mode
);
7613 DEBUG_EXPR_TREE_DECL (dval
) = ddecl
;
7614 SET_DECL_RTL (ddecl
, dval
);
7618 #ifdef ELF_ASCII_ESCAPES
7619 /* Default ASM_OUTPUT_LIMITED_STRING for ELF targets. */
7622 default_elf_asm_output_limited_string (FILE *f
, const char *s
)
7627 fputs (STRING_ASM_OP
, f
);
7632 escape
= ELF_ASCII_ESCAPES
[c
];
7640 putc ('0'+((c
>>6)&7), f
);
7641 putc ('0'+((c
>>3)&7), f
);
7642 putc ('0'+(c
&7), f
);
7655 /* Default ASM_OUTPUT_ASCII for ELF targets. */
7658 default_elf_asm_output_ascii (FILE *f
, const char *s
, unsigned int len
)
7660 const char *limit
= s
+ len
;
7661 const char *last_null
= NULL
;
7662 unsigned bytes_in_chunk
= 0;
7666 for (; s
< limit
; s
++)
7670 if (bytes_in_chunk
>= 60)
7679 for (p
= s
; p
< limit
&& *p
!= '\0'; p
++)
7686 if (p
< limit
&& (p
- s
) <= (long) ELF_STRING_LIMIT
)
7688 if (bytes_in_chunk
> 0)
7695 default_elf_asm_output_limited_string (f
, s
);
7700 if (bytes_in_chunk
== 0)
7701 fputs (ASCII_DATA_ASM_OP
"\"", f
);
7704 escape
= ELF_ASCII_ESCAPES
[c
];
7713 putc ('0'+((c
>>6)&7), f
);
7714 putc ('0'+((c
>>3)&7), f
);
7715 putc ('0'+(c
&7), f
);
7716 bytes_in_chunk
+= 4;
7721 bytes_in_chunk
+= 2;
7728 if (bytes_in_chunk
> 0)
7736 static GTY(()) section
*elf_init_array_section
;
7737 static GTY(()) section
*elf_fini_array_section
;
7740 get_elf_initfini_array_priority_section (int priority
,
7744 if (priority
!= DEFAULT_INIT_PRIORITY
)
7747 sprintf (buf
, "%s.%.5u",
7748 constructor_p
? ".init_array" : ".fini_array",
7750 sec
= get_section (buf
, SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7756 if (elf_init_array_section
== NULL
)
7757 elf_init_array_section
7758 = get_section (".init_array",
7759 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7760 sec
= elf_init_array_section
;
7764 if (elf_fini_array_section
== NULL
)
7765 elf_fini_array_section
7766 = get_section (".fini_array",
7767 SECTION_WRITE
| SECTION_NOTYPE
, NULL_TREE
);
7768 sec
= elf_fini_array_section
;
7774 /* Use .init_array section for constructors. */
7777 default_elf_init_array_asm_out_constructor (rtx symbol
, int priority
)
7779 section
*sec
= get_elf_initfini_array_priority_section (priority
,
7781 assemble_addr_to_section (symbol
, sec
);
7784 /* Use .fini_array section for destructors. */
7787 default_elf_fini_array_asm_out_destructor (rtx symbol
, int priority
)
7789 section
*sec
= get_elf_initfini_array_priority_section (priority
,
7791 assemble_addr_to_section (symbol
, sec
);
7794 /* Default TARGET_ASM_OUTPUT_IDENT hook.
7796 This is a bit of a cheat. The real default is a no-op, but this
7797 hook is the default for all targets with a .ident directive. */
7800 default_asm_output_ident_directive (const char *ident_str
)
7802 const char *ident_asm_op
= "\t.ident\t";
7804 /* If we are still in the front end, do not write out the string
7805 to asm_out_file. Instead, add a fake top-level asm statement.
7806 This allows the front ends to use this hook without actually
7807 writing to asm_out_file, to handle #ident or Pragma Ident. */
7808 if (symtab
->state
== PARSING
)
7810 char *buf
= ACONCAT ((ident_asm_op
, "\"", ident_str
, "\"\n", NULL
));
7811 symtab
->finalize_toplevel_asm (build_string (strlen (buf
), buf
));
7814 fprintf (asm_out_file
, "%s\"%s\"\n", ident_asm_op
, ident_str
);
7818 /* This function ensures that vtable_map variables are not only
7819 in the comdat section, but that each variable has its own unique
7820 comdat name. Without this the variables end up in the same section
7821 with a single comdat name.
7823 FIXME: resolve_unique_section needs to deal better with
7824 decls with both DECL_SECTION_NAME and DECL_ONE_ONLY. Once
7825 that is fixed, this if-else statement can be replaced with
7826 a single call to "switch_to_section (sect)". */
7829 handle_vtv_comdat_section (section
*sect
, const_tree decl ATTRIBUTE_UNUSED
)
7831 #if defined (OBJECT_FORMAT_ELF)
7832 targetm
.asm_out
.named_section (sect
->named
.name
,
7833 sect
->named
.common
.flags
7838 /* Neither OBJECT_FORMAT_PE, nor OBJECT_FORMAT_COFF is set here.
7839 Therefore the following check is used.
7840 In case a the target is PE or COFF a comdat group section
7841 is created, e.g. .vtable_map_vars$foo. The linker places
7842 everything in .vtable_map_vars at the end.
7844 A fix could be made in
7845 gcc/config/i386/winnt.c: i386_pe_unique_section. */
7850 if (TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
)
7851 name
= ACONCAT ((sect
->named
.name
, "$",
7852 IDENTIFIER_POINTER (DECL_NAME (decl
)), NULL
));
7854 name
= ACONCAT ((sect
->named
.name
, "$",
7855 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (DECL_NAME (decl
))),
7858 targetm
.asm_out
.named_section (name
,
7859 sect
->named
.common
.flags
7865 switch_to_section (sect
);
7869 #include "gt-varasm.h"