1/* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
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.
24
25 We also output the assembler code for constants stored in memory
26 and are responsible for combining constants with the same value. */
27
28#include "config.h"
29#include "system.h"
30#include "coretypes.h"
31#include "backend.h"
32#include "target.h"
33#include "rtl.h"
34#include "tree.h"
35#include "predict.h"
36#include "memmodel.h"
37#include "tm_p.h"
38#include "stringpool.h"
39#include "regs.h"
40#include "emit-rtl.h"
41#include "cgraph.h"
42#include "diagnostic-core.h"
43#include "fold-const.h"
44#include "stor-layout.h"
45#include "varasm.h"
46#include "flags.h"
47#include "stmt.h"
48#include "expr.h"
49#include "expmed.h"
50#include "output.h"
51#include "langhooks.h"
52#include "debug.h"
53#include "common/common-target.h"
54#include "stringpool.h"
55#include "attribs.h"
56#include "asan.h"
57#include "rtl-iter.h"
58
59#ifdef XCOFF_DEBUGGING_INFO
60#include "xcoffout.h" /* Needed for external data declarations. */
61#endif
62
63/* The (assembler) name of the first globally-visible object output. */
64extern GTY(()) const char *first_global_object_name;
65extern GTY(()) const char *weak_global_object_name;
66
67const char *first_global_object_name;
68const char *weak_global_object_name;
69
70struct addr_const;
71struct constant_descriptor_rtx;
72struct rtx_constant_pool;
73
74#define n_deferred_constants (crtl->varasm.deferred_constants)
75
76/* Number for making the label on the next
77 constant that is stored in memory. */
78
79static GTY(()) int const_labelno;
80
81/* Carry information from ASM_DECLARE_OBJECT_NAME
82 to ASM_FINISH_DECLARE_OBJECT. */
83
84int size_directive_output;
85
86/* The last decl for which assemble_variable was called,
87 if it did ASM_DECLARE_OBJECT_NAME.
88 If the last call to assemble_variable didn't do that,
89 this holds 0. */
90
91tree last_assemble_variable_decl;
92
93/* The following global variable indicates if the first basic block
94 in a function belongs to the cold partition or not. */
95
96bool first_function_block_is_cold;
97
98/* Whether we saw any functions with no_split_stack. */
99
100static bool saw_no_split_stack;
101
102static const char *strip_reg_name (const char *);
103static int contains_pointers_p (tree);
104#ifdef ASM_OUTPUT_EXTERNAL
105static bool incorporeal_function_p (tree);
106#endif
107static void decode_addr_const (tree, struct addr_const *);
108static hashval_t const_hash_1 (const tree);
109static int compare_constant (const tree, const tree);
110static void output_constant_def_contents (rtx);
111static void output_addressed_constants (tree);
112static unsigned HOST_WIDE_INT output_constant (tree, unsigned HOST_WIDE_INT,
113 unsigned int, bool);
114static void globalize_decl (tree);
115static bool decl_readonly_section_1 (enum section_category);
116#ifdef BSS_SECTION_ASM_OP
117#ifdef ASM_OUTPUT_ALIGNED_BSS
118static void asm_output_aligned_bss (FILE *, tree, const char *,
119 unsigned HOST_WIDE_INT, int)
120 ATTRIBUTE_UNUSED;
121#endif
122#endif /* BSS_SECTION_ASM_OP */
123static void mark_weak (tree);
124static void output_constant_pool (const char *, tree);
125static void handle_vtv_comdat_section (section *, const_tree);
126
127/* Well-known sections, each one associated with some sort of *_ASM_OP. */
128section *text_section;
129section *data_section;
130section *readonly_data_section;
131section *sdata_section;
132section *ctors_section;
133section *dtors_section;
134section *bss_section;
135section *sbss_section;
136
137/* Various forms of common section. All are guaranteed to be nonnull. */
138section *tls_comm_section;
139section *comm_section;
140section *lcomm_section;
141
142/* A SECTION_NOSWITCH section used for declaring global BSS variables.
143 May be null. */
144section *bss_noswitch_section;
145
146/* The section that holds the main exception table, when known. The section
147 is set either by the target's init_sections hook or by the first call to
148 switch_to_exception_section. */
149section *exception_section;
150
151/* The section that holds the DWARF2 frame unwind information, when known.
152 The section is set either by the target's init_sections hook or by the
153 first call to switch_to_eh_frame_section. */
154section *eh_frame_section;
155
156/* asm_out_file's current section. This is NULL if no section has yet
157 been selected or if we lose track of what the current section is. */
158section *in_section;
159
160/* True if code for the current function is currently being directed
161 at the cold section. */
162bool in_cold_section_p;
163
164/* The following global holds the "function name" for the code in the
165 cold section of a function, if hot/cold function splitting is enabled
166 and there was actually code that went into the cold section. A
167 pseudo function name is needed for the cold section of code for some
168 debugging tools that perform symbolization. */
169tree cold_function_name = NULL_TREE;
170
171/* A linked list of all the unnamed sections. */
172static GTY(()) section *unnamed_sections;
173
174/* Return a nonzero value if DECL has a section attribute. */
175#define IN_NAMED_SECTION(DECL) \
176 (VAR_OR_FUNCTION_DECL_P (DECL) && DECL_SECTION_NAME (DECL) != NULL)
177
178struct section_hasher : ggc_ptr_hash<section>
179{
180 typedef const char *compare_type;
181
182 static hashval_t hash (section *);
183 static bool equal (section *, const char *);
184};
185
186/* Hash table of named sections. */
187static GTY(()) hash_table<section_hasher> *section_htab;
188
189struct object_block_hasher : ggc_ptr_hash<object_block>
190{
191 typedef const section *compare_type;
192
193 static hashval_t hash (object_block *);
194 static bool equal (object_block *, const section *);
195};
196
197/* A table of object_blocks, indexed by section. */
198static GTY(()) hash_table<object_block_hasher> *object_block_htab;
199
200/* The next number to use for internal anchor labels. */
201static GTY(()) int anchor_labelno;
202
203/* A pool of constants that can be shared between functions. */
204static GTY(()) struct rtx_constant_pool *shared_constant_pool;
205
206/* Helper routines for maintaining section_htab. */
207
208bool
209section_hasher::equal (section *old, const char *new_name)
210{
211 return strcmp (old->named.name, new_name) == 0;
212}
213
214hashval_t
215section_hasher::hash (section *old)
216{
217 return htab_hash_string (old->named.name);
218}
219
220/* Return a hash value for section SECT. */
221
222static hashval_t
223hash_section (section *sect)
224{
225 if (sect->common.flags & SECTION_NAMED)
226 return htab_hash_string (sect->named.name);
227 return sect->common.flags;
228}
229
230/* Helper routines for maintaining object_block_htab. */
231
232inline bool
233object_block_hasher::equal (object_block *old, const section *new_section)
234{
235 return old->sect == new_section;
236}
237
238hashval_t
239object_block_hasher::hash (object_block *old)
240{
241 return hash_section (old->sect);
242}
243
244/* Return a new unnamed section with the given fields. */
245
246section *
247get_unnamed_section (unsigned int flags, void (*callback) (const void *),
248 const void *data)
249{
250 section *sect;
251
252 sect = ggc_alloc<section> ();
253 sect->unnamed.common.flags = flags | SECTION_UNNAMED;
254 sect->unnamed.callback = callback;
255 sect->unnamed.data = data;
256 sect->unnamed.next = unnamed_sections;
257
258 unnamed_sections = sect;
259 return sect;
260}
261
262/* Return a SECTION_NOSWITCH section with the given fields. */
263
264static section *
265get_noswitch_section (unsigned int flags, noswitch_section_callback callback)
266{
267 section *sect;
268
269 sect = ggc_alloc<section> ();
270 sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
271 sect->noswitch.callback = callback;
272
273 return sect;
274}
275
276/* Return the named section structure associated with NAME. Create
277 a new section with the given fields if no such structure exists. */
278
279section *
280get_section (const char *name, unsigned int flags, tree decl)
281{
282 section *sect, **slot;
283
284 slot = section_htab->find_slot_with_hash (name, htab_hash_string (name),
285 INSERT);
286 flags |= SECTION_NAMED;
287 if (*slot == NULL)
288 {
289 sect = ggc_alloc<section> ();
290 sect->named.common.flags = flags;
291 sect->named.name = ggc_strdup (name);
292 sect->named.decl = decl;
293 *slot = sect;
294 }
295 else
296 {
297 sect = *slot;
298 if ((sect->common.flags & ~SECTION_DECLARED) != flags
299 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
300 {
301 /* It is fine if one of the section flags is
302 SECTION_WRITE | SECTION_RELRO and the other has none of these
303 flags (i.e. read-only) in named sections and either the
304 section hasn't been declared yet or has been declared as writable.
305 In that case just make sure the resulting flags are
306 SECTION_WRITE | SECTION_RELRO, ie. writable only because of
307 relocations. */
308 if (((sect->common.flags ^ flags) & (SECTION_WRITE | SECTION_RELRO))
309 == (SECTION_WRITE | SECTION_RELRO)
310 && (sect->common.flags
311 & ~(SECTION_DECLARED | SECTION_WRITE | SECTION_RELRO))
312 == (flags & ~(SECTION_WRITE | SECTION_RELRO))
313 && ((sect->common.flags & SECTION_DECLARED) == 0
314 || (sect->common.flags & SECTION_WRITE)))
315 {
316 sect->common.flags |= (SECTION_WRITE | SECTION_RELRO);
317 return sect;
318 }
319 /* Sanity check user variables for flag changes. */
320 if (sect->named.decl != NULL
321 && DECL_P (sect->named.decl)
322 && decl != sect->named.decl)
323 {
324 if (decl != NULL && DECL_P (decl))
325 error ("%+qD causes a section type conflict with %qD",
326 decl, sect->named.decl);
327 else
328 error ("section type conflict with %qD", sect->named.decl);
329 inform (DECL_SOURCE_LOCATION (sect->named.decl),
330 "%qD was declared here", sect->named.decl);
331 }
332 else if (decl != NULL && DECL_P (decl))
333 error ("%+qD causes a section type conflict", decl);
334 else
335 error ("section type conflict");
336 /* Make sure we don't error about one section multiple times. */
337 sect->common.flags |= SECTION_OVERRIDE;
338 }
339 }
340 return sect;
341}
342
343/* Return true if the current compilation mode benefits from having
344 objects grouped into blocks. */
345
346static bool
347use_object_blocks_p (void)
348{
349 return flag_section_anchors;
350}
351
352/* Return the object_block structure for section SECT. Create a new
353 structure if we haven't created one already. Return null if SECT
354 itself is null. */
355
356static struct object_block *
357get_block_for_section (section *sect)
358{
359 struct object_block *block;
360
361 if (sect == NULL)
362 return NULL;
363
364 object_block **slot
365 = object_block_htab->find_slot_with_hash (sect, hash_section (sect),
366 INSERT);
367 block = *slot;
368 if (block == NULL)
369 {
370 block = ggc_cleared_alloc<object_block> ();
371 block->sect = sect;
372 *slot = block;
373 }
374 return block;
375}
376
377/* Create a symbol with label LABEL and place it at byte offset
378 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
379 is not yet known. LABEL must be a garbage-collected string. */
380
381static rtx
382create_block_symbol (const char *label, struct object_block *block,
383 HOST_WIDE_INT offset)
384{
385 rtx symbol;
386 unsigned int size;
387
388 /* Create the extended SYMBOL_REF. */
389 size = RTX_HDR_SIZE + sizeof (struct block_symbol);
390 symbol = (rtx) ggc_internal_alloc (size);
391
392 /* Initialize the normal SYMBOL_REF fields. */
393 memset (symbol, 0, size);
394 PUT_CODE (symbol, SYMBOL_REF);
395 PUT_MODE (symbol, Pmode);
396 XSTR (symbol, 0) = label;
397 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
398
399 /* Initialize the block_symbol stuff. */
400 SYMBOL_REF_BLOCK (symbol) = block;
401 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
402
403 return symbol;
404}
405
406/* Return a section with a particular name and with whatever SECTION_*
407 flags section_type_flags deems appropriate. The name of the section
408 is taken from NAME if nonnull, otherwise it is taken from DECL's
409 DECL_SECTION_NAME. DECL is the decl associated with the section
410 (see the section comment for details) and RELOC is as for
411 section_type_flags. */
412
413section *
414get_named_section (tree decl, const char *name, int reloc)
415{
416 unsigned int flags;
417
418 if (name == NULL)
419 {
420 gcc_assert (decl && DECL_P (decl) && DECL_SECTION_NAME (decl));
421 name = DECL_SECTION_NAME (decl);
422 }
423
424 flags = targetm.section_type_flags (decl, name, reloc);
425 return get_section (name, flags, decl);
426}
427
428/* Worker for resolve_unique_section. */
429
430static bool
431set_implicit_section (struct symtab_node *n, void *data ATTRIBUTE_UNUSED)
432{
433 n->implicit_section = true;
434 return false;
435}
436
437/* If required, set DECL_SECTION_NAME to a unique name. */
438
439void
440resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
441 int flag_function_or_data_sections)
442{
443 if (DECL_SECTION_NAME (decl) == NULL
444 && targetm_common.have_named_sections
445 && (flag_function_or_data_sections
446 || DECL_COMDAT_GROUP (decl)))
447 {
448 targetm.asm_out.unique_section (decl, reloc);
449 if (DECL_SECTION_NAME (decl))
450 symtab_node::get (decl)->call_for_symbol_and_aliases
451 (set_implicit_section, NULL, true);
452 }
453}
454
455#ifdef BSS_SECTION_ASM_OP
456
457#ifdef ASM_OUTPUT_ALIGNED_BSS
458
459/* Utility function for targets to use in implementing
460 ASM_OUTPUT_ALIGNED_BSS.
461 ??? It is believed that this function will work in most cases so such
462 support is localized here. */
463
464static void
465asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
466 const char *name, unsigned HOST_WIDE_INT size,
467 int align)
468{
469 switch_to_section (bss_section);
470 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
471#ifdef ASM_DECLARE_OBJECT_NAME
472 last_assemble_variable_decl = decl;
473 ASM_DECLARE_OBJECT_NAME (file, name, decl);
474#else
475 /* Standard thing is just output label for the object. */
476 ASM_OUTPUT_LABEL (file, name);
477#endif /* ASM_DECLARE_OBJECT_NAME */
478 ASM_OUTPUT_SKIP (file, size ? size : 1);
479}
480
481#endif
482
483#endif /* BSS_SECTION_ASM_OP */
484
485#ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
486/* Return the hot section for function DECL. Return text_section for
487 null DECLs. */
488
489static section *
490hot_function_section (tree decl)
491{
492 if (decl != NULL_TREE
493 && DECL_SECTION_NAME (decl) != NULL
494 && targetm_common.have_named_sections)
495 return get_named_section (decl, NULL, 0);
496 else
497 return text_section;
498}
499#endif
500
501/* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL)
502 is NULL.
503
504 When DECL_SECTION_NAME is non-NULL and it is implicit section and
505 NAMED_SECTION_SUFFIX is non-NULL, then produce section called
506 concatenate the name with NAMED_SECTION_SUFFIX.
507 Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */
508
509section *
510get_named_text_section (tree decl,
511 const char *text_section_name,
512 const char *named_section_suffix)
513{
514 if (decl && DECL_SECTION_NAME (decl))
515 {
516 if (named_section_suffix)
517 {
518 const char *dsn = DECL_SECTION_NAME (decl);
519 const char *stripped_name;
520 char *name, *buffer;
521
522 name = (char *) alloca (strlen (dsn) + 1);
523 memcpy (name, dsn,
524 strlen (dsn) + 1);
525
526 stripped_name = targetm.strip_name_encoding (name);
527
528 buffer = ACONCAT ((stripped_name, named_section_suffix, NULL));
529 return get_named_section (decl, buffer, 0);
530 }
531 else if (symtab_node::get (decl)->implicit_section)
532 {
533 const char *name;
534
535 /* Do not try to split gnu_linkonce functions. This gets somewhat
536 slipperly. */
537 if (DECL_COMDAT_GROUP (decl) && !HAVE_COMDAT_GROUP)
538 return NULL;
539 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
540 name = targetm.strip_name_encoding (name);
541 return get_named_section (decl, ACONCAT ((text_section_name, ".",
542 name, NULL)), 0);
543 }
544 else
545 return NULL;
546 }
547 return get_named_section (decl, text_section_name, 0);
548}
549
550/* Choose named function section based on its frequency. */
551
552section *
553default_function_section (tree decl, enum node_frequency freq,
554 bool startup, bool exit)
555{
556#if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG
557 /* Old GNU linkers have buggy --gc-section support, which sometimes
558 results in .gcc_except_table* sections being garbage collected. */
559 if (decl
560 && symtab_node::get (decl)->implicit_section)
561 return NULL;
562#endif
563
564 if (!flag_reorder_functions
565 || !targetm_common.have_named_sections)
566 return NULL;
567 /* Startup code should go to startup subsection unless it is
568 unlikely executed (this happens especially with function splitting
569 where we can split away unnecessary parts of static constructors. */
570 if (startup && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
571 {
572 /* If we do have a profile or(and) LTO phase is executed, we do not need
573 these ELF section. */
574 if (!in_lto_p || !flag_profile_values)
575 return get_named_text_section (decl, ".text.startup", NULL);
576 else
577 return NULL;
578 }
579
580 /* Similarly for exit. */
581 if (exit && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED)
582 return get_named_text_section (decl, ".text.exit", NULL);
583
584 /* Group cold functions together, similarly for hot code. */
585 switch (freq)
586 {
587 case NODE_FREQUENCY_UNLIKELY_EXECUTED:
588 return get_named_text_section (decl, ".text.unlikely", NULL);
589 case NODE_FREQUENCY_HOT:
590 /* If we do have a profile or(and) LTO phase is executed, we do not need
591 these ELF section. */
592 if (!in_lto_p || !flag_profile_values)
593 return get_named_text_section (decl, ".text.hot", NULL);
594 /* FALLTHRU */
595 default:
596 return NULL;
597 }
598}
599
600/* Return the section for function DECL.
601
602 If DECL is NULL_TREE, return the text section. We can be passed
603 NULL_TREE under some circumstances by dbxout.c at least.
604
605 If FORCE_COLD is true, return cold function section ignoring
606 the frequency info of cgraph_node. */
607
608static section *
609function_section_1 (tree decl, bool force_cold)
610{
611 section *section = NULL;
612 enum node_frequency freq = NODE_FREQUENCY_NORMAL;
613 bool startup = false, exit = false;
614
615 if (decl)
616 {
617 struct cgraph_node *node = cgraph_node::get (decl);
618
619 if (node)
620 {
621 freq = node->frequency;
622 startup = node->only_called_at_startup;
623 exit = node->only_called_at_exit;
624 }
625 }
626 if (force_cold)
627 freq = NODE_FREQUENCY_UNLIKELY_EXECUTED;
628
629#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
630 if (decl != NULL_TREE
631 && DECL_SECTION_NAME (decl) != NULL)
632 {
633 if (targetm.asm_out.function_section)
634 section = targetm.asm_out.function_section (decl, freq,
635 startup, exit);
636 if (section)
637 return section;
638 return get_named_section (decl, NULL, 0);
639 }
640 else
641 return targetm.asm_out.select_section
642 (decl, freq == NODE_FREQUENCY_UNLIKELY_EXECUTED,
643 symtab_node::get (decl)->definition_alignment ());
644#else
645 if (targetm.asm_out.function_section)
646 section = targetm.asm_out.function_section (decl, freq, startup, exit);
647 if (section)
648 return section;
649 return hot_function_section (decl);
650#endif
651}
652
653/* Return the section for function DECL.
654
655 If DECL is NULL_TREE, return the text section. We can be passed
656 NULL_TREE under some circumstances by dbxout.c at least. */
657
658section *
659function_section (tree decl)
660{
661 /* Handle cases where function splitting code decides
662 to put function entry point into unlikely executed section
663 despite the fact that the function itself is not cold
664 (i.e. it is called rarely but contains a hot loop that is
665 better to live in hot subsection for the code locality). */
666 return function_section_1 (decl,
667 first_function_block_is_cold);
668}
669
670/* Return the section for the current function, take IN_COLD_SECTION_P
671 into account. */
672
673section *
674current_function_section (void)
675{
676 return function_section_1 (current_function_decl, in_cold_section_p);
677}
678
679/* Tell assembler to switch to unlikely-to-be-executed text section. */
680
681section *
682unlikely_text_section (void)
683{
684 return function_section_1 (current_function_decl, true);
685}
686
687/* When called within a function context, return true if the function
688 has been assigned a cold text section and if SECT is that section.
689 When called outside a function context, return true if SECT is the
690 default cold section. */
691
692bool
693unlikely_text_section_p (section *sect)
694{
695 return sect == function_section_1 (current_function_decl, true);
696}
697
698/* Switch to the other function partition (if inside of hot section
699 into cold section, otherwise into the hot section). */
700
701void
702switch_to_other_text_partition (void)
703{
704 in_cold_section_p = !in_cold_section_p;
705 switch_to_section (current_function_section ());
706}
707
708/* Return the read-only data section associated with function DECL. */
709
710section *
711default_function_rodata_section (tree decl)
712{
713 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
714 {
715 const char *name = DECL_SECTION_NAME (decl);
716
717 if (DECL_COMDAT_GROUP (decl) && HAVE_COMDAT_GROUP)
718 {
719 const char *dot;
720 size_t len;
721 char* rname;
722
723 dot = strchr (name + 1, '.');
724 if (!dot)
725 dot = name;
726 len = strlen (dot) + 8;
727 rname = (char *) alloca (len);
728
729 strcpy (rname, ".rodata");
730 strcat (rname, dot);
731 return get_section (rname, SECTION_LINKONCE, decl);
732 }
733 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
734 else if (DECL_COMDAT_GROUP (decl)
735 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
736 {
737 size_t len = strlen (name) + 1;
738 char *rname = (char *) alloca (len);
739
740 memcpy (rname, name, len);
741 rname[14] = 'r';
742 return get_section (rname, SECTION_LINKONCE, decl);
743 }
744 /* For .text.foo we want to use .rodata.foo. */
745 else if (flag_function_sections && flag_data_sections
746 && strncmp (name, ".text.", 6) == 0)
747 {
748 size_t len = strlen (name) + 1;
749 char *rname = (char *) alloca (len + 2);
750
751 memcpy (rname, ".rodata", 7);
752 memcpy (rname + 7, name + 5, len - 5);
753 return get_section (rname, 0, decl);
754 }
755 }
756
757 return readonly_data_section;
758}
759
760/* Return the read-only data section associated with function DECL
761 for targets where that section should be always the single
762 readonly data section. */
763
764section *
765default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
766{
767 return readonly_data_section;
768}
769
770/* A subroutine of mergeable_string_section and mergeable_constant_section. */
771
772static const char *
773function_mergeable_rodata_prefix (void)
774{
775 section *s = targetm.asm_out.function_rodata_section (current_function_decl);
776 if (SECTION_STYLE (s) == SECTION_NAMED)
777 return s->named.name;
778 else
779 return targetm.asm_out.mergeable_rodata_prefix;
780}
781
782/* Return the section to use for string merging. */
783
784static section *
785mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
786 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
787 unsigned int flags ATTRIBUTE_UNUSED)
788{
789 HOST_WIDE_INT len;
790
791 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
792 && TREE_CODE (decl) == STRING_CST
793 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
794 && align <= 256
795 && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0
796 && TREE_STRING_LENGTH (decl) >= len)
797 {
798 scalar_int_mode mode;
799 unsigned int modesize;
800 const char *str;
801 HOST_WIDE_INT i;
802 int j, unit;
803 const char *prefix = function_mergeable_rodata_prefix ();
804 char *name = (char *) alloca (strlen (prefix) + 30);
805
806 mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
807 modesize = GET_MODE_BITSIZE (mode);
808 if (modesize >= 8 && modesize <= 256
809 && (modesize & (modesize - 1)) == 0)
810 {
811 if (align < modesize)
812 align = modesize;
813
814 str = TREE_STRING_POINTER (decl);
815 unit = GET_MODE_SIZE (mode);
816
817 /* Check for embedded NUL characters. */
818 for (i = 0; i < len; i += unit)
819 {
820 for (j = 0; j < unit; j++)
821 if (str[i + j] != '\0')
822 break;
823 if (j == unit)
824 break;
825 }
826 if (i == len - unit)
827 {
828 sprintf (name, "%s.str%d.%d", prefix,
829 modesize / 8, (int) (align / 8));
830 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
831 return get_section (name, flags, NULL);
832 }
833 }
834 }
835
836 return readonly_data_section;
837}
838
839/* Return the section to use for constant merging. */
840
841section *
842mergeable_constant_section (machine_mode mode ATTRIBUTE_UNUSED,
843 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
844 unsigned int flags ATTRIBUTE_UNUSED)
845{
846 unsigned int modesize = GET_MODE_BITSIZE (mode);
847
848 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
849 && mode != VOIDmode
850 && mode != BLKmode
851 && modesize <= align
852 && align >= 8
853 && align <= 256
854 && (align & (align - 1)) == 0)
855 {
856 const char *prefix = function_mergeable_rodata_prefix ();
857 char *name = (char *) alloca (strlen (prefix) + 30);
858
859 sprintf (name, "%s.cst%d", prefix, (int) (align / 8));
860 flags |= (align / 8) | SECTION_MERGE;
861 return get_section (name, flags, NULL);
862 }
863 return readonly_data_section;
864}
865
866/* Given NAME, a putative register name, discard any customary prefixes. */
867
868static const char *
869strip_reg_name (const char *name)
870{
871#ifdef REGISTER_PREFIX
872 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
873 name += strlen (REGISTER_PREFIX);
874#endif
875 if (name[0] == '%' || name[0] == '#')
876 name++;
877 return name;
878}
879
880/* The user has asked for a DECL to have a particular name. Set (or
881 change) it in such a way that we don't prefix an underscore to
882 it. */
883void
884set_user_assembler_name (tree decl, const char *name)
885{
886 char *starred = (char *) alloca (strlen (name) + 2);
887 starred[0] = '*';
888 strcpy (starred + 1, name);
889 symtab->change_decl_assembler_name (decl, get_identifier (starred));
890 SET_DECL_RTL (decl, NULL_RTX);
891}
892
893/* Decode an `asm' spec for a declaration as a register name.
894 Return the register number, or -1 if nothing specified,
895 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
896 or -3 if ASMSPEC is `cc' and is not recognized,
897 or -4 if ASMSPEC is `memory' and is not recognized.
898 Accept an exact spelling or a decimal number.
899 Prefixes such as % are optional. */
900
901int
902decode_reg_name_and_count (const char *asmspec, int *pnregs)
903{
904 /* Presume just one register is clobbered. */
905 *pnregs = 1;
906
907 if (asmspec != 0)
908 {
909 int i;
910
911 /* Get rid of confusing prefixes. */
912 asmspec = strip_reg_name (asmspec);
913
914 /* Allow a decimal number as a "register name". */
915 for (i = strlen (asmspec) - 1; i >= 0; i--)
916 if (! ISDIGIT (asmspec[i]))
917 break;
918 if (asmspec[0] != 0 && i < 0)
919 {
920 i = atoi (asmspec);
921 if (i < FIRST_PSEUDO_REGISTER && i >= 0 && reg_names[i][0])
922 return i;
923 else
924 return -2;
925 }
926
927 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
928 if (reg_names[i][0]
929 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
930 return i;
931
932#ifdef OVERLAPPING_REGISTER_NAMES
933 {
934 static const struct
935 {
936 const char *const name;
937 const int number;
938 const int nregs;
939 } table[] = OVERLAPPING_REGISTER_NAMES;
940
941 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
942 if (table[i].name[0]
943 && ! strcmp (asmspec, table[i].name))
944 {
945 *pnregs = table[i].nregs;
946 return table[i].number;
947 }
948 }
949#endif /* OVERLAPPING_REGISTER_NAMES */
950
951#ifdef ADDITIONAL_REGISTER_NAMES
952 {
953 static const struct { const char *const name; const int number; } table[]
954 = ADDITIONAL_REGISTER_NAMES;
955
956 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
957 if (table[i].name[0]
958 && ! strcmp (asmspec, table[i].name)
959 && reg_names[table[i].number][0])
960 return table[i].number;
961 }
962#endif /* ADDITIONAL_REGISTER_NAMES */
963
964 if (!strcmp (asmspec, "memory"))
965 return -4;
966
967 if (!strcmp (asmspec, "cc"))
968 return -3;
969
970 return -2;
971 }
972
973 return -1;
974}
975
976int
977decode_reg_name (const char *name)
978{
979 int count;
980 return decode_reg_name_and_count (name, &count);
981}
982
983
984/* Return true if DECL's initializer is suitable for a BSS section. */
985
986bool
987bss_initializer_p (const_tree decl)
988{
989 /* Do not put non-common constants into the .bss section, they belong in
990 a readonly section. */
991 return ((!TREE_READONLY (decl) || DECL_COMMON (decl))
992 && (DECL_INITIAL (decl) == NULL
993 /* In LTO we have no errors in program; error_mark_node is used
994 to mark offlined constructors. */
995 || (DECL_INITIAL (decl) == error_mark_node
996 && !in_lto_p)
997 || (flag_zero_initialized_in_bss
998 && initializer_zerop (DECL_INITIAL (decl)))));
999}
1000
1001/* Compute the alignment of variable specified by DECL.
1002 DONT_OUTPUT_DATA is from assemble_variable. */
1003
1004void
1005align_variable (tree decl, bool dont_output_data)
1006{
1007 unsigned int align = DECL_ALIGN (decl);
1008
1009 /* In the case for initialing an array whose length isn't specified,
1010 where we have not yet been able to do the layout,
1011 figure out the proper alignment now. */
1012 if (dont_output_data && DECL_SIZE (decl) == 0
1013 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1014 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1015
1016 /* Some object file formats have a maximum alignment which they support.
1017 In particular, a.out format supports a maximum alignment of 4. */
1018 if (align > MAX_OFILE_ALIGNMENT)
1019 {
1020 error ("alignment of %q+D is greater than maximum object "
1021 "file alignment %d", decl,
1022 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1023 align = MAX_OFILE_ALIGNMENT;
1024 }
1025
1026 if (! DECL_USER_ALIGN (decl))
1027 {
1028#ifdef DATA_ABI_ALIGNMENT
1029 unsigned int data_abi_align
1030 = DATA_ABI_ALIGNMENT (TREE_TYPE (decl), align);
1031 /* For backwards compatibility, don't assume the ABI alignment for
1032 TLS variables. */
1033 if (! DECL_THREAD_LOCAL_P (decl) || data_abi_align <= BITS_PER_WORD)
1034 align = data_abi_align;
1035#endif
1036
1037 /* On some machines, it is good to increase alignment sometimes.
1038 But as DECL_ALIGN is used both for actually emitting the variable
1039 and for code accessing the variable as guaranteed alignment, we
1040 can only increase the alignment if it is a performance optimization
1041 if the references to it must bind to the current definition. */
1042 if (decl_binds_to_current_def_p (decl)
1043 && !DECL_VIRTUAL_P (decl))
1044 {
1045#ifdef DATA_ALIGNMENT
1046 unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1047 /* Don't increase alignment too much for TLS variables - TLS space
1048 is too precious. */
1049 if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD)
1050 align = data_align;
1051#endif
1052 if (DECL_INITIAL (decl) != 0
1053 /* In LTO we have no errors in program; error_mark_node is used
1054 to mark offlined constructors. */
1055 && (in_lto_p || DECL_INITIAL (decl) != error_mark_node))
1056 {
1057 unsigned int const_align
1058 = targetm.constant_alignment (DECL_INITIAL (decl), align);
1059 /* Don't increase alignment too much for TLS variables - TLS
1060 space is too precious. */
1061 if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD)
1062 align = const_align;
1063 }
1064 }
1065 }
1066
1067 /* Reset the alignment in case we have made it tighter, so we can benefit
1068 from it in get_pointer_alignment. */
1069 SET_DECL_ALIGN (decl, align);
1070}
1071
1072/* Return DECL_ALIGN (decl), possibly increased for optimization purposes
1073 beyond what align_variable returned. */
1074
1075static unsigned int
1076get_variable_align (tree decl)
1077{
1078 unsigned int align = DECL_ALIGN (decl);
1079
1080 /* For user aligned vars or static vars align_variable already did
1081 everything. */
1082 if (DECL_USER_ALIGN (decl) || !TREE_PUBLIC (decl))
1083 return align;
1084
1085#ifdef DATA_ABI_ALIGNMENT
1086 if (DECL_THREAD_LOCAL_P (decl))
1087 align = DATA_ABI_ALIGNMENT (TREE_TYPE (decl), align);
1088#endif
1089
1090 /* For decls that bind to the current definition, align_variable
1091 did also everything, except for not assuming ABI required alignment
1092 of TLS variables. For other vars, increase the alignment here
1093 as an optimization. */
1094 if (!decl_binds_to_current_def_p (decl))
1095 {
1096 /* On some machines, it is good to increase alignment sometimes. */
1097#ifdef DATA_ALIGNMENT
1098 unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1099 /* Don't increase alignment too much for TLS variables - TLS space
1100 is too precious. */
1101 if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD)
1102 align = data_align;
1103#endif
1104 if (DECL_INITIAL (decl) != 0
1105 /* In LTO we have no errors in program; error_mark_node is used
1106 to mark offlined constructors. */
1107 && (in_lto_p || DECL_INITIAL (decl) != error_mark_node))
1108 {
1109 unsigned int const_align
1110 = targetm.constant_alignment (DECL_INITIAL (decl), align);
1111 /* Don't increase alignment too much for TLS variables - TLS space
1112 is too precious. */
1113 if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD)
1114 align = const_align;
1115 }
1116 }
1117
1118 return align;
1119}
1120
1121/* Return the section into which the given VAR_DECL or CONST_DECL
1122 should be placed. PREFER_NOSWITCH_P is true if a noswitch
1123 section should be used wherever possible. */
1124
1125section *
1126get_variable_section (tree decl, bool prefer_noswitch_p)
1127{
1128 addr_space_t as = ADDR_SPACE_GENERIC;
1129 int reloc;
1130 varpool_node *vnode = varpool_node::get (decl);
1131 if (vnode)
1132 {
1133 vnode = vnode->ultimate_alias_target ();
1134 decl = vnode->decl;
1135 }
1136
1137 if (TREE_TYPE (decl) != error_mark_node)
1138 as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
1139
1140 /* We need the constructor to figure out reloc flag. */
1141 if (vnode)
1142 vnode->get_constructor ();
1143
1144 if (DECL_COMMON (decl))
1145 {
1146 /* If the decl has been given an explicit section name, or it resides
1147 in a non-generic address space, then it isn't common, and shouldn't
1148 be handled as such. */
1149 gcc_assert (DECL_SECTION_NAME (decl) == NULL
1150 && ADDR_SPACE_GENERIC_P (as));
1151 if (DECL_THREAD_LOCAL_P (decl))
1152 return tls_comm_section;
1153 else if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
1154 return comm_section;
1155 }
1156
1157 if (DECL_INITIAL (decl) == error_mark_node)
1158 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1159 else if (DECL_INITIAL (decl))
1160 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1161 else
1162 reloc = 0;
1163
1164 resolve_unique_section (decl, reloc, flag_data_sections);
1165 if (IN_NAMED_SECTION (decl))
1166 {
1167 section *sect = get_named_section (decl, NULL, reloc);
1168
1169 if ((sect->common.flags & SECTION_BSS) && !bss_initializer_p (decl))
1170 {
1171 error_at (DECL_SOURCE_LOCATION (decl),
1172 "only zero initializers are allowed in section %qs",
1173 sect->named.name);
1174 DECL_INITIAL (decl) = error_mark_node;
1175 }
1176 return sect;
1177 }
1178
1179 if (ADDR_SPACE_GENERIC_P (as)
1180 && !DECL_THREAD_LOCAL_P (decl)
1181 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
1182 && bss_initializer_p (decl))
1183 {
1184 if (!TREE_PUBLIC (decl)
1185 && !((flag_sanitize & SANITIZE_ADDRESS)
1186 && asan_protect_global (decl)))
1187 return lcomm_section;
1188 if (bss_noswitch_section)
1189 return bss_noswitch_section;
1190 }
1191
1192 return targetm.asm_out.select_section (decl, reloc,
1193 get_variable_align (decl));
1194}
1195
1196/* Return the block into which object_block DECL should be placed. */
1197
1198static struct object_block *
1199get_block_for_decl (tree decl)
1200{
1201 section *sect;
1202
1203 if (VAR_P (decl))
1204 {
1205 /* The object must be defined in this translation unit. */
1206 if (DECL_EXTERNAL (decl))
1207 return NULL;
1208
1209 /* There's no point using object blocks for something that is
1210 isolated by definition. */
1211 if (DECL_COMDAT_GROUP (decl))
1212 return NULL;
1213 }
1214
1215 /* We can only calculate block offsets if the decl has a known
1216 constant size. */
1217 if (DECL_SIZE_UNIT (decl) == NULL)
1218 return NULL;
1219 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (decl)))
1220 return NULL;
1221
1222 /* Find out which section should contain DECL. We cannot put it into
1223 an object block if it requires a standalone definition. */
1224 if (VAR_P (decl))
1225 align_variable (decl, 0);
1226 sect = get_variable_section (decl, true);
1227 if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1228 return NULL;
1229
1230 return get_block_for_section (sect);
1231}
1232
1233/* Make sure block symbol SYMBOL is in block BLOCK. */
1234
1235static void
1236change_symbol_block (rtx symbol, struct object_block *block)
1237{
1238 if (block != SYMBOL_REF_BLOCK (symbol))
1239 {
1240 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
1241 SYMBOL_REF_BLOCK (symbol) = block;
1242 }
1243}
1244
1245/* Return true if it is possible to put DECL in an object_block. */
1246
1247static bool
1248use_blocks_for_decl_p (tree decl)
1249{
1250 struct symtab_node *snode;
1251
1252 /* Only data DECLs can be placed into object blocks. */
1253 if (!VAR_P (decl) && TREE_CODE (decl) != CONST_DECL)
1254 return false;
1255
1256 /* Detect decls created by dw2_force_const_mem. Such decls are
1257 special because DECL_INITIAL doesn't specify the decl's true value.
1258 dw2_output_indirect_constants will instead call assemble_variable
1259 with dont_output_data set to 1 and then print the contents itself. */
1260 if (DECL_INITIAL (decl) == decl)
1261 return false;
1262
1263 /* If this decl is an alias, then we don't want to emit a
1264 definition. */
1265 if (VAR_P (decl)
1266 && (snode = symtab_node::get (decl)) != NULL
1267 && snode->alias)
1268 return false;
1269
1270 return targetm.use_blocks_for_decl_p (decl);
1271}
1272
1273/* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
1274 until we find an identifier that is not itself a transparent alias.
1275 Modify the alias passed to it by reference (and all aliases on the
1276 way to the ultimate target), such that they do not have to be
1277 followed again, and return the ultimate target of the alias
1278 chain. */
1279
1280static inline tree
1281ultimate_transparent_alias_target (tree *alias)
1282{
1283 tree target = *alias;
1284
1285 if (IDENTIFIER_TRANSPARENT_ALIAS (target))
1286 {
1287 gcc_assert (TREE_CHAIN (target));
1288 target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
1289 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
1290 && ! TREE_CHAIN (target));
1291 *alias = target;
1292 }
1293
1294 return target;
1295}
1296
1297/* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
1298 have static storage duration. In other words, it should not be an
1299 automatic variable, including PARM_DECLs.
1300
1301 There is, however, one exception: this function handles variables
1302 explicitly placed in a particular register by the user.
1303
1304 This is never called for PARM_DECL nodes. */
1305
1306void
1307make_decl_rtl (tree decl)
1308{
1309 const char *name = 0;
1310 int reg_number;
1311 tree id;
1312 rtx x;
1313
1314 /* Check that we are not being given an automatic variable. */
1315 gcc_assert (TREE_CODE (decl) != PARM_DECL
1316 && TREE_CODE (decl) != RESULT_DECL);
1317
1318 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1319 gcc_assert (!VAR_P (decl)
1320 || TREE_STATIC (decl)
1321 || TREE_PUBLIC (decl)
1322 || DECL_EXTERNAL (decl)
1323 || DECL_REGISTER (decl));
1324
1325 /* And that we were not given a type or a label. */
1326 gcc_assert (TREE_CODE (decl) != TYPE_DECL
1327 && TREE_CODE (decl) != LABEL_DECL);
1328
1329 /* For a duplicate declaration, we can be called twice on the
1330 same DECL node. Don't discard the RTL already made. */
1331 if (DECL_RTL_SET_P (decl))
1332 {
1333 /* If the old RTL had the wrong mode, fix the mode. */
1334 x = DECL_RTL (decl);
1335 if (GET_MODE (x) != DECL_MODE (decl))
1336 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
1337
1338 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1339 return;
1340
1341 /* ??? Another way to do this would be to maintain a hashed
1342 table of such critters. Instead of adding stuff to a DECL
1343 to give certain attributes to it, we could use an external
1344 hash map from DECL to set of attributes. */
1345
1346 /* Let the target reassign the RTL if it wants.
1347 This is necessary, for example, when one machine specific
1348 decl attribute overrides another. */
1349 targetm.encode_section_info (decl, DECL_RTL (decl), false);
1350
1351 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1352 on the new decl information. */
1353 if (MEM_P (x)
1354 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1355 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
1356 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
1357
1358 return;
1359 }
1360
1361 /* If this variable belongs to the global constant pool, retrieve the
1362 pre-computed RTL or recompute it in LTO mode. */
1363 if (VAR_P (decl) && DECL_IN_CONSTANT_POOL (decl))
1364 {
1365 SET_DECL_RTL (decl, output_constant_def (DECL_INITIAL (decl), 1));
1366 return;
1367 }
1368
1369 id = DECL_ASSEMBLER_NAME (decl);
1370 if (TREE_CODE (decl) == FUNCTION_DECL
1371 && cgraph_node::get (decl)
1372 && cgraph_node::get (decl)->instrumentation_clone)
1373 ultimate_transparent_alias_target (&id);
1374 name = IDENTIFIER_POINTER (id);
1375
1376 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1377 && DECL_REGISTER (decl))
1378 {
1379 error ("register name not specified for %q+D", decl);
1380 }
1381 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1382 {
1383 const char *asmspec = name+1;
1384 machine_mode mode = DECL_MODE (decl);
1385 reg_number = decode_reg_name (asmspec);
1386 /* First detect errors in declaring global registers. */
1387 if (reg_number == -1)
1388 error ("register name not specified for %q+D", decl);
1389 else if (reg_number < 0)
1390 error ("invalid register name for %q+D", decl);
1391 else if (mode == BLKmode)
1392 error ("data type of %q+D isn%'t suitable for a register",
1393 decl);
1394 else if (!in_hard_reg_set_p (accessible_reg_set, mode, reg_number))
1395 error ("the register specified for %q+D cannot be accessed"
1396 " by the current target", decl);
1397 else if (!in_hard_reg_set_p (operand_reg_set, mode, reg_number))
1398 error ("the register specified for %q+D is not general enough"
1399 " to be used as a register variable", decl);
1400 else if (!targetm.hard_regno_mode_ok (reg_number, mode))
1401 error ("register specified for %q+D isn%'t suitable for data type",
1402 decl);
1403 /* Now handle properly declared static register variables. */
1404 else
1405 {
1406 int nregs;
1407
1408 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1409 {
1410 DECL_INITIAL (decl) = 0;
1411 error ("global register variable has initial value");
1412 }
1413 if (TREE_THIS_VOLATILE (decl))
1414 warning (OPT_Wvolatile_register_var,
1415 "optimization may eliminate reads and/or "
1416 "writes to register variables");
1417
1418 /* If the user specified one of the eliminables registers here,
1419 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1420 confused with that register and be eliminated. This usage is
1421 somewhat suspect... */
1422
1423 SET_DECL_RTL (decl, gen_raw_REG (mode, reg_number));
1424 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1425 REG_USERVAR_P (DECL_RTL (decl)) = 1;
1426
1427 if (TREE_STATIC (decl))
1428 {
1429 /* Make this register global, so not usable for anything
1430 else. */
1431#ifdef ASM_DECLARE_REGISTER_GLOBAL
1432 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1433 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1434#endif
1435 nregs = hard_regno_nregs (reg_number, mode);
1436 while (nregs > 0)
1437 globalize_reg (decl, reg_number + --nregs);
1438 }
1439
1440 /* As a register variable, it has no section. */
1441 return;
1442 }
1443 /* Avoid internal errors from invalid register
1444 specifications. */
1445 SET_DECL_ASSEMBLER_NAME (decl, NULL_TREE);
1446 DECL_HARD_REGISTER (decl) = 0;
1447 /* Also avoid SSA inconsistencies by pretending this is an external
1448 decl now. */
1449 DECL_EXTERNAL (decl) = 1;
1450 return;
1451 }
1452 /* Now handle ordinary static variables and functions (in memory).
1453 Also handle vars declared register invalidly. */
1454 else if (name[0] == '*')
1455 {
1456#ifdef REGISTER_PREFIX
1457 if (strlen (REGISTER_PREFIX) != 0)
1458 {
1459 reg_number = decode_reg_name (name);
1460 if (reg_number >= 0 || reg_number == -3)
1461 error ("register name given for non-register variable %q+D", decl);
1462 }
1463#endif
1464 }
1465
1466 /* Specifying a section attribute on a variable forces it into a
1467 non-.bss section, and thus it cannot be common. */
1468 /* FIXME: In general this code should not be necessary because
1469 visibility pass is doing the same work. But notice_global_symbol
1470 is called early and it needs to make DECL_RTL to get the name.
1471 we take care of recomputing the DECL_RTL after visibility is changed. */
1472 if (VAR_P (decl)
1473 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
1474 && DECL_SECTION_NAME (decl) != NULL
1475 && DECL_INITIAL (decl) == NULL_TREE
1476 && DECL_COMMON (decl))
1477 DECL_COMMON (decl) = 0;
1478
1479 /* Variables can't be both common and weak. */
1480 if (VAR_P (decl) && DECL_WEAK (decl))
1481 DECL_COMMON (decl) = 0;
1482
1483 if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1484 x = create_block_symbol (name, get_block_for_decl (decl), -1);
1485 else
1486 {
1487 machine_mode address_mode = Pmode;
1488 if (TREE_TYPE (decl) != error_mark_node)
1489 {
1490 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
1491 address_mode = targetm.addr_space.address_mode (as);
1492 }
1493 x = gen_rtx_SYMBOL_REF (address_mode, name);
1494 }
1495 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1496 SET_SYMBOL_REF_DECL (x, decl);
1497
1498 x = gen_rtx_MEM (DECL_MODE (decl), x);
1499 if (TREE_CODE (decl) != FUNCTION_DECL)
1500 set_mem_attributes (x, decl, 1);
1501 SET_DECL_RTL (decl, x);
1502
1503 /* Optionally set flags or add text to the name to record information
1504 such as that it is a function name.
1505 If the name is changed, the macro ASM_OUTPUT_LABELREF
1506 will have to know how to strip this information. */
1507 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1508}
1509
1510/* Like make_decl_rtl, but inhibit creation of new alias sets when
1511 calling make_decl_rtl. Also, reset DECL_RTL before returning the
1512 rtl. */
1513
1514rtx
1515make_decl_rtl_for_debug (tree decl)
1516{
1517 unsigned int save_aliasing_flag;
1518 rtx rtl;
1519
1520 if (DECL_RTL_SET_P (decl))
1521 return DECL_RTL (decl);
1522
1523 /* Kludge alert! Somewhere down the call chain, make_decl_rtl will
1524 call new_alias_set. If running with -fcompare-debug, sometimes
1525 we do not want to create alias sets that will throw the alias
1526 numbers off in the comparison dumps. So... clearing
1527 flag_strict_aliasing will keep new_alias_set() from creating a
1528 new set. */
1529 save_aliasing_flag = flag_strict_aliasing;
1530 flag_strict_aliasing = 0;
1531
1532 rtl = DECL_RTL (decl);
1533 /* Reset DECL_RTL back, as various parts of the compiler expects
1534 DECL_RTL set meaning it is actually going to be output. */
1535 SET_DECL_RTL (decl, NULL);
1536
1537 flag_strict_aliasing = save_aliasing_flag;
1538 return rtl;
1539}
1540
1541/* Output a string of literal assembler code
1542 for an `asm' keyword used between functions. */
1543
1544void
1545assemble_asm (tree string)
1546{
1547 const char *p;
1548 app_enable ();
1549
1550 if (TREE_CODE (string) == ADDR_EXPR)
1551 string = TREE_OPERAND (string, 0);
1552
1553 p = TREE_STRING_POINTER (string);
1554 fprintf (asm_out_file, "%s%s\n", p[0] == '\t' ? "" : "\t", p);
1555}
1556
1557/* Write the address of the entity given by SYMBOL to SEC. */
1558void
1559assemble_addr_to_section (rtx symbol, section *sec)
1560{
1561 switch_to_section (sec);
1562 assemble_align (POINTER_SIZE);
1563 assemble_integer (symbol, POINTER_SIZE_UNITS, POINTER_SIZE, 1);
1564}
1565
1566/* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1567 not) section for PRIORITY. */
1568section *
1569get_cdtor_priority_section (int priority, bool constructor_p)
1570{
1571 /* Buffer conservatively large enough for the full range of a 32-bit
1572 int plus the text below. */
1573 char buf[18];
1574
1575 /* ??? This only works reliably with the GNU linker. */
1576 sprintf (buf, "%s.%.5u",
1577 constructor_p ? ".ctors" : ".dtors",
1578 /* Invert the numbering so the linker puts us in the proper
1579 order; constructors are run from right to left, and the
1580 linker sorts in increasing order. */
1581 MAX_INIT_PRIORITY - priority);
1582 return get_section (buf, SECTION_WRITE, NULL);
1583}
1584
1585void
1586default_named_section_asm_out_destructor (rtx symbol, int priority)
1587{
1588 section *sec;
1589
1590 if (priority != DEFAULT_INIT_PRIORITY)
1591 sec = get_cdtor_priority_section (priority,
1592 /*constructor_p=*/false);
1593 else
1594 sec = get_section (".dtors", SECTION_WRITE, NULL);
1595
1596 assemble_addr_to_section (symbol, sec);
1597}
1598
1599#ifdef DTORS_SECTION_ASM_OP
1600void
1601default_dtor_section_asm_out_destructor (rtx symbol,
1602 int priority ATTRIBUTE_UNUSED)
1603{
1604 assemble_addr_to_section (symbol, dtors_section);
1605}
1606#endif
1607
1608void
1609default_named_section_asm_out_constructor (rtx symbol, int priority)
1610{
1611 section *sec;
1612
1613 if (priority != DEFAULT_INIT_PRIORITY)
1614 sec = get_cdtor_priority_section (priority,
1615 /*constructor_p=*/true);
1616 else
1617 sec = get_section (".ctors", SECTION_WRITE, NULL);
1618
1619 assemble_addr_to_section (symbol, sec);
1620}
1621
1622#ifdef CTORS_SECTION_ASM_OP
1623void
1624default_ctor_section_asm_out_constructor (rtx symbol,
1625 int priority ATTRIBUTE_UNUSED)
1626{
1627 assemble_addr_to_section (symbol, ctors_section);
1628}
1629#endif
1630
1631/* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1632 a nonzero value if the constant pool should be output before the
1633 start of the function, or a zero value if the pool should output
1634 after the end of the function. The default is to put it before the
1635 start. */
1636
1637#ifndef CONSTANT_POOL_BEFORE_FUNCTION
1638#define CONSTANT_POOL_BEFORE_FUNCTION 1
1639#endif
1640
1641/* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1642 to be output to assembler.
1643 Set first_global_object_name and weak_global_object_name as appropriate. */
1644
1645void
1646notice_global_symbol (tree decl)
1647{
1648 const char **t = &first_global_object_name;
1649
1650 if (first_global_object_name
1651 || !TREE_PUBLIC (decl)
1652 || DECL_EXTERNAL (decl)
1653 || !DECL_NAME (decl)
1654 || (VAR_P (decl) && DECL_HARD_REGISTER (decl))
1655 || (TREE_CODE (decl) != FUNCTION_DECL
1656 && (!VAR_P (decl)
1657 || (DECL_COMMON (decl)
1658 && (DECL_INITIAL (decl) == 0
1659 || DECL_INITIAL (decl) == error_mark_node)))))
1660 return;
1661
1662 /* We win when global object is found, but it is useful to know about weak
1663 symbol as well so we can produce nicer unique names. */
1664 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib)
1665 t = &weak_global_object_name;
1666
1667 if (!*t)
1668 {
1669 tree id = DECL_ASSEMBLER_NAME (decl);
1670 ultimate_transparent_alias_target (&id);
1671 *t = ggc_strdup (targetm.strip_name_encoding (IDENTIFIER_POINTER (id)));
1672 }
1673}
1674
1675/* If not using flag_reorder_blocks_and_partition, decide early whether the
1676 current function goes into the cold section, so that targets can use
1677 current_function_section during RTL expansion. DECL describes the
1678 function. */
1679
1680void
1681decide_function_section (tree decl)
1682{
1683 first_function_block_is_cold = false;
1684
1685 if (DECL_SECTION_NAME (decl))
1686 {
1687 struct cgraph_node *node = cgraph_node::get (current_function_decl);
1688 /* Calls to function_section rely on first_function_block_is_cold
1689 being accurate. */
1690 first_function_block_is_cold = (node
1691 && node->frequency
1692 == NODE_FREQUENCY_UNLIKELY_EXECUTED);
1693 }
1694
1695 in_cold_section_p = first_function_block_is_cold;
1696}
1697
1698/* Get the function's name, as described by its RTL. This may be
1699 different from the DECL_NAME name used in the source file. */
1700const char *
1701get_fnname_from_decl (tree decl)
1702{
1703 rtx x = DECL_RTL (decl);
1704 gcc_assert (MEM_P (x));
1705 x = XEXP (x, 0);
1706 gcc_assert (GET_CODE (x) == SYMBOL_REF);
1707 return XSTR (x, 0);
1708}
1709
1710/* Output assembler code for the constant pool of a function and associated
1711 with defining the name of the function. DECL describes the function.
1712 NAME is the function's name. For the constant pool, we use the current
1713 constant pool data. */
1714
1715void
1716assemble_start_function (tree decl, const char *fnname)
1717{
1718 int align;
1719 char tmp_label[100];
1720 bool hot_label_written = false;
1721
1722 if (crtl->has_bb_partition)
1723 {
1724 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1725 crtl->subsections.hot_section_label = ggc_strdup (tmp_label);
1726 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1727 crtl->subsections.cold_section_label = ggc_strdup (tmp_label);
1728 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1729 crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label);
1730 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1731 crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label);
1732 const_labelno++;
1733 cold_function_name = NULL_TREE;
1734 }
1735 else
1736 {
1737 crtl->subsections.hot_section_label = NULL;
1738 crtl->subsections.cold_section_label = NULL;
1739 crtl->subsections.hot_section_end_label = NULL;
1740 crtl->subsections.cold_section_end_label = NULL;
1741 }
1742
1743 /* The following code does not need preprocessing in the assembler. */
1744
1745 app_disable ();
1746
1747 if (CONSTANT_POOL_BEFORE_FUNCTION)
1748 output_constant_pool (fnname, decl);
1749
1750 align = symtab_node::get (decl)->definition_alignment ();
1751
1752 /* Make sure the not and cold text (code) sections are properly
1753 aligned. This is necessary here in the case where the function
1754 has both hot and cold sections, because we don't want to re-set
1755 the alignment when the section switch happens mid-function. */
1756
1757 if (crtl->has_bb_partition)
1758 {
1759 first_function_block_is_cold = false;
1760
1761 switch_to_section (unlikely_text_section ());
1762 assemble_align (align);
1763 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label);
1764
1765 /* When the function starts with a cold section, we need to explicitly
1766 align the hot section and write out the hot section label.
1767 But if the current function is a thunk, we do not have a CFG. */
1768 if (!cfun->is_thunk
1769 && BB_PARTITION (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb) == BB_COLD_PARTITION)
1770 {
1771 switch_to_section (text_section);
1772 assemble_align (align);
1773 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1774 hot_label_written = true;
1775 first_function_block_is_cold = true;
1776 }
1777 in_cold_section_p = first_function_block_is_cold;
1778 }
1779
1780
1781 /* Switch to the correct text section for the start of the function. */
1782
1783 switch_to_section (function_section (decl));
1784 if (crtl->has_bb_partition && !hot_label_written)
1785 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1786
1787 /* Tell assembler to move to target machine's alignment for functions. */
1788 align = floor_log2 (align / BITS_PER_UNIT);
1789 if (align > 0)
1790 {
1791 ASM_OUTPUT_ALIGN (asm_out_file, align);
1792 }
1793
1794 /* Handle a user-specified function alignment.
1795 Note that we still need to align to DECL_ALIGN, as above,
1796 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1797 if (! DECL_USER_ALIGN (decl)
1798 && align_functions_log > align
1799 && optimize_function_for_speed_p (cfun))
1800 {
1801#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1802 int align_log = align_functions_log;
1803#endif
1804 int max_skip = align_functions - 1;
1805 if (flag_limit_function_alignment && crtl->max_insn_address > 0
1806 && max_skip >= crtl->max_insn_address)
1807 max_skip = crtl->max_insn_address - 1;
1808
1809#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1810 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file, align_log, max_skip);
1811#else
1812 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1813#endif
1814 }
1815
1816#ifdef ASM_OUTPUT_FUNCTION_PREFIX
1817 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1818#endif
1819
1820 if (!DECL_IGNORED_P (decl))
1821 (*debug_hooks->begin_function) (decl);
1822
1823 /* Make function name accessible from other files, if appropriate. */
1824
1825 if (TREE_PUBLIC (decl)
1826 || (cgraph_node::get (decl)->instrumentation_clone
1827 && cgraph_node::get (decl)->instrumented_version
1828 && TREE_PUBLIC (cgraph_node::get (decl)->instrumented_version->decl)))
1829 {
1830 notice_global_symbol (decl);
1831
1832 globalize_decl (decl);
1833
1834 maybe_assemble_visibility (decl);
1835 }
1836
1837 if (DECL_PRESERVE_P (decl))
1838 targetm.asm_out.mark_decl_preserved (fnname);
1839
1840 unsigned HOST_WIDE_INT patch_area_size = function_entry_patch_area_size;
1841 unsigned HOST_WIDE_INT patch_area_entry = function_entry_patch_area_start;
1842
1843 tree patchable_function_entry_attr
1844 = lookup_attribute ("patchable_function_entry", DECL_ATTRIBUTES (decl));
1845 if (patchable_function_entry_attr)
1846 {
1847 tree pp_val = TREE_VALUE (patchable_function_entry_attr);
1848 tree patchable_function_entry_value1 = TREE_VALUE (pp_val);
1849
1850 if (tree_fits_uhwi_p (patchable_function_entry_value1))
1851 patch_area_size = tree_to_uhwi (patchable_function_entry_value1);
1852 else
1853 gcc_unreachable ();
1854
1855 patch_area_entry = 0;
1856 if (list_length (pp_val) > 1)
1857 {
1858 tree patchable_function_entry_value2 =
1859 TREE_VALUE (TREE_CHAIN (pp_val));
1860
1861 if (tree_fits_uhwi_p (patchable_function_entry_value2))
1862 patch_area_entry = tree_to_uhwi (patchable_function_entry_value2);
1863 else
1864 gcc_unreachable ();
1865 }
1866 }
1867
1868 if (patch_area_entry > patch_area_size)
1869 {
1870 if (patch_area_size > 0)
1871 warning (OPT_Wattributes, "Patchable function entry > size");
1872 patch_area_entry = 0;
1873 }
1874
1875 /* Emit the patching area before the entry label, if any. */
1876 if (patch_area_entry > 0)
1877 targetm.asm_out.print_patchable_function_entry (asm_out_file,
1878 patch_area_entry, true);
1879
1880 /* Do any machine/system dependent processing of the function name. */
1881#ifdef ASM_DECLARE_FUNCTION_NAME
1882 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1883#else
1884 /* Standard thing is just output label for the function. */
1885 ASM_OUTPUT_FUNCTION_LABEL (asm_out_file, fnname, current_function_decl);
1886#endif /* ASM_DECLARE_FUNCTION_NAME */
1887
1888 /* And the area after the label. Record it if we haven't done so yet. */
1889 if (patch_area_size > patch_area_entry)
1890 targetm.asm_out.print_patchable_function_entry (asm_out_file,
1891 patch_area_size-patch_area_entry,
1892 patch_area_entry == 0);
1893
1894 if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl)))
1895 saw_no_split_stack = true;
1896}
1897
1898/* Output assembler code associated with defining the size of the
1899 function. DECL describes the function. NAME is the function's name. */
1900
1901void
1902assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1903{
1904#ifdef ASM_DECLARE_FUNCTION_SIZE
1905 /* We could have switched section in the middle of the function. */
1906 if (crtl->has_bb_partition)
1907 switch_to_section (function_section (decl));
1908 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1909#endif
1910 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1911 {
1912 output_constant_pool (fnname, decl);
1913 switch_to_section (function_section (decl)); /* need to switch back */
1914 }
1915 /* Output labels for end of hot/cold text sections (to be used by
1916 debug info.) */
1917 if (crtl->has_bb_partition)
1918 {
1919 section *save_text_section;
1920
1921 save_text_section = in_section;
1922 switch_to_section (unlikely_text_section ());
1923#ifdef ASM_DECLARE_COLD_FUNCTION_SIZE
1924 if (cold_function_name != NULL_TREE)
1925 ASM_DECLARE_COLD_FUNCTION_SIZE (asm_out_file,
1926 IDENTIFIER_POINTER (cold_function_name),
1927 decl);
1928#endif
1929 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label);
1930 if (first_function_block_is_cold)
1931 switch_to_section (text_section);
1932 else
1933 switch_to_section (function_section (decl));
1934 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label);
1935 switch_to_section (save_text_section);
1936 }
1937}
1938
1939/* Assemble code to leave SIZE bytes of zeros. */
1940
1941void
1942assemble_zeros (unsigned HOST_WIDE_INT size)
1943{
1944 /* Do no output if -fsyntax-only. */
1945 if (flag_syntax_only)
1946 return;
1947
1948#ifdef ASM_NO_SKIP_IN_TEXT
1949 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1950 so we must output 0s explicitly in the text section. */
1951 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1952 {
1953 unsigned HOST_WIDE_INT i;
1954 for (i = 0; i < size; i++)
1955 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1956 }
1957 else
1958#endif
1959 if (size > 0)
1960 ASM_OUTPUT_SKIP (asm_out_file, size);
1961}
1962
1963/* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1964
1965void
1966assemble_align (int align)
1967{
1968 if (align > BITS_PER_UNIT)
1969 {
1970 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1971 }
1972}
1973
1974/* Assemble a string constant with the specified C string as contents. */
1975
1976void
1977assemble_string (const char *p, int size)
1978{
1979 int pos = 0;
1980 int maximum = 2000;
1981
1982 /* If the string is very long, split it up. */
1983
1984 while (pos < size)
1985 {
1986 int thissize = size - pos;
1987 if (thissize > maximum)
1988 thissize = maximum;
1989
1990 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1991
1992 pos += thissize;
1993 p += thissize;
1994 }
1995}
1996
1997
1998/* A noswitch_section_callback for lcomm_section. */
1999
2000static bool
2001emit_local (tree decl ATTRIBUTE_UNUSED,
2002 const char *name ATTRIBUTE_UNUSED,
2003 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
2004 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
2005{
2006#if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
2007 unsigned int align = symtab_node::get (decl)->definition_alignment ();
2008 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
2009 size, align);
2010 return true;
2011#elif defined ASM_OUTPUT_ALIGNED_LOCAL
2012 unsigned int align = symtab_node::get (decl)->definition_alignment ();
2013 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, align);
2014 return true;
2015#else
2016 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2017 return false;
2018#endif
2019}
2020
2021/* A noswitch_section_callback for bss_noswitch_section. */
2022
2023#if defined ASM_OUTPUT_ALIGNED_BSS
2024static bool
2025emit_bss (tree decl ATTRIBUTE_UNUSED,
2026 const char *name ATTRIBUTE_UNUSED,
2027 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
2028 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
2029{
2030 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size,
2031 get_variable_align (decl));
2032 return true;
2033}
2034#endif
2035
2036/* A noswitch_section_callback for comm_section. */
2037
2038static bool
2039emit_common (tree decl ATTRIBUTE_UNUSED,
2040 const char *name ATTRIBUTE_UNUSED,
2041 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
2042 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
2043{
2044#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
2045 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
2046 size, get_variable_align (decl));
2047 return true;
2048#elif defined ASM_OUTPUT_ALIGNED_COMMON
2049 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
2050 get_variable_align (decl));
2051 return true;
2052#else
2053 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
2054 return false;
2055#endif
2056}
2057
2058/* A noswitch_section_callback for tls_comm_section. */
2059
2060static bool
2061emit_tls_common (tree decl ATTRIBUTE_UNUSED,
2062 const char *name ATTRIBUTE_UNUSED,
2063 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
2064 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
2065{
2066#ifdef ASM_OUTPUT_TLS_COMMON
2067 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
2068 return true;
2069#else
2070 sorry ("thread-local COMMON data not implemented");
2071 return true;
2072#endif
2073}
2074
2075/* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
2076 NAME is the name of DECL's SYMBOL_REF. */
2077
2078static void
2079assemble_noswitch_variable (tree decl, const char *name, section *sect,
2080 unsigned int align)
2081{
2082 unsigned HOST_WIDE_INT size, rounded;
2083
2084 size = tree_to_uhwi (DECL_SIZE_UNIT (decl));
2085 rounded = size;
2086
2087 if ((flag_sanitize & SANITIZE_ADDRESS) && asan_protect_global (decl))
2088 size += asan_red_zone_size (size);
2089
2090 /* Don't allocate zero bytes of common,
2091 since that means "undefined external" in the linker. */
2092 if (size == 0)
2093 rounded = 1;
2094
2095 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2096 so that each uninitialized object starts on such a boundary. */
2097 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
2098 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2099 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2100
2101 if (!sect->noswitch.callback (decl, name, size, rounded)
2102 && (unsigned HOST_WIDE_INT) (align / BITS_PER_UNIT) > rounded)
2103 error ("requested alignment for %q+D is greater than "
2104 "implemented alignment of %wu", decl, rounded);
2105}
2106
2107/* A subroutine of assemble_variable. Output the label and contents of
2108 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
2109 is as for assemble_variable. */
2110
2111static void
2112assemble_variable_contents (tree decl, const char *name,
2113 bool dont_output_data)
2114{
2115 /* Do any machine/system dependent processing of the object. */
2116#ifdef ASM_DECLARE_OBJECT_NAME
2117 last_assemble_variable_decl = decl;
2118 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
2119#else
2120 /* Standard thing is just output label for the object. */
2121 ASM_OUTPUT_LABEL (asm_out_file, name);
2122#endif /* ASM_DECLARE_OBJECT_NAME */
2123
2124 if (!dont_output_data)
2125 {
2126 /* Caller is supposed to use varpool_get_constructor when it wants
2127 to output the body. */
2128 gcc_assert (!in_lto_p || DECL_INITIAL (decl) != error_mark_node);
2129 if (DECL_INITIAL (decl)
2130 && DECL_INITIAL (decl) != error_mark_node
2131 && !initializer_zerop (DECL_INITIAL (decl)))
2132 /* Output the actual data. */
2133 output_constant (DECL_INITIAL (decl),
2134 tree_to_uhwi (DECL_SIZE_UNIT (decl)),
2135 get_variable_align (decl),
2136 false);
2137 else
2138 /* Leave space for it. */
2139 assemble_zeros (tree_to_uhwi (DECL_SIZE_UNIT (decl)));
2140 targetm.asm_out.decl_end ();
2141 }
2142}
2143
2144/* Write out assembly for the variable DECL, which is not defined in
2145 the current translation unit. */
2146void
2147assemble_undefined_decl (tree decl)
2148{
2149 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
2150 targetm.asm_out.assemble_undefined_decl (asm_out_file, name, decl);
2151}
2152
2153/* Assemble everything that is needed for a variable or function declaration.
2154 Not used for automatic variables, and not used for function definitions.
2155 Should not be called for variables of incomplete structure type.
2156
2157 TOP_LEVEL is nonzero if this variable has file scope.
2158 AT_END is nonzero if this is the special handling, at end of compilation,
2159 to define things that have had only tentative definitions.
2160 DONT_OUTPUT_DATA if nonzero means don't actually output the
2161 initial value (that will be done by the caller). */
2162
2163void
2164assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
2165 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
2166{
2167 const char *name;
2168 rtx decl_rtl, symbol;
2169 section *sect;
2170 unsigned int align;
2171 bool asan_protected = false;
2172
2173 /* This function is supposed to handle VARIABLES. Ensure we have one. */
2174 gcc_assert (VAR_P (decl));
2175
2176 /* Emulated TLS had better not get this far. */
2177 gcc_checking_assert (targetm.have_tls || !DECL_THREAD_LOCAL_P (decl));
2178
2179 last_assemble_variable_decl = 0;
2180
2181 /* Normally no need to say anything here for external references,
2182 since assemble_external is called by the language-specific code
2183 when a declaration is first seen. */
2184
2185 if (DECL_EXTERNAL (decl))
2186 return;
2187
2188 /* Do nothing for global register variables. */
2189 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
2190 {
2191 TREE_ASM_WRITTEN (decl) = 1;
2192 return;
2193 }
2194
2195 /* If type was incomplete when the variable was declared,
2196 see if it is complete now. */
2197
2198 if (DECL_SIZE (decl) == 0)
2199 layout_decl (decl, 0);
2200
2201 /* Still incomplete => don't allocate it; treat the tentative defn
2202 (which is what it must have been) as an `extern' reference. */
2203
2204 if (!dont_output_data && DECL_SIZE (decl) == 0)
2205 {
2206 error ("storage size of %q+D isn%'t known", decl);
2207 TREE_ASM_WRITTEN (decl) = 1;
2208 return;
2209 }
2210
2211 /* The first declaration of a variable that comes through this function
2212 decides whether it is global (in C, has external linkage)
2213 or local (in C, has internal linkage). So do nothing more
2214 if this function has already run. */
2215
2216 if (TREE_ASM_WRITTEN (decl))
2217 return;
2218
2219 /* Make sure targetm.encode_section_info is invoked before we set
2220 ASM_WRITTEN. */
2221 decl_rtl = DECL_RTL (decl);
2222
2223 TREE_ASM_WRITTEN (decl) = 1;
2224
2225 /* Do no output if -fsyntax-only. */
2226 if (flag_syntax_only)
2227 return;
2228
2229 if (! dont_output_data
2230 && ! valid_constant_size_p (DECL_SIZE_UNIT (decl)))
2231 {
2232 error ("size of variable %q+D is too large", decl);
2233 return;
2234 }
2235
2236 gcc_assert (MEM_P (decl_rtl));
2237 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
2238 symbol = XEXP (decl_rtl, 0);
2239
2240 /* If this symbol belongs to the tree constant pool, output the constant
2241 if it hasn't already been written. */
2242 if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
2243 {
2244 tree decl = SYMBOL_REF_DECL (symbol);
2245 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
2246 output_constant_def_contents (symbol);
2247 return;
2248 }
2249
2250 app_disable ();
2251
2252 name = XSTR (symbol, 0);
2253 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
2254 notice_global_symbol (decl);
2255
2256 /* Compute the alignment of this data. */
2257
2258 align_variable (decl, dont_output_data);
2259
2260 if ((flag_sanitize & SANITIZE_ADDRESS)
2261 && asan_protect_global (decl))
2262 {
2263 asan_protected = true;
2264 SET_DECL_ALIGN (decl, MAX (DECL_ALIGN (decl),
2265 ASAN_RED_ZONE_SIZE * BITS_PER_UNIT));
2266 }
2267
2268 set_mem_align (decl_rtl, DECL_ALIGN (decl));
2269
2270 align = get_variable_align (decl);
2271
2272 if (TREE_PUBLIC (decl))
2273 maybe_assemble_visibility (decl);
2274
2275 if (DECL_PRESERVE_P (decl))
2276 targetm.asm_out.mark_decl_preserved (name);
2277
2278 /* First make the assembler name(s) global if appropriate. */
2279 sect = get_variable_section (decl, false);
2280 if (TREE_PUBLIC (decl)
2281 && (sect->common.flags & SECTION_COMMON) == 0)
2282 globalize_decl (decl);
2283
2284 /* Output any data that we will need to use the address of. */
2285 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
2286 output_addressed_constants (DECL_INITIAL (decl));
2287
2288 /* dbxout.c needs to know this. */
2289 if (sect && (sect->common.flags & SECTION_CODE) != 0)
2290 DECL_IN_TEXT_SECTION (decl) = 1;
2291
2292 /* If the decl is part of an object_block, make sure that the decl
2293 has been positioned within its block, but do not write out its
2294 definition yet. output_object_blocks will do that later. */
2295 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2296 {
2297 gcc_assert (!dont_output_data);
2298 place_block_symbol (symbol);
2299 }
2300 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
2301 assemble_noswitch_variable (decl, name, sect, align);
2302 else
2303 {
2304 /* Special-case handling of vtv comdat sections. */
2305 if (sect->named.name
2306 && (strcmp (sect->named.name, ".vtable_map_vars") == 0))
2307 handle_vtv_comdat_section (sect, decl);
2308 else
2309 switch_to_section (sect);
2310 if (align > BITS_PER_UNIT)
2311 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2312 assemble_variable_contents (decl, name, dont_output_data);
2313 if (asan_protected)
2314 {
2315 unsigned HOST_WIDE_INT int size
2316 = tree_to_uhwi (DECL_SIZE_UNIT (decl));
2317 assemble_zeros (asan_red_zone_size (size));
2318 }
2319 }
2320}
2321
2322
2323/* Given a function declaration (FN_DECL), this function assembles the
2324 function into the .preinit_array section. */
2325
2326void
2327assemble_vtv_preinit_initializer (tree fn_decl)
2328{
2329 section *sect;
2330 unsigned flags = SECTION_WRITE;
2331 rtx symbol = XEXP (DECL_RTL (fn_decl), 0);
2332
2333 flags |= SECTION_NOTYPE;
2334 sect = get_section (".preinit_array", flags, fn_decl);
2335 switch_to_section (sect);
2336 assemble_addr_to_section (symbol, sect);
2337}
2338
2339/* Return 1 if type TYPE contains any pointers. */
2340
2341static int
2342contains_pointers_p (tree type)
2343{
2344 switch (TREE_CODE (type))
2345 {
2346 case POINTER_TYPE:
2347 case REFERENCE_TYPE:
2348 /* I'm not sure whether OFFSET_TYPE needs this treatment,
2349 so I'll play safe and return 1. */
2350 case OFFSET_TYPE:
2351 return 1;
2352
2353 case RECORD_TYPE:
2354 case UNION_TYPE:
2355 case QUAL_UNION_TYPE:
2356 {
2357 tree fields;
2358 /* For a type that has fields, see if the fields have pointers. */
2359 for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields))
2360 if (TREE_CODE (fields) == FIELD_DECL
2361 && contains_pointers_p (TREE_TYPE (fields)))
2362 return 1;
2363 return 0;
2364 }
2365
2366 case ARRAY_TYPE:
2367 /* An array type contains pointers if its element type does. */
2368 return contains_pointers_p (TREE_TYPE (type));
2369
2370 default:
2371 return 0;
2372 }
2373}
2374
2375/* We delay assemble_external processing until
2376 the compilation unit is finalized. This is the best we can do for
2377 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2378 it all the way to final. See PR 17982 for further discussion. */
2379static GTY(()) tree pending_assemble_externals;
2380
2381#ifdef ASM_OUTPUT_EXTERNAL
2382/* Some targets delay some output to final using TARGET_ASM_FILE_END.
2383 As a result, assemble_external can be called after the list of externals
2384 is processed and the pointer set destroyed. */
2385static bool pending_assemble_externals_processed;
2386
2387/* Avoid O(external_decls**2) lookups in the pending_assemble_externals
2388 TREE_LIST in assemble_external. */
2389static hash_set<tree> *pending_assemble_externals_set;
2390
2391/* True if DECL is a function decl for which no out-of-line copy exists.
2392 It is assumed that DECL's assembler name has been set. */
2393
2394static bool
2395incorporeal_function_p (tree decl)
2396{
2397 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
2398 {
2399 const char *name;
2400
2401 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2402 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (decl)))
2403 return true;
2404
2405 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2406 /* Atomic or sync builtins which have survived this far will be
2407 resolved externally and therefore are not incorporeal. */
2408 if (strncmp (name, "__builtin_", 10) == 0)
2409 return true;
2410 }
2411 return false;
2412}
2413
2414/* Actually do the tests to determine if this is necessary, and invoke
2415 ASM_OUTPUT_EXTERNAL. */
2416static void
2417assemble_external_real (tree decl)
2418{
2419 rtx rtl = DECL_RTL (decl);
2420
2421 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
2422 && !SYMBOL_REF_USED (XEXP (rtl, 0))
2423 && !incorporeal_function_p (decl))
2424 {
2425 /* Some systems do require some output. */
2426 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
2427 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
2428 }
2429}
2430#endif
2431
2432void
2433process_pending_assemble_externals (void)
2434{
2435#ifdef ASM_OUTPUT_EXTERNAL
2436 tree list;
2437 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
2438 assemble_external_real (TREE_VALUE (list));
2439
2440 pending_assemble_externals = 0;
2441 pending_assemble_externals_processed = true;
2442 delete pending_assemble_externals_set;
2443#endif
2444}
2445
2446/* This TREE_LIST contains any weak symbol declarations waiting
2447 to be emitted. */
2448static GTY(()) tree weak_decls;
2449
2450/* Output something to declare an external symbol to the assembler,
2451 and qualifiers such as weakness. (Most assemblers don't need
2452 extern declaration, so we normally output nothing.) Do nothing if
2453 DECL is not external. */
2454
2455void
2456assemble_external (tree decl ATTRIBUTE_UNUSED)
2457{
2458 /* Make sure that the ASM_OUT_FILE is open.
2459 If it's not, we should not be calling this function. */
2460 gcc_assert (asm_out_file);
2461
2462 /* In a perfect world, the following condition would be true.
2463 Sadly, the Go front end emit assembly *from the front end*,
2464 bypassing the call graph. See PR52739. Fix before GCC 4.8. */
2465#if 0
2466 /* This function should only be called if we are expanding, or have
2467 expanded, to RTL.
2468 Ideally, only final.c would be calling this function, but it is
2469 not clear whether that would break things somehow. See PR 17982
2470 for further discussion. */
2471 gcc_assert (state == EXPANSION
2472 || state == FINISHED);
2473#endif
2474
2475 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
2476 return;
2477
2478 /* We want to output annotation for weak and external symbols at
2479 very last to check if they are references or not. */
2480
2481 if (TARGET_SUPPORTS_WEAK
2482 && DECL_WEAK (decl)
2483 /* TREE_STATIC is a weird and abused creature which is not
2484 generally the right test for whether an entity has been
2485 locally emitted, inlined or otherwise not-really-extern, but
2486 for declarations that can be weak, it happens to be
2487 match. */
2488 && !TREE_STATIC (decl)
2489 && lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
2490 && value_member (decl, weak_decls) == NULL_TREE)
2491 weak_decls = tree_cons (NULL, decl, weak_decls);
2492
2493#ifdef ASM_OUTPUT_EXTERNAL
2494 if (pending_assemble_externals_processed)
2495 {
2496 assemble_external_real (decl);
2497 return;
2498 }
2499
2500 if (! pending_assemble_externals_set->add (decl))
2501 pending_assemble_externals = tree_cons (NULL, decl,
2502 pending_assemble_externals);
2503#endif
2504}
2505
2506/* Similar, for calling a library function FUN. */
2507
2508void
2509assemble_external_libcall (rtx fun)
2510{
2511 /* Declare library function name external when first used, if nec. */
2512 if (! SYMBOL_REF_USED (fun))
2513 {
2514 SYMBOL_REF_USED (fun) = 1;
2515 targetm.asm_out.external_libcall (fun);
2516 }
2517}
2518
2519/* Assemble a label named NAME. */
2520
2521void
2522assemble_label (FILE *file, const char *name)
2523{
2524 ASM_OUTPUT_LABEL (file, name);
2525}
2526
2527/* Set the symbol_referenced flag for ID. */
2528void
2529mark_referenced (tree id)
2530{
2531 TREE_SYMBOL_REFERENCED (id) = 1;
2532}
2533
2534/* Set the symbol_referenced flag for DECL and notify callgraph. */
2535void
2536mark_decl_referenced (tree decl)
2537{
2538 if (TREE_CODE (decl) == FUNCTION_DECL)
2539 {
2540 /* Extern inline functions don't become needed when referenced.
2541 If we know a method will be emitted in other TU and no new
2542 functions can be marked reachable, just use the external
2543 definition. */
2544 struct cgraph_node *node = cgraph_node::get_create (decl);
2545 if (!DECL_EXTERNAL (decl)
2546 && !node->definition)
2547 node->mark_force_output ();
2548 }
2549 else if (VAR_P (decl))
2550 {
2551 varpool_node *node = varpool_node::get_create (decl);
2552 /* C++ frontend use mark_decl_references to force COMDAT variables
2553 to be output that might appear dead otherwise. */
2554 node->force_output = true;
2555 }
2556 /* else do nothing - we can get various sorts of CST nodes here,
2557 which do not need to be marked. */
2558}
2559
2560
2561/* Output to FILE (an assembly file) a reference to NAME. If NAME
2562 starts with a *, the rest of NAME is output verbatim. Otherwise
2563 NAME is transformed in a target-specific way (usually by the
2564 addition of an underscore). */
2565
2566void
2567assemble_name_raw (FILE *file, const char *name)
2568{
2569 if (name[0] == '*')
2570 fputs (&name[1], file);
2571 else
2572 ASM_OUTPUT_LABELREF (file, name);
2573}
2574
2575/* Like assemble_name_raw, but should be used when NAME might refer to
2576 an entity that is also represented as a tree (like a function or
2577 variable). If NAME does refer to such an entity, that entity will
2578 be marked as referenced. */
2579
2580void
2581assemble_name (FILE *file, const char *name)
2582{
2583 const char *real_name;
2584 tree id;
2585
2586 real_name = targetm.strip_name_encoding (name);
2587
2588 id = maybe_get_identifier (real_name);
2589 if (id)
2590 {
2591 tree id_orig = id;
2592
2593 mark_referenced (id);
2594 ultimate_transparent_alias_target (&id);
2595 if (id != id_orig)
2596 name = IDENTIFIER_POINTER (id);
2597 gcc_assert (! TREE_CHAIN (id));
2598 }
2599
2600 assemble_name_raw (file, name);
2601}
2602
2603/* Allocate SIZE bytes writable static space with a gensym name
2604 and return an RTX to refer to its address. */
2605
2606rtx
2607assemble_static_space (unsigned HOST_WIDE_INT size)
2608{
2609 char name[17];
2610 const char *namestring;
2611 rtx x;
2612
2613 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2614 ++const_labelno;
2615 namestring = ggc_strdup (name);
2616
2617 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2618 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2619
2620#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2621 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2622 BIGGEST_ALIGNMENT);
2623#else
2624#ifdef ASM_OUTPUT_ALIGNED_LOCAL
2625 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2626#else
2627 {
2628 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2629 so that each uninitialized object starts on such a boundary. */
2630 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2631 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2632 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2633 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2634 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2635 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2636 }
2637#endif
2638#endif
2639 return x;
2640}
2641
2642/* Assemble the static constant template for function entry trampolines.
2643 This is done at most once per compilation.
2644 Returns an RTX for the address of the template. */
2645
2646static GTY(()) rtx initial_trampoline;
2647
2648rtx
2649assemble_trampoline_template (void)
2650{
2651 char label[256];
2652 const char *name;
2653 int align;
2654 rtx symbol;
2655
2656 gcc_assert (targetm.asm_out.trampoline_template != NULL);
2657
2658 if (initial_trampoline)
2659 return initial_trampoline;
2660
2661 /* By default, put trampoline templates in read-only data section. */
2662
2663#ifdef TRAMPOLINE_SECTION
2664 switch_to_section (TRAMPOLINE_SECTION);
2665#else
2666 switch_to_section (readonly_data_section);
2667#endif
2668
2669 /* Write the assembler code to define one. */
2670 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2671 if (align > 0)
2672 ASM_OUTPUT_ALIGN (asm_out_file, align);
2673
2674 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2675 targetm.asm_out.trampoline_template (asm_out_file);
2676
2677 /* Record the rtl to refer to it. */
2678 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2679 name = ggc_strdup (label);
2680 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2681 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2682
2683 initial_trampoline = gen_const_mem (BLKmode, symbol);
2684 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2685 set_mem_size (initial_trampoline, TRAMPOLINE_SIZE);
2686
2687 return initial_trampoline;
2688}
2689
2690/* A and B are either alignments or offsets. Return the minimum alignment
2691 that may be assumed after adding the two together. */
2692
2693static inline unsigned
2694min_align (unsigned int a, unsigned int b)
2695{
2696 return least_bit_hwi (a | b);
2697}
2698
2699/* Return the assembler directive for creating a given kind of integer
2700 object. SIZE is the number of bytes in the object and ALIGNED_P
2701 indicates whether it is known to be aligned. Return NULL if the
2702 assembly dialect has no such directive.
2703
2704 The returned string should be printed at the start of a new line and
2705 be followed immediately by the object's initial value. */
2706
2707const char *
2708integer_asm_op (int size, int aligned_p)
2709{
2710 struct asm_int_op *ops;
2711
2712 if (aligned_p)
2713 ops = &targetm.asm_out.aligned_op;
2714 else
2715 ops = &targetm.asm_out.unaligned_op;
2716
2717 switch (size)
2718 {
2719 case 1:
2720 return targetm.asm_out.byte_op;
2721 case 2:
2722 return ops->hi;
2723 case 4:
2724 return ops->si;
2725 case 8:
2726 return ops->di;
2727 case 16:
2728 return ops->ti;
2729 default:
2730 return NULL;
2731 }
2732}
2733
2734/* Use directive OP to assemble an integer object X. Print OP at the
2735 start of the line, followed immediately by the value of X. */
2736
2737void
2738assemble_integer_with_op (const char *op, rtx x)
2739{
2740 fputs (op, asm_out_file);
2741 output_addr_const (asm_out_file, x);
2742 fputc ('\n', asm_out_file);
2743}
2744
2745/* The default implementation of the asm_out.integer target hook. */
2746
2747bool
2748default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2749 unsigned int size ATTRIBUTE_UNUSED,
2750 int aligned_p ATTRIBUTE_UNUSED)
2751{
2752 const char *op = integer_asm_op (size, aligned_p);
2753 /* Avoid GAS bugs for large values. Specifically negative values whose
2754 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2755 if (size > UNITS_PER_WORD && size > POINTER_SIZE_UNITS)
2756 return false;
2757 return op && (assemble_integer_with_op (op, x), true);
2758}
2759
2760/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2761 the alignment of the integer in bits. Return 1 if we were able to output
2762 the constant, otherwise 0. We must be able to output the constant,
2763 if FORCE is nonzero. */
2764
2765bool
2766assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2767{
2768 int aligned_p;
2769
2770 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2771
2772 /* See if the target hook can handle this kind of object. */
2773 if (targetm.asm_out.integer (x, size, aligned_p))
2774 return true;
2775
2776 /* If the object is a multi-byte one, try splitting it up. Split
2777 it into words it if is multi-word, otherwise split it into bytes. */
2778 if (size > 1)
2779 {
2780 machine_mode omode, imode;
2781 unsigned int subalign;
2782 unsigned int subsize, i;
2783 enum mode_class mclass;
2784
2785 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2786 subalign = MIN (align, subsize * BITS_PER_UNIT);
2787 if (GET_CODE (x) == CONST_FIXED)
2788 mclass = GET_MODE_CLASS (GET_MODE (x));
2789 else
2790 mclass = MODE_INT;
2791
2792 omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0).require ();
2793 imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0).require ();
2794
2795 for (i = 0; i < size; i += subsize)
2796 {
2797 rtx partial = simplify_subreg (omode, x, imode, i);
2798 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2799 break;
2800 }
2801 if (i == size)
2802 return true;
2803
2804 /* If we've printed some of it, but not all of it, there's no going
2805 back now. */
2806 gcc_assert (!i);
2807 }
2808
2809 gcc_assert (!force);
2810
2811 return false;
2812}
2813
2814/* Assemble the floating-point constant D into an object of size MODE. ALIGN
2815 is the alignment of the constant in bits. If REVERSE is true, D is output
2816 in reverse storage order. */
2817
2818void
2819assemble_real (REAL_VALUE_TYPE d, scalar_float_mode mode, unsigned int align,
2820 bool reverse)
2821{
2822 long data[4] = {0, 0, 0, 0};
2823 int bitsize, nelts, nunits, units_per;
2824 rtx elt;
2825
2826 /* This is hairy. We have a quantity of known size. real_to_target
2827 will put it into an array of *host* longs, 32 bits per element
2828 (even if long is more than 32 bits). We need to determine the
2829 number of array elements that are occupied (nelts) and the number
2830 of *target* min-addressable units that will be occupied in the
2831 object file (nunits). We cannot assume that 32 divides the
2832 mode's bitsize (size * BITS_PER_UNIT) evenly.
2833
2834 size * BITS_PER_UNIT is used here to make sure that padding bits
2835 (which might appear at either end of the value; real_to_target
2836 will include the padding bits in its output array) are included. */
2837
2838 nunits = GET_MODE_SIZE (mode);
2839 bitsize = nunits * BITS_PER_UNIT;
2840 nelts = CEIL (bitsize, 32);
2841 units_per = 32 / BITS_PER_UNIT;
2842
2843 real_to_target (data, &d, mode);
2844
2845 /* Put out the first word with the specified alignment. */
2846 if (reverse)
2847 elt = flip_storage_order (SImode, gen_int_mode (data[nelts - 1], SImode));
2848 else
2849 elt = GEN_INT (data[0]);
2850 assemble_integer (elt, MIN (nunits, units_per), align, 1);
2851 nunits -= units_per;
2852
2853 /* Subsequent words need only 32-bit alignment. */
2854 align = min_align (align, 32);
2855
2856 for (int i = 1; i < nelts; i++)
2857 {
2858 if (reverse)
2859 elt = flip_storage_order (SImode,
2860 gen_int_mode (data[nelts - 1 - i], SImode));
2861 else
2862 elt = GEN_INT (data[i]);
2863 assemble_integer (elt, MIN (nunits, units_per), align, 1);
2864 nunits -= units_per;
2865 }
2866}
2867
2868/* Given an expression EXP with a constant value,
2869 reduce it to the sum of an assembler symbol and an integer.
2870 Store them both in the structure *VALUE.
2871 EXP must be reducible. */
2872
2873struct addr_const {
2874 rtx base;
2875 HOST_WIDE_INT offset;
2876};
2877
2878static void
2879decode_addr_const (tree exp, struct addr_const *value)
2880{
2881 tree target = TREE_OPERAND (exp, 0);
2882 HOST_WIDE_INT offset = 0;
2883 rtx x;
2884
2885 while (1)
2886 {
2887 if (TREE_CODE (target) == COMPONENT_REF
2888 && tree_fits_shwi_p (byte_position (TREE_OPERAND (target, 1))))
2889 {
2890 offset += int_byte_position (TREE_OPERAND (target, 1));
2891 target = TREE_OPERAND (target, 0);
2892 }
2893 else if (TREE_CODE (target) == ARRAY_REF
2894 || TREE_CODE (target) == ARRAY_RANGE_REF)
2895 {
2896 /* Truncate big offset. */
2897 offset += (TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (target)))
2898 * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)));
2899 target = TREE_OPERAND (target, 0);
2900 }
2901 else if (TREE_CODE (target) == MEM_REF
2902 && TREE_CODE (TREE_OPERAND (target, 0)) == ADDR_EXPR)
2903 {
2904 offset += mem_ref_offset (target).to_short_addr ();
2905 target = TREE_OPERAND (TREE_OPERAND (target, 0), 0);
2906 }
2907 else if (TREE_CODE (target) == INDIRECT_REF
2908 && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR
2909 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0))
2910 == ADDR_EXPR)
2911 target = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target, 0), 0), 0);
2912 else
2913 break;
2914 }
2915
2916 switch (TREE_CODE (target))
2917 {
2918 case VAR_DECL:
2919 case FUNCTION_DECL:
2920 x = DECL_RTL (target);
2921 break;
2922
2923 case LABEL_DECL:
2924 x = gen_rtx_MEM (FUNCTION_MODE,
2925 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2926 break;
2927
2928 case REAL_CST:
2929 case FIXED_CST:
2930 case STRING_CST:
2931 case COMPLEX_CST:
2932 case CONSTRUCTOR:
2933 case INTEGER_CST:
2934 x = output_constant_def (target, 1);
2935 break;
2936
2937 case INDIRECT_REF:
2938 /* This deals with absolute addresses. */
2939 offset += tree_to_shwi (TREE_OPERAND (target, 0));
2940 x = gen_rtx_MEM (QImode,
2941 gen_rtx_SYMBOL_REF (Pmode, "origin of addresses"));
2942 break;
2943
2944 default:
2945 gcc_unreachable ();
2946 }
2947
2948 gcc_assert (MEM_P (x));
2949 x = XEXP (x, 0);
2950
2951 value->base = x;
2952 value->offset = offset;
2953}
2954
2955static GTY(()) hash_table<tree_descriptor_hasher> *const_desc_htab;
2956
2957static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2958
2959/* Constant pool accessor function. */
2960
2961hash_table<tree_descriptor_hasher> *
2962constant_pool_htab (void)
2963{
2964 return const_desc_htab;
2965}
2966
2967/* Compute a hash code for a constant expression. */
2968
2969hashval_t
2970tree_descriptor_hasher::hash (constant_descriptor_tree *ptr)
2971{
2972 return ptr->hash;
2973}
2974
2975static hashval_t
2976const_hash_1 (const tree exp)
2977{
2978 const char *p;
2979 hashval_t hi;
2980 int len, i;
2981 enum tree_code code = TREE_CODE (exp);
2982
2983 /* Either set P and LEN to the address and len of something to hash and
2984 exit the switch or return a value. */
2985
2986 switch (code)
2987 {
2988 case INTEGER_CST:
2989 p = (char *) &TREE_INT_CST_ELT (exp, 0);
2990 len = TREE_INT_CST_NUNITS (exp) * sizeof (HOST_WIDE_INT);
2991 break;
2992
2993 case REAL_CST:
2994 return real_hash (TREE_REAL_CST_PTR (exp));
2995
2996 case FIXED_CST:
2997 return fixed_hash (TREE_FIXED_CST_PTR (exp));
2998
2999 case STRING_CST:
3000 p = TREE_STRING_POINTER (exp);
3001 len = TREE_STRING_LENGTH (exp);
3002 break;
3003
3004 case COMPLEX_CST:
3005 return (const_hash_1 (TREE_REALPART (exp)) * 5
3006 + const_hash_1 (TREE_IMAGPART (exp)));
3007
3008 case VECTOR_CST:
3009 {
3010 hi = 7 + VECTOR_CST_NPATTERNS (exp);
3011 hi = hi * 563 + VECTOR_CST_NELTS_PER_PATTERN (exp);
3012 unsigned int count = vector_cst_encoded_nelts (exp);
3013 for (unsigned int i = 0; i < count; ++i)
3014 hi = hi * 563 + const_hash_1 (VECTOR_CST_ENCODED_ELT (exp, i));
3015 return hi;
3016 }
3017
3018 case CONSTRUCTOR:
3019 {
3020 unsigned HOST_WIDE_INT idx;
3021 tree value;
3022
3023 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
3024
3025 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
3026 if (value)
3027 hi = hi * 603 + const_hash_1 (value);
3028
3029 return hi;
3030 }
3031
3032 case ADDR_EXPR:
3033 case FDESC_EXPR:
3034 {
3035 struct addr_const value;
3036
3037 decode_addr_const (exp, &value);
3038 switch (GET_CODE (value.base))
3039 {
3040 case SYMBOL_REF:
3041 /* Don't hash the address of the SYMBOL_REF;
3042 only use the offset and the symbol name. */
3043 hi = value.offset;
3044 p = XSTR (value.base, 0);
3045 for (i = 0; p[i] != 0; i++)
3046 hi = ((hi * 613) + (unsigned) (p[i]));
3047 break;
3048
3049 case LABEL_REF:
3050 hi = (value.offset
3051 + CODE_LABEL_NUMBER (label_ref_label (value.base)) * 13);
3052 break;
3053
3054 default:
3055 gcc_unreachable ();
3056 }
3057 }
3058 return hi;
3059
3060 case PLUS_EXPR:
3061 case POINTER_PLUS_EXPR:
3062 case MINUS_EXPR:
3063 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
3064 + const_hash_1 (TREE_OPERAND (exp, 1)));
3065
3066 CASE_CONVERT:
3067 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
3068
3069 default:
3070 /* A language specific constant. Just hash the code. */
3071 return code;
3072 }
3073
3074 /* Compute hashing function. */
3075 hi = len;
3076 for (i = 0; i < len; i++)
3077 hi = ((hi * 613) + (unsigned) (p[i]));
3078
3079 return hi;
3080}
3081
3082/* Wrapper of compare_constant, for the htab interface. */
3083bool
3084tree_descriptor_hasher::equal (constant_descriptor_tree *c1,
3085 constant_descriptor_tree *c2)
3086{
3087 if (c1->hash != c2->hash)
3088 return 0;
3089 return compare_constant (c1->value, c2->value);
3090}
3091
3092/* Compare t1 and t2, and return 1 only if they are known to result in
3093 the same bit pattern on output. */
3094
3095static int
3096compare_constant (const tree t1, const tree t2)
3097{
3098 enum tree_code typecode;
3099
3100 if (t1 == NULL_TREE)
3101 return t2 == NULL_TREE;
3102 if (t2 == NULL_TREE)
3103 return 0;
3104
3105 if (TREE_CODE (t1) != TREE_CODE (t2))
3106 return 0;
3107
3108 switch (TREE_CODE (t1))
3109 {
3110 case INTEGER_CST:
3111 /* Integer constants are the same only if the same width of type. */
3112 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3113 return 0;
3114 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3115 return 0;
3116 return tree_int_cst_equal (t1, t2);
3117
3118 case REAL_CST:
3119 /* Real constants are the same only if the same width of type. In
3120 addition to the same width, we need to check whether the modes are the
3121 same. There might be two floating point modes that are the same size
3122 but have different representations, such as the PowerPC that has 2
3123 different 128-bit floating point types (IBM extended double and IEEE
3124 128-bit floating point). */
3125 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3126 return 0;
3127 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3128 return 0;
3129 return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
3130
3131 case FIXED_CST:
3132 /* Fixed constants are the same only if the same width of type. */
3133 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3134 return 0;
3135
3136 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
3137
3138 case STRING_CST:
3139 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3140 return 0;
3141
3142 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3143 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3144 TREE_STRING_LENGTH (t1)));
3145
3146 case COMPLEX_CST:
3147 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
3148 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
3149
3150 case VECTOR_CST:
3151 {
3152 if (VECTOR_CST_NPATTERNS (t1)
3153 != VECTOR_CST_NPATTERNS (t2))
3154 return 0;
3155
3156 if (VECTOR_CST_NELTS_PER_PATTERN (t1)
3157 != VECTOR_CST_NELTS_PER_PATTERN (t2))
3158 return 0;
3159
3160 unsigned int count = vector_cst_encoded_nelts (t1);
3161 for (unsigned int i = 0; i < count; ++i)
3162 if (!compare_constant (VECTOR_CST_ENCODED_ELT (t1, i),
3163 VECTOR_CST_ENCODED_ELT (t2, i)))
3164 return 0;
3165
3166 return 1;
3167 }
3168
3169 case CONSTRUCTOR:
3170 {
3171 vec<constructor_elt, va_gc> *v1, *v2;
3172 unsigned HOST_WIDE_INT idx;
3173
3174 typecode = TREE_CODE (TREE_TYPE (t1));
3175 if (typecode != TREE_CODE (TREE_TYPE (t2)))
3176 return 0;
3177
3178 if (typecode == ARRAY_TYPE)
3179 {
3180 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
3181 /* For arrays, check that mode, size and storage order match. */
3182 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
3183 || size_1 == -1
3184 || size_1 != int_size_in_bytes (TREE_TYPE (t2))
3185 || TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t1))
3186 != TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t2)))
3187 return 0;
3188 }
3189 else
3190 {
3191 /* For record and union constructors, require exact type
3192 equality. */
3193 if (TREE_TYPE (t1) != TREE_TYPE (t2))
3194 return 0;
3195 }
3196
3197 v1 = CONSTRUCTOR_ELTS (t1);
3198 v2 = CONSTRUCTOR_ELTS (t2);
3199 if (vec_safe_length (v1) != vec_safe_length (v2))
3200 return 0;
3201
3202 for (idx = 0; idx < vec_safe_length (v1); ++idx)
3203 {
3204 constructor_elt *c1 = &(*v1)[idx];
3205 constructor_elt *c2 = &(*v2)[idx];
3206
3207 /* Check that each value is the same... */
3208 if (!compare_constant (c1->value, c2->value))
3209 return 0;
3210 /* ... and that they apply to the same fields! */
3211 if (typecode == ARRAY_TYPE)
3212 {
3213 if (!compare_constant (c1->index, c2->index))
3214 return 0;
3215 }
3216 else
3217 {
3218 if (c1->index != c2->index)
3219 return 0;
3220 }
3221 }
3222
3223 return 1;
3224 }
3225
3226 case ADDR_EXPR:
3227 case FDESC_EXPR:
3228 {
3229 struct addr_const value1, value2;
3230 enum rtx_code code;
3231 int ret;
3232
3233 decode_addr_const (t1, &value1);
3234 decode_addr_const (t2, &value2);
3235
3236 if (value1.offset != value2.offset)
3237 return 0;
3238
3239 code = GET_CODE (value1.base);
3240 if (code != GET_CODE (value2.base))
3241 return 0;
3242
3243 switch (code)
3244 {
3245 case SYMBOL_REF:
3246 ret = (strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
3247 break;
3248
3249 case LABEL_REF:
3250 ret = (CODE_LABEL_NUMBER (label_ref_label (value1.base))
3251 == CODE_LABEL_NUMBER (label_ref_label (value2.base)));
3252 break;
3253
3254 default:
3255 gcc_unreachable ();
3256 }
3257 return ret;
3258 }
3259
3260 case PLUS_EXPR:
3261 case POINTER_PLUS_EXPR:
3262 case MINUS_EXPR:
3263 case RANGE_EXPR:
3264 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3265 && compare_constant (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3266
3267 CASE_CONVERT:
3268 case VIEW_CONVERT_EXPR:
3269 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3270
3271 default:
3272 return 0;
3273 }
3274
3275 gcc_unreachable ();
3276}
3277
3278/* Return the section into which constant EXP should be placed. */
3279
3280static section *
3281get_constant_section (tree exp, unsigned int align)
3282{
3283 return targetm.asm_out.select_section (exp,
3284 compute_reloc_for_constant (exp),
3285 align);
3286}
3287
3288/* Return the size of constant EXP in bytes. */
3289
3290static HOST_WIDE_INT
3291get_constant_size (tree exp)
3292{
3293 HOST_WIDE_INT size;
3294
3295 size = int_size_in_bytes (TREE_TYPE (exp));
3296 if (TREE_CODE (exp) == STRING_CST)
3297 size = MAX (TREE_STRING_LENGTH (exp), size);
3298 return size;
3299}
3300
3301/* Subroutine of output_constant_def:
3302 No constant equal to EXP is known to have been output.
3303 Make a constant descriptor to enter EXP in the hash table.
3304 Assign the label number and construct RTL to refer to the
3305 constant's location in memory.
3306 Caller is responsible for updating the hash table. */
3307
3308static struct constant_descriptor_tree *
3309build_constant_desc (tree exp)
3310{
3311 struct constant_descriptor_tree *desc;
3312 rtx symbol, rtl;
3313 char label[256];
3314 int labelno;
3315 tree decl;
3316
3317 desc = ggc_alloc<constant_descriptor_tree> ();
3318 desc->value = exp;
3319
3320 /* Create a string containing the label name, in LABEL. */
3321 labelno = const_labelno++;
3322 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3323
3324 /* Construct the VAR_DECL associated with the constant. */
3325 decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label),
3326 TREE_TYPE (exp));
3327 DECL_ARTIFICIAL (decl) = 1;
3328 DECL_IGNORED_P (decl) = 1;
3329 TREE_READONLY (decl) = 1;
3330 TREE_STATIC (decl) = 1;
3331 TREE_ADDRESSABLE (decl) = 1;
3332 /* We don't set the RTL yet as this would cause varpool to assume that the
3333 variable is referenced. Moreover, it would just be dropped in LTO mode.
3334 Instead we set the flag that will be recognized in make_decl_rtl. */
3335 DECL_IN_CONSTANT_POOL (decl) = 1;
3336 DECL_INITIAL (decl) = desc->value;
3337 /* ??? targetm.constant_alignment hasn't been updated for vector types on
3338 most architectures so use DATA_ALIGNMENT as well, except for strings. */
3339 if (TREE_CODE (exp) == STRING_CST)
3340 SET_DECL_ALIGN (decl, targetm.constant_alignment (exp, DECL_ALIGN (decl)));
3341 else
3342 align_variable (decl, 0);
3343
3344 /* Now construct the SYMBOL_REF and the MEM. */
3345 if (use_object_blocks_p ())
3346 {
3347 int align = (TREE_CODE (decl) == CONST_DECL
3348 || (VAR_P (decl) && DECL_IN_CONSTANT_POOL (decl))
3349 ? DECL_ALIGN (decl)
3350 : symtab_node::get (decl)->definition_alignment ());
3351 section *sect = get_constant_section (exp, align);
3352 symbol = create_block_symbol (ggc_strdup (label),
3353 get_block_for_section (sect), -1);
3354 }
3355 else
3356 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3357 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3358 SET_SYMBOL_REF_DECL (symbol, decl);
3359 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3360
3361 rtl = gen_const_mem (TYPE_MODE (TREE_TYPE (exp)), symbol);
3362 set_mem_attributes (rtl, exp, 1);
3363 set_mem_alias_set (rtl, 0);
3364
3365 /* Putting EXP into the literal pool might have imposed a different
3366 alignment which should be visible in the RTX as well. */
3367 set_mem_align (rtl, DECL_ALIGN (decl));
3368
3369 /* We cannot share RTX'es in pool entries.
3370 Mark this piece of RTL as required for unsharing. */
3371 RTX_FLAG (rtl, used) = 1;
3372
3373 /* Set flags or add text to the name to record information, such as
3374 that it is a local symbol. If the name is changed, the macro
3375 ASM_OUTPUT_LABELREF will have to know how to strip this
3376 information. This call might invalidate our local variable
3377 SYMBOL; we can't use it afterward. */
3378 targetm.encode_section_info (exp, rtl, true);
3379
3380 desc->rtl = rtl;
3381
3382 return desc;
3383}
3384
3385/* Return an rtx representing a reference to constant data in memory
3386 for the constant expression EXP.
3387
3388 If assembler code for such a constant has already been output,
3389 return an rtx to refer to it.
3390 Otherwise, output such a constant in memory
3391 and generate an rtx for it.
3392
3393 If DEFER is nonzero, this constant can be deferred and output only
3394 if referenced in the function after all optimizations.
3395
3396 `const_desc_table' records which constants already have label strings. */
3397
3398rtx
3399output_constant_def (tree exp, int defer)
3400{
3401 struct constant_descriptor_tree *desc;
3402 struct constant_descriptor_tree key;
3403
3404 /* Look up EXP in the table of constant descriptors. If we didn't find
3405 it, create a new one. */
3406 key.value = exp;
3407 key.hash = const_hash_1 (exp);
3408 constant_descriptor_tree **loc
3409 = const_desc_htab->find_slot_with_hash (&key, key.hash, INSERT);
3410
3411 desc = *loc;
3412 if (desc == 0)
3413 {
3414 desc = build_constant_desc (exp);
3415 desc->hash = key.hash;
3416 *loc = desc;
3417 }
3418
3419 maybe_output_constant_def_contents (desc, defer);
3420 return desc->rtl;
3421}
3422
3423/* Subroutine of output_constant_def: Decide whether or not we need to
3424 output the constant DESC now, and if so, do it. */
3425static void
3426maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
3427 int defer)
3428{
3429 rtx symbol = XEXP (desc->rtl, 0);
3430 tree exp = desc->value;
3431
3432 if (flag_syntax_only)
3433 return;
3434
3435 if (TREE_ASM_WRITTEN (exp))
3436 /* Already output; don't do it again. */
3437 return;
3438
3439 /* We can always defer constants as long as the context allows
3440 doing so. */
3441 if (defer)
3442 {
3443 /* Increment n_deferred_constants if it exists. It needs to be at
3444 least as large as the number of constants actually referred to
3445 by the function. If it's too small we'll stop looking too early
3446 and fail to emit constants; if it's too large we'll only look
3447 through the entire function when we could have stopped earlier. */
3448 if (cfun)
3449 n_deferred_constants++;
3450 return;
3451 }
3452
3453 output_constant_def_contents (symbol);
3454}
3455
3456/* Subroutine of output_constant_def_contents. Output the definition
3457 of constant EXP, which is pointed to by label LABEL. ALIGN is the
3458 constant's alignment in bits. */
3459
3460static void
3461assemble_constant_contents (tree exp, const char *label, unsigned int align)
3462{
3463 HOST_WIDE_INT size;
3464
3465 size = get_constant_size (exp);
3466
3467 /* Do any machine/system dependent processing of the constant. */
3468 targetm.asm_out.declare_constant_name (asm_out_file, label, exp, size);
3469
3470 /* Output the value of EXP. */
3471 output_constant (exp, size, align, false);
3472
3473 targetm.asm_out.decl_end ();
3474}
3475
3476/* We must output the constant data referred to by SYMBOL; do so. */
3477
3478static void
3479output_constant_def_contents (rtx symbol)
3480{
3481 tree decl = SYMBOL_REF_DECL (symbol);
3482 tree exp = DECL_INITIAL (decl);
3483 bool asan_protected = false;
3484
3485 /* Make sure any other constants whose addresses appear in EXP
3486 are assigned label numbers. */
3487 output_addressed_constants (exp);
3488
3489 /* We are no longer deferring this constant. */
3490 TREE_ASM_WRITTEN (decl) = TREE_ASM_WRITTEN (exp) = 1;
3491
3492 if ((flag_sanitize & SANITIZE_ADDRESS)
3493 && TREE_CODE (exp) == STRING_CST
3494 && asan_protect_global (exp))
3495 {
3496 asan_protected = true;
3497 SET_DECL_ALIGN (decl, MAX (DECL_ALIGN (decl),
3498 ASAN_RED_ZONE_SIZE * BITS_PER_UNIT));
3499 }
3500
3501 /* If the constant is part of an object block, make sure that the
3502 decl has been positioned within its block, but do not write out
3503 its definition yet. output_object_blocks will do that later. */
3504 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
3505 place_block_symbol (symbol);
3506 else
3507 {
3508 int align = (TREE_CODE (decl) == CONST_DECL
3509 || (VAR_P (decl) && DECL_IN_CONSTANT_POOL (decl))
3510 ? DECL_ALIGN (decl)
3511 : symtab_node::get (decl)->definition_alignment ());
3512 switch_to_section (get_constant_section (exp, align));
3513 if (align > BITS_PER_UNIT)
3514 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3515 assemble_constant_contents (exp, XSTR (symbol, 0), align);
3516 if (asan_protected)
3517 {
3518 HOST_WIDE_INT size = get_constant_size (exp);
3519 assemble_zeros (asan_red_zone_size (size));
3520 }
3521 }
3522}
3523
3524/* Look up EXP in the table of constant descriptors. Return the rtl
3525 if it has been emitted, else null. */
3526
3527rtx
3528lookup_constant_def (tree exp)
3529{
3530 struct constant_descriptor_tree key;
3531
3532 key.value = exp;
3533 key.hash = const_hash_1 (exp);
3534 constant_descriptor_tree *desc
3535 = const_desc_htab->find_with_hash (&key, key.hash);
3536
3537 return (desc ? desc->rtl : NULL_RTX);
3538}
3539
3540/* Return a tree representing a reference to constant data in memory
3541 for the constant expression EXP.
3542
3543 This is the counterpart of output_constant_def at the Tree level. */
3544
3545tree
3546tree_output_constant_def (tree exp)
3547{
3548 struct constant_descriptor_tree *desc, key;
3549 tree decl;
3550
3551 /* Look up EXP in the table of constant descriptors. If we didn't find
3552 it, create a new one. */
3553 key.value = exp;
3554 key.hash = const_hash_1 (exp);
3555 constant_descriptor_tree **loc
3556 = const_desc_htab->find_slot_with_hash (&key, key.hash, INSERT);
3557
3558 desc = *loc;
3559 if (desc == 0)
3560 {
3561 desc = build_constant_desc (exp);
3562 desc->hash = key.hash;
3563 *loc = desc;
3564 }
3565
3566 decl = SYMBOL_REF_DECL (XEXP (desc->rtl, 0));
3567 varpool_node::finalize_decl (decl);
3568 return decl;
3569}
3570
3571struct GTY((chain_next ("%h.next"), for_user)) constant_descriptor_rtx {
3572 struct constant_descriptor_rtx *next;
3573 rtx mem;
3574 rtx sym;
3575 rtx constant;
3576 HOST_WIDE_INT offset;
3577 hashval_t hash;
3578 fixed_size_mode mode;
3579 unsigned int align;
3580 int labelno;
3581 int mark;
3582};
3583
3584struct const_rtx_desc_hasher : ggc_ptr_hash<constant_descriptor_rtx>
3585{
3586 static hashval_t hash (constant_descriptor_rtx *);
3587 static bool equal (constant_descriptor_rtx *, constant_descriptor_rtx *);
3588};
3589
3590/* Used in the hash tables to avoid outputting the same constant
3591 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3592 are output once per function, not once per file. */
3593/* ??? Only a few targets need per-function constant pools. Most
3594 can use one per-file pool. Should add a targetm bit to tell the
3595 difference. */
3596
3597struct GTY(()) rtx_constant_pool {
3598 /* Pointers to first and last constant in pool, as ordered by offset. */
3599 struct constant_descriptor_rtx *first;
3600 struct constant_descriptor_rtx *last;
3601
3602 /* Hash facility for making memory-constants from constant rtl-expressions.
3603 It is used on RISC machines where immediate integer arguments and
3604 constant addresses are restricted so that such constants must be stored
3605 in memory. */
3606 hash_table<const_rtx_desc_hasher> *const_rtx_htab;
3607
3608 /* Current offset in constant pool (does not include any
3609 machine-specific header). */
3610 HOST_WIDE_INT offset;
3611};
3612
3613/* Hash and compare functions for const_rtx_htab. */
3614
3615hashval_t
3616const_rtx_desc_hasher::hash (constant_descriptor_rtx *desc)
3617{
3618 return desc->hash;
3619}
3620
3621bool
3622const_rtx_desc_hasher::equal (constant_descriptor_rtx *x,
3623 constant_descriptor_rtx *y)
3624{
3625 if (x->mode != y->mode)
3626 return 0;
3627 return rtx_equal_p (x->constant, y->constant);
3628}
3629
3630/* Hash one component of a constant. */
3631
3632static hashval_t
3633const_rtx_hash_1 (const_rtx x)
3634{
3635 unsigned HOST_WIDE_INT hwi;
3636 machine_mode mode;
3637 enum rtx_code code;
3638 hashval_t h;
3639 int i;
3640
3641 code = GET_CODE (x);
3642 mode = GET_MODE (x);
3643 h = (hashval_t) code * 1048573 + mode;
3644
3645 switch (code)
3646 {
3647 case CONST_INT:
3648 hwi = INTVAL (x);
3649
3650 fold_hwi:
3651 {
3652 int shift = sizeof (hashval_t) * CHAR_BIT;
3653 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3654
3655 h ^= (hashval_t) hwi;
3656 for (i = 1; i < n; ++i)
3657 {
3658 hwi >>= shift;
3659 h ^= (hashval_t) hwi;
3660 }
3661 }
3662 break;
3663
3664 case CONST_WIDE_INT:
3665 hwi = 0;
3666 {
3667 for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++)
3668 hwi ^= CONST_WIDE_INT_ELT (x, i);
3669 goto fold_hwi;
3670 }
3671
3672 case CONST_DOUBLE:
3673 if (TARGET_SUPPORTS_WIDE_INT == 0 && mode == VOIDmode)
3674 {
3675 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3676 goto fold_hwi;
3677 }
3678 else
3679 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3680 break;
3681
3682 case CONST_FIXED:
3683 h ^= fixed_hash (CONST_FIXED_VALUE (x));
3684 break;
3685
3686 case SYMBOL_REF:
3687 h ^= htab_hash_string (XSTR (x, 0));
3688 break;
3689
3690 case LABEL_REF:
3691 h = h * 251 + CODE_LABEL_NUMBER (label_ref_label (x));
3692 break;
3693
3694 case UNSPEC:
3695 case UNSPEC_VOLATILE:
3696 h = h * 251 + XINT (x, 1);
3697 break;
3698
3699 default:
3700 break;
3701 }
3702
3703 return h;
3704}
3705
3706/* Compute a hash value for X, which should be a constant. */
3707
3708static hashval_t
3709const_rtx_hash (rtx x)
3710{
3711 hashval_t h = 0;
3712 subrtx_iterator::array_type array;
3713 FOR_EACH_SUBRTX (iter, array, x, ALL)
3714 h = h * 509 + const_rtx_hash_1 (*iter);
3715 return h;
3716}
3717
3718
3719/* Create and return a new rtx constant pool. */
3720
3721static struct rtx_constant_pool *
3722create_constant_pool (void)
3723{
3724 struct rtx_constant_pool *pool;
3725
3726 pool = ggc_alloc<rtx_constant_pool> ();
3727 pool->const_rtx_htab = hash_table<const_rtx_desc_hasher>::create_ggc (31);
3728 pool->first = NULL;
3729 pool->last = NULL;
3730 pool->offset = 0;
3731 return pool;
3732}
3733
3734/* Initialize constant pool hashing for a new function. */
3735
3736void
3737init_varasm_status (void)
3738{
3739 crtl->varasm.pool = create_constant_pool ();
3740 crtl->varasm.deferred_constants = 0;
3741}
3742
3743/* Given a MINUS expression, simplify it if both sides
3744 include the same symbol. */
3745
3746rtx
3747simplify_subtraction (rtx x)
3748{
3749 rtx r = simplify_rtx (x);
3750 return r ? r : x;
3751}
3752
3753/* Given a constant rtx X, make (or find) a memory constant for its value
3754 and return a MEM rtx to refer to it in memory. IN_MODE is the mode
3755 of X. */
3756
3757rtx
3758force_const_mem (machine_mode in_mode, rtx x)
3759{
3760 struct constant_descriptor_rtx *desc, tmp;
3761 struct rtx_constant_pool *pool;
3762 char label[256];
3763 rtx def, symbol;
3764 hashval_t hash;
3765 unsigned int align;
3766 constant_descriptor_rtx **slot;
3767 fixed_size_mode mode;
3768
3769 /* We can't force variable-sized objects to memory. */
3770 if (!is_a <fixed_size_mode> (in_mode, &mode))
3771 return NULL_RTX;
3772
3773 /* If we're not allowed to drop X into the constant pool, don't. */
3774 if (targetm.cannot_force_const_mem (mode, x))
3775 return NULL_RTX;
3776
3777 /* Record that this function has used a constant pool entry. */
3778 crtl->uses_const_pool = 1;
3779
3780 /* Decide which pool to use. */
3781 pool = (targetm.use_blocks_for_constant_p (mode, x)
3782 ? shared_constant_pool
3783 : crtl->varasm.pool);
3784
3785 /* Lookup the value in the hashtable. */
3786 tmp.constant = x;
3787 tmp.mode = mode;
3788 hash = const_rtx_hash (x);
3789 slot = pool->const_rtx_htab->find_slot_with_hash (&tmp, hash, INSERT);
3790 desc = *slot;
3791
3792 /* If the constant was already present, return its memory. */
3793 if (desc)
3794 return copy_rtx (desc->mem);
3795
3796 /* Otherwise, create a new descriptor. */
3797 desc = ggc_alloc<constant_descriptor_rtx> ();
3798 *slot = desc;
3799
3800 /* Align the location counter as required by EXP's data type. */
3801 machine_mode align_mode = (mode == VOIDmode ? word_mode : mode);
3802 align = targetm.static_rtx_alignment (align_mode);
3803
3804 pool->offset += (align / BITS_PER_UNIT) - 1;
3805 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3806
3807 desc->next = NULL;
3808 desc->constant = copy_rtx (tmp.constant);
3809 desc->offset = pool->offset;
3810 desc->hash = hash;
3811 desc->mode = mode;
3812 desc->align = align;
3813 desc->labelno = const_labelno;
3814 desc->mark = 0;
3815
3816 pool->offset += GET_MODE_SIZE (mode);
3817 if (pool->last)
3818 pool->last->next = desc;
3819 else
3820 pool->first = pool->last = desc;
3821 pool->last = desc;
3822
3823 /* Create a string containing the label name, in LABEL. */
3824 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3825 ++const_labelno;
3826
3827 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3828 the constants pool. */
3829 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3830 {
3831 section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3832 symbol = create_block_symbol (ggc_strdup (label),
3833 get_block_for_section (sect), -1);
3834 }
3835 else
3836 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3837 desc->sym = symbol;
3838 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3839 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3840 SET_SYMBOL_REF_CONSTANT (symbol, desc);
3841
3842 /* Construct the MEM. */
3843 desc->mem = def = gen_const_mem (mode, symbol);
3844 set_mem_align (def, align);
3845
3846 /* If we're dropping a label to the constant pool, make sure we
3847 don't delete it. */
3848 if (GET_CODE (x) == LABEL_REF)
3849 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3850
3851 return copy_rtx (def);
3852}
3853
3854/* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3855
3856rtx
3857get_pool_constant (const_rtx addr)
3858{
3859 return SYMBOL_REF_CONSTANT (addr)->constant;
3860}
3861
3862/* Given a constant pool SYMBOL_REF, return the corresponding constant
3863 and whether it has been output or not. */
3864
3865rtx
3866get_pool_constant_mark (rtx addr, bool *pmarked)
3867{
3868 struct constant_descriptor_rtx *desc;
3869
3870 desc = SYMBOL_REF_CONSTANT (addr);
3871 *pmarked = (desc->mark != 0);
3872 return desc->constant;
3873}
3874
3875/* Similar, return the mode. */
3876
3877fixed_size_mode
3878get_pool_mode (const_rtx addr)
3879{
3880 return SYMBOL_REF_CONSTANT (addr)->mode;
3881}
3882
3883/* Return TRUE if and only if the constant pool has no entries. Note
3884 that even entries we might end up choosing not to emit are counted
3885 here, so there is the potential for missed optimizations. */
3886
3887bool
3888constant_pool_empty_p (void)
3889{
3890 return crtl->varasm.pool->first == NULL;
3891}
3892
3893/* Worker function for output_constant_pool_1. Emit assembly for X
3894 in MODE with known alignment ALIGN. */
3895
3896static void
3897output_constant_pool_2 (fixed_size_mode mode, rtx x, unsigned int align)
3898{
3899 switch (GET_MODE_CLASS (mode))
3900 {
3901 case MODE_FLOAT:
3902 case MODE_DECIMAL_FLOAT:
3903 {
3904 gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x));
3905 assemble_real (*CONST_DOUBLE_REAL_VALUE (x),
3906 as_a <scalar_float_mode> (mode), align, false);
3907 break;
3908 }
3909
3910 case MODE_INT:
3911 case MODE_PARTIAL_INT:
3912 case MODE_FRACT:
3913 case MODE_UFRACT:
3914 case MODE_ACCUM:
3915 case MODE_UACCUM:
3916 case MODE_POINTER_BOUNDS:
3917 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3918 break;
3919
3920 case MODE_VECTOR_FLOAT:
3921 case MODE_VECTOR_INT:
3922 case MODE_VECTOR_FRACT:
3923 case MODE_VECTOR_UFRACT:
3924 case MODE_VECTOR_ACCUM:
3925 case MODE_VECTOR_UACCUM:
3926 {
3927 int i, units;
3928 scalar_mode submode = GET_MODE_INNER (mode);
3929 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3930
3931 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3932 units = CONST_VECTOR_NUNITS (x);
3933
3934 for (i = 0; i < units; i++)
3935 {
3936 rtx elt = CONST_VECTOR_ELT (x, i);
3937 output_constant_pool_2 (submode, elt, i ? subalign : align);
3938 }
3939 }
3940 break;
3941
3942 default:
3943 gcc_unreachable ();
3944 }
3945}
3946
3947/* Worker function for output_constant_pool. Emit constant DESC,
3948 giving it ALIGN bits of alignment. */
3949
3950static void
3951output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3952 unsigned int align)
3953{
3954 rtx x, tmp;
3955
3956 x = desc->constant;
3957
3958 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3959 whose CODE_LABEL has been deleted. This can occur if a jump table
3960 is eliminated by optimization. If so, write a constant of zero
3961 instead. Note that this can also happen by turning the
3962 CODE_LABEL into a NOTE. */
3963 /* ??? This seems completely and utterly wrong. Certainly it's
3964 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3965 functioning even with rtx_insn::deleted and friends. */
3966
3967 tmp = x;
3968 switch (GET_CODE (tmp))
3969 {
3970 case CONST:
3971 if (GET_CODE (XEXP (tmp, 0)) != PLUS
3972 || GET_CODE (XEXP (XEXP (tmp, 0), 0)) != LABEL_REF)
3973 break;
3974 tmp = XEXP (XEXP (tmp, 0), 0);
3975 /* FALLTHRU */
3976
3977 case LABEL_REF:
3978 {
3979 rtx_insn *insn = label_ref_label (tmp);
3980 gcc_assert (!insn->deleted ());
3981 gcc_assert (!NOTE_P (insn)
3982 || NOTE_KIND (insn) != NOTE_INSN_DELETED);
3983 break;
3984 }
3985
3986 default:
3987 break;
3988 }
3989
3990#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3991 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3992 align, desc->labelno, done);
3993#endif
3994
3995 assemble_align (align);
3996
3997 /* Output the label. */
3998 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3999
4000 /* Output the data.
4001 Pass actual alignment value while emitting string constant to asm code
4002 as function 'output_constant_pool_1' explicitly passes the alignment as 1
4003 assuming that the data is already aligned which prevents the generation
4004 of fix-up table entries. */
4005 output_constant_pool_2 (desc->mode, x, desc->align);
4006
4007 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
4008 sections have proper size. */
4009 if (align > GET_MODE_BITSIZE (desc->mode)
4010 && in_section
4011 && (in_section->common.flags & SECTION_MERGE))
4012 assemble_align (align);
4013
4014#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4015 done:
4016#endif
4017 return;
4018}
4019
4020/* Recompute the offsets of entries in POOL, and the overall size of
4021 POOL. Do this after calling mark_constant_pool to ensure that we
4022 are computing the offset values for the pool which we will actually
4023 emit. */
4024
4025static void
4026recompute_pool_offsets (struct rtx_constant_pool *pool)
4027{
4028 struct constant_descriptor_rtx *desc;
4029 pool->offset = 0;
4030
4031 for (desc = pool->first; desc ; desc = desc->next)
4032 if (desc->mark)
4033 {
4034 /* Recalculate offset. */
4035 unsigned int align = desc->align;
4036 pool->offset += (align / BITS_PER_UNIT) - 1;
4037 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
4038 desc->offset = pool->offset;
4039 pool->offset += GET_MODE_SIZE (desc->mode);
4040 }
4041}
4042
4043/* Mark all constants that are referenced by SYMBOL_REFs in X.
4044 Emit referenced deferred strings. */
4045
4046static void
4047mark_constants_in_pattern (rtx insn)
4048{
4049 subrtx_iterator::array_type array;
4050 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
4051 {
4052 const_rtx x = *iter;
4053 if (GET_CODE (x) == SYMBOL_REF)
4054 {
4055 if (CONSTANT_POOL_ADDRESS_P (x))
4056 {
4057 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
4058 if (desc->mark == 0)
4059 {
4060 desc->mark = 1;
4061 iter.substitute (desc->constant);
4062 }
4063 }
4064 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
4065 {
4066 tree decl = SYMBOL_REF_DECL (x);
4067 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
4068 {
4069 n_deferred_constants--;
4070 output_constant_def_contents (CONST_CAST_RTX (x));
4071 }
4072 }
4073 }
4074 }
4075}
4076
4077/* Look through appropriate parts of INSN, marking all entries in the
4078 constant pool which are actually being used. Entries that are only
4079 referenced by other constants are also marked as used. Emit
4080 deferred strings that are used. */
4081
4082static void
4083mark_constants (rtx_insn *insn)
4084{
4085 if (!INSN_P (insn))
4086 return;
4087
4088 /* Insns may appear inside a SEQUENCE. Only check the patterns of
4089 insns, not any notes that may be attached. We don't want to mark
4090 a constant just because it happens to appear in a REG_EQUIV note. */
4091 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (PATTERN (insn)))
4092 {
4093 int i, n = seq->len ();
4094 for (i = 0; i < n; ++i)
4095 {
4096 rtx subinsn = seq->element (i);
4097 if (INSN_P (subinsn))
4098 mark_constants_in_pattern (subinsn);
4099 }
4100 }
4101 else
4102 mark_constants_in_pattern (insn);
4103}
4104
4105/* Look through the instructions for this function, and mark all the
4106 entries in POOL which are actually being used. Emit deferred constants
4107 which have indeed been used. */
4108
4109static void
4110mark_constant_pool (void)
4111{
4112 rtx_insn *insn;
4113
4114 if (!crtl->uses_const_pool && n_deferred_constants == 0)
4115 return;
4116
4117 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4118 mark_constants (insn);
4119}
4120
4121/* Write all the constants in POOL. */
4122
4123static void
4124output_constant_pool_contents (struct rtx_constant_pool *pool)
4125{
4126 struct constant_descriptor_rtx *desc;
4127
4128 for (desc = pool->first; desc ; desc = desc->next)
4129 if (desc->mark)
4130 {
4131 /* If the constant is part of an object_block, make sure that
4132 the constant has been positioned within its block, but do not
4133 write out its definition yet. output_object_blocks will do
4134 that later. */
4135 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
4136 && SYMBOL_REF_BLOCK (desc->sym))
4137 place_block_symbol (desc->sym);
4138 else
4139 {
4140 switch_to_section (targetm.asm_out.select_rtx_section
4141 (desc->mode, desc->constant, desc->align));
4142 output_constant_pool_1 (desc, desc->align);
4143 }
4144 }
4145}
4146
4147/* Mark all constants that are used in the current function, then write
4148 out the function's private constant pool. */
4149
4150static void
4151output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
4152 tree fndecl ATTRIBUTE_UNUSED)
4153{
4154 struct rtx_constant_pool *pool = crtl->varasm.pool;
4155
4156 /* It is possible for gcc to call force_const_mem and then to later
4157 discard the instructions which refer to the constant. In such a
4158 case we do not need to output the constant. */
4159 mark_constant_pool ();
4160
4161 /* Having marked the constant pool entries we'll actually emit, we
4162 now need to rebuild the offset information, which may have become
4163 stale. */
4164 recompute_pool_offsets (pool);
4165
4166#ifdef ASM_OUTPUT_POOL_PROLOGUE
4167 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
4168#endif
4169
4170 output_constant_pool_contents (pool);
4171
4172#ifdef ASM_OUTPUT_POOL_EPILOGUE
4173 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
4174#endif
4175}
4176
4177/* Write the contents of the shared constant pool. */
4178
4179void
4180output_shared_constant_pool (void)
4181{
4182 output_constant_pool_contents (shared_constant_pool);
4183}
4184
4185/* Determine what kind of relocations EXP may need. */
4186
4187int
4188compute_reloc_for_constant (tree exp)
4189{
4190 int reloc = 0, reloc2;
4191 tree tem;
4192
4193 switch (TREE_CODE (exp))
4194 {
4195 case ADDR_EXPR:
4196 case FDESC_EXPR:
4197 /* Go inside any operations that get_inner_reference can handle and see
4198 if what's inside is a constant: no need to do anything here for
4199 addresses of variables or functions. */
4200 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
4201 tem = TREE_OPERAND (tem, 0))
4202 ;
4203
4204 if (TREE_CODE (tem) == MEM_REF
4205 && TREE_CODE (TREE_OPERAND (tem, 0)) == ADDR_EXPR)
4206 {
4207 reloc = compute_reloc_for_constant (TREE_OPERAND (tem, 0));
4208 break;
4209 }
4210
4211 if (!targetm.binds_local_p (tem))
4212 reloc |= 2;
4213 else
4214 reloc |= 1;
4215 break;
4216
4217 case PLUS_EXPR:
4218 case POINTER_PLUS_EXPR:
4219 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
4220 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
4221 break;
4222
4223 case MINUS_EXPR:
4224 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
4225 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
4226 /* The difference of two local labels is computable at link time. */
4227 if (reloc == 1 && reloc2 == 1)
4228 reloc = 0;
4229 else
4230 reloc |= reloc2;
4231 break;
4232
4233 CASE_CONVERT:
4234 case VIEW_CONVERT_EXPR:
4235 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
4236 break;
4237
4238 case CONSTRUCTOR:
4239 {
4240 unsigned HOST_WIDE_INT idx;
4241 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
4242 if (tem != 0)
4243 reloc |= compute_reloc_for_constant (tem);
4244 }
4245 break;
4246
4247 default:
4248 break;
4249 }
4250 return reloc;
4251}
4252
4253/* Find all the constants whose addresses are referenced inside of EXP,
4254 and make sure assembler code with a label has been output for each one.
4255 Indicate whether an ADDR_EXPR has been encountered. */
4256
4257static void
4258output_addressed_constants (tree exp)
4259{
4260 tree tem;
4261
4262 switch (TREE_CODE (exp))
4263 {
4264 case ADDR_EXPR:
4265 case FDESC_EXPR:
4266 /* Go inside any operations that get_inner_reference can handle and see
4267 if what's inside is a constant: no need to do anything here for
4268 addresses of variables or functions. */
4269 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
4270 tem = TREE_OPERAND (tem, 0))
4271 ;
4272
4273 /* If we have an initialized CONST_DECL, retrieve the initializer. */
4274 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
4275 tem = DECL_INITIAL (tem);
4276
4277 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
4278 output_constant_def (tem, 0);
4279
4280 if (TREE_CODE (tem) == MEM_REF)
4281 output_addressed_constants (TREE_OPERAND (tem, 0));
4282 break;
4283
4284 case PLUS_EXPR:
4285 case POINTER_PLUS_EXPR:
4286 case MINUS_EXPR:
4287 output_addressed_constants (TREE_OPERAND (exp, 1));
4288 gcc_fallthrough ();
4289
4290 CASE_CONVERT:
4291 case VIEW_CONVERT_EXPR:
4292 output_addressed_constants (TREE_OPERAND (exp, 0));
4293 break;
4294
4295 case CONSTRUCTOR:
4296 {
4297 unsigned HOST_WIDE_INT idx;
4298 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
4299 if (tem != 0)
4300 output_addressed_constants (tem);
4301 }
4302 break;
4303
4304 default:
4305 break;
4306 }
4307}
4308
4309/* Whether a constructor CTOR is a valid static constant initializer if all
4310 its elements are. This used to be internal to initializer_constant_valid_p
4311 and has been exposed to let other functions like categorize_ctor_elements
4312 evaluate the property while walking a constructor for other purposes. */
4313
4314bool
4315constructor_static_from_elts_p (const_tree ctor)
4316{
4317 return (TREE_CONSTANT (ctor)
4318 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
4319 || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE
4320 || TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE));
4321}
4322
4323static tree initializer_constant_valid_p_1 (tree value, tree endtype,
4324 tree *cache);
4325
4326/* A subroutine of initializer_constant_valid_p. VALUE is a MINUS_EXPR,
4327 PLUS_EXPR or POINTER_PLUS_EXPR. This looks for cases of VALUE
4328 which are valid when ENDTYPE is an integer of any size; in
4329 particular, this does not accept a pointer minus a constant. This
4330 returns null_pointer_node if the VALUE is an absolute constant
4331 which can be used to initialize a static variable. Otherwise it
4332 returns NULL. */
4333
4334static tree
4335narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache)
4336{
4337 tree op0, op1;
4338
4339 if (!INTEGRAL_TYPE_P (endtype))
4340 return NULL_TREE;
4341
4342 op0 = TREE_OPERAND (value, 0);
4343 op1 = TREE_OPERAND (value, 1);
4344
4345 /* Like STRIP_NOPS except allow the operand mode to widen. This
4346 works around a feature of fold that simplifies (int)(p1 - p2) to
4347 ((int)p1 - (int)p2) under the theory that the narrower operation
4348 is cheaper. */
4349
4350 while (CONVERT_EXPR_P (op0)
4351 || TREE_CODE (op0) == NON_LVALUE_EXPR)
4352 {
4353 tree inner = TREE_OPERAND (op0, 0);
4354 if (inner == error_mark_node
4355 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
4356 || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op0)))
4357 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner)))))
4358 break;
4359 op0 = inner;
4360 }
4361
4362 while (CONVERT_EXPR_P (op1)
4363 || TREE_CODE (op1) == NON_LVALUE_EXPR)
4364 {
4365 tree inner = TREE_OPERAND (op1, 0);
4366 if (inner == error_mark_node
4367 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
4368 || (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (op1)))
4369 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (inner)))))
4370 break;
4371 op1 = inner;
4372 }
4373
4374 op0 = initializer_constant_valid_p_1 (op0, endtype, cache);
4375 if (!op0)
4376 return NULL_TREE;
4377
4378 op1 = initializer_constant_valid_p_1 (op1, endtype,
4379 cache ? cache + 2 : NULL);
4380 /* Both initializers must be known. */
4381 if (op1)
4382 {
4383 if (op0 == op1
4384 && (op0 == null_pointer_node
4385 || TREE_CODE (value) == MINUS_EXPR))
4386 return null_pointer_node;
4387
4388 /* Support differences between labels. */
4389 if (TREE_CODE (op0) == LABEL_DECL
4390 && TREE_CODE (op1) == LABEL_DECL)
4391 return null_pointer_node;
4392
4393 if (TREE_CODE (op0) == STRING_CST
4394 && TREE_CODE (op1) == STRING_CST
4395 && operand_equal_p (op0, op1, 1))
4396 return null_pointer_node;
4397 }
4398
4399 return NULL_TREE;
4400}
4401
4402/* Helper function of initializer_constant_valid_p.
4403 Return nonzero if VALUE is a valid constant-valued expression
4404 for use in initializing a static variable; one that can be an
4405 element of a "constant" initializer.
4406
4407 Return null_pointer_node if the value is absolute;
4408 if it is relocatable, return the variable that determines the relocation.
4409 We assume that VALUE has been folded as much as possible;
4410 therefore, we do not need to check for such things as
4411 arithmetic-combinations of integers.
4412
4413 Use CACHE (pointer to 2 tree values) for caching if non-NULL. */
4414
4415static tree
4416initializer_constant_valid_p_1 (tree value, tree endtype, tree *cache)
4417{
4418 tree ret;
4419
4420 switch (TREE_CODE (value))
4421 {
4422 case CONSTRUCTOR:
4423 if (constructor_static_from_elts_p (value))
4424 {
4425 unsigned HOST_WIDE_INT idx;
4426 tree elt;
4427 bool absolute = true;
4428
4429 if (cache && cache[0] == value)
4430 return cache[1];
4431 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
4432 {
4433 tree reloc;
4434 reloc = initializer_constant_valid_p_1 (elt, TREE_TYPE (elt),
4435 NULL);
4436 if (!reloc
4437 /* An absolute value is required with reverse SSO. */
4438 || (reloc != null_pointer_node
4439 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (value))
4440 && !AGGREGATE_TYPE_P (TREE_TYPE (elt))))
4441 {
4442 if (cache)
4443 {
4444 cache[0] = value;
4445 cache[1] = NULL_TREE;
4446 }
4447 return NULL_TREE;
4448 }
4449 if (reloc != null_pointer_node)
4450 absolute = false;
4451 }
4452 /* For a non-absolute relocation, there is no single
4453 variable that can be "the variable that determines the
4454 relocation." */
4455 if (cache)
4456 {
4457 cache[0] = value;
4458 cache[1] = absolute ? null_pointer_node : error_mark_node;
4459 }
4460 return absolute ? null_pointer_node : error_mark_node;
4461 }
4462
4463 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
4464
4465 case INTEGER_CST:
4466 case VECTOR_CST:
4467 case REAL_CST:
4468 case FIXED_CST:
4469 case STRING_CST:
4470 case COMPLEX_CST:
4471 return null_pointer_node;
4472
4473 case ADDR_EXPR:
4474 case FDESC_EXPR:
4475 {
4476 tree op0 = staticp (TREE_OPERAND (value, 0));
4477 if (op0)
4478 {
4479 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out
4480 to be a constant, this is old-skool offsetof-like nonsense. */
4481 if (TREE_CODE (op0) == INDIRECT_REF
4482 && TREE_CONSTANT (TREE_OPERAND (op0, 0)))
4483 return null_pointer_node;
4484 /* Taking the address of a nested function involves a trampoline,
4485 unless we don't need or want one. */
4486 if (TREE_CODE (op0) == FUNCTION_DECL
4487 && DECL_STATIC_CHAIN (op0)
4488 && !TREE_NO_TRAMPOLINE (value))
4489 return NULL_TREE;
4490 /* "&{...}" requires a temporary to hold the constructed
4491 object. */
4492 if (TREE_CODE (op0) == CONSTRUCTOR)
4493 return NULL_TREE;
4494 }
4495 return op0;
4496 }
4497
4498 case NON_LVALUE_EXPR:
4499 return initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
4500 endtype, cache);
4501
4502 case VIEW_CONVERT_EXPR:
4503 {
4504 tree src = TREE_OPERAND (value, 0);
4505 tree src_type = TREE_TYPE (src);
4506 tree dest_type = TREE_TYPE (value);
4507
4508 /* Allow view-conversions from aggregate to non-aggregate type only
4509 if the bit pattern is fully preserved afterwards; otherwise, the
4510 RTL expander won't be able to apply a subsequent transformation
4511 to the underlying constructor. */
4512 if (AGGREGATE_TYPE_P (src_type) && !AGGREGATE_TYPE_P (dest_type))
4513 {
4514 if (TYPE_MODE (endtype) == TYPE_MODE (dest_type))
4515 return initializer_constant_valid_p_1 (src, endtype, cache);
4516 else
4517 return NULL_TREE;
4518 }
4519
4520 /* Allow all other kinds of view-conversion. */
4521 return initializer_constant_valid_p_1 (src, endtype, cache);
4522 }
4523
4524 CASE_CONVERT:
4525 {
4526 tree src = TREE_OPERAND (value, 0);
4527 tree src_type = TREE_TYPE (src);
4528 tree dest_type = TREE_TYPE (value);
4529
4530 /* Allow conversions between pointer types, floating-point
4531 types, and offset types. */
4532 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
4533 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
4534 || (TREE_CODE (dest_type) == OFFSET_TYPE
4535 && TREE_CODE (src_type) == OFFSET_TYPE))
4536 return initializer_constant_valid_p_1 (src, endtype, cache);
4537
4538 /* Allow length-preserving conversions between integer types. */
4539 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
4540 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
4541 return initializer_constant_valid_p_1 (src, endtype, cache);
4542
4543 /* Allow conversions between other integer types only if
4544 explicit value. Don't allow sign-extension to a type larger
4545 than word and pointer, there aren't relocations that would
4546 allow to sign extend it to a wider type. */
4547 if (INTEGRAL_TYPE_P (dest_type)
4548 && INTEGRAL_TYPE_P (src_type)
4549 && (TYPE_UNSIGNED (src_type)
4550 || TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type)
4551 || TYPE_PRECISION (dest_type) <= BITS_PER_WORD
4552 || TYPE_PRECISION (dest_type) <= POINTER_SIZE))
4553 {
4554 tree inner = initializer_constant_valid_p_1 (src, endtype, cache);
4555 if (inner == null_pointer_node)
4556 return null_pointer_node;
4557 break;
4558 }
4559
4560 /* Allow (int) &foo provided int is as wide as a pointer. */
4561 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
4562 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
4563 return initializer_constant_valid_p_1 (src, endtype, cache);
4564
4565 /* Likewise conversions from int to pointers, but also allow
4566 conversions from 0. */
4567 if ((POINTER_TYPE_P (dest_type)
4568 || TREE_CODE (dest_type) == OFFSET_TYPE)
4569 && INTEGRAL_TYPE_P (src_type))
4570 {
4571 if (TREE_CODE (src) == INTEGER_CST
4572 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
4573 return null_pointer_node;
4574 if (integer_zerop (src))
4575 return null_pointer_node;
4576 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
4577 return initializer_constant_valid_p_1 (src, endtype, cache);
4578 }
4579
4580 /* Allow conversions to struct or union types if the value
4581 inside is okay. */
4582 if (TREE_CODE (dest_type) == RECORD_TYPE
4583 || TREE_CODE (dest_type) == UNION_TYPE)
4584 return initializer_constant_valid_p_1 (src, endtype, cache);
4585 }
4586 break;
4587
4588 case POINTER_PLUS_EXPR:
4589 case PLUS_EXPR:
4590 /* Any valid floating-point constants will have been folded by now;
4591 with -frounding-math we hit this with addition of two constants. */
4592 if (TREE_CODE (endtype) == REAL_TYPE)
4593 return NULL_TREE;
4594 if (cache && cache[0] == value)
4595 return cache[1];
4596 if (! INTEGRAL_TYPE_P (endtype)
4597 || TYPE_PRECISION (endtype) >= TYPE_PRECISION (TREE_TYPE (value)))
4598 {
4599 tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE };
4600 tree valid0
4601 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0),
4602 endtype, ncache);
4603 tree valid1
4604 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 1),
4605 endtype, ncache + 2);
4606 /* If either term is absolute, use the other term's relocation. */
4607