1/* Output variables, constants and external declarations, for GNU compiler. 2 Copyright (C) 1987-2015 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 "tm.h" 32#include "rtl.h" 33#include "hash-set.h" 34#include "machmode.h" 35#include "vec.h" 36#include "double-int.h" 37#include "input.h" 38#include "alias.h" 39#include "symtab.h" 40#include "wide-int.h" 41#include "inchash.h" 42#include "tree.h" 43#include "fold-const.h" 44#include "stor-layout.h" 45#include "stringpool.h" 46#include "varasm.h" 47#include "flags.h" 48#include "hard-reg-set.h" 49#include "function.h" 50#include "hashtab.h" 51#include "statistics.h" 52#include "real.h" 53#include "fixed-value.h" 54#include "insn-config.h" 55#include "expmed.h" 56#include "dojump.h" 57#include "explow.h" 58#include "calls.h" 59#include "emit-rtl.h" 60#include "stmt.h" 61#include "expr.h" 62#include "regs.h" 63#include "output.h" 64#include "diagnostic-core.h" 65#include "ggc.h" 66#include "langhooks.h" 67#include "tm_p.h" 68#include "debug.h" 69#include "target.h" 70#include "common/common-target.h" 71#include "targhooks.h" 72#include "predict.h" 73#include "dominance.h" 74#include "cfg.h" 75#include "basic-block.h" 76#include "hash-map.h" 77#include "is-a.h" 78#include "plugin-api.h" 79#include "ipa-ref.h" 80#include "cgraph.h" 81#include "asan.h" 82#include "rtl-iter.h" 83#include "tree-chkp.h" 84 85#ifdef XCOFF_DEBUGGING_INFO 86#include "xcoffout.h" /* Needed for external data 87 declarations for e.g. AIX 4.x. */ 88#endif 89 90/* The (assembler) name of the first globally-visible object output. */ 91extern GTY(()) const char *first_global_object_name; 92extern GTY(()) const char *weak_global_object_name; 93 94const char *first_global_object_name; 95const char *weak_global_object_name; 96 97struct addr_const; 98struct constant_descriptor_rtx; 99struct rtx_constant_pool; 100 101#define n_deferred_constants (crtl->varasm.deferred_constants) 102 103/* Number for making the label on the next 104 constant that is stored in memory. */ 105 106static GTY(()) int const_labelno; 107 108/* Carry information from ASM_DECLARE_OBJECT_NAME 109 to ASM_FINISH_DECLARE_OBJECT. */ 110 111int size_directive_output; 112 113/* The last decl for which assemble_variable was called, 114 if it did ASM_DECLARE_OBJECT_NAME. 115 If the last call to assemble_variable didn't do that, 116 this holds 0. */ 117 118tree last_assemble_variable_decl; 119 120/* The following global variable indicates if the first basic block 121 in a function belongs to the cold partition or not. */ 122 123bool first_function_block_is_cold; 124 125/* Whether we saw any functions with no_split_stack. */ 126 127static bool saw_no_split_stack; 128 129static const char *strip_reg_name (const char *); 130static int contains_pointers_p (tree); 131#ifdef ASM_OUTPUT_EXTERNAL 132static bool incorporeal_function_p (tree); 133#endif 134static void decode_addr_const (tree, struct addr_const *); 135static hashval_t const_hash_1 (const tree); 136static int compare_constant (const tree, const tree); 137static void output_constant_def_contents (rtx); 138static void output_addressed_constants (tree); 139static unsigned HOST_WIDE_INT output_constant (tree, unsigned HOST_WIDE_INT, 140 unsigned int); 141static void globalize_decl (tree); 142static bool decl_readonly_section_1 (enum section_category); 143#ifdef BSS_SECTION_ASM_OP 144#ifdef ASM_OUTPUT_ALIGNED_BSS 145static void asm_output_aligned_bss (FILE *, tree, const char *, 146 unsigned HOST_WIDE_INT, int) 147 ATTRIBUTE_UNUSED; 148#endif 149#endif /* BSS_SECTION_ASM_OP */ 150static void mark_weak (tree); 151static void output_constant_pool (const char *, tree); 152 153/* Well-known sections, each one associated with some sort of *_ASM_OP. */ 154section *text_section; 155section *data_section; 156section *readonly_data_section; 157section *sdata_section; 158section *ctors_section; 159section *dtors_section; 160section *bss_section; 161section *sbss_section; 162 163/* Various forms of common section. All are guaranteed to be nonnull. */ 164section *tls_comm_section; 165section *comm_section; 166section *lcomm_section; 167 168/* A SECTION_NOSWITCH section used for declaring global BSS variables. 169 May be null. */ 170section *bss_noswitch_section; 171 172/* The section that holds the main exception table, when known. The section 173 is set either by the target's init_sections hook or by the first call to 174 switch_to_exception_section. */ 175section *exception_section; 176 177/* The section that holds the DWARF2 frame unwind information, when known. 178 The section is set either by the target's init_sections hook or by the 179 first call to switch_to_eh_frame_section. */ 180section *eh_frame_section; 181 182/* asm_out_file's current section. This is NULL if no section has yet 183 been selected or if we lose track of what the current section is. */ 184section *in_section; 185 186/* True if code for the current function is currently being directed 187 at the cold section. */ 188bool in_cold_section_p; 189 190/* A linked list of all the unnamed sections. */ 191static GTY(()) section *unnamed_sections; 192 193/* Return a nonzero value if DECL has a section attribute. */ 194#define IN_NAMED_SECTION(DECL) \ 195 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \ 196 && DECL_SECTION_NAME (DECL) != NULL) 197 198struct section_hasher : ggc_hasher<section *> 199{ 200 typedef const char *compare_type; 201 202 static hashval_t hash (section *); 203 static bool equal (section *, const char *); 204}; 205 206/* Hash table of named sections. */ 207static GTY(()) hash_table<section_hasher> *section_htab; 208 209struct object_block_hasher : ggc_hasher<object_block *> 210{ 211 typedef const section *compare_type; 212 213 static hashval_t hash (object_block *); 214 static bool equal (object_block *, const section *); 215}; 216 217/* A table of object_blocks, indexed by section. */ 218static GTY(()) hash_table<object_block_hasher> *object_block_htab; 219 220/* The next number to use for internal anchor labels. */ 221static GTY(()) int anchor_labelno; 222 223/* A pool of constants that can be shared between functions. */ 224static GTY(()) struct rtx_constant_pool *shared_constant_pool; 225 226/* Helper routines for maintaining section_htab. */ 227 228bool 229section_hasher::equal (section *old, const char *new_name) 230{ 231 return strcmp (old->named.name, new_name) == 0; 232} 233 234hashval_t 235section_hasher::hash (section *old) 236{ 237 return htab_hash_string (old->named.name); 238} 239 240/* Return a hash value for section SECT. */ 241 242static hashval_t 243hash_section (section *sect) 244{ 245 if (sect->common.flags & SECTION_NAMED) 246 return htab_hash_string (sect->named.name); 247 return sect->common.flags; 248} 249 250/* Helper routines for maintaining object_block_htab. */ 251 252inline bool 253object_block_hasher::equal (object_block *old, const section *new_section) 254{ 255 return old->sect == new_section; 256} 257 258hashval_t 259object_block_hasher::hash (object_block *old) 260{ 261 return hash_section (old->sect); 262} 263 264/* Return a new unnamed section with the given fields. */ 265 266section * 267get_unnamed_section (unsigned int flags, void (*callback) (const void *), 268 const void *data) 269{ 270 section *sect; 271 272 sect = ggc_alloc<section> (); 273 sect->unnamed.common.flags = flags | SECTION_UNNAMED; 274 sect->unnamed.callback = callback; 275 sect->unnamed.data = data; 276 sect->unnamed.next = unnamed_sections; 277 278 unnamed_sections = sect; 279 return sect; 280} 281 282/* Return a SECTION_NOSWITCH section with the given fields. */ 283 284static section * 285get_noswitch_section (unsigned int flags, noswitch_section_callback callback) 286{ 287 section *sect; 288 289 sect = ggc_alloc<section> (); 290 sect->noswitch.common.flags = flags | SECTION_NOSWITCH; 291 sect->noswitch.callback = callback; 292 293 return sect; 294} 295 296/* Return the named section structure associated with NAME. Create 297 a new section with the given fields if no such structure exists. */ 298 299section * 300get_section (const char *name, unsigned int flags, tree decl) 301{ 302 section *sect, **slot; 303 304 slot = section_htab->find_slot_with_hash (name, htab_hash_string (name), 305 INSERT); 306 flags |= SECTION_NAMED; 307 if (*slot == NULL) 308 { 309 sect = ggc_alloc<section> (); 310 sect->named.common.flags = flags; 311 sect->named.name = ggc_strdup (name); 312 sect->named.decl = decl; 313 *slot = sect; 314 } 315 else 316 { 317 sect = *slot; 318 if ((sect->common.flags & ~SECTION_DECLARED) != flags 319 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0) 320 { 321 /* It is fine if one of the section flags is 322 SECTION_WRITE | SECTION_RELRO and the other has none of these 323 flags (i.e. read-only) in named sections and either the 324 section hasn't been declared yet or has been declared as writable. 325 In that case just make sure the resulting flags are 326 SECTION_WRITE | SECTION_RELRO, ie. writable only because of 327 relocations. */ 328 if (((sect->common.flags ^ flags) & (SECTION_WRITE | SECTION_RELRO)) 329 == (SECTION_WRITE | SECTION_RELRO) 330 && (sect->common.flags 331 & ~(SECTION_DECLARED | SECTION_WRITE | SECTION_RELRO)) 332 == (flags & ~(SECTION_WRITE | SECTION_RELRO)) 333 && ((sect->common.flags & SECTION_DECLARED) == 0 334 || (sect->common.flags & SECTION_WRITE))) 335 { 336 sect->common.flags |= (SECTION_WRITE | SECTION_RELRO); 337 return sect; 338 } 339 /* Sanity check user variables for flag changes. */ 340 if (sect->named.decl != NULL 341 && DECL_P (sect->named.decl) 342 && decl != sect->named.decl) 343 { 344 if (decl != NULL && DECL_P (decl)) 345 error ("%+D causes a section type conflict with %D", 346 decl, sect->named.decl); 347 else 348 error ("section type conflict with %D", sect->named.decl); 349 inform (DECL_SOURCE_LOCATION (sect->named.decl), 350 "%qD was declared here", sect->named.decl); 351 } 352 else if (decl != NULL && DECL_P (decl)) 353 error ("%+D causes a section type conflict", decl); 354 else 355 error ("section type conflict"); 356 /* Make sure we don't error about one section multiple times. */ 357 sect->common.flags |= SECTION_OVERRIDE; 358 } 359 } 360 return sect; 361} 362 363/* Return true if the current compilation mode benefits from having 364 objects grouped into blocks. */ 365 366static bool 367use_object_blocks_p (void) 368{ 369 return flag_section_anchors; 370} 371 372/* Return the object_block structure for section SECT. Create a new 373 structure if we haven't created one already. Return null if SECT 374 itself is null. */ 375 376static struct object_block * 377get_block_for_section (section *sect) 378{ 379 struct object_block *block; 380 381 if (sect == NULL) 382 return NULL; 383 384 object_block **slot 385 = object_block_htab->find_slot_with_hash (sect, hash_section (sect), 386 INSERT); 387 block = *slot; 388 if (block == NULL) 389 { 390 block = ggc_cleared_alloc<object_block> (); 391 block->sect = sect; 392 *slot = block; 393 } 394 return block; 395} 396 397/* Create a symbol with label LABEL and place it at byte offset 398 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset 399 is not yet known. LABEL must be a garbage-collected string. */ 400 401static rtx 402create_block_symbol (const char *label, struct object_block *block, 403 HOST_WIDE_INT offset) 404{ 405 rtx symbol; 406 unsigned int size; 407 408 /* Create the extended SYMBOL_REF. */ 409 size = RTX_HDR_SIZE + sizeof (struct block_symbol); 410 symbol = (rtx) ggc_internal_alloc (size); 411 412 /* Initialize the normal SYMBOL_REF fields. */ 413 memset (symbol, 0, size); 414 PUT_CODE (symbol, SYMBOL_REF); 415 PUT_MODE (symbol, Pmode); 416 XSTR (symbol, 0) = label; 417 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO; 418 419 /* Initialize the block_symbol stuff. */ 420 SYMBOL_REF_BLOCK (symbol) = block; 421 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset; 422 423 return symbol; 424} 425 426/* Return a section with a particular name and with whatever SECTION_* 427 flags section_type_flags deems appropriate. The name of the section 428 is taken from NAME if nonnull, otherwise it is taken from DECL's 429 DECL_SECTION_NAME. DECL is the decl associated with the section 430 (see the section comment for details) and RELOC is as for 431 section_type_flags. */ 432 433section * 434get_named_section (tree decl, const char *name, int reloc) 435{ 436 unsigned int flags; 437 438 if (name == NULL) 439 { 440 gcc_assert (decl && DECL_P (decl) && DECL_SECTION_NAME (decl)); 441 name = DECL_SECTION_NAME (decl); 442 } 443 444 flags = targetm.section_type_flags (decl, name, reloc); 445 return get_section (name, flags, decl); 446} 447 448/* Worker for resolve_unique_section. */ 449 450static bool 451set_implicit_section (struct symtab_node *n, void *data ATTRIBUTE_UNUSED) 452{ 453 n->implicit_section = true; 454 return false; 455} 456 457/* If required, set DECL_SECTION_NAME to a unique name. */ 458 459void 460resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED, 461 int flag_function_or_data_sections) 462{ 463 if (DECL_SECTION_NAME (decl) == NULL 464 && targetm_common.have_named_sections 465 && (flag_function_or_data_sections 466 || DECL_COMDAT_GROUP (decl))) 467 { 468 targetm.asm_out.unique_section (decl, reloc); 469 if (DECL_SECTION_NAME (decl)) 470 symtab_node::get (decl)->call_for_symbol_and_aliases 471 (set_implicit_section, NULL, true); 472 } 473} 474 475#ifdef BSS_SECTION_ASM_OP 476 477#ifdef ASM_OUTPUT_ALIGNED_BSS 478 479/* Utility function for targets to use in implementing 480 ASM_OUTPUT_ALIGNED_BSS. 481 ??? It is believed that this function will work in most cases so such 482 support is localized here. */ 483 484static void 485asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED, 486 const char *name, unsigned HOST_WIDE_INT size, 487 int align) 488{ 489 switch_to_section (bss_section); 490 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); 491#ifdef ASM_DECLARE_OBJECT_NAME 492 last_assemble_variable_decl = decl; 493 ASM_DECLARE_OBJECT_NAME (file, name, decl); 494#else 495 /* Standard thing is just output label for the object. */ 496 ASM_OUTPUT_LABEL (file, name); 497#endif /* ASM_DECLARE_OBJECT_NAME */ 498 ASM_OUTPUT_SKIP (file, size ? size : 1); 499} 500 501#endif 502 503#endif /* BSS_SECTION_ASM_OP */ 504 505#ifndef USE_SELECT_SECTION_FOR_FUNCTIONS 506/* Return the hot section for function DECL. Return text_section for 507 null DECLs. */ 508 509static section * 510hot_function_section (tree decl) 511{ 512 if (decl != NULL_TREE 513 && DECL_SECTION_NAME (decl) != NULL 514 && targetm_common.have_named_sections) 515 return get_named_section (decl, NULL, 0); 516 else 517 return text_section; 518} 519#endif 520 521/* Return section for TEXT_SECTION_NAME if DECL or DECL_SECTION_NAME (DECL) 522 is NULL. 523 524 When DECL_SECTION_NAME is non-NULL and it is implicit section and 525 NAMED_SECTION_SUFFIX is non-NULL, then produce section called 526 concatenate the name with NAMED_SECTION_SUFFIX. 527 Otherwise produce "TEXT_SECTION_NAME.IMPLICIT_NAME". */ 528 529section * 530get_named_text_section (tree decl, 531 const char *text_section_name, 532 const char *named_section_suffix) 533{ 534 if (decl && DECL_SECTION_NAME (decl)) 535 { 536 if (named_section_suffix) 537 { 538 const char *dsn = DECL_SECTION_NAME (decl); 539 const char *stripped_name; 540 char *name, *buffer; 541 542 name = (char *) alloca (strlen (dsn) + 1); 543 memcpy (name, dsn, 544 strlen (dsn) + 1); 545 546 stripped_name = targetm.strip_name_encoding (name); 547 548 buffer = ACONCAT ((stripped_name, named_section_suffix, NULL)); 549 return get_named_section (decl, buffer, 0); 550 } 551 else if (symtab_node::get (decl)->implicit_section) 552 { 553 const char *name; 554 555 /* Do not try to split gnu_linkonce functions. This gets somewhat 556 slipperly. */ 557 if (DECL_COMDAT_GROUP (decl) && !HAVE_COMDAT_GROUP) 558 return NULL; 559 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 560 name = targetm.strip_name_encoding (name); 561 return get_named_section (decl, ACONCAT ((text_section_name, ".", 562 name, NULL)), 0); 563 } 564 else 565 return NULL; 566 } 567 return get_named_section (decl, text_section_name, 0); 568} 569 570/* Choose named function section based on its frequency. */ 571 572section * 573default_function_section (tree decl, enum node_frequency freq, 574 bool startup, bool exit) 575{ 576#if defined HAVE_LD_EH_GC_SECTIONS && defined HAVE_LD_EH_GC_SECTIONS_BUG 577 /* Old GNU linkers have buggy --gc-section support, which sometimes 578 results in .gcc_except_table* sections being garbage collected. */ 579 if (decl 580 && symtab_node::get (decl)->implicit_section) 581 return NULL; 582#endif 583 584 if (!flag_reorder_functions 585 || !targetm_common.have_named_sections) 586 return NULL; 587 /* Startup code should go to startup subsection unless it is 588 unlikely executed (this happens especially with function splitting 589 where we can split away unnecessary parts of static constructors. */ 590 if (startup && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED) 591 { 592 /* If we do have a profile or(and) LTO phase is executed, we do not need 593 these ELF section. */ 594 if (!in_lto_p || !flag_profile_values) 595 return get_named_text_section (decl, ".text.startup", NULL); 596 else 597 return NULL; 598 } 599 600 /* Similarly for exit. */ 601 if (exit && freq != NODE_FREQUENCY_UNLIKELY_EXECUTED) 602 return get_named_text_section (decl, ".text.exit", NULL); 603 604 /* Group cold functions together, similarly for hot code. */ 605 switch (freq) 606 { 607 case NODE_FREQUENCY_UNLIKELY_EXECUTED: 608 return get_named_text_section (decl, ".text.unlikely", NULL); 609 case NODE_FREQUENCY_HOT: 610 /* If we do have a profile or(and) LTO phase is executed, we do not need 611 these ELF section. */ 612 if (!in_lto_p || !flag_profile_values) 613 return get_named_text_section (decl, ".text.hot", NULL); 614 default: 615 return NULL; 616 } 617} 618 619/* Return the section for function DECL. 620 621 If DECL is NULL_TREE, return the text section. We can be passed 622 NULL_TREE under some circumstances by dbxout.c at least. 623 624 If FORCE_COLD is true, return cold function section ignoring 625 the frequency info of cgraph_node. */ 626 627static section * 628function_section_1 (tree decl, bool force_cold) 629{ 630 section *section = NULL; 631 enum node_frequency freq = NODE_FREQUENCY_NORMAL; 632 bool startup = false, exit = false; 633 634 if (decl) 635 { 636 struct cgraph_node *node = cgraph_node::get (decl); 637 638 if (node) 639 { 640 freq = node->frequency; 641 startup = node->only_called_at_startup; 642 exit = node->only_called_at_exit; 643 } 644 } 645 if (force_cold) 646 freq = NODE_FREQUENCY_UNLIKELY_EXECUTED; 647 648#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS 649 if (decl != NULL_TREE 650 && DECL_SECTION_NAME (decl) != NULL) 651 { 652 if (targetm.asm_out.function_section) 653 section = targetm.asm_out.function_section (decl, freq, 654 startup, exit); 655 if (section) 656 return section; 657 return get_named_section (decl, NULL, 0); 658 } 659 else 660 return targetm.asm_out.select_section 661 (decl, freq == NODE_FREQUENCY_UNLIKELY_EXECUTED, 662 symtab_node::get (decl)->definition_alignment ()); 663#else 664 if (targetm.asm_out.function_section) 665 section = targetm.asm_out.function_section (decl, freq, startup, exit); 666 if (section) 667 return section; 668 return hot_function_section (decl); 669#endif 670} 671 672/* Return the section for function DECL. 673 674 If DECL is NULL_TREE, return the text section. We can be passed 675 NULL_TREE under some circumstances by dbxout.c at least. */ 676 677section * 678function_section (tree decl) 679{ 680 /* Handle cases where function splitting code decides 681 to put function entry point into unlikely executed section 682 despite the fact that the function itself is not cold 683 (i.e. it is called rarely but contains a hot loop that is 684 better to live in hot subsection for the code locality). */ 685 return function_section_1 (decl, 686 first_function_block_is_cold); 687} 688 689/* Return the section for the current function, take IN_COLD_SECTION_P 690 into account. */ 691 692section * 693current_function_section (void) 694{ 695 return function_section_1 (current_function_decl, in_cold_section_p); 696} 697 698/* Tell assembler to switch to unlikely-to-be-executed text section. */ 699 700section * 701unlikely_text_section (void) 702{ 703 return function_section_1 (current_function_decl, true); 704} 705 706/* When called within a function context, return true if the function 707 has been assigned a cold text section and if SECT is that section. 708 When called outside a function context, return true if SECT is the 709 default cold section. */ 710 711bool 712unlikely_text_section_p (section *sect) 713{ 714 return sect == function_section_1 (current_function_decl, true); 715} 716 717/* Return the read-only data section associated with function DECL. */ 718 719section * 720default_function_rodata_section (tree decl) 721{ 722 if (decl != NULL_TREE && DECL_SECTION_NAME (decl)) 723 { 724 const char *name = DECL_SECTION_NAME (decl); 725 726 if (DECL_COMDAT_GROUP (decl) && HAVE_COMDAT_GROUP) 727 { 728 const char *dot; 729 size_t len; 730 char* rname; 731 732 dot = strchr (name + 1, '.'); 733 if (!dot) 734 dot = name; 735 len = strlen (dot) + 8; 736 rname = (char *) alloca (len); 737 738 strcpy (rname, ".rodata"); 739 strcat (rname, dot); 740 return get_section (rname, SECTION_LINKONCE, decl); 741 } 742 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */ 743 else if (DECL_COMDAT_GROUP (decl) 744 && strncmp (name, ".gnu.linkonce.t.", 16) == 0) 745 { 746 size_t len = strlen (name) + 1; 747 char *rname = (char *) alloca (len); 748 749 memcpy (rname, name, len); 750 rname[14] = 'r'; 751 return get_section (rname, SECTION_LINKONCE, decl); 752 } 753 /* For .text.foo we want to use .rodata.foo. */ 754 else if (flag_function_sections && flag_data_sections 755 && strncmp (name, ".text.", 6) == 0) 756 { 757 size_t len = strlen (name) + 1; 758 char *rname = (char *) alloca (len + 2); 759 760 memcpy (rname, ".rodata", 7); 761 memcpy (rname + 7, name + 5, len - 5); 762 return get_section (rname, 0, decl); 763 } 764 } 765 766 return readonly_data_section; 767} 768 769/* Return the read-only data section associated with function DECL 770 for targets where that section should be always the single 771 readonly data section. */ 772 773section * 774default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED) 775{ 776 return readonly_data_section; 777} 778 779/* Return the section to use for string merging. */ 780 781static section * 782mergeable_string_section (tree decl ATTRIBUTE_UNUSED, 783 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED, 784 unsigned int flags ATTRIBUTE_UNUSED) 785{ 786 HOST_WIDE_INT len; 787 788 if (HAVE_GAS_SHF_MERGE && flag_merge_constants 789 && TREE_CODE (decl) == STRING_CST 790 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 791 && align <= 256 792 && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0 793 && TREE_STRING_LENGTH (decl) >= len) 794 { 795 machine_mode mode; 796 unsigned int modesize; 797 const char *str; 798 HOST_WIDE_INT i; 799 int j, unit; 800 const char *prefix = targetm.asm_out.mergeable_rodata_prefix; 801 char *name = (char *) alloca (strlen (prefix) + 30); 802 803 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl))); 804 modesize = GET_MODE_BITSIZE (mode); 805 if (modesize >= 8 && modesize <= 256 806 && (modesize & (modesize - 1)) == 0) 807 { 808 if (align < modesize) 809 align = modesize; 810 811 str = TREE_STRING_POINTER (decl); 812 unit = GET_MODE_SIZE (mode); 813 814 /* Check for embedded NUL characters. */ 815 for (i = 0; i < len; i += unit) 816 { 817 for (j = 0; j < unit; j++) 818 if (str[i + j] != '\0') 819 break; 820 if (j == unit) 821 break; 822 } 823 if (i == len - unit) 824 { 825 sprintf (name, "%s.str%d.%d", prefix, 826 modesize / 8, (int) (align / 8)); 827 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS; 828 return get_section (name, flags, NULL); 829 } 830 } 831 } 832 833 return readonly_data_section; 834} 835 836/* Return the section to use for constant merging. */ 837 838section * 839mergeable_constant_section (machine_mode mode ATTRIBUTE_UNUSED, 840 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED, 841 unsigned int flags ATTRIBUTE_UNUSED) 842{ 843 unsigned int modesize = GET_MODE_BITSIZE (mode); 844 845 if (HAVE_GAS_SHF_MERGE && flag_merge_constants 846 && mode != VOIDmode 847 && mode != BLKmode 848 && modesize <= align 849 && align >= 8 850 && align <= 256 851 && (align & (align - 1)) == 0) 852 { 853 const char *prefix = targetm.asm_out.mergeable_rodata_prefix; 854 char *name = (char *) alloca (strlen (prefix) + 30); 855 856 sprintf (name, "%s.cst%d", prefix, (int) (align / 8)); 857 flags |= (align / 8) | SECTION_MERGE; 858 return get_section (name, flags, NULL); 859 } 860 return readonly_data_section; 861} 862 863/* Given NAME, a putative register name, discard any customary prefixes. */ 864 865static const char * 866strip_reg_name (const char *name) 867{ 868#ifdef REGISTER_PREFIX 869 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX))) 870 name += strlen (REGISTER_PREFIX); 871#endif 872 if (name[0] == '%' || name[0] == '#') 873 name++; 874 return name; 875} 876 877/* The user has asked for a DECL to have a particular name. Set (or 878 change) it in such a way that we don't prefix an underscore to 879 it. */ 880void 881set_user_assembler_name (tree decl, const char *name) 882{ 883 char *starred = (char *) alloca (strlen (name) + 2); 884 starred[0] = '*'; 885 strcpy (starred + 1, name); 886 symtab->change_decl_assembler_name (decl, get_identifier (starred)); 887 SET_DECL_RTL (decl, NULL_RTX); 888} 889 890/* Decode an `asm' spec for a declaration as a register name. 891 Return the register number, or -1 if nothing specified, 892 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized, 893 or -3 if ASMSPEC is `cc' and is not recognized, 894 or -4 if ASMSPEC is `memory' and is not recognized. 895 Accept an exact spelling or a decimal number. 896 Prefixes such as % are optional. */ 897 898int 899decode_reg_name_and_count (const char *asmspec, int *pnregs) 900{ 901 /* Presume just one register is clobbered. */ 902 *pnregs = 1; 903 904 if (asmspec != 0) 905 { 906 int i; 907 908 /* Get rid of confusing prefixes. */ 909 asmspec = strip_reg_name (asmspec); 910 911 /* Allow a decimal number as a "register name". */ 912 for (i = strlen (asmspec) - 1; i >= 0; i--) 913 if (! ISDIGIT (asmspec[i])) 914 break; 915 if (asmspec[0] != 0 && i < 0) 916 { 917 i = atoi (asmspec); 918 if (i < FIRST_PSEUDO_REGISTER && i >= 0 && reg_names[i][0]) 919 return i; 920 else 921 return -2; 922 } 923 924 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 925 if (reg_names[i][0] 926 && ! strcmp (asmspec, strip_reg_name (reg_names[i]))) 927 return i; 928 929#ifdef OVERLAPPING_REGISTER_NAMES 930 { 931 static const struct 932 { 933 const char *const name; 934 const int number; 935 const int nregs; 936 } table[] = OVERLAPPING_REGISTER_NAMES; 937 938 for (i = 0; i < (int) ARRAY_SIZE (table); i++) 939 if (table[i].name[0] 940 && ! strcmp (asmspec, table[i].name)) 941 { 942 *pnregs = table[i].nregs; 943 return table[i].number; 944 } 945 } 946#endif /* OVERLAPPING_REGISTER_NAMES */ 947 948#ifdef ADDITIONAL_REGISTER_NAMES 949 { 950 static const struct { const char *const name; const int number; } table[] 951 = ADDITIONAL_REGISTER_NAMES; 952 953 for (i = 0; i < (int) ARRAY_SIZE (table); i++) 954 if (table[i].name[0] 955 && ! strcmp (asmspec, table[i].name) 956 && reg_names[table[i].number][0]) 957 return table[i].number; 958 } 959#endif /* ADDITIONAL_REGISTER_NAMES */ 960 961 if (!strcmp (asmspec, "memory")) 962 return -4; 963 964 if (!strcmp (asmspec, "cc")) 965 return -3; 966 967 return -2; 968 } 969 970 return -1; 971} 972 973int 974decode_reg_name (const char *name) 975{ 976 int count; 977 return decode_reg_name_and_count (name, &count); 978} 979 980 981/* Return true if DECL's initializer is suitable for a BSS section. */ 982 983bool 984bss_initializer_p (const_tree decl) 985{ 986 return (DECL_INITIAL (decl) == NULL 987 /* In LTO we have no errors in program; error_mark_node is used 988 to mark offlined constructors. */ 989 || (DECL_INITIAL (decl) == error_mark_node 990 && !in_lto_p) 991 || (flag_zero_initialized_in_bss 992 /* Leave constant zeroes in .rodata so they 993 can be shared. */ 994 && !TREE_READONLY (decl) 995 && initializer_zerop (DECL_INITIAL (decl)))); 996} 997 998/* Compute the alignment of variable specified by DECL. 999 DONT_OUTPUT_DATA is from assemble_variable. */ 1000 1001void 1002align_variable (tree decl, bool dont_output_data) 1003{ 1004 unsigned int align = DECL_ALIGN (decl); 1005 1006 /* In the case for initialing an array whose length isn't specified, 1007 where we have not yet been able to do the layout, 1008 figure out the proper alignment now. */ 1009 if (dont_output_data && DECL_SIZE (decl) == 0 1010 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 1011 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl)))); 1012 1013 /* Some object file formats have a maximum alignment which they support. 1014 In particular, a.out format supports a maximum alignment of 4. */ 1015 if (align > MAX_OFILE_ALIGNMENT) 1016 { 1017 error ("alignment of %q+D is greater than maximum object " 1018 "file alignment %d", decl, 1019 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT); 1020 align = MAX_OFILE_ALIGNMENT; 1021 } 1022 1023 if (! DECL_USER_ALIGN (decl)) 1024 { 1025#ifdef DATA_ABI_ALIGNMENT 1026 unsigned int data_abi_align 1027 = DATA_ABI_ALIGNMENT (TREE_TYPE (decl), align); 1028 /* For backwards compatibility, don't assume the ABI alignment for 1029 TLS variables. */ 1030 if (! DECL_THREAD_LOCAL_P (decl) || data_abi_align <= BITS_PER_WORD) 1031 align = data_abi_align; 1032#endif 1033 1034 /* On some machines, it is good to increase alignment sometimes. 1035 But as DECL_ALIGN is used both for actually emitting the variable 1036 and for code accessing the variable as guaranteed alignment, we 1037 can only increase the alignment if it is a performance optimization 1038 if the references to it must bind to the current definition. */ 1039 if (decl_binds_to_current_def_p (decl) 1040 && !DECL_VIRTUAL_P (decl)) 1041 { 1042#ifdef DATA_ALIGNMENT 1043 unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align); 1044 /* Don't increase alignment too much for TLS variables - TLS space 1045 is too precious. */ 1046 if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD) 1047 align = data_align; 1048#endif 1049#ifdef CONSTANT_ALIGNMENT 1050 if (DECL_INITIAL (decl) != 0 1051 /* In LTO we have no errors in program; error_mark_node is used 1052 to mark offlined constructors. */ 1053 && (in_lto_p || DECL_INITIAL (decl) != error_mark_node)) 1054 { 1055 unsigned int const_align 1056 = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align); 1057 /* Don't increase alignment too much for TLS variables - TLS 1058 space is too precious. */ 1059 if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD) 1060 align = const_align; 1061 } 1062#endif 1063 } 1064 } 1065 1066 /* Reset the alignment in case we have made it tighter, so we can benefit 1067 from it in get_pointer_alignment. */ 1068 DECL_ALIGN (decl) = align; 1069} 1070 1071/* Return DECL_ALIGN (decl), possibly increased for optimization purposes 1072 beyond what align_variable returned. */ 1073 1074static unsigned int 1075get_variable_align (tree decl) 1076{ 1077 unsigned int align = DECL_ALIGN (decl); 1078 1079 /* For user aligned vars or static vars align_variable already did 1080 everything. */ 1081 if (DECL_USER_ALIGN (decl) || !TREE_PUBLIC (decl)) 1082 return align; 1083 1084#ifdef DATA_ABI_ALIGNMENT 1085 if (DECL_THREAD_LOCAL_P (decl)) 1086 align = DATA_ABI_ALIGNMENT (TREE_TYPE (decl), align); 1087#endif 1088 1089 /* For decls that bind to the current definition, align_variable 1090 did also everything, except for not assuming ABI required alignment 1091 of TLS variables. For other vars, increase the alignment here 1092 as an optimization. */ 1093 if (!decl_binds_to_current_def_p (decl)) 1094 { 1095 /* On some machines, it is good to increase alignment sometimes. */ 1096#ifdef DATA_ALIGNMENT 1097 unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align); 1098 /* Don't increase alignment too much for TLS variables - TLS space 1099 is too precious. */ 1100 if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD) 1101 align = data_align; 1102#endif 1103#ifdef CONSTANT_ALIGNMENT 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 = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), 1110 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#endif 1117 } 1118 1119 return align; 1120} 1121 1122/* Return the section into which the given VAR_DECL or CONST_DECL 1123 should be placed. PREFER_NOSWITCH_P is true if a noswitch 1124 section should be used wherever possible. */ 1125 1126section * 1127get_variable_section (tree decl, bool prefer_noswitch_p) 1128{ 1129 addr_space_t as = ADDR_SPACE_GENERIC; 1130 int reloc; 1131 varpool_node *vnode = varpool_node::get (decl); 1132 if (vnode) 1133 { 1134 vnode = vnode->ultimate_alias_target (); 1135 decl = vnode->decl; 1136 } 1137 1138 if (TREE_TYPE (decl) != error_mark_node) 1139 as = TYPE_ADDR_SPACE (TREE_TYPE (decl)); 1140 1141 /* We need the constructor to figure out reloc flag. */ 1142 if (vnode) 1143 vnode->get_constructor (); 1144 1145 if (DECL_COMMON (decl)) 1146 { 1147 /* If the decl has been given an explicit section name, or it resides 1148 in a non-generic address space, then it isn't common, and shouldn't 1149 be handled as such. */ 1150 gcc_assert (DECL_SECTION_NAME (decl) == NULL 1151 && ADDR_SPACE_GENERIC_P (as)); 1152 if (DECL_THREAD_LOCAL_P (decl)) 1153 return tls_comm_section; 1154 else if (TREE_PUBLIC (decl) && bss_initializer_p (decl)) 1155 return comm_section; 1156 } 1157 1158 if (DECL_INITIAL (decl) == error_mark_node) 1159 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0; 1160 else if (DECL_INITIAL (decl)) 1161 reloc = compute_reloc_for_constant (DECL_INITIAL (decl)); 1162 else 1163 reloc = 0; 1164 1165 resolve_unique_section (decl, reloc, flag_data_sections); 1166 if (IN_NAMED_SECTION (decl)) 1167 return get_named_section (decl, NULL, reloc); 1168 1169 if (ADDR_SPACE_GENERIC_P (as) 1170 && !DECL_THREAD_LOCAL_P (decl) 1171 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections) 1172 && bss_initializer_p (decl)) 1173 { 1174 if (!TREE_PUBLIC (decl) 1175 && !((flag_sanitize & SANITIZE_ADDRESS) 1176 && asan_protect_global (decl))) 1177 return lcomm_section; 1178 if (bss_noswitch_section) 1179 return bss_noswitch_section; 1180 } 1181 1182 return targetm.asm_out.select_section (decl, reloc, 1183 get_variable_align (decl)); 1184} 1185 1186/* Return the block into which object_block DECL should be placed. */ 1187 1188static struct object_block * 1189get_block_for_decl (tree decl) 1190{ 1191 section *sect; 1192 1193 if (TREE_CODE (decl) == VAR_DECL) 1194 { 1195 /* The object must be defined in this translation unit. */ 1196 if (DECL_EXTERNAL (decl)) 1197 return NULL; 1198 1199 /* There's no point using object blocks for something that is 1200 isolated by definition. */ 1201 if (DECL_COMDAT_GROUP (decl)) 1202 return NULL; 1203 } 1204 1205 /* We can only calculate block offsets if the decl has a known 1206 constant size. */ 1207 if (DECL_SIZE_UNIT (decl) == NULL) 1208 return NULL; 1209 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (decl))) 1210 return NULL; 1211 1212 /* Find out which section should contain DECL. We cannot put it into 1213 an object block if it requires a standalone definition. */ 1214 if (TREE_CODE (decl) == VAR_DECL) 1215 align_variable (decl, 0); 1216 sect = get_variable_section (decl, true); 1217 if (SECTION_STYLE (sect) == SECTION_NOSWITCH) 1218 return NULL; 1219 1220 return get_block_for_section (sect); 1221} 1222 1223/* Make sure block symbol SYMBOL is in block BLOCK. */ 1224 1225static void 1226change_symbol_block (rtx symbol, struct object_block *block) 1227{ 1228 if (block != SYMBOL_REF_BLOCK (symbol)) 1229 { 1230 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0); 1231 SYMBOL_REF_BLOCK (symbol) = block; 1232 } 1233} 1234 1235/* Return true if it is possible to put DECL in an object_block. */ 1236 1237static bool 1238use_blocks_for_decl_p (tree decl) 1239{ 1240 struct symtab_node *snode; 1241 1242 /* Only data DECLs can be placed into object blocks. */ 1243 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL) 1244 return false; 1245 1246 /* Detect decls created by dw2_force_const_mem. Such decls are 1247 special because DECL_INITIAL doesn't specify the decl's true value. 1248 dw2_output_indirect_constants will instead call assemble_variable 1249 with dont_output_data set to 1 and then print the contents itself. */ 1250 if (DECL_INITIAL (decl) == decl) 1251 return false; 1252 1253 /* If this decl is an alias, then we don't want to emit a 1254 definition. */ 1255 if (TREE_CODE (decl) == VAR_DECL 1256 && (snode = symtab_node::get (decl)) != NULL 1257 && snode->alias) 1258 return false; 1259 1260 return targetm.use_blocks_for_decl_p (decl); 1261} 1262 1263/* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS 1264 until we find an identifier that is not itself a transparent alias. 1265 Modify the alias passed to it by reference (and all aliases on the 1266 way to the ultimate target), such that they do not have to be 1267 followed again, and return the ultimate target of the alias 1268 chain. */ 1269 1270static inline tree 1271ultimate_transparent_alias_target (tree *alias) 1272{ 1273 tree target = *alias; 1274 1275 if (IDENTIFIER_TRANSPARENT_ALIAS (target)) 1276 { 1277 gcc_assert (TREE_CHAIN (target)); 1278 target = ultimate_transparent_alias_target (&TREE_CHAIN (target)); 1279 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target) 1280 && ! TREE_CHAIN (target)); 1281 *alias = target; 1282 } 1283 1284 return target; 1285} 1286 1287/* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should 1288 have static storage duration. In other words, it should not be an 1289 automatic variable, including PARM_DECLs. 1290 1291 There is, however, one exception: this function handles variables 1292 explicitly placed in a particular register by the user. 1293 1294 This is never called for PARM_DECL nodes. */ 1295 1296void 1297make_decl_rtl (tree decl) 1298{ 1299 const char *name = 0; 1300 int reg_number; 1301 tree id; 1302 rtx x; 1303 1304 /* Check that we are not being given an automatic variable. */ 1305 gcc_assert (TREE_CODE (decl) != PARM_DECL 1306 && TREE_CODE (decl) != RESULT_DECL); 1307 1308 /* A weak alias has TREE_PUBLIC set but not the other bits. */ 1309 gcc_assert (TREE_CODE (decl) != VAR_DECL 1310 || TREE_STATIC (decl) 1311 || TREE_PUBLIC (decl) 1312 || DECL_EXTERNAL (decl) 1313 || DECL_REGISTER (decl)); 1314 1315 /* And that we were not given a type or a label. */ 1316 gcc_assert (TREE_CODE (decl) != TYPE_DECL 1317 && TREE_CODE (decl) != LABEL_DECL); 1318 1319 /* For a duplicate declaration, we can be called twice on the 1320 same DECL node. Don't discard the RTL already made. */ 1321 if (DECL_RTL_SET_P (decl)) 1322 { 1323 /* If the old RTL had the wrong mode, fix the mode. */ 1324 x = DECL_RTL (decl); 1325 if (GET_MODE (x) != DECL_MODE (decl)) 1326 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0)); 1327 1328 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)) 1329 return; 1330 1331 /* ??? Another way to do this would be to maintain a hashed 1332 table of such critters. Instead of adding stuff to a DECL 1333 to give certain attributes to it, we could use an external 1334 hash map from DECL to set of attributes. */ 1335 1336 /* Let the target reassign the RTL if it wants. 1337 This is necessary, for example, when one machine specific 1338 decl attribute overrides another. */ 1339 targetm.encode_section_info (decl, DECL_RTL (decl), false); 1340 1341 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based 1342 on the new decl information. */ 1343 if (MEM_P (x) 1344 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF 1345 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0))) 1346 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl)); 1347 1348 return; 1349 } 1350 1351 /* If this variable belongs to the global constant pool, retrieve the 1352 pre-computed RTL or recompute it in LTO mode. */ 1353 if (TREE_CODE (decl) == VAR_DECL && DECL_IN_CONSTANT_POOL (decl)) 1354 { 1355 SET_DECL_RTL (decl, output_constant_def (DECL_INITIAL (decl), 1)); 1356 return; 1357 } 1358 1359 id = DECL_ASSEMBLER_NAME (decl); 1360 if (TREE_CODE (decl) == FUNCTION_DECL 1361 && cgraph_node::get (decl) 1362 && cgraph_node::get (decl)->instrumentation_clone) 1363 ultimate_transparent_alias_target (&id); 1364 name = IDENTIFIER_POINTER (id); 1365 1366 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL 1367 && DECL_REGISTER (decl)) 1368 { 1369 error ("register name not specified for %q+D", decl); 1370 } 1371 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)) 1372 { 1373 const char *asmspec = name+1; 1374 machine_mode mode = DECL_MODE (decl); 1375 reg_number = decode_reg_name (asmspec); 1376 /* First detect errors in declaring global registers. */ 1377 if (reg_number == -1) 1378 error ("register name not specified for %q+D", decl); 1379 else if (reg_number < 0) 1380 error ("invalid register name for %q+D", decl); 1381 else if (mode == BLKmode) 1382 error ("data type of %q+D isn%'t suitable for a register", 1383 decl); 1384 else if (!in_hard_reg_set_p (accessible_reg_set, mode, reg_number)) 1385 error ("the register specified for %q+D cannot be accessed" 1386 " by the current target", decl); 1387 else if (!in_hard_reg_set_p (operand_reg_set, mode, reg_number)) 1388 error ("the register specified for %q+D is not general enough" 1389 " to be used as a register variable", decl); 1390 else if (!HARD_REGNO_MODE_OK (reg_number, mode)) 1391 error ("register specified for %q+D isn%'t suitable for data type", 1392 decl); 1393 /* Now handle properly declared static register variables. */ 1394 else 1395 { 1396 int nregs; 1397 1398 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl)) 1399 { 1400 DECL_INITIAL (decl) = 0; 1401 error ("global register variable has initial value"); 1402 } 1403 if (TREE_THIS_VOLATILE (decl)) 1404 warning (OPT_Wvolatile_register_var, 1405 "optimization may eliminate reads and/or " 1406 "writes to register variables"); 1407 1408 /* If the user specified one of the eliminables registers here, 1409 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable 1410 confused with that register and be eliminated. This usage is 1411 somewhat suspect... */ 1412 1413 SET_DECL_RTL (decl, gen_rtx_raw_REG (mode, reg_number)); 1414 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number; 1415 REG_USERVAR_P (DECL_RTL (decl)) = 1; 1416 1417 if (TREE_STATIC (decl)) 1418 { 1419 /* Make this register global, so not usable for anything 1420 else. */ 1421#ifdef ASM_DECLARE_REGISTER_GLOBAL 1422 name = IDENTIFIER_POINTER (DECL_NAME (decl)); 1423 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name); 1424#endif 1425 nregs = hard_regno_nregs[reg_number][mode]; 1426 while (nregs > 0) 1427 globalize_reg (decl, reg_number + --nregs); 1428 } 1429 1430 /* As a register variable, it has no section. */ 1431 return; 1432 } 1433 /* Avoid internal errors from invalid register 1434 specifications. */ 1435 SET_DECL_ASSEMBLER_NAME (decl, NULL_TREE); 1436 DECL_HARD_REGISTER (decl) = 0; 1437 /* Also avoid SSA inconsistencies by pretending this is an external 1438 decl now. */ 1439 DECL_EXTERNAL (decl) = 1; 1440 return; 1441 } 1442 /* Now handle ordinary static variables and functions (in memory). 1443 Also handle vars declared register invalidly. */ 1444 else if (name[0] == '*') 1445 { 1446#ifdef REGISTER_PREFIX 1447 if (strlen (REGISTER_PREFIX) != 0) 1448 { 1449 reg_number = decode_reg_name (name); 1450 if (reg_number >= 0 || reg_number == -3) 1451 error ("register name given for non-register variable %q+D", decl); 1452 } 1453#endif 1454 } 1455 1456 /* Specifying a section attribute on a variable forces it into a 1457 non-.bss section, and thus it cannot be common. */ 1458 /* FIXME: In general this code should not be necessary because 1459 visibility pass is doing the same work. But notice_global_symbol 1460 is called early and it needs to make DECL_RTL to get the name. 1461 we take care of recomputing the DECL_RTL after visibility is changed. */ 1462 if (TREE_CODE (decl) == VAR_DECL 1463 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)) 1464 && DECL_SECTION_NAME (decl) != NULL 1465 && DECL_INITIAL (decl) == NULL_TREE 1466 && DECL_COMMON (decl)) 1467 DECL_COMMON (decl) = 0; 1468 1469 /* Variables can't be both common and weak. */ 1470 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl)) 1471 DECL_COMMON (decl) = 0; 1472 1473 if (use_object_blocks_p () && use_blocks_for_decl_p (decl)) 1474 x = create_block_symbol (name, get_block_for_decl (decl), -1); 1475 else 1476 { 1477 machine_mode address_mode = Pmode; 1478 if (TREE_TYPE (decl) != error_mark_node) 1479 { 1480 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (decl)); 1481 address_mode = targetm.addr_space.address_mode (as); 1482 } 1483 x = gen_rtx_SYMBOL_REF (address_mode, name); 1484 } 1485 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl); 1486 SET_SYMBOL_REF_DECL (x, decl); 1487 1488 x = gen_rtx_MEM (DECL_MODE (decl), x); 1489 if (TREE_CODE (decl) != FUNCTION_DECL) 1490 set_mem_attributes (x, decl, 1); 1491 SET_DECL_RTL (decl, x); 1492 1493 /* Optionally set flags or add text to the name to record information 1494 such as that it is a function name. 1495 If the name is changed, the macro ASM_OUTPUT_LABELREF 1496 will have to know how to strip this information. */ 1497 targetm.encode_section_info (decl, DECL_RTL (decl), true); 1498} 1499 1500/* Like make_decl_rtl, but inhibit creation of new alias sets when 1501 calling make_decl_rtl. Also, reset DECL_RTL before returning the 1502 rtl. */ 1503 1504rtx 1505make_decl_rtl_for_debug (tree decl) 1506{ 1507 unsigned int save_aliasing_flag; 1508 rtx rtl; 1509 1510 if (DECL_RTL_SET_P (decl)) 1511 return DECL_RTL (decl); 1512 1513 /* Kludge alert! Somewhere down the call chain, make_decl_rtl will 1514 call new_alias_set. If running with -fcompare-debug, sometimes 1515 we do not want to create alias sets that will throw the alias 1516 numbers off in the comparison dumps. So... clearing 1517 flag_strict_aliasing will keep new_alias_set() from creating a 1518 new set. */ 1519 save_aliasing_flag = flag_strict_aliasing; 1520 flag_strict_aliasing = 0; 1521 1522 rtl = DECL_RTL (decl); 1523 /* Reset DECL_RTL back, as various parts of the compiler expects 1524 DECL_RTL set meaning it is actually going to be output. */ 1525 SET_DECL_RTL (decl, NULL); 1526 1527 flag_strict_aliasing = save_aliasing_flag; 1528 return rtl; 1529} 1530 1531/* Output a string of literal assembler code 1532 for an `asm' keyword used between functions. */ 1533 1534void 1535assemble_asm (tree string) 1536{ 1537 const char *p; 1538 app_enable (); 1539 1540 if (TREE_CODE (string) == ADDR_EXPR) 1541 string = TREE_OPERAND (string, 0); 1542 1543 p = TREE_STRING_POINTER (string); 1544 fprintf (asm_out_file, "%s%s\n", p[0] == '\t' ? "" : "\t", p); 1545} 1546 1547/* Write the address of the entity given by SYMBOL to SEC. */ 1548void 1549assemble_addr_to_section (rtx symbol, section *sec) 1550{ 1551 switch_to_section (sec); 1552 assemble_align (POINTER_SIZE); 1553 assemble_integer (symbol, POINTER_SIZE_UNITS, POINTER_SIZE, 1); 1554} 1555 1556/* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if 1557 not) section for PRIORITY. */ 1558section * 1559get_cdtor_priority_section (int priority, bool constructor_p) 1560{ 1561 char buf[16]; 1562 1563 /* ??? This only works reliably with the GNU linker. */ 1564 sprintf (buf, "%s.%.5u", 1565 constructor_p ? ".ctors" : ".dtors", 1566 /* Invert the numbering so the linker puts us in the proper 1567 order; constructors are run from right to left, and the 1568 linker sorts in increasing order. */ 1569 MAX_INIT_PRIORITY - priority); 1570 return get_section (buf, SECTION_WRITE, NULL); 1571} 1572 1573void 1574default_named_section_asm_out_destructor (rtx symbol, int priority) 1575{ 1576 section *sec; 1577 1578 if (priority != DEFAULT_INIT_PRIORITY) 1579 sec = get_cdtor_priority_section (priority, 1580 /*constructor_p=*/false); 1581 else 1582 sec = get_section (".dtors", SECTION_WRITE, NULL); 1583 1584 assemble_addr_to_section (symbol, sec); 1585} 1586 1587#ifdef DTORS_SECTION_ASM_OP 1588void 1589default_dtor_section_asm_out_destructor (rtx symbol, 1590 int priority ATTRIBUTE_UNUSED) 1591{ 1592 assemble_addr_to_section (symbol, dtors_section); 1593} 1594#endif 1595 1596void 1597default_named_section_asm_out_constructor (rtx symbol, int priority) 1598{ 1599 section *sec; 1600 1601 if (priority != DEFAULT_INIT_PRIORITY) 1602 sec = get_cdtor_priority_section (priority, 1603 /*constructor_p=*/true); 1604 else 1605 sec = get_section (".ctors", SECTION_WRITE, NULL); 1606 1607 assemble_addr_to_section (symbol, sec); 1608} 1609 1610#ifdef CTORS_SECTION_ASM_OP 1611void 1612default_ctor_section_asm_out_constructor (rtx symbol, 1613 int priority ATTRIBUTE_UNUSED) 1614{ 1615 assemble_addr_to_section (symbol, ctors_section); 1616} 1617#endif 1618 1619/* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with 1620 a nonzero value if the constant pool should be output before the 1621 start of the function, or a zero value if the pool should output 1622 after the end of the function. The default is to put it before the 1623 start. */ 1624 1625#ifndef CONSTANT_POOL_BEFORE_FUNCTION 1626#define CONSTANT_POOL_BEFORE_FUNCTION 1 1627#endif 1628 1629/* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going 1630 to be output to assembler. 1631 Set first_global_object_name and weak_global_object_name as appropriate. */ 1632 1633void 1634notice_global_symbol (tree decl) 1635{ 1636 const char **t = &first_global_object_name; 1637 1638 if (first_global_object_name 1639 || !TREE_PUBLIC (decl) 1640 || DECL_EXTERNAL (decl) 1641 || !DECL_NAME (decl) 1642 || (TREE_CODE (decl) == VAR_DECL && DECL_HARD_REGISTER (decl)) 1643 || (TREE_CODE (decl) != FUNCTION_DECL 1644 && (TREE_CODE (decl) != VAR_DECL 1645 || (DECL_COMMON (decl) 1646 && (DECL_INITIAL (decl) == 0 1647 || DECL_INITIAL (decl) == error_mark_node))))) 1648 return; 1649 1650 /* We win when global object is found, but it is useful to know about weak 1651 symbol as well so we can produce nicer unique names. */ 1652 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib) 1653 t = &weak_global_object_name; 1654 1655 if (!*t) 1656 { 1657 tree id = DECL_ASSEMBLER_NAME (decl); 1658 ultimate_transparent_alias_target (&id); 1659 *t = ggc_strdup (targetm.strip_name_encoding (IDENTIFIER_POINTER (id))); 1660 } 1661} 1662 1663/* If not using flag_reorder_blocks_and_partition, decide early whether the 1664 current function goes into the cold section, so that targets can use 1665 current_function_section during RTL expansion. DECL describes the 1666 function. */ 1667 1668void 1669decide_function_section (tree decl) 1670{ 1671 first_function_block_is_cold = false; 1672 1673 if (flag_reorder_blocks_and_partition) 1674 /* We will decide in assemble_start_function. */ 1675 return; 1676 1677 if (DECL_SECTION_NAME (decl)) 1678 { 1679 struct cgraph_node *node = cgraph_node::get (current_function_decl); 1680 /* Calls to function_section rely on first_function_block_is_cold 1681 being accurate. */ 1682 first_function_block_is_cold = (node 1683 && node->frequency 1684 == NODE_FREQUENCY_UNLIKELY_EXECUTED); 1685 } 1686 1687 in_cold_section_p = first_function_block_is_cold; 1688} 1689 1690/* Get the function's name, as described by its RTL. This may be 1691 different from the DECL_NAME name used in the source file. */ 1692const char * 1693get_fnname_from_decl (tree decl) 1694{ 1695 rtx x = DECL_RTL (decl); 1696 gcc_assert (MEM_P (x)); 1697 x = XEXP (x, 0); 1698 gcc_assert (GET_CODE (x) == SYMBOL_REF); 1699 return XSTR (x, 0); 1700} 1701 1702/* Output assembler code for the constant pool of a function and associated 1703 with defining the name of the function. DECL describes the function. 1704 NAME is the function's name. For the constant pool, we use the current 1705 constant pool data. */ 1706 1707void 1708assemble_start_function (tree decl, const char *fnname) 1709{ 1710 int align; 1711 char tmp_label[100]; 1712 bool hot_label_written = false; 1713 1714 if (flag_reorder_blocks_and_partition) 1715 { 1716 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno); 1717 crtl->subsections.hot_section_label = ggc_strdup (tmp_label); 1718 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno); 1719 crtl->subsections.cold_section_label = ggc_strdup (tmp_label); 1720 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno); 1721 crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label); 1722 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno); 1723 crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label); 1724 const_labelno++; 1725 } 1726 else 1727 { 1728 crtl->subsections.hot_section_label = NULL; 1729 crtl->subsections.cold_section_label = NULL; 1730 crtl->subsections.hot_section_end_label = NULL; 1731 crtl->subsections.cold_section_end_label = NULL; 1732 } 1733 1734 /* The following code does not need preprocessing in the assembler. */ 1735 1736 app_disable (); 1737 1738 if (CONSTANT_POOL_BEFORE_FUNCTION) 1739 output_constant_pool (fnname, decl); 1740 1741 align = symtab_node::get (decl)->definition_alignment (); 1742 1743 /* Make sure the not and cold text (code) sections are properly 1744 aligned. This is necessary here in the case where the function 1745 has both hot and cold sections, because we don't want to re-set 1746 the alignment when the section switch happens mid-function. */ 1747 1748 if (flag_reorder_blocks_and_partition) 1749 { 1750 first_function_block_is_cold = false; 1751 1752 switch_to_section (unlikely_text_section ()); 1753 assemble_align (align); 1754 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label); 1755 1756 /* When the function starts with a cold section, we need to explicitly 1757 align the hot section and write out the hot section label. 1758 But if the current function is a thunk, we do not have a CFG. */ 1759 if (!cfun->is_thunk 1760 && BB_PARTITION (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb) == BB_COLD_PARTITION) 1761 { 1762 switch_to_section (text_section); 1763 assemble_align (align); 1764 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label); 1765 hot_label_written = true; 1766 first_function_block_is_cold = true; 1767 } 1768 in_cold_section_p = first_function_block_is_cold; 1769 } 1770 1771 1772 /* Switch to the correct text section for the start of the function. */ 1773 1774 switch_to_section (function_section (decl)); 1775 if (flag_reorder_blocks_and_partition 1776 && !hot_label_written) 1777 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label); 1778 1779 /* Tell assembler to move to target machine's alignment for functions. */ 1780 align = floor_log2 (align / BITS_PER_UNIT); 1781 if (align > 0) 1782 { 1783 ASM_OUTPUT_ALIGN (asm_out_file, align); 1784 } 1785 1786 /* Handle a user-specified function alignment. 1787 Note that we still need to align to DECL_ALIGN, as above, 1788 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */ 1789 if (! DECL_USER_ALIGN (decl) 1790 && align_functions_log > align 1791 && optimize_function_for_speed_p (cfun)) 1792 { 1793#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN 1794 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file, 1795 align_functions_log, align_functions - 1); 1796#else 1797 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log); 1798#endif 1799 } 1800 1801#ifdef ASM_OUTPUT_FUNCTION_PREFIX 1802 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname); 1803#endif 1804 1805 if (!DECL_IGNORED_P (decl)) 1806 (*debug_hooks->begin_function) (decl); 1807 1808 /* Make function name accessible from other files, if appropriate. */ 1809 1810 if (TREE_PUBLIC (decl) 1811 || (cgraph_node::get (decl)->instrumentation_clone 1812 && cgraph_node::get (decl)->instrumented_version 1813 && TREE_PUBLIC (cgraph_node::get (decl)->instrumented_version->decl))) 1814 { 1815 notice_global_symbol (decl); 1816 1817 globalize_decl (decl); 1818 1819 maybe_assemble_visibility (decl); 1820 } 1821 1822 if (DECL_PRESERVE_P (decl)) 1823 targetm.asm_out.mark_decl_preserved (fnname); 1824 1825 /* Do any machine/system dependent processing of the function name. */ 1826#ifdef ASM_DECLARE_FUNCTION_NAME 1827 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl); 1828#else 1829 /* Standard thing is just output label for the function. */ 1830 ASM_OUTPUT_FUNCTION_LABEL (asm_out_file, fnname, current_function_decl); 1831#endif /* ASM_DECLARE_FUNCTION_NAME */ 1832 1833 if (lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (decl))) 1834 saw_no_split_stack = true; 1835} 1836 1837/* Output assembler code associated with defining the size of the 1838 function. DECL describes the function. NAME is the function's name. */ 1839 1840void 1841assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED) 1842{ 1843#ifdef ASM_DECLARE_FUNCTION_SIZE 1844 /* We could have switched section in the middle of the function. */ 1845 if (flag_reorder_blocks_and_partition) 1846 switch_to_section (function_section (decl)); 1847 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl); 1848#endif 1849 if (! CONSTANT_POOL_BEFORE_FUNCTION) 1850 { 1851 output_constant_pool (fnname, decl); 1852 switch_to_section (function_section (decl)); /* need to switch back */ 1853 } 1854 /* Output labels for end of hot/cold text sections (to be used by 1855 debug info.) */ 1856 if (flag_reorder_blocks_and_partition) 1857 { 1858 section *save_text_section; 1859 1860 save_text_section = in_section; 1861 switch_to_section (unlikely_text_section ()); 1862 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label); 1863 if (first_function_block_is_cold) 1864 switch_to_section (text_section); 1865 else 1866 switch_to_section (function_section (decl)); 1867 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label); 1868 switch_to_section (save_text_section); 1869 } 1870} 1871 1872/* Assemble code to leave SIZE bytes of zeros. */ 1873 1874void 1875assemble_zeros (unsigned HOST_WIDE_INT size) 1876{ 1877 /* Do no output if -fsyntax-only. */ 1878 if (flag_syntax_only) 1879 return; 1880 1881#ifdef ASM_NO_SKIP_IN_TEXT 1882 /* The `space' pseudo in the text section outputs nop insns rather than 0s, 1883 so we must output 0s explicitly in the text section. */ 1884 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0) 1885 { 1886 unsigned HOST_WIDE_INT i; 1887 for (i = 0; i < size; i++) 1888 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1); 1889 } 1890 else 1891#endif 1892 if (size > 0) 1893 ASM_OUTPUT_SKIP (asm_out_file, size); 1894} 1895 1896/* Assemble an alignment pseudo op for an ALIGN-bit boundary. */ 1897 1898void 1899assemble_align (int align) 1900{ 1901 if (align > BITS_PER_UNIT) 1902 { 1903 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT)); 1904 } 1905} 1906 1907/* Assemble a string constant with the specified C string as contents. */ 1908 1909void 1910assemble_string (const char *p, int size) 1911{ 1912 int pos = 0; 1913 int maximum = 2000; 1914 1915 /* If the string is very long, split it up. */ 1916 1917 while (pos < size) 1918 { 1919 int thissize = size - pos; 1920 if (thissize > maximum) 1921 thissize = maximum; 1922 1923 ASM_OUTPUT_ASCII (asm_out_file, p, thissize); 1924 1925 pos += thissize; 1926 p += thissize; 1927 } 1928} 1929 1930 1931/* A noswitch_section_callback for lcomm_section. */ 1932 1933static bool 1934emit_local (tree decl ATTRIBUTE_UNUSED, 1935 const char *name ATTRIBUTE_UNUSED, 1936 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1937 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1938{ 1939#if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL 1940 unsigned int align = symtab_node::get (decl)->definition_alignment (); 1941 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, 1942 size, align); 1943 return true; 1944#elif defined ASM_OUTPUT_ALIGNED_LOCAL 1945 unsigned int align = symtab_node::get (decl)->definition_alignment (); 1946 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, align); 1947 return true; 1948#else 1949 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); 1950 return false; 1951#endif 1952} 1953 1954/* A noswitch_section_callback for bss_noswitch_section. */ 1955 1956#if defined ASM_OUTPUT_ALIGNED_BSS 1957static bool 1958emit_bss (tree decl ATTRIBUTE_UNUSED, 1959 const char *name ATTRIBUTE_UNUSED, 1960 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1961 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1962{ 1963#if defined ASM_OUTPUT_ALIGNED_BSS 1964 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, 1965 get_variable_align (decl)); 1966 return true; 1967#endif 1968} 1969#endif 1970 1971/* A noswitch_section_callback for comm_section. */ 1972 1973static bool 1974emit_common (tree decl ATTRIBUTE_UNUSED, 1975 const char *name ATTRIBUTE_UNUSED, 1976 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1977 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1978{ 1979#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON 1980 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, 1981 size, get_variable_align (decl)); 1982 return true; 1983#elif defined ASM_OUTPUT_ALIGNED_COMMON 1984 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, 1985 get_variable_align (decl)); 1986 return true; 1987#else 1988 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded); 1989 return false; 1990#endif 1991} 1992 1993/* A noswitch_section_callback for tls_comm_section. */ 1994 1995static bool 1996emit_tls_common (tree decl ATTRIBUTE_UNUSED, 1997 const char *name ATTRIBUTE_UNUSED, 1998 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1999 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 2000{ 2001#ifdef ASM_OUTPUT_TLS_COMMON 2002 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size); 2003 return true; 2004#else 2005 sorry ("thread-local COMMON data not implemented"); 2006 return true; 2007#endif 2008} 2009 2010/* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT. 2011 NAME is the name of DECL's SYMBOL_REF. */ 2012 2013static void 2014assemble_noswitch_variable (tree decl, const char *name, section *sect, 2015 unsigned int align) 2016{ 2017 unsigned HOST_WIDE_INT size, rounded; 2018 2019 size = tree_to_uhwi (DECL_SIZE_UNIT (decl)); 2020 rounded = size; 2021 2022 if ((flag_sanitize & SANITIZE_ADDRESS) && asan_protect_global (decl)) 2023 size += asan_red_zone_size (size); 2024 2025 /* Don't allocate zero bytes of common, 2026 since that means "undefined external" in the linker. */ 2027 if (size == 0) 2028 rounded = 1; 2029 2030 /* Round size up to multiple of BIGGEST_ALIGNMENT bits 2031 so that each uninitialized object starts on such a boundary. */ 2032 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1; 2033 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 2034 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 2035 2036 if (!sect->noswitch.callback (decl, name, size, rounded) 2037 && (unsigned HOST_WIDE_INT) (align / BITS_PER_UNIT) > rounded) 2038 error ("requested alignment for %q+D is greater than " 2039 "implemented alignment of %wu", decl, rounded); 2040} 2041 2042/* A subroutine of assemble_variable. Output the label and contents of 2043 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA 2044 is as for assemble_variable. */ 2045 2046static void 2047assemble_variable_contents (tree decl, const char *name, 2048 bool dont_output_data) 2049{ 2050 /* Do any machine/system dependent processing of the object. */ 2051#ifdef ASM_DECLARE_OBJECT_NAME 2052 last_assemble_variable_decl = decl; 2053 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl); 2054#else 2055 /* Standard thing is just output label for the object. */ 2056 ASM_OUTPUT_LABEL (asm_out_file, name); 2057#endif /* ASM_DECLARE_OBJECT_NAME */ 2058 2059 if (!dont_output_data) 2060 { 2061 /* Caller is supposed to use varpool_get_constructor when it wants 2062 to output the body. */ 2063 gcc_assert (!in_lto_p || DECL_INITIAL (decl) != error_mark_node); 2064 if (DECL_INITIAL (decl) 2065 && DECL_INITIAL (decl) != error_mark_node 2066 && !initializer_zerop (DECL_INITIAL (decl))) 2067 /* Output the actual data. */ 2068 output_constant (DECL_INITIAL (decl), 2069 tree_to_uhwi (DECL_SIZE_UNIT (decl)), 2070 get_variable_align (decl)); 2071 else 2072 /* Leave space for it. */ 2073 assemble_zeros (tree_to_uhwi (DECL_SIZE_UNIT (decl))); 2074 targetm.asm_out.decl_end (); 2075 } 2076} 2077 2078/* Write out assembly for the variable DECL, which is not defined in 2079 the current translation unit. */ 2080void 2081assemble_undefined_decl (tree decl) 2082{ 2083 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); 2084 targetm.asm_out.assemble_undefined_decl (asm_out_file, name, decl); 2085} 2086 2087/* Assemble everything that is needed for a variable or function declaration. 2088 Not used for automatic variables, and not used for function definitions. 2089 Should not be called for variables of incomplete structure type. 2090 2091 TOP_LEVEL is nonzero if this variable has file scope. 2092 AT_END is nonzero if this is the special handling, at end of compilation, 2093 to define things that have had only tentative definitions. 2094 DONT_OUTPUT_DATA if nonzero means don't actually output the 2095 initial value (that will be done by the caller). */ 2096 2097void 2098assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, 2099 int at_end ATTRIBUTE_UNUSED, int dont_output_data) 2100{ 2101 const char *name; 2102 rtx decl_rtl, symbol; 2103 section *sect; 2104 unsigned int align; 2105 bool asan_protected = false; 2106 2107 /* This function is supposed to handle VARIABLES. Ensure we have one. */ 2108 gcc_assert (TREE_CODE (decl) == VAR_DECL); 2109 2110 /* Emulated TLS had better not get this far. */ 2111 gcc_checking_assert (targetm.have_tls || !DECL_THREAD_LOCAL_P (decl)); 2112 2113 last_assemble_variable_decl = 0; 2114 2115 /* Normally no need to say anything here for external references, 2116 since assemble_external is called by the language-specific code 2117 when a declaration is first seen. */ 2118 2119 if (DECL_EXTERNAL (decl)) 2120 return; 2121 2122 /* Do nothing for global register variables. */ 2123 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl))) 2124 { 2125 TREE_ASM_WRITTEN (decl) = 1; 2126 return; 2127 } 2128 2129 /* If type was incomplete when the variable was declared, 2130 see if it is complete now. */ 2131 2132 if (DECL_SIZE (decl) == 0) 2133 layout_decl (decl, 0); 2134 2135 /* Still incomplete => don't allocate it; treat the tentative defn 2136 (which is what it must have been) as an `extern' reference. */ 2137 2138 if (!dont_output_data && DECL_SIZE (decl) == 0) 2139 { 2140 error ("storage size of %q+D isn%'t known", decl); 2141 TREE_ASM_WRITTEN (decl) = 1; 2142 return; 2143 } 2144 2145 /* The first declaration of a variable that comes through this function 2146 decides whether it is global (in C, has external linkage) 2147 or local (in C, has internal linkage). So do nothing more 2148 if this function has already run. */ 2149 2150 if (TREE_ASM_WRITTEN (decl)) 2151 return; 2152 2153 /* Make sure targetm.encode_section_info is invoked before we set 2154 ASM_WRITTEN. */ 2155 decl_rtl = DECL_RTL (decl); 2156 2157 TREE_ASM_WRITTEN (decl) = 1; 2158 2159 /* Do no output if -fsyntax-only. */ 2160 if (flag_syntax_only) 2161 return; 2162 2163 if (! dont_output_data 2164 && ! valid_constant_size_p (DECL_SIZE_UNIT (decl))) 2165 { 2166 error ("size of variable %q+D is too large", decl); 2167 return; 2168 } 2169 2170 gcc_assert (MEM_P (decl_rtl)); 2171 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF); 2172 symbol = XEXP (decl_rtl, 0); 2173 2174 /* If this symbol belongs to the tree constant pool, output the constant 2175 if it hasn't already been written. */ 2176 if (TREE_CONSTANT_POOL_ADDRESS_P (symbol)) 2177 { 2178 tree decl = SYMBOL_REF_DECL (symbol); 2179 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl))) 2180 output_constant_def_contents (symbol); 2181 return; 2182 } 2183 2184 app_disable (); 2185 2186 name = XSTR (symbol, 0); 2187 if (TREE_PUBLIC (decl) && DECL_NAME (decl)) 2188 notice_global_symbol (decl); 2189 2190 /* Compute the alignment of this data. */ 2191 2192 align_variable (decl, dont_output_data); 2193 2194 if ((flag_sanitize & SANITIZE_ADDRESS) 2195 && asan_protect_global (decl)) 2196 { 2197 asan_protected = true; 2198 DECL_ALIGN (decl) = MAX (DECL_ALIGN (decl), 2199 ASAN_RED_ZONE_SIZE * BITS_PER_UNIT); 2200 } 2201 2202 set_mem_align (decl_rtl, DECL_ALIGN (decl)); 2203 2204 align = get_variable_align (decl); 2205 2206 if (TREE_PUBLIC (decl)) 2207 maybe_assemble_visibility (decl); 2208 2209 if (DECL_PRESERVE_P (decl)) 2210 targetm.asm_out.mark_decl_preserved (name); 2211 2212 /* First make the assembler name(s) global if appropriate. */ 2213 sect = get_variable_section (decl, false); 2214 if (TREE_PUBLIC (decl) 2215 && (sect->common.flags & SECTION_COMMON) == 0) 2216 globalize_decl (decl); 2217 2218 /* Output any data that we will need to use the address of. */ 2219 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node) 2220 output_addressed_constants (DECL_INITIAL (decl)); 2221 2222 /* dbxout.c needs to know this. */ 2223 if (sect && (sect->common.flags & SECTION_CODE) != 0) 2224 DECL_IN_TEXT_SECTION (decl) = 1; 2225 2226 /* If the decl is part of an object_block, make sure that the decl 2227 has been positioned within its block, but do not write out its 2228 definition yet. output_object_blocks will do that later. */ 2229 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol)) 2230 { 2231 gcc_assert (!dont_output_data); 2232 place_block_symbol (symbol); 2233 } 2234 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH) 2235 assemble_noswitch_variable (decl, name, sect, align); 2236 else 2237 { 2238 /* The following bit of code ensures that vtable_map 2239 variables are not only in the comdat section, but that 2240 each variable has its own unique comdat name. If this 2241 code is removed, the variables end up in the same section 2242 with a single comdat name. 2243 2244 FIXME: resolve_unique_section needs to deal better with 2245 decls with both DECL_SECTION_NAME and DECL_ONE_ONLY. Once 2246 that is fixed, this if-else statement can be replaced with 2247 a single call to "switch_to_section (sect)". */ 2248 if (sect->named.name 2249 && (strcmp (sect->named.name, ".vtable_map_vars") == 0)) 2250 { 2251#if defined (OBJECT_FORMAT_ELF) 2252 targetm.asm_out.named_section (sect->named.name, 2253 sect->named.common.flags 2254 | SECTION_LINKONCE, 2255 DECL_NAME (decl)); 2256 in_section = sect; 2257#elif defined (TARGET_PECOFF) 2258 /* Neither OBJECT_FORMAT_PE, nor OBJECT_FORMAT_COFF is set here. 2259 Therefore the following check is used. 2260 In case a the target is PE or COFF a comdat group section 2261 is created, e.g. .vtable_map_vars$foo. The linker places 2262 everything in .vtable_map_vars at the end. 2263 2264 A fix could be made in 2265 gcc/config/i386/winnt.c: i386_pe_unique_section. */ 2266 if (TARGET_PECOFF) 2267 { 2268 char *name; 2269 2270 if (TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE) 2271 name = ACONCAT ((sect->named.name, "$", 2272 IDENTIFIER_POINTER (DECL_NAME (decl)), NULL)); 2273 else 2274 name = ACONCAT ((sect->named.name, "$", 2275 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (DECL_NAME (decl))), 2276 NULL)); 2277 2278 targetm.asm_out.named_section (name, 2279 sect->named.common.flags 2280 | SECTION_LINKONCE, 2281 DECL_NAME (decl)); 2282 in_section = sect; 2283 } 2284#else 2285 switch_to_section (sect); 2286#endif 2287 } 2288 else 2289 switch_to_section (sect); 2290 if (align > BITS_PER_UNIT) 2291 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT)); 2292 assemble_variable_contents (decl, name, dont_output_data); 2293 if (asan_protected) 2294 { 2295 unsigned HOST_WIDE_INT int size 2296 = tree_to_uhwi (DECL_SIZE_UNIT (decl)); 2297 assemble_zeros (asan_red_zone_size (size)); 2298 } 2299 } 2300} 2301 2302 2303/* Given a function declaration (FN_DECL), this function assembles the 2304 function into the .preinit_array section. */ 2305 2306void 2307assemble_vtv_preinit_initializer (tree fn_decl) 2308{ 2309 section *sect; 2310 unsigned flags = SECTION_WRITE; 2311 rtx symbol = XEXP (DECL_RTL (fn_decl), 0); 2312 2313 flags |= SECTION_NOTYPE; 2314 sect = get_section (".preinit_array", flags, fn_decl); 2315 switch_to_section (sect); 2316 assemble_addr_to_section (symbol, sect); 2317} 2318 2319/* Return 1 if type TYPE contains any pointers. */ 2320 2321static int 2322contains_pointers_p (tree type) 2323{ 2324 switch (TREE_CODE (type)) 2325 { 2326 case POINTER_TYPE: 2327 case REFERENCE_TYPE: 2328 /* I'm not sure whether OFFSET_TYPE needs this treatment, 2329 so I'll play safe and return 1. */ 2330 case OFFSET_TYPE: 2331 return 1; 2332 2333 case RECORD_TYPE: 2334 case UNION_TYPE: 2335 case QUAL_UNION_TYPE: 2336 { 2337 tree fields; 2338 /* For a type that has fields, see if the fields have pointers. */ 2339 for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields)) 2340 if (TREE_CODE (fields) == FIELD_DECL 2341 && contains_pointers_p (TREE_TYPE (fields))) 2342 return 1; 2343 return 0; 2344 } 2345 2346 case ARRAY_TYPE: 2347 /* An array type contains pointers if its element type does. */ 2348 return contains_pointers_p (TREE_TYPE (type)); 2349 2350 default: 2351 return 0; 2352 } 2353} 2354 2355/* We delay assemble_external processing until 2356 the compilation unit is finalized. This is the best we can do for 2357 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay 2358 it all the way to final. See PR 17982 for further discussion. */ 2359static GTY(()) tree pending_assemble_externals; 2360 2361#ifdef ASM_OUTPUT_EXTERNAL 2362/* Some targets delay some output to final using TARGET_ASM_FILE_END. 2363 As a result, assemble_external can be called after the list of externals 2364 is processed and the pointer set destroyed. */ 2365static bool pending_assemble_externals_processed; 2366 2367/* Avoid O(external_decls**2) lookups in the pending_assemble_externals 2368 TREE_LIST in assemble_external. */ 2369static hash_set<tree> *pending_assemble_externals_set; 2370 2371/* True if DECL is a function decl for which no out-of-line copy exists. 2372 It is assumed that DECL's assembler name has been set. */ 2373 2374static bool 2375incorporeal_function_p (tree decl) 2376{ 2377 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) 2378 { 2379 const char *name; 2380 2381 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 2382 && (DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA 2383 || DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA_WITH_ALIGN)) 2384 return true; 2385 2386 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 2387 /* Atomic or sync builtins which have survived this far will be 2388 resolved externally and therefore are not incorporeal. */ 2389 if (strncmp (name, "__builtin_", 10) == 0) 2390 return true; 2391 } 2392 return false; 2393} 2394 2395/* Actually do the tests to determine if this is necessary, and invoke 2396 ASM_OUTPUT_EXTERNAL. */ 2397static void 2398assemble_external_real (tree decl) 2399{ 2400 rtx rtl = DECL_RTL (decl); 2401 2402 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF 2403 && !SYMBOL_REF_USED (XEXP (rtl, 0)) 2404 && !incorporeal_function_p (decl)) 2405 { 2406 /* Some systems do require some output. */ 2407 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1; 2408 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0)); 2409 } 2410} 2411#endif 2412 2413void 2414process_pending_assemble_externals (void) 2415{ 2416#ifdef ASM_OUTPUT_EXTERNAL 2417 tree list; 2418 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list)) 2419 assemble_external_real (TREE_VALUE (list)); 2420 2421 pending_assemble_externals = 0; 2422 pending_assemble_externals_processed = true; 2423 delete pending_assemble_externals_set; 2424#endif 2425} 2426 2427/* This TREE_LIST contains any weak symbol declarations waiting 2428 to be emitted. */ 2429static GTY(()) tree weak_decls; 2430 2431/* Output something to declare an external symbol to the assembler, 2432 and qualifiers such as weakness. (Most assemblers don't need 2433 extern declaration, so we normally output nothing.) Do nothing if 2434 DECL is not external. */ 2435 2436void 2437assemble_external (tree decl ATTRIBUTE_UNUSED) 2438{ 2439 /* Make sure that the ASM_OUT_FILE is open. 2440 If it's not, we should not be calling this function. */ 2441 gcc_assert (asm_out_file); 2442 2443 /* In a perfect world, the following condition would be true. 2444 Sadly, the Java and Go front ends emit assembly *from the front end*, 2445 bypassing the call graph. See PR52739. Fix before GCC 4.8. */ 2446#if 0 2447 /* This function should only be called if we are expanding, or have 2448 expanded, to RTL. 2449 Ideally, only final.c would be calling this function, but it is 2450 not clear whether that would break things somehow. See PR 17982 2451 for further discussion. */ 2452 gcc_assert (state == EXPANSION 2453 || state == FINISHED); 2454#endif 2455 2456 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl)) 2457 return; 2458 2459 /* We want to output annotation for weak and external symbols at 2460 very last to check if they are references or not. */ 2461 2462 if (TARGET_SUPPORTS_WEAK 2463 && DECL_WEAK (decl) 2464 /* TREE_STATIC is a weird and abused creature which is not 2465 generally the right test for whether an entity has been 2466 locally emitted, inlined or otherwise not-really-extern, but 2467 for declarations that can be weak, it happens to be 2468 match. */ 2469 && !TREE_STATIC (decl) 2470 && lookup_attribute ("weak", DECL_ATTRIBUTES (decl)) 2471 && value_member (decl, weak_decls) == NULL_TREE) 2472 weak_decls = tree_cons (NULL, decl, weak_decls); 2473 2474#ifdef ASM_OUTPUT_EXTERNAL 2475 if (pending_assemble_externals_processed) 2476 { 2477 assemble_external_real (decl); 2478 return; 2479 } 2480 2481 if (! pending_assemble_externals_set->add (decl)) 2482 pending_assemble_externals = tree_cons (NULL, decl, 2483 pending_assemble_externals); 2484#endif 2485} 2486 2487/* Similar, for calling a library function FUN. */ 2488 2489void 2490assemble_external_libcall (rtx fun) 2491{ 2492 /* Declare library function name external when first used, if nec. */ 2493 if (! SYMBOL_REF_USED (fun)) 2494 { 2495 SYMBOL_REF_USED (fun) = 1; 2496 targetm.asm_out.external_libcall (fun); 2497 } 2498} 2499 2500/* Assemble a label named NAME. */ 2501 2502void 2503assemble_label (FILE *file, const char *name) 2504{ 2505 ASM_OUTPUT_LABEL (file, name); 2506} 2507 2508/* Set the symbol_referenced flag for ID. */ 2509void 2510mark_referenced (tree id) 2511{ 2512 TREE_SYMBOL_REFERENCED (id) = 1; 2513} 2514 2515/* Set the symbol_referenced flag for DECL and notify callgraph. */ 2516void 2517mark_decl_referenced (tree decl) 2518{ 2519 if (TREE_CODE (decl) == FUNCTION_DECL) 2520 { 2521 /* Extern inline functions don't become needed when referenced. 2522 If we know a method will be emitted in other TU and no new 2523 functions can be marked reachable, just use the external 2524 definition. */ 2525 struct cgraph_node *node = cgraph_node::get_create (decl); 2526 if (!DECL_EXTERNAL (decl) 2527 && !node->definition) 2528 node->mark_force_output (); 2529 } 2530 else if (TREE_CODE (decl) == VAR_DECL) 2531 { 2532 varpool_node *node = varpool_node::get_create (decl); 2533 /* C++ frontend use mark_decl_references to force COMDAT variables 2534 to be output that might appear dead otherwise. */ 2535 node->force_output = true; 2536 } 2537 /* else do nothing - we can get various sorts of CST nodes here, 2538 which do not need to be marked. */ 2539} 2540 2541 2542/* Output to FILE (an assembly file) a reference to NAME. If NAME 2543 starts with a *, the rest of NAME is output verbatim. Otherwise 2544 NAME is transformed in a target-specific way (usually by the 2545 addition of an underscore). */ 2546 2547void 2548assemble_name_raw (FILE *file, const char *name) 2549{ 2550 if (name[0] == '*') 2551 fputs (&name[1], file); 2552 else 2553 ASM_OUTPUT_LABELREF (file, name); 2554} 2555 2556/* Like assemble_name_raw, but should be used when NAME might refer to 2557 an entity that is also represented as a tree (like a function or 2558 variable). If NAME does refer to such an entity, that entity will 2559 be marked as referenced. */ 2560 2561void 2562assemble_name (FILE *file, const char *name) 2563{ 2564 const char *real_name; 2565 tree id; 2566 2567 real_name = targetm.strip_name_encoding (name); 2568 2569 id = maybe_get_identifier (real_name); 2570 if (id) 2571 { 2572 tree id_orig = id; 2573 2574 mark_referenced (id); 2575 ultimate_transparent_alias_target (&id); 2576 if (id != id_orig) 2577 name = IDENTIFIER_POINTER (id); 2578 gcc_assert (! TREE_CHAIN (id)); 2579 } 2580 2581 assemble_name_raw (file, name); 2582} 2583 2584/* Allocate SIZE bytes writable static space with a gensym name 2585 and return an RTX to refer to its address. */ 2586 2587rtx 2588assemble_static_space (unsigned HOST_WIDE_INT size) 2589{ 2590 char name[12]; 2591 const char *namestring; 2592 rtx x; 2593 2594 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno); 2595 ++const_labelno; 2596 namestring = ggc_strdup (name); 2597 2598 x = gen_rtx_SYMBOL_REF (Pmode, namestring); 2599 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL; 2600 2601#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL 2602 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size, 2603 BIGGEST_ALIGNMENT); 2604#else 2605#ifdef ASM_OUTPUT_ALIGNED_LOCAL 2606 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT); 2607#else 2608 { 2609 /* Round size up to multiple of BIGGEST_ALIGNMENT bits 2610 so that each uninitialized object starts on such a boundary. */ 2611 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */ 2612 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED 2613 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1) 2614 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 2615 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 2616 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); 2617 } 2618#endif 2619#endif 2620 return x; 2621} 2622 2623/* Assemble the static constant template for function entry trampolines. 2624 This is done at most once per compilation. 2625 Returns an RTX for the address of the template. */ 2626 2627static GTY(()) rtx initial_trampoline; 2628 2629rtx 2630assemble_trampoline_template (void) 2631{ 2632 char label[256]; 2633 const char *name; 2634 int align; 2635 rtx symbol; 2636 2637 gcc_assert (targetm.asm_out.trampoline_template != NULL); 2638 2639 if (initial_trampoline) 2640 return initial_trampoline; 2641 2642 /* By default, put trampoline templates in read-only data section. */ 2643 2644#ifdef TRAMPOLINE_SECTION 2645 switch_to_section (TRAMPOLINE_SECTION); 2646#else 2647 switch_to_section (readonly_data_section); 2648#endif 2649 2650 /* Write the assembler code to define one. */ 2651 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT); 2652 if (align > 0) 2653 ASM_OUTPUT_ALIGN (asm_out_file, align); 2654 2655 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0); 2656 targetm.asm_out.trampoline_template (asm_out_file); 2657 2658 /* Record the rtl to refer to it. */ 2659 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0); 2660 name = ggc_strdup (label); 2661 symbol = gen_rtx_SYMBOL_REF (Pmode, name); 2662 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL; 2663 2664 initial_trampoline = gen_const_mem (BLKmode, symbol); 2665 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT); 2666 set_mem_size (initial_trampoline, TRAMPOLINE_SIZE); 2667 2668 return initial_trampoline; 2669} 2670 2671/* A and B are either alignments or offsets. Return the minimum alignment 2672 that may be assumed after adding the two together. */ 2673 2674static inline unsigned 2675min_align (unsigned int a, unsigned int b) 2676{ 2677 return (a | b) & -(a | b); 2678} 2679 2680/* Return the assembler directive for creating a given kind of integer 2681 object. SIZE is the number of bytes in the object and ALIGNED_P 2682 indicates whether it is known to be aligned. Return NULL if the 2683 assembly dialect has no such directive. 2684 2685 The returned string should be printed at the start of a new line and 2686 be followed immediately by the object's initial value. */ 2687 2688const char * 2689integer_asm_op (int size, int aligned_p) 2690{ 2691 struct asm_int_op *ops; 2692 2693 if (aligned_p) 2694 ops = &targetm.asm_out.aligned_op; 2695 else 2696 ops = &targetm.asm_out.unaligned_op; 2697 2698 switch (size) 2699 { 2700 case 1: 2701 return targetm.asm_out.byte_op; 2702 case 2: 2703 return ops->hi; 2704 case 4: 2705 return ops->si; 2706 case 8: 2707 return ops->di; 2708 case 16: 2709 return ops->ti; 2710 default: 2711 return NULL; 2712 } 2713} 2714 2715/* Use directive OP to assemble an integer object X. Print OP at the 2716 start of the line, followed immediately by the value of X. */ 2717 2718void 2719assemble_integer_with_op (const char *op, rtx x) 2720{ 2721 fputs (op, asm_out_file); 2722 output_addr_const (asm_out_file, x); 2723 fputc ('\n', asm_out_file); 2724} 2725 2726/* The default implementation of the asm_out.integer target hook. */ 2727 2728bool 2729default_assemble_integer (rtx x ATTRIBUTE_UNUSED, 2730 unsigned int size ATTRIBUTE_UNUSED, 2731 int aligned_p ATTRIBUTE_UNUSED) 2732{ 2733 const char *op = integer_asm_op (size, aligned_p); 2734 /* Avoid GAS bugs for large values. Specifically negative values whose 2735 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */ 2736 if (size > UNITS_PER_WORD && size > POINTER_SIZE_UNITS) 2737 return false; 2738 return op && (assemble_integer_with_op (op, x), true); 2739} 2740 2741/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is 2742 the alignment of the integer in bits. Return 1 if we were able to output 2743 the constant, otherwise 0. We must be able to output the constant, 2744 if FORCE is nonzero. */ 2745 2746bool 2747assemble_integer (rtx x, unsigned int size, unsigned int align, int force) 2748{ 2749 int aligned_p; 2750 2751 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT)); 2752 2753 /* See if the target hook can handle this kind of object. */ 2754 if (targetm.asm_out.integer (x, size, aligned_p)) 2755 return true; 2756 2757 /* If the object is a multi-byte one, try splitting it up. Split 2758 it into words it if is multi-word, otherwise split it into bytes. */ 2759 if (size > 1) 2760 { 2761 machine_mode omode, imode; 2762 unsigned int subalign; 2763 unsigned int subsize, i; 2764 enum mode_class mclass; 2765 2766 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1; 2767 subalign = MIN (align, subsize * BITS_PER_UNIT); 2768 if (GET_CODE (x) == CONST_FIXED) 2769 mclass = GET_MODE_CLASS (GET_MODE (x)); 2770 else 2771 mclass = MODE_INT; 2772 2773 omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0); 2774 imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0); 2775 2776 for (i = 0; i < size; i += subsize) 2777 { 2778 rtx partial = simplify_subreg (omode, x, imode, i); 2779 if (!partial || !assemble_integer (partial, subsize, subalign, 0)) 2780 break; 2781 } 2782 if (i == size) 2783 return true; 2784 2785 /* If we've printed some of it, but not all of it, there's no going 2786 back now. */ 2787 gcc_assert (!i); 2788 } 2789 2790 gcc_assert (!force); 2791 2792 return false; 2793} 2794 2795void 2796assemble_real (REAL_VALUE_TYPE d, machine_mode mode, unsigned int align) 2797{ 2798 long data[4] = {0, 0, 0, 0}; 2799 int i; 2800 int bitsize, nelts, nunits, units_per; 2801 2802 /* This is hairy. We have a quantity of known size. real_to_target 2803 will put it into an array of *host* longs, 32 bits per element 2804 (even if long is more than 32 bits). We need to determine the 2805 number of array elements that are occupied (nelts) and the number 2806 of *target* min-addressable units that will be occupied in the 2807 object file (nunits). We cannot assume that 32 divides the 2808 mode's bitsize (size * BITS_PER_UNIT) evenly. 2809 2810 size * BITS_PER_UNIT is used here to make sure that padding bits 2811 (which might appear at either end of the value; real_to_target 2812 will include the padding bits in its output array) are included. */ 2813 2814 nunits = GET_MODE_SIZE (mode); 2815 bitsize = nunits * BITS_PER_UNIT; 2816 nelts = CEIL (bitsize, 32); 2817 units_per = 32 / BITS_PER_UNIT; 2818 2819 real_to_target (data, &d, mode); 2820 2821 /* Put out the first word with the specified alignment. */ 2822 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1); 2823 nunits -= units_per; 2824 2825 /* Subsequent words need only 32-bit alignment. */ 2826 align = min_align (align, 32); 2827 2828 for (i = 1; i < nelts; i++) 2829 { 2830 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1); 2831 nunits -= units_per; 2832 } 2833} 2834 2835/* Given an expression EXP with a constant value, 2836 reduce it to the sum of an assembler symbol and an integer. 2837 Store them both in the structure *VALUE. 2838 EXP must be reducible. */ 2839 2840struct addr_const { 2841 rtx base; 2842 HOST_WIDE_INT offset; 2843}; 2844 2845static void 2846decode_addr_const (tree exp, struct addr_const *value) 2847{ 2848 tree target = TREE_OPERAND (exp, 0); 2849 int offset = 0; 2850 rtx x; 2851 2852 while (1) 2853 { 2854 if (TREE_CODE (target) == COMPONENT_REF 2855 && tree_fits_shwi_p (byte_position (TREE_OPERAND (target, 1)))) 2856 { 2857 offset += int_byte_position (TREE_OPERAND (target, 1)); 2858 target = TREE_OPERAND (target, 0); 2859 } 2860 else if (TREE_CODE (target) == ARRAY_REF 2861 || TREE_CODE (target) == ARRAY_RANGE_REF) 2862 { 2863 offset += (tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (target))) 2864 * tree_to_shwi (TREE_OPERAND (target, 1))); 2865 target = TREE_OPERAND (target, 0); 2866 } 2867 else if (TREE_CODE (target) == MEM_REF 2868 && TREE_CODE (TREE_OPERAND (target, 0)) == ADDR_EXPR) 2869 { 2870 offset += mem_ref_offset (target).to_short_addr (); 2871 target = TREE_OPERAND (TREE_OPERAND (target, 0), 0); 2872 } 2873 else if (TREE_CODE (target) == INDIRECT_REF 2874 && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR 2875 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0)) 2876 == ADDR_EXPR) 2877 target = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target, 0), 0), 0); 2878 else 2879 break; 2880 } 2881 2882 switch (TREE_CODE (target)) 2883 { 2884 case VAR_DECL: 2885 case FUNCTION_DECL: 2886 x = DECL_RTL (target); 2887 break; 2888 2889 case LABEL_DECL: 2890 x = gen_rtx_MEM (FUNCTION_MODE, 2891 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target))); 2892 break; 2893 2894 case REAL_CST: 2895 case FIXED_CST: 2896 case STRING_CST: 2897 case COMPLEX_CST: 2898 case CONSTRUCTOR: 2899 case INTEGER_CST: 2900 x = output_constant_def (target, 1); 2901 break; 2902 2903 default: 2904 gcc_unreachable (); 2905 } 2906 2907 gcc_assert (MEM_P (x)); 2908 x = XEXP (x, 0); 2909 2910 value->base = x; 2911 value->offset = offset; 2912} 2913 2914static GTY(()) hash_table<tree_descriptor_hasher> *const_desc_htab; 2915 2916static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int); 2917 2918/* Constant pool accessor function. */ 2919 2920hash_table<tree_descriptor_hasher> * 2921constant_pool_htab (void) 2922{ 2923 return const_desc_htab; 2924} 2925 2926/* Compute a hash code for a constant expression. */ 2927 2928hashval_t 2929tree_descriptor_hasher::hash (constant_descriptor_tree *ptr) 2930{ 2931 return ptr->hash; 2932} 2933 2934static hashval_t 2935const_hash_1 (const tree exp) 2936{ 2937 const char *p; 2938 hashval_t hi; 2939 int len, i; 2940 enum tree_code code = TREE_CODE (exp); 2941 2942 /* Either set P and LEN to the address and len of something to hash and 2943 exit the switch or return a value. */ 2944 2945 switch (code) 2946 { 2947 case INTEGER_CST: 2948 p = (char *) &TREE_INT_CST_ELT (exp, 0); 2949 len = TREE_INT_CST_NUNITS (exp) * sizeof (HOST_WIDE_INT); 2950 break; 2951 2952 case REAL_CST: 2953 return real_hash (TREE_REAL_CST_PTR (exp)); 2954 2955 case FIXED_CST: 2956 return fixed_hash (TREE_FIXED_CST_PTR (exp)); 2957 2958 case STRING_CST: 2959 p = TREE_STRING_POINTER (exp); 2960 len = TREE_STRING_LENGTH (exp); 2961 break; 2962 2963 case COMPLEX_CST: 2964 return (const_hash_1 (TREE_REALPART (exp)) * 5 2965 + const_hash_1 (TREE_IMAGPART (exp))); 2966 2967 case VECTOR_CST: 2968 { 2969 unsigned i; 2970 2971 hi = 7 + VECTOR_CST_NELTS (exp); 2972 2973 for (i = 0; i < VECTOR_CST_NELTS (exp); ++i) 2974 hi = hi * 563 + const_hash_1 (VECTOR_CST_ELT (exp, i)); 2975 2976 return hi; 2977 } 2978 2979 case CONSTRUCTOR: 2980 { 2981 unsigned HOST_WIDE_INT idx; 2982 tree value; 2983 2984 hi = 5 + int_size_in_bytes (TREE_TYPE (exp)); 2985 2986 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value) 2987 if (value) 2988 hi = hi * 603 + const_hash_1 (value); 2989 2990 return hi; 2991 } 2992 2993 case ADDR_EXPR: 2994 case FDESC_EXPR: 2995 { 2996 struct addr_const value; 2997 2998 decode_addr_const (exp, &value); 2999 switch (GET_CODE (value.base)) 3000 { 3001 case SYMBOL_REF: 3002 /* Don't hash the address of the SYMBOL_REF; 3003 only use the offset and the symbol name. */ 3004 hi = value.offset; 3005 p = XSTR (value.base, 0); 3006 for (i = 0; p[i] != 0; i++) 3007 hi = ((hi * 613) + (unsigned) (p[i])); 3008 break; 3009 3010 case LABEL_REF: 3011 hi = (value.offset 3012 + CODE_LABEL_NUMBER (LABEL_REF_LABEL (value.base)) * 13); 3013 break; 3014 3015 default: 3016 gcc_unreachable (); 3017 } 3018 } 3019 return hi; 3020 3021 case PLUS_EXPR: 3022 case POINTER_PLUS_EXPR: 3023 case MINUS_EXPR: 3024 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9 3025 + const_hash_1 (TREE_OPERAND (exp, 1))); 3026 3027 CASE_CONVERT: 3028 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2; 3029 3030 default: 3031 /* A language specific constant. Just hash the code. */ 3032 return code; 3033 } 3034 3035 /* Compute hashing function. */ 3036 hi = len; 3037 for (i = 0; i < len; i++) 3038 hi = ((hi * 613) + (unsigned) (p[i])); 3039 3040 return hi; 3041} 3042 3043/* Wrapper of compare_constant, for the htab interface. */ 3044bool 3045tree_descriptor_hasher::equal (constant_descriptor_tree *c1, 3046 constant_descriptor_tree *c2) 3047{ 3048 if (c1->hash != c2->hash) 3049 return 0; 3050 return compare_constant (c1->value, c2->value); 3051} 3052 3053/* Compare t1 and t2, and return 1 only if they are known to result in 3054 the same bit pattern on output. */ 3055 3056static int 3057compare_constant (const tree t1, const tree t2) 3058{ 3059 enum tree_code typecode; 3060 3061 if (t1 == NULL_TREE) 3062 return t2 == NULL_TREE; 3063 if (t2 == NULL_TREE) 3064 return 0; 3065 3066 if (TREE_CODE (t1) != TREE_CODE (t2)) 3067 return 0; 3068 3069 switch (TREE_CODE (t1)) 3070 { 3071 case INTEGER_CST: 3072 /* Integer constants are the same only if the same width of type. */ 3073 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) 3074 return 0; 3075 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))) 3076 return 0; 3077 return tree_int_cst_equal (t1, t2); 3078 3079 case REAL_CST: 3080 /* Real constants are the same only if the same width of type. */ 3081 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) 3082 return 0; 3083 3084 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 3085 3086 case FIXED_CST: 3087 /* Fixed constants are the same only if the same width of type. */ 3088 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) 3089 return 0; 3090 3091 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2)); 3092 3093 case STRING_CST: 3094 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))) 3095 return 0; 3096 3097 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 3098 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 3099 TREE_STRING_LENGTH (t1))); 3100 3101 case COMPLEX_CST: 3102 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2)) 3103 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2))); 3104 3105 case VECTOR_CST: 3106 { 3107 unsigned i; 3108 3109 if (VECTOR_CST_NELTS (t1) != VECTOR_CST_NELTS (t2)) 3110 return 0; 3111 3112 for (i = 0; i < VECTOR_CST_NELTS (t1); ++i) 3113 if (!compare_constant (VECTOR_CST_ELT (t1, i), 3114 VECTOR_CST_ELT (t2, i))) 3115 return 0; 3116 3117 return 1; 3118 } 3119 3120 case CONSTRUCTOR: 3121 { 3122 vec<constructor_elt, va_gc> *v1, *v2; 3123 unsigned HOST_WIDE_INT idx; 3124 3125 typecode = TREE_CODE (TREE_TYPE (t1)); 3126 if (typecode != TREE_CODE (TREE_TYPE (t2))) 3127 return 0; 3128 3129 if (typecode == ARRAY_TYPE) 3130 { 3131 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1)); 3132 /* For arrays, check that the sizes all match. */ 3133 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)) 3134 || size_1 == -1 3135 || size_1 != int_size_in_bytes (TREE_TYPE (t2))) 3136 return 0; 3137 } 3138 else 3139 { 3140 /* For record and union constructors, require exact type 3141 equality. */ 3142 if (TREE_TYPE (t1) != TREE_TYPE (t2)) 3143 return 0; 3144 } 3145 3146 v1 = CONSTRUCTOR_ELTS (t1); 3147 v2 = CONSTRUCTOR_ELTS (t2); 3148 if (vec_safe_length (v1) != vec_safe_length (v2)) 3149 return 0; 3150 3151 for (idx = 0; idx < vec_safe_length (v1); ++idx) 3152 { 3153 constructor_elt *c1 = &(*v1)[idx]; 3154 constructor_elt *c2 = &(*v2)[idx]; 3155 3156 /* Check that each value is the same... */ 3157 if (!compare_constant (c1->value, c2->value)) 3158 return 0; 3159 /* ... and that they apply to the same fields! */ 3160 if (typecode == ARRAY_TYPE) 3161 { 3162 if (!compare_constant (c1->index, c2->index)) 3163 return 0; 3164 } 3165 else 3166 { 3167 if (c1->index != c2->index) 3168 return 0; 3169 } 3170 } 3171 3172 return 1; 3173 } 3174 3175 case ADDR_EXPR: 3176 case FDESC_EXPR: 3177 { 3178 struct addr_const value1, value2; 3179 enum rtx_code code; 3180 int ret; 3181 3182 decode_addr_const (t1, &value1); 3183 decode_addr_const (t2, &value2); 3184 3185 if (value1.offset != value2.offset) 3186 return 0; 3187 3188 code = GET_CODE (value1.base); 3189 if (code != GET_CODE (value2.base)) 3190 return 0; 3191 3192 switch (code) 3193 { 3194 case SYMBOL_REF: 3195 ret = (strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0); 3196 break; 3197 3198 case LABEL_REF: 3199 ret = (CODE_LABEL_NUMBER (LABEL_REF_LABEL (value1.base)) 3200 == CODE_LABEL_NUMBER (LABEL_REF_LABEL (value2.base))); 3201 break; 3202 3203 default: 3204 gcc_unreachable (); 3205 } 3206 return ret; 3207 } 3208 3209 case PLUS_EXPR: 3210 case POINTER_PLUS_EXPR: 3211 case MINUS_EXPR: 3212 case RANGE_EXPR: 3213 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)) 3214 && compare_constant (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); 3215 3216 CASE_CONVERT: 3217 case VIEW_CONVERT_EXPR: 3218 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 3219 3220 default: 3221 return 0; 3222 } 3223 3224 gcc_unreachable (); 3225} 3226 3227/* Return the section into which constant EXP should be placed. */ 3228 3229static section * 3230get_constant_section (tree exp, unsigned int align) 3231{ 3232 return targetm.asm_out.select_section (exp, 3233 compute_reloc_for_constant (exp), 3234 align); 3235} 3236 3237/* Return the size of constant EXP in bytes. */ 3238 3239static HOST_WIDE_INT 3240get_constant_size (tree exp) 3241{ 3242 HOST_WIDE_INT size; 3243 3244 size = int_size_in_bytes (TREE_TYPE (exp)); 3245 if (TREE_CODE (exp) == STRING_CST) 3246 size = MAX (TREE_STRING_LENGTH (exp), size); 3247 return size; 3248} 3249 3250/* Subroutine of output_constant_def: 3251 No constant equal to EXP is known to have been output. 3252 Make a constant descriptor to enter EXP in the hash table. 3253 Assign the label number and construct RTL to refer to the 3254 constant's location in memory. 3255 Caller is responsible for updating the hash table. */ 3256 3257static struct constant_descriptor_tree * 3258build_constant_desc (tree exp) 3259{ 3260 struct constant_descriptor_tree *desc; 3261 rtx symbol, rtl; 3262 char label[256]; 3263 int labelno; 3264 tree decl; 3265 3266 desc = ggc_alloc<constant_descriptor_tree> (); 3267 desc->value = exp; 3268 3269 /* Create a string containing the label name, in LABEL. */ 3270 labelno = const_labelno++; 3271 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno); 3272 3273 /* Construct the VAR_DECL associated with the constant. */ 3274 decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label), 3275 TREE_TYPE (exp)); 3276 DECL_ARTIFICIAL (decl) = 1; 3277 DECL_IGNORED_P (decl) = 1; 3278 TREE_READONLY (decl) = 1; 3279 TREE_STATIC (decl) = 1; 3280 TREE_ADDRESSABLE (decl) = 1; 3281 /* We don't set the RTL yet as this would cause varpool to assume that the 3282 variable is referenced. Moreover, it would just be dropped in LTO mode. 3283 Instead we set the flag that will be recognized in make_decl_rtl. */ 3284 DECL_IN_CONSTANT_POOL (decl) = 1; 3285 DECL_INITIAL (decl) = desc->value; 3286 /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most 3287 architectures so use DATA_ALIGNMENT as well, except for strings. */ 3288 if (TREE_CODE (exp) == STRING_CST) 3289 { 3290#ifdef CONSTANT_ALIGNMENT 3291 DECL_ALIGN (decl) = CONSTANT_ALIGNMENT (exp, DECL_ALIGN (decl)); 3292#endif 3293 } 3294 else 3295 align_variable (decl, 0); 3296 3297 /* Now construct the SYMBOL_REF and the MEM. */ 3298 if (use_object_blocks_p ()) 3299 { 3300 int align = (TREE_CODE (decl) == CONST_DECL 3301 || (TREE_CODE (decl) == VAR_DECL 3302 && DECL_IN_CONSTANT_POOL (decl)) 3303 ? DECL_ALIGN (decl) 3304 : symtab_node::get (decl)->definition_alignment ()); 3305 section *sect = get_constant_section (exp, align); 3306 symbol = create_block_symbol (ggc_strdup (label), 3307 get_block_for_section (sect), -1); 3308 } 3309 else 3310 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)); 3311 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL; 3312 SET_SYMBOL_REF_DECL (symbol, decl); 3313 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1; 3314 3315 rtl = gen_const_mem (TYPE_MODE (TREE_TYPE (exp)), symbol); 3316 set_mem_attributes (rtl, exp, 1); 3317 set_mem_alias_set (rtl, 0); 3318 3319 /* We cannot share RTX'es in pool entries. 3320 Mark this piece of RTL as required for unsharing. */ 3321 RTX_FLAG (rtl, used) = 1; 3322 3323 /* Set flags or add text to the name to record information, such as 3324 that it is a local symbol. If the name is changed, the macro 3325 ASM_OUTPUT_LABELREF will have to know how to strip this 3326 information. This call might invalidate our local variable 3327 SYMBOL; we can't use it afterward. */ 3328 targetm.encode_section_info (exp, rtl, true); 3329 3330 desc->rtl = rtl; 3331 3332 return desc; 3333} 3334 3335/* Return an rtx representing a reference to constant data in memory 3336 for the constant expression EXP. 3337 3338 If assembler code for such a constant has already been output, 3339 return an rtx to refer to it. 3340 Otherwise, output such a constant in memory 3341 and generate an rtx for it. 3342 3343 If DEFER is nonzero, this constant can be deferred and output only 3344 if referenced in the function after all optimizations. 3345 3346 `const_desc_table' records which constants already have label strings. */ 3347 3348rtx 3349output_constant_def (tree exp, int defer) 3350{ 3351 struct constant_descriptor_tree *desc; 3352 struct constant_descriptor_tree key; 3353 3354 /* Look up EXP in the table of constant descriptors. If we didn't find 3355 it, create a new one. */ 3356 key.value = exp; 3357 key.hash = const_hash_1 (exp); 3358 constant_descriptor_tree **loc 3359 = const_desc_htab->find_slot_with_hash (&key, key.hash, INSERT); 3360 3361 desc = *loc; 3362 if (desc == 0) 3363 { 3364 desc = build_constant_desc (exp); 3365 desc->hash = key.hash; 3366 *loc = desc; 3367 } 3368 3369 maybe_output_constant_def_contents (desc, defer); 3370 return desc->rtl; 3371} 3372 3373/* Subroutine of output_constant_def: Decide whether or not we need to 3374 output the constant DESC now, and if so, do it. */ 3375static void 3376maybe_output_constant_def_contents (struct constant_descriptor_tree *desc, 3377 int defer) 3378{ 3379 rtx symbol = XEXP (desc->rtl, 0); 3380 tree exp = desc->value; 3381 3382 if (flag_syntax_only) 3383 return; 3384 3385 if (TREE_ASM_WRITTEN (exp)) 3386 /* Already output; don't do it again. */ 3387 return; 3388 3389 /* We can always defer constants as long as the context allows 3390 doing so. */ 3391 if (defer) 3392 { 3393 /* Increment n_deferred_constants if it exists. It needs to be at 3394 least as large as the number of constants actually referred to 3395 by the function. If it's too small we'll stop looking too early 3396 and fail to emit constants; if it's too large we'll only look 3397 through the entire function when we could have stopped earlier. */ 3398 if (cfun) 3399 n_deferred_constants++; 3400 return; 3401 } 3402 3403 output_constant_def_contents (symbol); 3404} 3405 3406/* Subroutine of output_constant_def_contents. Output the definition 3407 of constant EXP, which is pointed to by label LABEL. ALIGN is the 3408 constant's alignment in bits. */ 3409 3410static void 3411assemble_constant_contents (tree exp, const char *label, unsigned int align) 3412{ 3413 HOST_WIDE_INT size; 3414 3415 size = get_constant_size (exp); 3416 3417 /* Do any machine/system dependent processing of the constant. */ 3418 targetm.asm_out.declare_constant_name (asm_out_file, label, exp, size); 3419 3420 /* Output the value of EXP. */ 3421 output_constant (exp, size, align); 3422 3423 targetm.asm_out.decl_end (); 3424} 3425 3426/* We must output the constant data referred to by SYMBOL; do so. */ 3427 3428static void 3429output_constant_def_contents (rtx symbol) 3430{ 3431 tree decl = SYMBOL_REF_DECL (symbol); 3432 tree exp = DECL_INITIAL (decl); 3433 bool asan_protected = false; 3434 3435 /* Make sure any other constants whose addresses appear in EXP 3436 are assigned label numbers. */ 3437 output_addressed_constants (exp); 3438 3439 /* We are no longer deferring this constant. */ 3440 TREE_ASM_WRITTEN (decl) = TREE_ASM_WRITTEN (exp) = 1; 3441 3442 if ((flag_sanitize & SANITIZE_ADDRESS) 3443 && TREE_CODE (exp) == STRING_CST 3444 && asan_protect_global (exp)) 3445 { 3446 asan_protected = true; 3447 DECL_ALIGN (decl) = MAX (DECL_ALIGN (decl), 3448 ASAN_RED_ZONE_SIZE * BITS_PER_UNIT); 3449 } 3450 3451 /* If the constant is part of an object block, make sure that the 3452 decl has been positioned within its block, but do not write out 3453 its definition yet. output_object_blocks will do that later. */ 3454 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol)) 3455 place_block_symbol (symbol); 3456 else 3457 { 3458 int align = (TREE_CODE (decl) == CONST_DECL 3459 || (TREE_CODE (decl) == VAR_DECL 3460 && DECL_IN_CONSTANT_POOL (decl)) 3461 ? DECL_ALIGN (decl) 3462 : symtab_node::get (decl)->definition_alignment ()); 3463 switch_to_section (get_constant_section (exp, align)); 3464 if (align > BITS_PER_UNIT) 3465 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT)); 3466 assemble_constant_contents (exp, XSTR (symbol, 0), align); 3467 if (asan_protected) 3468 { 3469 HOST_WIDE_INT size = get_constant_size (exp); 3470 assemble_zeros (asan_red_zone_size (size)); 3471 } 3472 } 3473} 3474 3475/* Look up EXP in the table of constant descriptors. Return the rtl 3476 if it has been emitted, else null. */ 3477 3478rtx 3479lookup_constant_def (tree exp) 3480{ 3481 struct constant_descriptor_tree key; 3482 3483 key.value = exp; 3484 key.hash = const_hash_1 (exp); 3485 constant_descriptor_tree *desc 3486 = const_desc_htab->find_with_hash (&key, key.hash); 3487 3488 return (desc ? desc->rtl : NULL_RTX); 3489} 3490 3491/* Return a tree representing a reference to constant data in memory 3492 for the constant expression EXP. 3493 3494 This is the counterpart of output_constant_def at the Tree level. */ 3495 3496tree 3497tree_output_constant_def (tree exp) 3498{ 3499 struct constant_descriptor_tree *desc, key; 3500 tree decl; 3501 3502 /* Look up EXP in the table of constant descriptors. If we didn't find 3503 it, create a new one. */ 3504 key.value = exp; 3505 key.hash = const_hash_1 (exp); 3506 constant_descriptor_tree **loc 3507 = const_desc_htab->find_slot_with_hash (&key, key.hash, INSERT); 3508 3509 desc = *loc; 3510 if (desc == 0) 3511 { 3512 desc = build_constant_desc (exp); 3513 desc->hash = key.hash; 3514 *loc = desc; 3515 } 3516 3517 decl = SYMBOL_REF_DECL (XEXP (desc->rtl, 0)); 3518 varpool_node::finalize_decl (decl); 3519 return decl; 3520} 3521 3522struct GTY((chain_next ("%h.next"), for_user)) constant_descriptor_rtx { 3523 struct constant_descriptor_rtx *next; 3524 rtx mem; 3525 rtx sym; 3526 rtx constant; 3527 HOST_WIDE_INT offset; 3528 hashval_t hash; 3529 machine_mode mode; 3530 unsigned int align; 3531 int labelno; 3532 int mark; 3533}; 3534 3535struct const_rtx_desc_hasher : ggc_hasher<constant_descriptor_rtx *> 3536{ 3537 static hashval_t hash (constant_descriptor_rtx *); 3538 static bool equal (constant_descriptor_rtx *, constant_descriptor_rtx *); 3539}; 3540 3541/* Used in the hash tables to avoid outputting the same constant 3542 twice. Unlike 'struct constant_descriptor_tree', RTX constants 3543 are output once per function, not once per file. */ 3544/* ??? Only a few targets need per-function constant pools. Most 3545 can use one per-file pool. Should add a targetm bit to tell the 3546 difference. */ 3547 3548struct GTY(()) rtx_constant_pool { 3549 /* Pointers to first and last constant in pool, as ordered by offset. */ 3550 struct constant_descriptor_rtx *first; 3551 struct constant_descriptor_rtx *last; 3552 3553 /* Hash facility for making memory-constants from constant rtl-expressions. 3554 It is used on RISC machines where immediate integer arguments and 3555 constant addresses are restricted so that such constants must be stored 3556 in memory. */ 3557 hash_table<const_rtx_desc_hasher> *const_rtx_htab; 3558 3559 /* Current offset in constant pool (does not include any 3560 machine-specific header). */ 3561 HOST_WIDE_INT offset; 3562}; 3563 3564/* Hash and compare functions for const_rtx_htab. */ 3565 3566hashval_t 3567const_rtx_desc_hasher::hash (constant_descriptor_rtx *desc) 3568{ 3569 return desc->hash; 3570} 3571 3572bool 3573const_rtx_desc_hasher::equal (constant_descriptor_rtx *x, 3574 constant_descriptor_rtx *y) 3575{ 3576 if (x->mode != y->mode) 3577 return 0; 3578 return rtx_equal_p (x->constant, y->constant); 3579} 3580 3581/* Hash one component of a constant. */ 3582 3583static hashval_t 3584const_rtx_hash_1 (const_rtx x) 3585{ 3586 unsigned HOST_WIDE_INT hwi; 3587 machine_mode mode; 3588 enum rtx_code code; 3589 hashval_t h; 3590 int i; 3591 3592 code = GET_CODE (x); 3593 mode = GET_MODE (x); 3594 h = (hashval_t) code * 1048573 + mode; 3595 3596 switch (code) 3597 { 3598 case CONST_INT: 3599 hwi = INTVAL (x); 3600 3601 fold_hwi: 3602 { 3603 int shift = sizeof (hashval_t) * CHAR_BIT; 3604 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t); 3605 3606 h ^= (hashval_t) hwi; 3607 for (i = 1; i < n; ++i) 3608 { 3609 hwi >>= shift; 3610 h ^= (hashval_t) hwi; 3611 } 3612 } 3613 break; 3614 3615 case CONST_WIDE_INT: 3616 hwi = GET_MODE_PRECISION (mode); 3617 { 3618 for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++) 3619 hwi ^= CONST_WIDE_INT_ELT (x, i); 3620 goto fold_hwi; 3621 } 3622 3623 case CONST_DOUBLE: 3624 if (TARGET_SUPPORTS_WIDE_INT == 0 && mode == VOIDmode) 3625 { 3626 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x); 3627 goto fold_hwi; 3628 } 3629 else 3630 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x)); 3631 break; 3632 3633 case CONST_FIXED: 3634 h ^= fixed_hash (CONST_FIXED_VALUE (x)); 3635 break; 3636 3637 case SYMBOL_REF: 3638 h ^= htab_hash_string (XSTR (x, 0)); 3639 break; 3640 3641 case LABEL_REF: 3642 h = h * 251 + CODE_LABEL_NUMBER (LABEL_REF_LABEL (x)); 3643 break; 3644 3645 case UNSPEC: 3646 case UNSPEC_VOLATILE: 3647 h = h * 251 + XINT (x, 1); 3648 break; 3649 3650 default: 3651 break; 3652 } 3653 3654 return h; 3655} 3656 3657/* Compute a hash value for X, which should be a constant. */ 3658 3659static hashval_t 3660const_rtx_hash (rtx x) 3661{ 3662 hashval_t h = 0; 3663 subrtx_iterator::array_type array; 3664 FOR_EACH_SUBRTX (iter, array, x, ALL) 3665 h = h * 509 + const_rtx_hash_1 (*iter); 3666 return h; 3667} 3668 3669 3670/* Create and return a new rtx constant pool. */ 3671 3672static struct rtx_constant_pool * 3673create_constant_pool (void) 3674{ 3675 struct rtx_constant_pool *pool; 3676 3677 pool = ggc_alloc<rtx_constant_pool> (); 3678 pool->const_rtx_htab = hash_table<const_rtx_desc_hasher>::create_ggc (31); 3679 pool->first = NULL; 3680 pool->last = NULL; 3681 pool->offset = 0; 3682 return pool; 3683} 3684 3685/* Initialize constant pool hashing for a new function. */ 3686 3687void 3688init_varasm_status (void) 3689{ 3690 crtl->varasm.pool = create_constant_pool (); 3691 crtl->varasm.deferred_constants = 0; 3692} 3693 3694/* Given a MINUS expression, simplify it if both sides 3695 include the same symbol. */ 3696 3697rtx 3698simplify_subtraction (rtx x) 3699{ 3700 rtx r = simplify_rtx (x); 3701 return r ? r : x; 3702} 3703 3704/* Given a constant rtx X, make (or find) a memory constant for its value 3705 and return a MEM rtx to refer to it in memory. */ 3706 3707rtx 3708force_const_mem (machine_mode mode, rtx x) 3709{ 3710 struct constant_descriptor_rtx *desc, tmp; 3711 struct rtx_constant_pool *pool; 3712 char label[256]; 3713 rtx def, symbol; 3714 hashval_t hash; 3715 unsigned int align; 3716 constant_descriptor_rtx **slot; 3717 3718 /* If we're not allowed to drop X into the constant pool, don't. */ 3719 if (targetm.cannot_force_const_mem (mode, x)) 3720 return NULL_RTX; 3721 3722 /* Record that this function has used a constant pool entry. */ 3723 crtl->uses_const_pool = 1; 3724 3725 /* Decide which pool to use. */ 3726 pool = (targetm.use_blocks_for_constant_p (mode, x) 3727 ? shared_constant_pool 3728 : crtl->varasm.pool); 3729 3730 /* Lookup the value in the hashtable. */ 3731 tmp.constant = x; 3732 tmp.mode = mode; 3733 hash = const_rtx_hash (x); 3734 slot = pool->const_rtx_htab->find_slot_with_hash (&tmp, hash, INSERT); 3735 desc = *slot; 3736 3737 /* If the constant was already present, return its memory. */ 3738 if (desc) 3739 return copy_rtx (desc->mem); 3740 3741 /* Otherwise, create a new descriptor. */ 3742 desc = ggc_alloc<constant_descriptor_rtx> (); 3743 *slot = desc; 3744 3745 /* Align the location counter as required by EXP's data type. */ 3746 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode); 3747#ifdef CONSTANT_ALIGNMENT 3748 { 3749 tree type = lang_hooks.types.type_for_mode (mode, 0); 3750 if (type != NULL_TREE) 3751 align = CONSTANT_ALIGNMENT (make_tree (type, x), align); 3752 } 3753#endif 3754 3755 pool->offset += (align / BITS_PER_UNIT) - 1; 3756 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1); 3757 3758 desc->next = NULL; 3759 desc->constant = copy_rtx (tmp.constant); 3760 desc->offset = pool->offset; 3761 desc->hash = hash; 3762 desc->mode = mode; 3763 desc->align = align; 3764 desc->labelno = const_labelno; 3765 desc->mark = 0; 3766 3767 pool->offset += GET_MODE_SIZE (mode); 3768 if (pool->last) 3769 pool->last->next = desc; 3770 else 3771 pool->first = pool->last = desc; 3772 pool->last = desc; 3773 3774 /* Create a string containing the label name, in LABEL. */ 3775 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno); 3776 ++const_labelno; 3777 3778 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to 3779 the constants pool. */ 3780 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x)) 3781 { 3782 section *sect = targetm.asm_out.select_rtx_section (mode, x, align); 3783 symbol = create_block_symbol (ggc_strdup (label), 3784 get_block_for_section (sect), -1); 3785 } 3786 else 3787 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)); 3788 desc->sym = symbol; 3789 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL; 3790 CONSTANT_POOL_ADDRESS_P (symbol) = 1; 3791 SET_SYMBOL_REF_CONSTANT (symbol, desc); 3792 3793 /* Construct the MEM. */ 3794 desc->mem = def = gen_const_mem (mode, symbol); 3795 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); 3796 set_mem_align (def, align); 3797 3798 /* If we're dropping a label to the constant pool, make sure we 3799 don't delete it. */ 3800 if (GET_CODE (x) == LABEL_REF) 3801 LABEL_PRESERVE_P (XEXP (x, 0)) = 1; 3802 3803 return copy_rtx (def); 3804} 3805 3806/* Given a constant pool SYMBOL_REF, return the corresponding constant. */ 3807 3808rtx 3809get_pool_constant (const_rtx addr) 3810{ 3811 return SYMBOL_REF_CONSTANT (addr)->constant; 3812} 3813 3814/* Given a constant pool SYMBOL_REF, return the corresponding constant 3815 and whether it has been output or not. */ 3816 3817rtx 3818get_pool_constant_mark (rtx addr, bool *pmarked) 3819{ 3820 struct constant_descriptor_rtx *desc; 3821 3822 desc = SYMBOL_REF_CONSTANT (addr); 3823 *pmarked = (desc->mark != 0); 3824 return desc->constant; 3825} 3826 3827/* Similar, return the mode. */ 3828 3829machine_mode 3830get_pool_mode (const_rtx addr) 3831{ 3832 return SYMBOL_REF_CONSTANT (addr)->mode; 3833} 3834 3835/* Return the size of the constant pool. */ 3836 3837int 3838get_pool_size (void) 3839{ 3840 return crtl->varasm.pool->offset; 3841} 3842 3843/* Worker function for output_constant_pool_1. Emit assembly for X 3844 in MODE with known alignment ALIGN. */ 3845 3846static void 3847output_constant_pool_2 (machine_mode mode, rtx x, unsigned int align) 3848{ 3849 switch (GET_MODE_CLASS (mode)) 3850 { 3851 case MODE_FLOAT: 3852 case MODE_DECIMAL_FLOAT: 3853 { 3854 REAL_VALUE_TYPE r; 3855 3856 gcc_assert (CONST_DOUBLE_AS_FLOAT_P (x)); 3857 REAL_VALUE_FROM_CONST_DOUBLE (r, x); 3858 assemble_real (r, mode, align); 3859 break; 3860 } 3861 3862 case MODE_INT: 3863 case MODE_PARTIAL_INT: 3864 case MODE_FRACT: 3865 case MODE_UFRACT: 3866 case MODE_ACCUM: 3867 case MODE_UACCUM: 3868 case MODE_POINTER_BOUNDS: 3869 assemble_integer (x, GET_MODE_SIZE (mode), align, 1); 3870 break; 3871 3872 case MODE_VECTOR_FLOAT: 3873 case MODE_VECTOR_INT: 3874 case MODE_VECTOR_FRACT: 3875 case MODE_VECTOR_UFRACT: 3876 case MODE_VECTOR_ACCUM: 3877 case MODE_VECTOR_UACCUM: 3878 { 3879 int i, units; 3880 machine_mode submode = GET_MODE_INNER (mode); 3881 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode)); 3882 3883 gcc_assert (GET_CODE (x) == CONST_VECTOR); 3884 units = CONST_VECTOR_NUNITS (x); 3885 3886 for (i = 0; i < units; i++) 3887 { 3888 rtx elt = CONST_VECTOR_ELT (x, i); 3889 output_constant_pool_2 (submode, elt, i ? subalign : align); 3890 } 3891 } 3892 break; 3893 3894 default: 3895 gcc_unreachable (); 3896 } 3897} 3898 3899/* Worker function for output_constant_pool. Emit constant DESC, 3900 giving it ALIGN bits of alignment. */ 3901 3902static void 3903output_constant_pool_1 (struct constant_descriptor_rtx *desc, 3904 unsigned int align) 3905{ 3906 rtx x, tmp; 3907 3908 x = desc->constant; 3909 3910 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF) 3911 whose CODE_LABEL has been deleted. This can occur if a jump table 3912 is eliminated by optimization. If so, write a constant of zero 3913 instead. Note that this can also happen by turning the 3914 CODE_LABEL into a NOTE. */ 3915 /* ??? This seems completely and utterly wrong. Certainly it's 3916 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper 3917 functioning even with rtx_insn::deleted and friends. */ 3918 3919 tmp = x; 3920 switch (GET_CODE (tmp)) 3921 { 3922 case CONST: 3923 if (GET_CODE (XEXP (tmp, 0)) != PLUS 3924 || GET_CODE (XEXP (XEXP (tmp, 0), 0)) != LABEL_REF) 3925 break; 3926 tmp = XEXP (XEXP (tmp, 0), 0); 3927 /* FALLTHRU */ 3928 3929 case LABEL_REF: 3930 tmp = LABEL_REF_LABEL (tmp); 3931 gcc_assert (!as_a<rtx_insn *> (tmp)->deleted ()); 3932 gcc_assert (!NOTE_P (tmp) 3933 || NOTE_KIND (tmp) != NOTE_INSN_DELETED); 3934 break; 3935 3936 default: 3937 break; 3938 } 3939 3940#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY 3941 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode, 3942 align, desc->labelno, done); 3943#endif 3944 3945 assemble_align (align); 3946 3947 /* Output the label. */ 3948 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno); 3949 3950 /* Output the data. */ 3951 output_constant_pool_2 (desc->mode, x, align); 3952 3953 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS 3954 sections have proper size. */ 3955 if (align > GET_MODE_BITSIZE (desc->mode) 3956 && in_section 3957 && (in_section->common.flags & SECTION_MERGE)) 3958 assemble_align (align); 3959 3960#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY 3961 done: 3962#endif 3963 return; 3964} 3965 3966/* Mark all constants that are referenced by SYMBOL_REFs in X. 3967 Emit referenced deferred strings. */ 3968 3969static void 3970mark_constants_in_pattern (rtx insn) 3971{ 3972 subrtx_iterator::array_type array; 3973 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL) 3974 { 3975 const_rtx x = *iter; 3976 if (GET_CODE (x) == SYMBOL_REF) 3977 { 3978 if (CONSTANT_POOL_ADDRESS_P (x)) 3979 { 3980 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x); 3981 if (desc->mark == 0) 3982 { 3983 desc->mark = 1; 3984 iter.substitute (desc->constant); 3985 } 3986 } 3987 else if (TREE_CONSTANT_POOL_ADDRESS_P (x)) 3988 { 3989 tree decl = SYMBOL_REF_DECL (x); 3990 if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl))) 3991 { 3992 n_deferred_constants--; 3993 output_constant_def_contents (CONST_CAST_RTX (x)); 3994 } 3995 } 3996 } 3997 } 3998} 3999 4000/* Look through appropriate parts of INSN, marking all entries in the 4001 constant pool which are actually being used. Entries that are only 4002 referenced by other constants are also marked as used. Emit 4003 deferred strings that are used. */ 4004 4005static void 4006mark_constants (rtx_insn *insn) 4007{ 4008 if (!INSN_P (insn)) 4009 return; 4010 4011 /* Insns may appear inside a SEQUENCE. Only check the patterns of 4012 insns, not any notes that may be attached. We don't want to mark 4013 a constant just because it happens to appear in a REG_EQUIV note. */ 4014 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (PATTERN (insn))) 4015 { 4016 int i, n = seq->len (); 4017 for (i = 0; i < n; ++i) 4018 { 4019 rtx subinsn = seq->element (i); 4020 if (INSN_P (subinsn)) 4021 mark_constants_in_pattern (subinsn); 4022 } 4023 } 4024 else 4025 mark_constants_in_pattern (insn); 4026} 4027 4028/* Look through the instructions for this function, and mark all the 4029 entries in POOL which are actually being used. Emit deferred constants 4030 which have indeed been used. */ 4031 4032static void 4033mark_constant_pool (void) 4034{ 4035 rtx_insn *insn; 4036 4037 if (!crtl->uses_const_pool && n_deferred_constants == 0) 4038 return; 4039 4040 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 4041 mark_constants (insn); 4042} 4043 4044/* Write all the constants in POOL. */ 4045 4046static void 4047output_constant_pool_contents (struct rtx_constant_pool *pool) 4048{ 4049 struct constant_descriptor_rtx *desc; 4050 4051 for (desc = pool->first; desc ; desc = desc->next) 4052 if (desc->mark) 4053 { 4054 /* If the constant is part of an object_block, make sure that 4055 the constant has been positioned within its block, but do not 4056 write out its definition yet. output_object_blocks will do 4057 that later. */ 4058 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym) 4059 && SYMBOL_REF_BLOCK (desc->sym)) 4060 place_block_symbol (desc->sym); 4061 else 4062 { 4063 switch_to_section (targetm.asm_out.select_rtx_section 4064 (desc->mode, desc->constant, desc->align)); 4065 output_constant_pool_1 (desc, desc->align); 4066 } 4067 } 4068} 4069 4070/* Mark all constants that are used in the current function, then write 4071 out the function's private constant pool. */ 4072 4073static void 4074output_constant_pool (const char *fnname ATTRIBUTE_UNUSED, 4075 tree fndecl ATTRIBUTE_UNUSED) 4076{ 4077 struct rtx_constant_pool *pool = crtl->varasm.pool; 4078 4079 /* It is possible for gcc to call force_const_mem and then to later 4080 discard the instructions which refer to the constant. In such a 4081 case we do not need to output the constant. */ 4082 mark_constant_pool (); 4083 4084#ifdef ASM_OUTPUT_POOL_PROLOGUE 4085 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset); 4086#endif 4087 4088 output_constant_pool_contents (pool); 4089 4090#ifdef ASM_OUTPUT_POOL_EPILOGUE 4091 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset); 4092#endif 4093} 4094 4095/* Write the contents of the shared constant pool. */ 4096 4097void 4098output_shared_constant_pool (void) 4099{ 4100 output_constant_pool_contents (shared_constant_pool); 4101} 4102 4103/* Determine what kind of relocations EXP may need. */ 4104 4105int 4106compute_reloc_for_constant (tree exp) 4107{ 4108 int reloc = 0, reloc2; 4109 tree tem; 4110 4111 switch (TREE_CODE (exp)) 4112 { 4113 case ADDR_EXPR: 4114 case FDESC_EXPR: 4115 /* Go inside any operations that get_inner_reference can handle and see 4116 if what's inside is a constant: no need to do anything here for 4117 addresses of variables or functions. */ 4118 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem); 4119 tem = TREE_OPERAND (tem, 0)) 4120 ; 4121 4122 if (TREE_CODE (tem) == MEM_REF 4123 && TREE_CODE (TREE_OPERAND (tem, 0)) == ADDR_EXPR) 4124 { 4125 reloc = compute_reloc_for_constant (TREE_OPERAND (tem, 0)); 4126 break; 4127 } 4128 4129 if (!targetm.binds_local_p (tem)) 4130 reloc |= 2; 4131 else 4132 reloc |= 1; 4133 break; 4134 4135 case PLUS_EXPR: 4136 case POINTER_PLUS_EXPR: 4137 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 4138 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1)); 4139 break; 4140 4141 case MINUS_EXPR: 4142 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 4143 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1)); 4144 /* The difference of two local labels is computable at link time. */ 4145 if (reloc == 1 && reloc2 == 1) 4146 reloc = 0; 4147 else 4148 reloc |= reloc2; 4149 break; 4150 4151 CASE_CONVERT: 4152 case VIEW_CONVERT_EXPR: 4153 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 4154 break; 4155 4156 case CONSTRUCTOR: 4157 { 4158 unsigned HOST_WIDE_INT idx; 4159 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem) 4160 if (tem != 0) 4161 reloc |= compute_reloc_for_constant (tem); 4162 } 4163 break; 4164 4165 default: 4166 break; 4167 } 4168 return reloc; 4169} 4170 4171/* Find all the constants whose addresses are referenced inside of EXP, 4172 and make sure assembler code with a label has been output for each one. 4173 Indicate whether an ADDR_EXPR has been encountered. */ 4174 4175static void 4176output_addressed_constants (tree exp) 4177{ 4178 tree tem; 4179 4180 switch (TREE_CODE (exp)) 4181 { 4182 case ADDR_EXPR: 4183 case FDESC_EXPR: 4184 /* Go inside any operations that get_inner_reference can handle and see 4185 if what's inside is a constant: no need to do anything here for 4186 addresses of variables or functions. */ 4187 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem); 4188 tem = TREE_OPERAND (tem, 0)) 4189 ; 4190 4191 /* If we have an initialized CONST_DECL, retrieve the initializer. */ 4192 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem)) 4193 tem = DECL_INITIAL (tem); 4194 4195 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR) 4196 output_constant_def (tem, 0); 4197 4198 if (TREE_CODE (tem) == MEM_REF) 4199 output_addressed_constants (TREE_OPERAND (tem, 0)); 4200 break; 4201 4202 case PLUS_EXPR: 4203 case POINTER_PLUS_EXPR: 4204 case MINUS_EXPR: 4205 output_addressed_constants (TREE_OPERAND (exp, 1)); 4206 /* Fall through. */ 4207 4208 CASE_CONVERT: 4209 case VIEW_CONVERT_EXPR: 4210 output_addressed_constants (TREE_OPERAND (exp, 0)); 4211 break; 4212 4213 case CONSTRUCTOR: 4214 { 4215 unsigned HOST_WIDE_INT idx; 4216 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem) 4217 if (tem != 0) 4218 output_addressed_constants (tem); 4219 } 4220 break; 4221 4222 default: 4223 break; 4224 } 4225} 4226 4227/* Whether a constructor CTOR is a valid static constant initializer if all 4228 its elements are. This used to be internal to initializer_constant_valid_p 4229 and has been exposed to let other functions like categorize_ctor_elements 4230 evaluate the property while walking a constructor for other purposes. */ 4231 4232bool 4233constructor_static_from_elts_p (const_tree ctor) 4234{ 4235 return (TREE_CONSTANT (ctor) 4236 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE 4237 || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE 4238 || TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE)); 4239} 4240 4241static tree initializer_constant_valid_p_1 (tree value, tree endtype, 4242 tree *cache); 4243 4244/* A subroutine of initializer_constant_valid_p. VALUE is a MINUS_EXPR, 4245 PLUS_EXPR or POINTER_PLUS_EXPR. This looks for cases of VALUE 4246 which are valid when ENDTYPE is an integer of any size; in 4247 particular, this does not accept a pointer minus a constant. This 4248 returns null_pointer_node if the VALUE is an absolute constant 4249 which can be used to initialize a static variable. Otherwise it 4250 returns NULL. */ 4251 4252static tree 4253narrowing_initializer_constant_valid_p (tree value, tree endtype, tree *cache) 4254{ 4255 tree op0, op1; 4256 4257 if (!INTEGRAL_TYPE_P (endtype)) 4258 return NULL_TREE; 4259 4260 op0 = TREE_OPERAND (value, 0); 4261 op1 = TREE_OPERAND (value, 1); 4262 4263 /* Like STRIP_NOPS except allow the operand mode to widen. This 4264 works around a feature of fold that simplifies (int)(p1 - p2) to 4265 ((int)p1 - (int)p2) under the theory that the narrower operation 4266 is cheaper. */ 4267 4268 while (CONVERT_EXPR_P (op0) 4269 || TREE_CODE (op0) == NON_LVALUE_EXPR) 4270 { 4271 tree inner = TREE_OPERAND (op0, 0); 4272 if (inner == error_mark_node 4273 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) 4274 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))) 4275 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) 4276 break; 4277 op0 = inner; 4278 } 4279 4280 while (CONVERT_EXPR_P (op1) 4281 || TREE_CODE (op1) == NON_LVALUE_EXPR) 4282 { 4283 tree inner = TREE_OPERAND (op1, 0); 4284 if (inner == error_mark_node 4285 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) 4286 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1))) 4287 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) 4288 break; 4289 op1 = inner; 4290 } 4291 4292 op0 = initializer_constant_valid_p_1 (op0, endtype, cache); 4293 if (!op0) 4294 return NULL_TREE; 4295 4296 op1 = initializer_constant_valid_p_1 (op1, endtype, 4297 cache ? cache + 2 : NULL); 4298 /* Both initializers must be known. */ 4299 if (op1) 4300 { 4301 if (op0 == op1 4302 && (op0 == null_pointer_node 4303 || TREE_CODE (value) == MINUS_EXPR)) 4304 return null_pointer_node; 4305 4306 /* Support differences between labels. */ 4307 if (TREE_CODE (op0) == LABEL_DECL 4308 && TREE_CODE (op1) == LABEL_DECL) 4309 return null_pointer_node; 4310 4311 if (TREE_CODE (op0) == STRING_CST 4312 && TREE_CODE (op1) == STRING_CST 4313 && operand_equal_p (op0, op1, 1)) 4314 return null_pointer_node; 4315 } 4316 4317 return NULL_TREE; 4318} 4319 4320/* Helper function of initializer_constant_valid_p. 4321 Return nonzero if VALUE is a valid constant-valued expression 4322 for use in initializing a static variable; one that can be an 4323 element of a "constant" initializer. 4324 4325 Return null_pointer_node if the value is absolute; 4326 if it is relocatable, return the variable that determines the relocation. 4327 We assume that VALUE has been folded as much as possible; 4328 therefore, we do not need to check for such things as 4329 arithmetic-combinations of integers. 4330 4331 Use CACHE (pointer to 2 tree values) for caching if non-NULL. */ 4332 4333static tree 4334initializer_constant_valid_p_1 (tree value, tree endtype, tree *cache) 4335{ 4336 tree ret; 4337 4338 switch (TREE_CODE (value)) 4339 { 4340 case CONSTRUCTOR: 4341 if (constructor_static_from_elts_p (value)) 4342 { 4343 unsigned HOST_WIDE_INT idx; 4344 tree elt; 4345 bool absolute = true; 4346 4347 if (cache && cache[0] == value) 4348 return cache[1]; 4349 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt) 4350 { 4351 tree reloc; 4352 reloc = initializer_constant_valid_p_1 (elt, TREE_TYPE (elt), 4353 NULL); 4354 if (!reloc) 4355 { 4356 if (cache) 4357 { 4358 cache[0] = value; 4359 cache[1] = NULL_TREE; 4360 } 4361 return NULL_TREE; 4362 } 4363 if (reloc != null_pointer_node) 4364 absolute = false; 4365 } 4366 /* For a non-absolute relocation, there is no single 4367 variable that can be "the variable that determines the 4368 relocation." */ 4369 if (cache) 4370 { 4371 cache[0] = value; 4372 cache[1] = absolute ? null_pointer_node : error_mark_node; 4373 } 4374 return absolute ? null_pointer_node : error_mark_node; 4375 } 4376 4377 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE; 4378 4379 case INTEGER_CST: 4380 case VECTOR_CST: 4381 case REAL_CST: 4382 case FIXED_CST: 4383 case STRING_CST: 4384 case COMPLEX_CST: 4385 return null_pointer_node; 4386 4387 case ADDR_EXPR: 4388 case FDESC_EXPR: 4389 { 4390 tree op0 = staticp (TREE_OPERAND (value, 0)); 4391 if (op0) 4392 { 4393 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out 4394 to be a constant, this is old-skool offsetof-like nonsense. */ 4395 if (TREE_CODE (op0) == INDIRECT_REF 4396 && TREE_CONSTANT (TREE_OPERAND (op0, 0))) 4397 return null_pointer_node; 4398 /* Taking the address of a nested function involves a trampoline, 4399 unless we don't need or want one. */ 4400 if (TREE_CODE (op0) == FUNCTION_DECL 4401 && DECL_STATIC_CHAIN (op0) 4402 && !TREE_NO_TRAMPOLINE (value)) 4403 return NULL_TREE; 4404 /* "&{...}" requires a temporary to hold the constructed 4405 object. */ 4406 if (TREE_CODE (op0) == CONSTRUCTOR) 4407 return NULL_TREE; 4408 } 4409 return op0; 4410 } 4411 4412 case NON_LVALUE_EXPR: 4413 return initializer_constant_valid_p_1 (TREE_OPERAND (value, 0), 4414 endtype, cache); 4415 4416 case VIEW_CONVERT_EXPR: 4417 { 4418 tree src = TREE_OPERAND (value, 0); 4419 tree src_type = TREE_TYPE (src); 4420 tree dest_type = TREE_TYPE (value); 4421 4422 /* Allow view-conversions from aggregate to non-aggregate type only 4423 if the bit pattern is fully preserved afterwards; otherwise, the 4424 RTL expander won't be able to apply a subsequent transformation 4425 to the underlying constructor. */ 4426 if (AGGREGATE_TYPE_P (src_type) && !AGGREGATE_TYPE_P (dest_type)) 4427 { 4428 if (TYPE_MODE (endtype) == TYPE_MODE (dest_type)) 4429 return initializer_constant_valid_p_1 (src, endtype, cache); 4430 else 4431 return NULL_TREE; 4432 } 4433 4434 /* Allow all other kinds of view-conversion. */ 4435 return initializer_constant_valid_p_1 (src, endtype, cache); 4436 } 4437 4438 CASE_CONVERT: 4439 { 4440 tree src = TREE_OPERAND (value, 0); 4441 tree src_type = TREE_TYPE (src); 4442 tree dest_type = TREE_TYPE (value); 4443 4444 /* Allow conversions between pointer types, floating-point 4445 types, and offset types. */ 4446 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)) 4447 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type)) 4448 || (TREE_CODE (dest_type) == OFFSET_TYPE 4449 && TREE_CODE (src_type) == OFFSET_TYPE)) 4450 return initializer_constant_valid_p_1 (src, endtype, cache); 4451 4452 /* Allow length-preserving conversions between integer types. */ 4453 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type) 4454 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type))) 4455 return initializer_constant_valid_p_1 (src, endtype, cache); 4456 4457 /* Allow conversions between other integer types only if 4458 explicit value. */ 4459 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)) 4460 { 4461 tree inner = initializer_constant_valid_p_1 (src, endtype, cache); 4462 if (inner == null_pointer_node) 4463 return null_pointer_node; 4464 break; 4465 } 4466 4467 /* Allow (int) &foo provided int is as wide as a pointer. */ 4468 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type) 4469 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))) 4470 return initializer_constant_valid_p_1 (src, endtype, cache); 4471 4472 /* Likewise conversions from int to pointers, but also allow 4473 conversions from 0. */ 4474 if ((POINTER_TYPE_P (dest_type) 4475 || TREE_CODE (dest_type) == OFFSET_TYPE) 4476 && INTEGRAL_TYPE_P (src_type)) 4477 { 4478 if (TREE_CODE (src) == INTEGER_CST 4479 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)) 4480 return null_pointer_node; 4481 if (integer_zerop (src)) 4482 return null_pointer_node; 4483 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type)) 4484 return initializer_constant_valid_p_1 (src, endtype, cache); 4485 } 4486 4487 /* Allow conversions to struct or union types if the value 4488 inside is okay. */ 4489 if (TREE_CODE (dest_type) == RECORD_TYPE 4490 || TREE_CODE (dest_type) == UNION_TYPE) 4491 return initializer_constant_valid_p_1 (src, endtype, cache); 4492 } 4493 break; 4494 4495 case POINTER_PLUS_EXPR: 4496 case PLUS_EXPR: 4497 /* Any valid floating-point constants will have been folded by now; 4498 with -frounding-math we hit this with addition of two constants. */ 4499 if (TREE_CODE (endtype) == REAL_TYPE) 4500 return NULL_TREE; 4501 if (cache && cache[0] == value) 4502 return cache[1]; 4503 if (! INTEGRAL_TYPE_P (endtype) 4504 || TYPE_PRECISION (endtype) >= TYPE_PRECISION (TREE_TYPE (value))) 4505 { 4506 tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE }; 4507 tree valid0 4508 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0), 4509 endtype, ncache); 4510 tree valid1 4511 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 1), 4512 endtype, ncache + 2); 4513 /* If either term is absolute, use the other term's relocation. */ 4514 if (valid0 == null_pointer_node) 4515 ret = valid1; 4516 else if (valid1 == null_pointer_node) 4517 ret = valid0; 4518 /* Support narrowing pointer differences. */ 4519 else 4520 ret = narrowing_initializer_constant_valid_p (value, endtype, 4521 ncache); 4522 } 4523 else 4524 /* Support narrowing pointer differences. */ 4525 ret = narrowing_initializer_constant_valid_p (value, endtype, NULL); 4526 if (cache) 4527 { 4528 cache[0] = value; 4529 cache[1] = ret; 4530 } 4531 return ret; 4532 4533 case MINUS_EXPR: 4534 if (TREE_CODE (endtype) == REAL_TYPE) 4535 return NULL_TREE; 4536 if (cache && cache[0] == value) 4537 return cache[1]; 4538 if (! INTEGRAL_TYPE_P (endtype) 4539 || TYPE_PRECISION (endtype) >= TYPE_PRECISION (TREE_TYPE (value))) 4540 { 4541 tree ncache[4] = { NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE }; 4542 tree valid0 4543 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 0), 4544 endtype, ncache); 4545 tree valid1 4546 = initializer_constant_valid_p_1 (TREE_OPERAND (value, 1), 4547 endtype, ncache + 2); 4548 /* Win if second argument is absolute. */ 4549 if (valid1 == null_pointer_node) 4550 ret = valid0; 4551 /* Win if both arguments have the same relocation. 4552 Then the value is absolute. */ 4553 else if (valid0 == valid1 && valid0 != 0) 4554 ret = null_pointer_node; 4555 /* Since GCC guarantees that string constants are unique in the 4556 generated code, a subtraction between two copies of the same 4557 constant string is absolute. */ 4558 else if (valid0 && TREE_CODE (valid0) == STRING_CST 4559 && valid1 && TREE_CODE (valid1) == STRING_CST 4560 && operand_equal_p (valid0, valid1, 1)) 4561 ret = null_pointer_node; 4562 /* Support narrowing differences. */ 4563 else 4564 ret = narrowing_initializer_constant_valid_p (value, endtype, 4565 ncache); 4566 } 4567 else 4568 /* Support narrowing differences. */ 4569 ret = narrowing_initializer_constant_valid_p (value, endtype, NULL); 4570 if (cache) 4571 { 4572 cache[0] = value; 4573 cache[1] = ret; 4574 } 4575 return ret; 4576 4577 default: 4578 break; 4579 } 4580 4581 return NULL_TREE; 4582} 4583 4584/* Return nonzero if VALUE is a valid constant-valued expression 4585 for use in initializing a static variable; one that can be an 4586 element of a "constant" initializer. 4587 4588 Return null_pointer_node if the value is absolute; 4589 if it is relocatable, return the variable that determines the relocation. 4590 We assume that VALUE has been folded as much as possible; 4591 therefore, we do not need to check for such things as 4592 arithmetic-combinations of integers. */ 4593tree 4594initializer_constant_valid_p (tree value, tree endtype) 4595{ 4596 return initializer_constant_valid_p_1 (value, endtype, NULL); 4597} 4598 4599/* Return true if VALUE is a valid constant-valued expression 4600 for use in initializing a static bit-field; one that can be 4601 an element of a "constant" initializer. */ 4602 4603bool 4604initializer_constant_valid_for_bitfield_p (tree value) 4605{ 4606 /* For bitfields we support integer constants or possibly nested aggregates 4607 of such. */ 4608 switch (TREE_CODE (value)) 4609 { 4610 case CONSTRUCTOR: 4611 { 4612 unsigned HOST_WIDE_INT idx; 4613 tree elt; 4614 4615 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt) 4616 if (!initializer_constant_valid_for_bitfield_p (elt)) 4617 return false; 4618 return true; 4619 } 4620 4621 case INTEGER_CST: 4622 case REAL_CST: 4623 return true; 4624 4625 case VIEW_CONVERT_EXPR: 4626 case NON_LVALUE_EXPR: 4627 return 4628 initializer_constant_valid_for_bitfield_p (TREE_OPERAND (value, 0)); 4629 4630 default: 4631 break; 4632 } 4633 4634 return false; 4635} 4636 4637/* output_constructor outer state of relevance in recursive calls, typically 4638 for nested aggregate bitfields. */ 4639 4640typedef struct { 4641 unsigned int bit_offset; /* current position in ... */ 4642 int byte; /* ... the outer byte buffer. */ 4643} oc_outer_state; 4644 4645static unsigned HOST_WIDE_INT 4646 output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int, 4647 oc_outer_state *); 4648 4649/* Output assembler code for constant EXP, with no label. 4650 This includes the pseudo-op such as ".int" or ".byte", and a newline. 4651 Assumes output_addressed_constants has been done on EXP already. 4652 4653 Generate at least SIZE bytes of assembler data, padding at the end 4654 with zeros if necessary. SIZE must always be specified. The returned 4655 value is the actual number of bytes of assembler data generated, which 4656 may be bigger than SIZE if the object contains a variable length field. 4657 4658 SIZE is important for structure constructors, 4659 since trailing members may have been omitted from the constructor. 4660 It is also important for initialization of arrays from string constants 4661 since the full length of the string constant might not be wanted. 4662 It is also needed for initialization of unions, where the initializer's 4663 type is just one member, and that may not be as long as the union. 4664 4665 There a case in which we would fail to output exactly SIZE bytes: 4666 for a structure constructor that wants to produce more than SIZE bytes. 4667 But such constructors will never be generated for any possible input. 4668 4669 ALIGN is the alignment of the data in bits. */ 4670 4671static unsigned HOST_WIDE_INT 4672output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) 4673{ 4674 enum tree_code code; 4675 unsigned HOST_WIDE_INT thissize; 4676 4677 if (size == 0 || flag_syntax_only) 4678 return size; 4679 4680 /* See if we're trying to initialize a pointer in a non-default mode 4681 to the address of some declaration somewhere. If the target says 4682 the mode is valid for pointers, assume the target has a way of 4683 resolving it. */ 4684 if (TREE_CODE (exp) == NOP_EXPR 4685 && POINTER_TYPE_P (TREE_TYPE (exp)) 4686 && targetm.addr_space.valid_pointer_mode 4687 (TYPE_MODE (TREE_TYPE (exp)), 4688 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))))) 4689 { 4690 tree saved_type = TREE_TYPE (exp); 4691 4692 /* Peel off any intermediate conversions-to-pointer for valid 4693 pointer modes. */ 4694 while (TREE_CODE (exp) == NOP_EXPR 4695 && POINTER_TYPE_P (TREE_TYPE (exp)) 4696 && targetm.addr_space.valid_pointer_mode 4697 (TYPE_MODE (TREE_TYPE (exp)), 4698 TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp))))) 4699 exp = TREE_OPERAND (exp, 0); 4700 4701 /* If what we're left with is the address of something, we can 4702 convert the address to the final type and output it that 4703 way. */ 4704 if (TREE_CODE (exp) == ADDR_EXPR) 4705 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0)); 4706 /* Likewise for constant ints. */ 4707 else if (TREE_CODE (exp) == INTEGER_CST) 4708 exp = wide_int_to_tree (saved_type, exp); 4709 4710 } 4711 4712 /* Eliminate any conversions since we'll be outputting the underlying 4713 constant. */ 4714 while (CONVERT_EXPR_P (exp) 4715 || TREE_CODE (exp) == NON_LVALUE_EXPR 4716 || TREE_CODE (exp) == VIEW_CONVERT_EXPR) 4717 { 4718 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp)); 4719 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0))); 4720 4721 /* Make sure eliminating the conversion is really a no-op, except with 4722 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and 4723 union types to allow for Ada unchecked unions. */ 4724 if (type_size > op_size 4725 && TREE_CODE (exp) != VIEW_CONVERT_EXPR 4726 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE) 4727 /* Keep the conversion. */ 4728 break; 4729 else 4730 exp = TREE_OPERAND (exp, 0); 4731 } 4732 4733 code = TREE_CODE (TREE_TYPE (exp)); 4734 thissize = int_size_in_bytes (TREE_TYPE (exp)); 4735 4736 /* Allow a constructor with no elements for any data type. 4737 This means to fill the space with zeros. */ 4738 if (TREE_CODE (exp) == CONSTRUCTOR 4739 && vec_safe_is_empty (CONSTRUCTOR_ELTS (exp))) 4740 { 4741 assemble_zeros (size); 4742 return size; 4743 } 4744 4745 if (TREE_CODE (exp) == FDESC_EXPR) 4746 { 4747#ifdef ASM_OUTPUT_FDESC 4748 HOST_WIDE_INT part = tree_to_shwi (TREE_OPERAND (exp, 1)); 4749 tree decl = TREE_OPERAND (exp, 0); 4750 ASM_OUTPUT_FDESC (asm_out_file, decl, part); 4751#else 4752 gcc_unreachable (); 4753#endif 4754 return size; 4755 } 4756 4757 /* Now output the underlying data. If we've handling the padding, return. 4758 Otherwise, break and ensure SIZE is the size written. */ 4759 switch (code) 4760 { 4761 case BOOLEAN_TYPE: 4762 case INTEGER_TYPE: 4763 case ENUMERAL_TYPE: 4764 case POINTER_TYPE: 4765 case REFERENCE_TYPE: 4766 case OFFSET_TYPE: 4767 case FIXED_POINT_TYPE: 4768 case POINTER_BOUNDS_TYPE: 4769 case NULLPTR_TYPE: 4770 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode, 4771 EXPAND_INITIALIZER), 4772 MIN (size, thissize), align, 0)) 4773 error ("initializer for integer/fixed-point value is too complicated"); 4774 break; 4775 4776 case REAL_TYPE: 4777 if (TREE_CODE (exp) != REAL_CST) 4778 error ("initializer for floating value is not a floating constant"); 4779 else 4780 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align); 4781 break; 4782 4783 case COMPLEX_TYPE: 4784 output_constant (TREE_REALPART (exp), thissize / 2, align); 4785 output_constant (TREE_IMAGPART (exp), thissize / 2, 4786 min_align (align, BITS_PER_UNIT * (thissize / 2))); 4787 break; 4788 4789 case ARRAY_TYPE: 4790 case VECTOR_TYPE: 4791 switch (TREE_CODE (exp)) 4792 { 4793 case CONSTRUCTOR: 4794 return output_constructor (exp, size, align, NULL); 4795 case STRING_CST: 4796 thissize 4797 = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp), size); 4798 assemble_string (TREE_STRING_POINTER (exp), thissize); 4799 break; 4800 case VECTOR_CST: 4801 { 4802 machine_mode inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp))); 4803 unsigned int nalign = MIN (align, GET_MODE_ALIGNMENT (inner)); 4804 int elt_size = GET_MODE_SIZE (inner); 4805 output_constant (VECTOR_CST_ELT (exp, 0), elt_size, align); 4806 thissize = elt_size; 4807 for (unsigned int i = 1; i < VECTOR_CST_NELTS (exp); i++) 4808 { 4809 output_constant (VECTOR_CST_ELT (exp, i), elt_size, nalign); 4810 thissize += elt_size; 4811 } 4812 break; 4813 } 4814 default: 4815 gcc_unreachable (); 4816 } 4817 break; 4818 4819 case RECORD_TYPE: 4820 case UNION_TYPE: 4821 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR); 4822 return output_constructor (exp, size, align, NULL); 4823 4824 case ERROR_MARK: 4825 return 0; 4826 4827 default: 4828 gcc_unreachable (); 4829 } 4830 4831 if (size > thissize) 4832 assemble_zeros (size - thissize); 4833 4834 return size; 4835} 4836 4837 4838/* Subroutine of output_constructor, used for computing the size of 4839 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array 4840 type with an unspecified upper bound. */ 4841 4842static unsigned HOST_WIDE_INT 4843array_size_for_constructor (tree val) 4844{ 4845 tree max_index; 4846 unsigned HOST_WIDE_INT cnt; 4847 tree index, value, tmp; 4848 offset_int i; 4849 4850 /* This code used to attempt to handle string constants that are not 4851 arrays of single-bytes, but nothing else does, so there's no point in 4852 doing it here. */ 4853 if (TREE_CODE (val) == STRING_CST) 4854 return TREE_STRING_LENGTH (val); 4855 4856 max_index = NULL_TREE; 4857 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value) 4858 { 4859 if (TREE_CODE (index) == RANGE_EXPR) 4860 index = TREE_OPERAND (index, 1); 4861 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index)) 4862 max_index = index; 4863 } 4864 4865 if (max_index == NULL_TREE) 4866 return 0; 4867 4868 /* Compute the total number of array elements. */ 4869 tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val))); 4870 i = wi::to_offset (max_index) - wi::to_offset (tmp) + 1; 4871 4872 /* Multiply by the array element unit size to find number of bytes. */ 4873 i *= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val)))); 4874 4875 gcc_assert (wi::fits_uhwi_p (i)); 4876 return i.to_uhwi (); 4877} 4878 4879/* Other datastructures + helpers for output_constructor. */ 4880 4881/* output_constructor local state to support interaction with helpers. */ 4882 4883typedef struct { 4884 4885 /* Received arguments. */ 4886 tree exp; /* Constructor expression. */ 4887 tree type; /* Type of constructor expression. */ 4888 unsigned HOST_WIDE_INT size; /* # bytes to output - pad if necessary. */ 4889 unsigned int align; /* Known initial alignment. */ 4890 tree min_index; /* Lower bound if specified for an array. */ 4891 4892 /* Output processing state. */ 4893 HOST_WIDE_INT total_bytes; /* # bytes output so far / current position. */ 4894 int byte; /* Part of a bitfield byte yet to be output. */ 4895 int last_relative_index; /* Implicit or explicit index of the last 4896 array element output within a bitfield. */ 4897 bool byte_buffer_in_use; /* Whether BYTE is in use. */ 4898 4899 /* Current element. */ 4900 tree field; /* Current field decl in a record. */ 4901 tree val; /* Current element value. */ 4902 tree index; /* Current element index. */ 4903 4904} oc_local_state; 4905 4906/* Helper for output_constructor. From the current LOCAL state, output a 4907 RANGE_EXPR element. */ 4908 4909static void 4910output_constructor_array_range (oc_local_state *local) 4911{ 4912 unsigned HOST_WIDE_INT fieldsize 4913 = int_size_in_bytes (TREE_TYPE (local->type)); 4914 4915 HOST_WIDE_INT lo_index 4916 = tree_to_shwi (TREE_OPERAND (local->index, 0)); 4917 HOST_WIDE_INT hi_index 4918 = tree_to_shwi (TREE_OPERAND (local->index, 1)); 4919 HOST_WIDE_INT index; 4920 4921 unsigned int align2 4922 = min_align (local->align, fieldsize * BITS_PER_UNIT); 4923 4924 for (index = lo_index; index <= hi_index; index++) 4925 { 4926 /* Output the element's initial value. */ 4927 if (local->val == NULL_TREE) 4928 assemble_zeros (fieldsize); 4929 else 4930 fieldsize = output_constant (local->val, fieldsize, align2); 4931 4932 /* Count its size. */ 4933 local->total_bytes += fieldsize; 4934 } 4935} 4936 4937/* Helper for output_constructor. From the current LOCAL state, output a 4938 field element that is not true bitfield or part of an outer one. */ 4939 4940static void 4941output_constructor_regular_field (oc_local_state *local) 4942{ 4943 /* Field size and position. Since this structure is static, we know the 4944 positions are constant. */ 4945 unsigned HOST_WIDE_INT fieldsize; 4946 HOST_WIDE_INT fieldpos; 4947 4948 unsigned int align2; 4949 4950 /* Output any buffered-up bit-fields preceding this element. */ 4951 if (local->byte_buffer_in_use) 4952 { 4953 assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1); 4954 local->total_bytes++; 4955 local->byte_buffer_in_use = false; 4956 } 4957 4958 if (local->index != NULL_TREE) 4959 { 4960 /* Perform the index calculation in modulo arithmetic but 4961 sign-extend the result because Ada has negative DECL_FIELD_OFFSETs 4962 but we are using an unsigned sizetype. */ 4963 unsigned prec = TYPE_PRECISION (sizetype); 4964 offset_int idx = wi::sext (wi::to_offset (local->index) 4965 - wi::to_offset (local->min_index), prec); 4966 fieldpos = (idx * wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (local->val)))) 4967 .to_short_addr (); 4968 } 4969 else if (local->field != NULL_TREE) 4970 fieldpos = int_byte_position (local->field); 4971 else 4972 fieldpos = 0; 4973 4974 /* Advance to offset of this element. 4975 Note no alignment needed in an array, since that is guaranteed 4976 if each element has the proper size. */ 4977 if (local->field != NULL_TREE || local->index != NULL_TREE) 4978 { 4979 if (fieldpos > local->total_bytes) 4980 { 4981 assemble_zeros (fieldpos - local->total_bytes); 4982 local->total_bytes = fieldpos; 4983 } 4984 else 4985 /* Must not go backwards. */ 4986 gcc_assert (fieldpos == local->total_bytes); 4987 } 4988 4989 /* Find the alignment of this element. */ 4990 align2 = min_align (local->align, BITS_PER_UNIT * fieldpos); 4991 4992 /* Determine size this element should occupy. */ 4993 if (local->field) 4994 { 4995 fieldsize = 0; 4996 4997 /* If this is an array with an unspecified upper bound, 4998 the initializer determines the size. */ 4999 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL, 5000 but we cannot do this until the deprecated support for 5001 initializing zero-length array members is removed. */ 5002 if (TREE_CODE (TREE_TYPE (local->field)) == ARRAY_TYPE 5003 && TYPE_DOMAIN (TREE_TYPE (local->field)) 5004 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (local->field)))) 5005 { 5006 fieldsize = array_size_for_constructor (local->val); 5007 /* Given a non-empty initialization, this field had 5008 better be last. */ 5009 gcc_assert (!fieldsize || !DECL_CHAIN (local->field)); 5010 } 5011 else 5012 fieldsize = tree_to_uhwi (DECL_SIZE_UNIT (local->field)); 5013 } 5014 else 5015 fieldsize = int_size_in_bytes (TREE_TYPE (local->type)); 5016 5017 /* Output the element's initial value. */ 5018 if (local->val == NULL_TREE) 5019 assemble_zeros (fieldsize); 5020 else 5021 fieldsize = output_constant (local->val, fieldsize, align2); 5022 5023 /* Count its size. */ 5024 local->total_bytes += fieldsize; 5025} 5026 5027/* Helper for output_constructor. From the LOCAL state, output an element 5028 that is a true bitfield or part of an outer one. BIT_OFFSET is the offset 5029 from the start of a possibly ongoing outer byte buffer. */ 5030 5031static void 5032output_constructor_bitfield (oc_local_state *local, unsigned int bit_offset) 5033{ 5034 /* Bit size of this element. */ 5035 HOST_WIDE_INT ebitsize 5036 = (local->field 5037 ? tree_to_uhwi (DECL_SIZE (local->field)) 5038 : tree_to_uhwi (TYPE_SIZE (TREE_TYPE (local->type)))); 5039 5040 /* Relative index of this element if this is an array component. */ 5041 HOST_WIDE_INT relative_index 5042 = (!local->field 5043 ? (local->index 5044 ? (tree_to_shwi (local->index) 5045 - tree_to_shwi (local->min_index)) 5046 : local->last_relative_index + 1) 5047 : 0); 5048 5049 /* Bit position of this element from the start of the containing 5050 constructor. */ 5051 HOST_WIDE_INT constructor_relative_ebitpos 5052 = (local->field 5053 ? int_bit_position (local->field) 5054 : ebitsize * relative_index); 5055 5056 /* Bit position of this element from the start of a possibly ongoing 5057 outer byte buffer. */ 5058 HOST_WIDE_INT byte_relative_ebitpos 5059 = bit_offset + constructor_relative_ebitpos; 5060 5061 /* From the start of a possibly ongoing outer byte buffer, offsets to 5062 the first bit of this element and to the first bit past the end of 5063 this element. */ 5064 HOST_WIDE_INT next_offset = byte_relative_ebitpos; 5065 HOST_WIDE_INT end_offset = byte_relative_ebitpos + ebitsize; 5066 5067 local->last_relative_index = relative_index; 5068 5069 if (local->val == NULL_TREE) 5070 local->val = integer_zero_node; 5071 5072 while (TREE_CODE (local->val) == VIEW_CONVERT_EXPR 5073 || TREE_CODE (local->val) == NON_LVALUE_EXPR) 5074 local->val = TREE_OPERAND (local->val, 0); 5075 5076 if (TREE_CODE (local->val) != INTEGER_CST 5077 && TREE_CODE (local->val) != CONSTRUCTOR) 5078 { 5079 error ("invalid initial value for member %qE", DECL_NAME (local->field)); 5080 return; 5081 } 5082 5083 /* If this field does not start in this (or next) byte, skip some bytes. */ 5084 if (next_offset / BITS_PER_UNIT != local->total_bytes) 5085 { 5086 /* Output remnant of any bit field in previous bytes. */ 5087 if (local->byte_buffer_in_use) 5088 { 5089 assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1); 5090 local->total_bytes++; 5091 local->byte_buffer_in_use = false; 5092 } 5093 5094 /* If still not at proper byte, advance to there. */ 5095 if (next_offset / BITS_PER_UNIT != local->total_bytes) 5096 { 5097 gcc_assert (next_offset / BITS_PER_UNIT >= local->total_bytes); 5098 assemble_zeros (next_offset / BITS_PER_UNIT - local->total_bytes); 5099 local->total_bytes = next_offset / BITS_PER_UNIT; 5100 } 5101 } 5102 5103 /* Set up the buffer if necessary. */ 5104 if (!local->byte_buffer_in_use) 5105 { 5106 local->byte = 0; 5107 if (ebitsize > 0) 5108 local->byte_buffer_in_use = true; 5109 } 5110 5111 /* If this is nested constructor, recurse passing the bit offset and the 5112 pending data, then retrieve the new pending data afterwards. */ 5113 if (TREE_CODE (local->val) == CONSTRUCTOR) 5114 { 5115 oc_outer_state temp_state; 5116 temp_state.bit_offset = next_offset % BITS_PER_UNIT; 5117 temp_state.byte = local->byte; 5118 local->total_bytes 5119 += output_constructor (local->val, 0, 0, &temp_state); 5120 local->byte = temp_state.byte; 5121 return; 5122 } 5123 5124 /* Otherwise, we must split the element into pieces that fall within 5125 separate bytes, and combine each byte with previous or following 5126 bit-fields. */ 5127 while (next_offset < end_offset) 5128 { 5129 int this_time; 5130 int shift; 5131 HOST_WIDE_INT value; 5132 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT; 5133 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT; 5134 5135 /* Advance from byte to byte within this element when necessary. */ 5136 while (next_byte != local->total_bytes) 5137 { 5138 assemble_integer (GEN_INT (local->byte), 1, BITS_PER_UNIT, 1); 5139 local->total_bytes++; 5140 local->byte = 0; 5141 } 5142 5143 /* Number of bits we can process at once (all part of the same byte). */ 5144 this_time = MIN (end_offset - next_offset, BITS_PER_UNIT - next_bit); 5145 if (BYTES_BIG_ENDIAN) 5146 { 5147 /* On big-endian machine, take the most significant bits (of the 5148 bits that are significant) first and put them into bytes from 5149 the most significant end. */ 5150 shift = end_offset - next_offset - this_time; 5151 5152 /* Don't try to take a bunch of bits that cross 5153 the word boundary in the INTEGER_CST. We can 5154 only select bits from one element. */ 5155 if ((shift / HOST_BITS_PER_WIDE_INT) 5156 != ((shift + this_time - 1) / HOST_BITS_PER_WIDE_INT)) 5157 { 5158 const int end = shift + this_time - 1; 5159 shift = end & -HOST_BITS_PER_WIDE_INT; 5160 this_time = end - shift + 1; 5161 } 5162 5163 /* Now get the bits from the appropriate constant word. */ 5164 value = TREE_INT_CST_ELT (local->val, shift / HOST_BITS_PER_WIDE_INT); 5165 shift = shift & (HOST_BITS_PER_WIDE_INT - 1); 5166 5167 /* Get the result. This works only when: 5168 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */ 5169 local->byte |= (((value >> shift) 5170 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1)) 5171 << (BITS_PER_UNIT - this_time - next_bit)); 5172 } 5173 else 5174 { 5175 /* On little-endian machines, take the least significant bits of 5176 the value first and pack them starting at the least significant 5177 bits of the bytes. */ 5178 shift = next_offset - byte_relative_ebitpos; 5179 5180 /* Don't try to take a bunch of bits that cross 5181 the word boundary in the INTEGER_CST. We can 5182 only select bits from one element. */ 5183 if ((shift / HOST_BITS_PER_WIDE_INT) 5184 != ((shift + this_time - 1) / HOST_BITS_PER_WIDE_INT)) 5185 this_time 5186 = HOST_BITS_PER_WIDE_INT - (shift & (HOST_BITS_PER_WIDE_INT - 1)); 5187 5188 /* Now get the bits from the appropriate constant word. */ 5189 value = TREE_INT_CST_ELT (local->val, shift / HOST_BITS_PER_WIDE_INT); 5190 shift = shift & (HOST_BITS_PER_WIDE_INT - 1); 5191 5192 /* Get the result. This works only when: 5193 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */ 5194 local->byte |= (((value >> shift) 5195 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1)) 5196 << next_bit); 5197 } 5198 5199 next_offset += this_time; 5200 local->byte_buffer_in_use = true; 5201 } 5202} 5203 5204/* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants). 5205 Generate at least SIZE bytes, padding if necessary. OUTER designates the 5206 caller output state of relevance in recursive invocations. */ 5207 5208static unsigned HOST_WIDE_INT 5209output_constructor (tree exp, unsigned HOST_WIDE_INT size, 5210 unsigned int align, oc_outer_state *outer) 5211{ 5212 unsigned HOST_WIDE_INT cnt; 5213 constructor_elt *ce; 5214 5215 oc_local_state local; 5216 5217 /* Setup our local state to communicate with helpers. */ 5218 local.exp = exp; 5219 local.type = TREE_TYPE (exp); 5220 local.size = size; 5221 local.align = align; 5222 if (TREE_CODE (local.type) == ARRAY_TYPE && TYPE_DOMAIN (local.type)) 5223 local.min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (local.type)); 5224 else 5225 local.min_index = NULL_TREE; 5226 5227 local.total_bytes = 0; 5228 local.byte_buffer_in_use = outer != NULL; 5229 local.byte = outer ? outer->byte : 0; 5230 local.last_relative_index = -1; 5231 5232 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT); 5233 5234 /* As CE goes through the elements of the constant, FIELD goes through the 5235 structure fields if the constant is a structure. If the constant is a 5236 union, we override this by getting the field from the TREE_LIST element. 5237 But the constant could also be an array. Then FIELD is zero. 5238 5239 There is always a maximum of one element in the chain LINK for unions 5240 (even if the initializer in a source program incorrectly contains 5241 more one). */ 5242 5243 if (TREE_CODE (local.type) == RECORD_TYPE) 5244 local.field = TYPE_FIELDS (local.type); 5245 else 5246 local.field = NULL_TREE; 5247 5248 for (cnt = 0; 5249 vec_safe_iterate (CONSTRUCTOR_ELTS (exp), cnt, &ce); 5250 cnt++, local.field = local.field ? DECL_CHAIN (local.field) : 0) 5251 { 5252 local.val = ce->value; 5253 local.index = NULL_TREE; 5254 5255 /* The element in a union constructor specifies the proper field 5256 or index. */ 5257 if (RECORD_OR_UNION_TYPE_P (local.type) && ce->index != NULL_TREE) 5258 local.field = ce->index; 5259 5260 else if (TREE_CODE (local.type) == ARRAY_TYPE) 5261 local.index = ce->index; 5262 5263 if (local.field && flag_verbose_asm) 5264 fprintf (asm_out_file, "%s %s:\n", 5265 ASM_COMMENT_START, 5266 DECL_NAME (local.field) 5267 ? IDENTIFIER_POINTER (DECL_NAME (local.field)) 5268 : "<anonymous>"); 5269 5270 /* Eliminate the marker that makes a cast not be an lvalue. */ 5271 if (local.val != NULL_TREE) 5272 STRIP_NOPS (local.val); 5273 5274 /* Output the current element, using the appropriate helper ... */ 5275 5276 /* For an array slice not part of an outer bitfield. */ 5277 if (!outer 5278 && local.index != NULL_TREE 5279 && TREE_CODE (local.index) == RANGE_EXPR) 5280 output_constructor_array_range (&local); 5281 5282 /* For a field that is neither a true bitfield nor part of an outer one, 5283 known to be at least byte aligned and multiple-of-bytes long. */ 5284 else if (!outer 5285 && (local.field == NULL_TREE 5286 || !CONSTRUCTOR_BITFIELD_P (local.field))) 5287 output_constructor_regular_field (&local); 5288 5289 /* For a true bitfield or part of an outer one. Only INTEGER_CSTs are 5290 supported for scalar fields, so we may need to convert first. */ 5291 else 5292 { 5293 if (TREE_CODE (local.val) == REAL_CST) 5294 local.val 5295 = fold_unary (VIEW_CONVERT_EXPR, 5296 build_nonstandard_integer_type 5297 (TYPE_PRECISION (TREE_TYPE (local.val)), 0), 5298 local.val); 5299 output_constructor_bitfield (&local, outer ? outer->bit_offset : 0); 5300 } 5301 } 5302 5303 /* If we are not at toplevel, save the pending data for our caller. 5304 Otherwise output the pending data and padding zeros as needed. */ 5305 if (outer) 5306 outer->byte = local.byte; 5307 else 5308 { 5309 if (local.byte_buffer_in_use) 5310 { 5311 assemble_integer (GEN_INT (local.byte), 1, BITS_PER_UNIT, 1); 5312 local.total_bytes++; 5313 } 5314 5315 if ((unsigned HOST_WIDE_INT)local.total_bytes < local.size) 5316 { 5317 assemble_zeros (local.size - local.total_bytes); 5318 local.total_bytes = local.size; 5319 } 5320 } 5321 5322 return local.total_bytes; 5323} 5324 5325/* Mark DECL as weak. */ 5326 5327static void 5328mark_weak (tree decl) 5329{ 5330 if (DECL_WEAK (decl)) 5331 return; 5332 5333 struct symtab_node *n = symtab_node::get (decl); 5334 if (n && n->refuse_visibility_changes) 5335 error ("%+D declared weak after being used", decl); 5336 DECL_WEAK (decl) = 1; 5337 5338 if (DECL_RTL_SET_P (decl) 5339 && MEM_P (DECL_RTL (decl)) 5340 && XEXP (DECL_RTL (decl), 0) 5341 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF) 5342 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1; 5343} 5344 5345/* Merge weak status between NEWDECL and OLDDECL. */ 5346 5347void 5348merge_weak (tree newdecl, tree olddecl) 5349{ 5350 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl)) 5351 { 5352 if (DECL_WEAK (newdecl) && TARGET_SUPPORTS_WEAK) 5353 { 5354 tree *pwd; 5355 /* We put the NEWDECL on the weak_decls list at some point 5356 and OLDDECL as well. Keep just OLDDECL on the list. */ 5357 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd)) 5358 if (TREE_VALUE (*pwd) == newdecl) 5359 { 5360 *pwd = TREE_CHAIN (*pwd); 5361 break; 5362 } 5363 } 5364 return; 5365 } 5366 5367 if (DECL_WEAK (newdecl)) 5368 { 5369 tree wd; 5370 5371 /* NEWDECL is weak, but OLDDECL is not. */ 5372 5373 /* If we already output the OLDDECL, we're in trouble; we can't 5374 go back and make it weak. This should never happen in 5375 unit-at-a-time compilation. */ 5376 gcc_assert (!TREE_ASM_WRITTEN (olddecl)); 5377 5378 /* If we've already generated rtl referencing OLDDECL, we may 5379 have done so in a way that will not function properly with 5380 a weak symbol. Again in unit-at-a-time this should be 5381 impossible. */ 5382 gcc_assert (!TREE_USED (olddecl) 5383 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl))); 5384 5385 if (TARGET_SUPPORTS_WEAK) 5386 { 5387 /* We put the NEWDECL on the weak_decls list at some point. 5388 Replace it with the OLDDECL. */ 5389 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd)) 5390 if (TREE_VALUE (wd) == newdecl) 5391 { 5392 TREE_VALUE (wd) = olddecl; 5393 break; 5394 } 5395 /* We may not find the entry on the list. If NEWDECL is a 5396 weak alias, then we will have already called 5397 globalize_decl to remove the entry; in that case, we do 5398 not need to do anything. */ 5399 } 5400 5401 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */ 5402 mark_weak (olddecl); 5403 } 5404 else 5405 /* OLDDECL was weak, but NEWDECL was not explicitly marked as 5406 weak. Just update NEWDECL to indicate that it's weak too. */ 5407 mark_weak (newdecl); 5408} 5409 5410/* Declare DECL to be a weak symbol. */ 5411 5412void 5413declare_weak (tree decl) 5414{ 5415 gcc_assert (TREE_CODE (decl) != FUNCTION_DECL || !TREE_ASM_WRITTEN (decl)); 5416 if (! TREE_PUBLIC (decl)) 5417 error ("weak declaration of %q+D must be public", decl); 5418 else if (!TARGET_SUPPORTS_WEAK) 5419 warning (0, "weak declaration of %q+D not supported", decl); 5420 5421 mark_weak (decl); 5422 if (!lookup_attribute ("weak", DECL_ATTRIBUTES (decl))) 5423 DECL_ATTRIBUTES (decl) 5424 = tree_cons (get_identifier ("weak"), NULL, DECL_ATTRIBUTES (decl)); 5425} 5426 5427static void 5428weak_finish_1 (tree decl) 5429{ 5430#if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL) 5431 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 5432#endif 5433 5434 if (! TREE_USED (decl)) 5435 return; 5436 5437#ifdef ASM_WEAKEN_DECL 5438 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL); 5439#else 5440#ifdef ASM_WEAKEN_LABEL 5441 ASM_WEAKEN_LABEL (asm_out_file, name); 5442#else 5443#ifdef ASM_OUTPUT_WEAK_ALIAS 5444 { 5445 static bool warn_once = 0; 5446 if (! warn_once) 5447 { 5448 warning (0, "only weak aliases are supported in this configuration"); 5449 warn_once = 1; 5450 } 5451 return; 5452 } 5453#endif 5454#endif 5455#endif 5456} 5457 5458/* Fiven an assembly name, find the decl it is associated with. */ 5459static tree 5460find_decl (tree target) 5461{ 5462 symtab_node *node = symtab_node::get_for_asmname (target); 5463 if (node) 5464 return node->decl; 5465 return NULL_TREE; 5466} 5467 5468/* This TREE_LIST contains weakref targets. */ 5469 5470static GTY(()) tree weakref_targets; 5471 5472/* Emit any pending weak declarations. */ 5473 5474void 5475weak_finish (void) 5476{ 5477 tree t; 5478 5479 for (t = weakref_targets; t; t = TREE_CHAIN (t)) 5480 { 5481 tree alias_decl = TREE_PURPOSE (t); 5482 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t)); 5483 5484 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl))) 5485 /* Remove alias_decl from the weak list, but leave entries for 5486 the target alone. */ 5487 target = NULL_TREE; 5488#ifndef ASM_OUTPUT_WEAKREF 5489 else if (! TREE_SYMBOL_REFERENCED (target)) 5490 { 5491 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not 5492 defined, otherwise we and weak_finish_1 would use 5493 different macros. */ 5494# if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL 5495 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target)); 5496# else 5497 tree decl = find_decl (target); 5498 5499 if (! decl) 5500 { 5501 decl = build_decl (DECL_SOURCE_LOCATION (alias_decl), 5502 TREE_CODE (alias_decl), target, 5503 TREE_TYPE (alias_decl)); 5504 5505 DECL_EXTERNAL (decl) = 1; 5506 TREE_PUBLIC (decl) = 1; 5507 DECL_ARTIFICIAL (decl) = 1; 5508 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl); 5509 TREE_USED (decl) = 1; 5510 } 5511 5512 weak_finish_1 (decl); 5513# endif 5514 } 5515#endif 5516 5517 { 5518 tree *p; 5519 tree t2; 5520 5521 /* Remove the alias and the target from the pending weak list 5522 so that we do not emit any .weak directives for the former, 5523 nor multiple .weak directives for the latter. */ 5524 for (p = &weak_decls; (t2 = *p) ; ) 5525 { 5526 if (TREE_VALUE (t2) == alias_decl 5527 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2))) 5528 *p = TREE_CHAIN (t2); 5529 else 5530 p = &TREE_CHAIN (t2); 5531 } 5532 5533 /* Remove other weakrefs to the same target, to speed things up. */ 5534 for (p = &TREE_CHAIN (t); (t2 = *p) ; ) 5535 { 5536 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2))) 5537 *p = TREE_CHAIN (t2); 5538 else 5539 p = &TREE_CHAIN (t2); 5540 } 5541 } 5542 } 5543 5544 for (t = weak_decls; t; t = TREE_CHAIN (t)) 5545 { 5546 tree decl = TREE_VALUE (t); 5547 5548 weak_finish_1 (decl); 5549 } 5550} 5551 5552/* Emit the assembly bits to indicate that DECL is globally visible. */ 5553 5554static void 5555globalize_decl (tree decl) 5556{ 5557 5558#if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) 5559 if (DECL_WEAK (decl)) 5560 { 5561 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); 5562 tree *p, t; 5563 5564#ifdef ASM_WEAKEN_DECL 5565 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0); 5566#else 5567 ASM_WEAKEN_LABEL (asm_out_file, name); 5568#endif 5569 5570 /* Remove this function from the pending weak list so that 5571 we do not emit multiple .weak directives for it. */ 5572 for (p = &weak_decls; (t = *p) ; ) 5573 { 5574 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t))) 5575 *p = TREE_CHAIN (t); 5576 else 5577 p = &TREE_CHAIN (t); 5578 } 5579 5580 /* Remove weakrefs to the same target from the pending weakref 5581 list, for the same reason. */ 5582 for (p = &weakref_targets; (t = *p) ; ) 5583 { 5584 if (DECL_ASSEMBLER_NAME (decl) 5585 == ultimate_transparent_alias_target (&TREE_VALUE (t))) 5586 *p = TREE_CHAIN (t); 5587 else 5588 p = &TREE_CHAIN (t); 5589 } 5590 5591 return; 5592 } 5593#endif 5594 5595 targetm.asm_out.globalize_decl_name (asm_out_file, decl); 5596} 5597 5598vec<alias_pair, va_gc> *alias_pairs; 5599 5600/* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF 5601 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose 5602 tree node is DECL to have the value of the tree node TARGET. */ 5603 5604void 5605do_assemble_alias (tree decl, tree target) 5606{ 5607 tree id; 5608 5609 /* Emulated TLS had better not get this var. */ 5610 gcc_assert (!(!targetm.have_tls 5611 && TREE_CODE (decl) == VAR_DECL 5612 && DECL_THREAD_LOCAL_P (decl))); 5613 5614 if (TREE_ASM_WRITTEN (decl)) 5615 return; 5616 5617 id = DECL_ASSEMBLER_NAME (decl); 5618 ultimate_transparent_alias_target (&id); 5619 ultimate_transparent_alias_target (&target); 5620 5621 /* We must force creation of DECL_RTL for debug info generation, even though 5622 we don't use it here. */ 5623 make_decl_rtl (decl); 5624 5625 TREE_ASM_WRITTEN (decl) = 1; 5626 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1; 5627 TREE_ASM_WRITTEN (id) = 1; 5628 5629 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 5630 { 5631 if (!TREE_SYMBOL_REFERENCED (target)) 5632 weakref_targets = tree_cons (decl, target, weakref_targets); 5633 5634#ifdef ASM_OUTPUT_WEAKREF 5635 ASM_OUTPUT_WEAKREF (asm_out_file, decl, 5636 IDENTIFIER_POINTER (id), 5637 IDENTIFIER_POINTER (target)); 5638#else 5639 if (!TARGET_SUPPORTS_WEAK) 5640 { 5641 error_at (DECL_SOURCE_LOCATION (decl), 5642 "weakref is not supported in this configuration"); 5643 return; 5644 } 5645#endif 5646 return; 5647 } 5648 5649#ifdef ASM_OUTPUT_DEF 5650 tree orig_decl = decl; 5651 5652 if (TREE_CODE (decl) == FUNCTION_DECL 5653 && cgraph_node::get (decl)->instrumentation_clone 5654 && cgraph_node::get (decl)->instrumented_version) 5655 orig_decl = cgraph_node::get (decl)->instrumented_version->decl; 5656 5657 /* Make name accessible from other files, if appropriate. */ 5658 5659 if (TREE_PUBLIC (decl) || TREE_PUBLIC (orig_decl)) 5660 { 5661 globalize_decl (decl); 5662 maybe_assemble_visibility (decl); 5663 } 5664 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))) 5665 { 5666#if defined (ASM_OUTPUT_TYPE_DIRECTIVE) 5667 if (targetm.has_ifunc_p ()) 5668 ASM_OUTPUT_TYPE_DIRECTIVE 5669 (asm_out_file, IDENTIFIER_POINTER (id), 5670 IFUNC_ASM_TYPE); 5671 else 5672#endif 5673 error_at (DECL_SOURCE_LOCATION (decl), 5674 "ifunc is not supported on this target"); 5675 } 5676 5677# ifdef ASM_OUTPUT_DEF_FROM_DECLS 5678 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target); 5679# else 5680 ASM_OUTPUT_DEF (asm_out_file, 5681 IDENTIFIER_POINTER (id), 5682 IDENTIFIER_POINTER (target)); 5683# endif 5684#elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL) 5685 { 5686 const char *name; 5687 tree *p, t; 5688 5689 name = IDENTIFIER_POINTER (id); 5690# ifdef ASM_WEAKEN_DECL 5691 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target)); 5692# else 5693 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target)); 5694# endif 5695 /* Remove this function from the pending weak list so that 5696 we do not emit multiple .weak directives for it. */ 5697 for (p = &weak_decls; (t = *p) ; ) 5698 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)) 5699 || id == DECL_ASSEMBLER_NAME (TREE_VALUE (t))) 5700 *p = TREE_CHAIN (t); 5701 else 5702 p = &TREE_CHAIN (t); 5703 5704 /* Remove weakrefs to the same target from the pending weakref 5705 list, for the same reason. */ 5706 for (p = &weakref_targets; (t = *p) ; ) 5707 { 5708 if (id == ultimate_transparent_alias_target (&TREE_VALUE (t))) 5709 *p = TREE_CHAIN (t); 5710 else 5711 p = &TREE_CHAIN (t); 5712 } 5713 } 5714#endif 5715} 5716 5717/* Emit an assembler directive to make the symbol for DECL an alias to 5718 the symbol for TARGET. */ 5719 5720void 5721assemble_alias (tree decl, tree target) 5722{ 5723 tree target_decl; 5724 5725 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 5726 { 5727 tree alias = DECL_ASSEMBLER_NAME (decl); 5728 5729 ultimate_transparent_alias_target (&target); 5730 5731 if (alias == target) 5732 error ("weakref %q+D ultimately targets itself", decl); 5733 if (TREE_PUBLIC (decl)) 5734 error ("weakref %q+D must have static linkage", decl); 5735 } 5736 else 5737 { 5738#if !defined (ASM_OUTPUT_DEF) 5739# if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL) 5740 error_at (DECL_SOURCE_LOCATION (decl), 5741 "alias definitions not supported in this configuration"); 5742 TREE_ASM_WRITTEN (decl) = 1; 5743 return; 5744# else 5745 if (!DECL_WEAK (decl)) 5746 { 5747 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))) 5748 error_at (DECL_SOURCE_LOCATION (decl), 5749 "ifunc is not supported in this configuration"); 5750 else 5751 error_at (DECL_SOURCE_LOCATION (decl), 5752 "only weak aliases are supported in this configuration"); 5753 TREE_ASM_WRITTEN (decl) = 1; 5754 return; 5755 } 5756# endif 5757#endif 5758 } 5759 TREE_USED (decl) = 1; 5760 5761 /* Allow aliases to aliases. */ 5762 if (TREE_CODE (decl) == FUNCTION_DECL) 5763 cgraph_node::get_create (decl)->alias = true; 5764 else 5765 varpool_node::get_create (decl)->alias = true; 5766 5767 /* If the target has already been emitted, we don't have to queue the 5768 alias. This saves a tad of memory. */ 5769 if (symtab->global_info_ready) 5770 target_decl = find_decl (target); 5771 else 5772 target_decl= NULL; 5773 if ((target_decl && TREE_ASM_WRITTEN (target_decl)) 5774 || symtab->state >= EXPANSION) 5775 do_assemble_alias (decl, target); 5776 else 5777 { 5778 alias_pair p = {decl, target}; 5779 vec_safe_push (alias_pairs, p); 5780 } 5781} 5782 5783/* Record and output a table of translations from original function 5784 to its transaction aware clone. Note that tm_pure functions are 5785 considered to be their own clone. */ 5786 5787struct tm_clone_hasher : ggc_cache_hasher<tree_map *> 5788{ 5789 static hashval_t hash (tree_map *m) { return tree_map_hash (m); } 5790 static bool equal (tree_map *a, tree_map *b) { return tree_map_eq (a, b); } 5791 5792 static void handle_cache_entry (tree_map *&e) 5793 { 5794 if (e != HTAB_EMPTY_ENTRY || e != HTAB_DELETED_ENTRY) 5795 { 5796 extern void gt_ggc_mx (tree_map *&); 5797 if (ggc_marked_p (e->base.from)) 5798 gt_ggc_mx (e); 5799 else 5800 e = static_cast<tree_map *> (HTAB_DELETED_ENTRY); 5801 } 5802 } 5803}; 5804 5805static GTY((cache)) 5806 hash_table<tm_clone_hasher> *tm_clone_hash; 5807 5808void 5809record_tm_clone_pair (tree o, tree n) 5810{ 5811 struct tree_map **slot, *h; 5812 5813 if (tm_clone_hash == NULL) 5814 tm_clone_hash = hash_table<tm_clone_hasher>::create_ggc (32); 5815 5816 h = ggc_alloc<tree_map> (); 5817 h->hash = htab_hash_pointer (o); 5818 h->base.from = o; 5819 h->to = n; 5820 5821 slot = tm_clone_hash->find_slot_with_hash (h, h->hash, INSERT); 5822 *slot = h; 5823} 5824 5825tree 5826get_tm_clone_pair (tree o) 5827{ 5828 if (tm_clone_hash) 5829 { 5830 struct tree_map *h, in; 5831 5832 in.base.from = o; 5833 in.hash = htab_hash_pointer (o); 5834 h = tm_clone_hash->find_with_hash (&in, in.hash); 5835 if (h) 5836 return h->to; 5837 } 5838 return NULL_TREE; 5839} 5840 5841typedef struct tm_alias_pair 5842{ 5843 unsigned int uid; 5844 tree from; 5845 tree to; 5846} tm_alias_pair; 5847 5848 5849/* Dump the actual pairs to the .tm_clone_table section. */ 5850 5851static void 5852dump_tm_clone_pairs (vec<tm_alias_pair> tm_alias_pairs) 5853{ 5854 unsigned i; 5855 tm_alias_pair *p; 5856 bool switched = false; 5857 5858 FOR_EACH_VEC_ELT (tm_alias_pairs, i, p) 5859 { 5860 tree src = p->from; 5861 tree dst = p->to; 5862 struct cgraph_node *src_n = cgraph_node::get (src); 5863 struct cgraph_node *dst_n = cgraph_node::get (dst); 5864 5865 /* The function ipa_tm_create_version() marks the clone as needed if 5866 the original function was needed. But we also mark the clone as 5867 needed if we ever called the clone indirectly through 5868 TM_GETTMCLONE. If neither of these are true, we didn't generate 5869 a clone, and we didn't call it indirectly... no sense keeping it 5870 in the clone table. */ 5871 if (!dst_n || !dst_n->definition) 5872 continue; 5873 5874 /* This covers the case where we have optimized the original 5875 function away, and only access the transactional clone. */ 5876 if (!src_n || !src_n->definition) 5877 continue; 5878 5879 if (!switched) 5880 { 5881 switch_to_section (targetm.asm_out.tm_clone_table_section ()); 5882 assemble_align (POINTER_SIZE); 5883 switched = true; 5884 } 5885 5886 assemble_integer (XEXP (DECL_RTL (src), 0), 5887 POINTER_SIZE_UNITS, POINTER_SIZE, 1); 5888 assemble_integer (XEXP (DECL_RTL (dst), 0), 5889 POINTER_SIZE_UNITS, POINTER_SIZE, 1); 5890 } 5891} 5892 5893/* Provide a default for the tm_clone_table section. */ 5894 5895section * 5896default_clone_table_section (void) 5897{ 5898 return get_named_section (NULL, ".tm_clone_table", 3); 5899} 5900 5901/* Helper comparison function for qsorting by the DECL_UID stored in 5902 alias_pair->emitted_diags. */ 5903 5904static int 5905tm_alias_pair_cmp (const void *x, const void *y) 5906{ 5907 const tm_alias_pair *p1 = (const tm_alias_pair *) x; 5908 const tm_alias_pair *p2 = (const tm_alias_pair *) y; 5909 if (p1->uid < p2->uid) 5910 return -1; 5911 if (p1->uid > p2->uid) 5912 return 1; 5913 return 0; 5914} 5915 5916void 5917finish_tm_clone_pairs (void) 5918{ 5919 vec<tm_alias_pair> tm_alias_pairs = vNULL; 5920 5921 if (tm_clone_hash == NULL) 5922 return; 5923 5924 /* We need a determenistic order for the .tm_clone_table, otherwise 5925 we will get bootstrap comparison failures, so dump the hash table 5926 to a vector, sort it, and dump the vector. */ 5927 5928 /* Dump the hashtable to a vector. */ 5929 tree_map *map; 5930 hash_table<tm_clone_hasher>::iterator iter; 5931 FOR_EACH_HASH_TABLE_ELEMENT (*tm_clone_hash, map, tree_map *, iter) 5932 { 5933 tm_alias_pair p = {DECL_UID (map->base.from), map->base.from, map->to}; 5934 tm_alias_pairs.safe_push (p); 5935 } 5936 /* Sort it. */ 5937 tm_alias_pairs.qsort (tm_alias_pair_cmp); 5938 5939 /* Dump it. */ 5940 dump_tm_clone_pairs (tm_alias_pairs); 5941 5942 tm_clone_hash->empty (); 5943 tm_clone_hash = NULL; 5944 tm_alias_pairs.release (); 5945} 5946 5947 5948/* Emit an assembler directive to set symbol for DECL visibility to 5949 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */ 5950 5951void 5952default_assemble_visibility (tree decl ATTRIBUTE_UNUSED, 5953 int vis ATTRIBUTE_UNUSED) 5954{ 5955#ifdef HAVE_GAS_HIDDEN 5956 static const char * const visibility_types[] = { 5957 NULL, "protected", "hidden", "internal" 5958 }; 5959 5960 const char *name, *type; 5961 tree id; 5962 5963 id = DECL_ASSEMBLER_NAME (decl); 5964 ultimate_transparent_alias_target (&id); 5965 name = IDENTIFIER_POINTER (id); 5966 5967 type = visibility_types[vis]; 5968 5969 fprintf (asm_out_file, "\t.%s\t", type); 5970 assemble_name (asm_out_file, name); 5971 fprintf (asm_out_file, "\n"); 5972#else 5973 if (!DECL_ARTIFICIAL (decl)) 5974 warning (OPT_Wattributes, "visibility attribute not supported " 5975 "in this configuration; ignored"); 5976#endif 5977} 5978 5979/* A helper function to call assemble_visibility when needed for a decl. */ 5980 5981int 5982maybe_assemble_visibility (tree decl) 5983{ 5984 enum symbol_visibility vis = DECL_VISIBILITY (decl); 5985 5986 if (TREE_CODE (decl) == FUNCTION_DECL 5987 && cgraph_node::get (decl) 5988 && cgraph_node::get (decl)->instrumentation_clone 5989 && cgraph_node::get (decl)->instrumented_version) 5990 vis = DECL_VISIBILITY (cgraph_node::get (decl)->instrumented_version->decl); 5991 5992 if (vis != VISIBILITY_DEFAULT) 5993 { 5994 targetm.asm_out.assemble_visibility (decl, vis); 5995 return 1; 5996 } 5997 else 5998 return 0; 5999} 6000 6001/* Returns 1 if the target configuration supports defining public symbols 6002 so that one of them will be chosen at link time instead of generating a 6003 multiply-defined symbol error, whether through the use of weak symbols or 6004 a target-specific mechanism for having duplicates discarded. */ 6005 6006int 6007supports_one_only (void) 6008{ 6009 if (SUPPORTS_ONE_ONLY) 6010 return 1; 6011 return TARGET_SUPPORTS_WEAK; 6012} 6013 6014/* Set up DECL as a public symbol that can be defined in multiple 6015 translation units without generating a linker error. */ 6016 6017void 6018make_decl_one_only (tree decl, tree comdat_group) 6019{ 6020 struct symtab_node *symbol; 6021 gcc_assert (TREE_CODE (decl) == VAR_DECL 6022 || TREE_CODE (decl) == FUNCTION_DECL); 6023 6024 TREE_PUBLIC (decl) = 1; 6025 6026 if (TREE_CODE (decl) == VAR_DECL) 6027 symbol = varpool_node::get_create (decl); 6028 else 6029 symbol = cgraph_node::get_create (decl); 6030 6031 if (SUPPORTS_ONE_ONLY) 6032 { 6033#ifdef MAKE_DECL_ONE_ONLY 6034 MAKE_DECL_ONE_ONLY (decl); 6035#endif 6036 symbol->set_comdat_group (comdat_group); 6037 } 6038 else if (TREE_CODE (decl) == VAR_DECL 6039 && (DECL_INITIAL (decl) == 0 6040 || (!in_lto_p && DECL_INITIAL (decl) == error_mark_node))) 6041 DECL_COMMON (decl) = 1; 6042 else 6043 { 6044 gcc_assert (TARGET_SUPPORTS_WEAK); 6045 DECL_WEAK (decl) = 1; 6046 } 6047} 6048 6049void 6050init_varasm_once (void) 6051{ 6052 section_htab = hash_table<section_hasher>::create_ggc (31); 6053 object_block_htab = hash_table<object_block_hasher>::create_ggc (31); 6054 const_desc_htab = hash_table<tree_descriptor_hasher>::create_ggc (1009); 6055 6056 shared_constant_pool = create_constant_pool (); 6057 6058#ifdef TEXT_SECTION_ASM_OP 6059 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op, 6060 TEXT_SECTION_ASM_OP); 6061#endif 6062 6063#ifdef DATA_SECTION_ASM_OP 6064 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op, 6065 DATA_SECTION_ASM_OP); 6066#endif 6067 6068#ifdef SDATA_SECTION_ASM_OP 6069 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op, 6070 SDATA_SECTION_ASM_OP); 6071#endif 6072 6073#ifdef READONLY_DATA_SECTION_ASM_OP 6074 readonly_data_section = get_unnamed_section (0, output_section_asm_op, 6075 READONLY_DATA_SECTION_ASM_OP); 6076#endif 6077 6078#ifdef CTORS_SECTION_ASM_OP 6079 ctors_section = get_unnamed_section (0, output_section_asm_op, 6080 CTORS_SECTION_ASM_OP); 6081#endif 6082 6083#ifdef DTORS_SECTION_ASM_OP 6084 dtors_section = get_unnamed_section (0, output_section_asm_op, 6085 DTORS_SECTION_ASM_OP); 6086#endif 6087 6088#ifdef BSS_SECTION_ASM_OP 6089 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS, 6090 output_section_asm_op, 6091 BSS_SECTION_ASM_OP); 6092#endif 6093 6094#ifdef SBSS_SECTION_ASM_OP 6095 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS, 6096 output_section_asm_op, 6097 SBSS_SECTION_ASM_OP); 6098#endif 6099 6100 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 6101 | SECTION_COMMON, emit_tls_common); 6102 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 6103 | SECTION_COMMON, emit_local); 6104 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 6105 | SECTION_COMMON, emit_common); 6106 6107#if defined ASM_OUTPUT_ALIGNED_BSS 6108 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS, 6109 emit_bss); 6110#endif 6111 6112 targetm.asm_out.init_sections (); 6113 6114 if (readonly_data_section == NULL) 6115 readonly_data_section = text_section; 6116 6117#ifdef ASM_OUTPUT_EXTERNAL 6118 pending_assemble_externals_set = new hash_set<tree>; 6119#endif 6120} 6121 6122enum tls_model 6123decl_default_tls_model (const_tree decl) 6124{ 6125 enum tls_model kind; 6126 bool is_local; 6127 6128 is_local = targetm.binds_local_p (decl); 6129 if (!flag_shlib) 6130 { 6131 if (is_local) 6132 kind = TLS_MODEL_LOCAL_EXEC; 6133 else 6134 kind = TLS_MODEL_INITIAL_EXEC; 6135 } 6136 6137 /* Local dynamic is inefficient when we're not combining the 6138 parts of the address. */ 6139 else if (optimize && is_local) 6140 kind = TLS_MODEL_LOCAL_DYNAMIC; 6141 else 6142 kind = TLS_MODEL_GLOBAL_DYNAMIC; 6143 if (kind < flag_tls_default) 6144 kind = flag_tls_default; 6145 6146 return kind; 6147} 6148 6149/* Select a set of attributes for section NAME based on the properties 6150 of DECL and whether or not RELOC indicates that DECL's initializer 6151 might contain runtime relocations. 6152 6153 We make the section read-only and executable for a function decl, 6154 read-only for a const data decl, and writable for a non-const data decl. */ 6155 6156unsigned int 6157default_section_type_flags (tree decl, const char *name, int reloc) 6158{ 6159 unsigned int flags; 6160 6161 if (decl && TREE_CODE (decl) == FUNCTION_DECL) 6162 flags = SECTION_CODE; 6163 else if (decl) 6164 { 6165 enum section_category category 6166 = categorize_decl_for_section (decl, reloc); 6167 if (decl_readonly_section_1 (category)) 6168 flags = 0; 6169 else if (category == SECCAT_DATA_REL_RO 6170 || category == SECCAT_DATA_REL_RO_LOCAL) 6171 flags = SECTION_WRITE | SECTION_RELRO; 6172 else 6173 flags = SECTION_WRITE; 6174 } 6175 else 6176 { 6177 flags = SECTION_WRITE; 6178 if (strcmp (name, ".data.rel.ro") == 0 6179 || strcmp (name, ".data.rel.ro.local") == 0) 6180 flags |= SECTION_RELRO; 6181 } 6182 6183 if (decl && DECL_P (decl) && DECL_COMDAT_GROUP (decl)) 6184 flags |= SECTION_LINKONCE; 6185 6186 if (strcmp (name, ".vtable_map_vars") == 0) 6187 flags |= SECTION_LINKONCE; 6188 6189 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 6190 flags |= SECTION_TLS | SECTION_WRITE; 6191 6192 if (strcmp (name, ".bss") == 0 6193 || strncmp (name, ".bss.", 5) == 0 6194 || strncmp (name, ".gnu.linkonce.b.", 16) == 0 6195 || strcmp (name, ".persistent.bss") == 0 6196 || strcmp (name, ".sbss") == 0 6197 || strncmp (name, ".sbss.", 6) == 0 6198 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0) 6199 flags |= SECTION_BSS; 6200 6201 if (strcmp (name, ".tdata") == 0 6202 || strncmp (name, ".tdata.", 7) == 0 6203 || strncmp (name, ".gnu.linkonce.td.", 17) == 0) 6204 flags |= SECTION_TLS; 6205 6206 if (strcmp (name, ".tbss") == 0 6207 || strncmp (name, ".tbss.", 6) == 0 6208 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0) 6209 flags |= SECTION_TLS | SECTION_BSS; 6210 6211 /* These three sections have special ELF types. They are neither 6212 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't 6213 want to print a section type (@progbits or @nobits). If someone 6214 is silly enough to emit code or TLS variables to one of these 6215 sections, then don't handle them specially. */ 6216 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS)) 6217 && (strcmp (name, ".init_array") == 0 6218 || strcmp (name, ".fini_array") == 0 6219 || strcmp (name, ".preinit_array") == 0)) 6220 flags |= SECTION_NOTYPE; 6221 6222 return flags; 6223} 6224 6225/* Return true if the target supports some form of global BSS, 6226 either through bss_noswitch_section, or by selecting a BSS 6227 section in TARGET_ASM_SELECT_SECTION. */ 6228 6229bool 6230have_global_bss_p (void) 6231{ 6232 return bss_noswitch_section || targetm.have_switchable_bss_sections; 6233} 6234 6235/* Output assembly to switch to section NAME with attribute FLAGS. 6236 Four variants for common object file formats. */ 6237 6238void 6239default_no_named_section (const char *name ATTRIBUTE_UNUSED, 6240 unsigned int flags ATTRIBUTE_UNUSED, 6241 tree decl ATTRIBUTE_UNUSED) 6242{ 6243 /* Some object formats don't support named sections at all. The 6244 front-end should already have flagged this as an error. */ 6245 gcc_unreachable (); 6246} 6247 6248#ifndef TLS_SECTION_ASM_FLAG 6249#define TLS_SECTION_ASM_FLAG 'T' 6250#endif 6251 6252void 6253default_elf_asm_named_section (const char *name, unsigned int flags, 6254 tree decl ATTRIBUTE_UNUSED) 6255{ 6256 char flagchars[10], *f = flagchars; 6257 6258 /* If we have already declared this section, we can use an 6259 abbreviated form to switch back to it -- unless this section is 6260 part of a COMDAT groups, in which case GAS requires the full 6261 declaration every time. */ 6262 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 6263 && (flags & SECTION_DECLARED)) 6264 { 6265 fprintf (asm_out_file, "\t.section\t%s\n", name); 6266 return; 6267 } 6268 6269 if (!(flags & SECTION_DEBUG)) 6270 *f++ = 'a'; 6271#if defined (HAVE_GAS_SECTION_EXCLUDE) && HAVE_GAS_SECTION_EXCLUDE == 1 6272 if (flags & SECTION_EXCLUDE) 6273 *f++ = 'e'; 6274#endif 6275 if (flags & SECTION_WRITE) 6276 *f++ = 'w'; 6277 if (flags & SECTION_CODE) 6278 *f++ = 'x'; 6279 if (flags & SECTION_SMALL) 6280 *f++ = 's'; 6281 if (flags & SECTION_MERGE) 6282 *f++ = 'M'; 6283 if (flags & SECTION_STRINGS) 6284 *f++ = 'S'; 6285 if (flags & SECTION_TLS) 6286 *f++ = TLS_SECTION_ASM_FLAG; 6287 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 6288 *f++ = 'G'; 6289 *f = '\0'; 6290 6291 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars); 6292 6293 if (!(flags & SECTION_NOTYPE)) 6294 { 6295 const char *type; 6296 const char *format; 6297 6298 if (flags & SECTION_BSS) 6299 type = "nobits"; 6300 else 6301 type = "progbits"; 6302 6303 format = ",@%s"; 6304 /* On platforms that use "@" as the assembly comment character, 6305 use "%" instead. */ 6306 if (strcmp (ASM_COMMENT_START, "@") == 0) 6307 format = ",%%%s"; 6308 fprintf (asm_out_file, format, type); 6309 6310 if (flags & SECTION_ENTSIZE) 6311 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE); 6312 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 6313 { 6314 if (TREE_CODE (decl) == IDENTIFIER_NODE) 6315 fprintf (asm_out_file, ",%s,comdat", IDENTIFIER_POINTER (decl)); 6316 else 6317 fprintf (asm_out_file, ",%s,comdat", 6318 IDENTIFIER_POINTER (DECL_COMDAT_GROUP (decl))); 6319 } 6320 } 6321 6322 putc ('\n', asm_out_file); 6323} 6324 6325void 6326default_coff_asm_named_section (const char *name, unsigned int flags, 6327 tree decl ATTRIBUTE_UNUSED) 6328{ 6329 char flagchars[8], *f = flagchars; 6330 6331 if (flags & SECTION_WRITE) 6332 *f++ = 'w'; 6333 if (flags & SECTION_CODE) 6334 *f++ = 'x'; 6335 *f = '\0'; 6336 6337 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars); 6338} 6339 6340void 6341default_pe_asm_named_section (const char *name, unsigned int flags, 6342 tree decl) 6343{ 6344 default_coff_asm_named_section (name, flags, decl); 6345 6346 if (flags & SECTION_LINKONCE) 6347 { 6348 /* Functions may have been compiled at various levels of 6349 optimization so we can't use `same_size' here. 6350 Instead, have the linker pick one. */ 6351 fprintf (asm_out_file, "\t.linkonce %s\n", 6352 (flags & SECTION_CODE ? "discard" : "same_size")); 6353 } 6354} 6355 6356/* The lame default section selector. */ 6357 6358section * 6359default_select_section (tree decl, int reloc, 6360 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED) 6361{ 6362 if (DECL_P (decl)) 6363 { 6364 if (decl_readonly_section (decl, reloc)) 6365 return readonly_data_section; 6366 } 6367 else if (TREE_CODE (decl) == CONSTRUCTOR) 6368 { 6369 if (! ((flag_pic && reloc) 6370 || !TREE_READONLY (decl) 6371 || TREE_SIDE_EFFECTS (decl) 6372 || !TREE_CONSTANT (decl))) 6373 return readonly_data_section; 6374 } 6375 else if (TREE_CODE (decl) == STRING_CST) 6376 return readonly_data_section; 6377 else if (! (flag_pic && reloc)) 6378 return readonly_data_section; 6379 6380 return data_section; 6381} 6382 6383enum section_category 6384categorize_decl_for_section (const_tree decl, int reloc) 6385{ 6386 enum section_category ret; 6387 6388 if (TREE_CODE (decl) == FUNCTION_DECL) 6389 return SECCAT_TEXT; 6390 else if (TREE_CODE (decl) == STRING_CST) 6391 { 6392 if ((flag_sanitize & SANITIZE_ADDRESS) 6393 && asan_protect_global (CONST_CAST_TREE (decl))) 6394 /* or !flag_merge_constants */ 6395 return SECCAT_RODATA; 6396 else 6397 return SECCAT_RODATA_MERGE_STR; 6398 } 6399 else if (TREE_CODE (decl) == VAR_DECL) 6400 { 6401 if (bss_initializer_p (decl)) 6402 ret = SECCAT_BSS; 6403 else if (! TREE_READONLY (decl) 6404 || TREE_SIDE_EFFECTS (decl) 6405 || ! TREE_CONSTANT (DECL_INITIAL (decl))) 6406 { 6407 /* Here the reloc_rw_mask is not testing whether the section should 6408 be read-only or not, but whether the dynamic link will have to 6409 do something. If so, we wish to segregate the data in order to 6410 minimize cache misses inside the dynamic linker. */ 6411 if (reloc & targetm.asm_out.reloc_rw_mask ()) 6412 ret = reloc == 1 ? SECCAT_DATA_REL_LOCAL : SECCAT_DATA_REL; 6413 else 6414 ret = SECCAT_DATA; 6415 } 6416 else if (reloc & targetm.asm_out.reloc_rw_mask ()) 6417 ret = reloc == 1 ? SECCAT_DATA_REL_RO_LOCAL : SECCAT_DATA_REL_RO; 6418 else if (reloc || flag_merge_constants < 2 6419 || ((flag_sanitize & SANITIZE_ADDRESS) 6420 && asan_protect_global (CONST_CAST_TREE (decl)))) 6421 /* C and C++ don't allow different variables to share the same 6422 location. -fmerge-all-constants allows even that (at the 6423 expense of not conforming). */ 6424 ret = SECCAT_RODATA; 6425 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST) 6426 ret = SECCAT_RODATA_MERGE_STR_INIT; 6427 else 6428 ret = SECCAT_RODATA_MERGE_CONST; 6429 } 6430 else if (TREE_CODE (decl) == CONSTRUCTOR) 6431 { 6432 if ((reloc & targetm.asm_out.reloc_rw_mask ()) 6433 || TREE_SIDE_EFFECTS (decl) 6434 || ! TREE_CONSTANT (decl)) 6435 ret = SECCAT_DATA; 6436 else 6437 ret = SECCAT_RODATA; 6438 } 6439 else 6440 ret = SECCAT_RODATA; 6441 6442 /* There are no read-only thread-local sections. */ 6443 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 6444 { 6445 /* Note that this would be *just* SECCAT_BSS, except that there's 6446 no concept of a read-only thread-local-data section. */ 6447 if (ret == SECCAT_BSS 6448 || (flag_zero_initialized_in_bss 6449 && initializer_zerop (DECL_INITIAL (decl)))) 6450 ret = SECCAT_TBSS; 6451 else 6452 ret = SECCAT_TDATA; 6453 } 6454 6455 /* If the target uses small data sections, select it. */ 6456 else if (targetm.in_small_data_p (decl)) 6457 { 6458 if (ret == SECCAT_BSS) 6459 ret = SECCAT_SBSS; 6460 else if (targetm.have_srodata_section && ret == SECCAT_RODATA) 6461 ret = SECCAT_SRODATA; 6462 else 6463 ret = SECCAT_SDATA; 6464 } 6465 6466 return ret; 6467} 6468 6469static bool 6470decl_readonly_section_1 (enum section_category category) 6471{ 6472 switch (category) 6473 { 6474 case SECCAT_RODATA: 6475 case SECCAT_RODATA_MERGE_STR: 6476 case SECCAT_RODATA_MERGE_STR_INIT: 6477 case SECCAT_RODATA_MERGE_CONST: 6478 case SECCAT_SRODATA: 6479 return true; 6480 default: 6481 return false; 6482 } 6483} 6484 6485bool 6486decl_readonly_section (const_tree decl, int reloc) 6487{ 6488 return decl_readonly_section_1 (categorize_decl_for_section (decl, reloc)); 6489} 6490 6491/* Select a section based on the above categorization. */ 6492 6493section * 6494default_elf_select_section (tree decl, int reloc, 6495 unsigned HOST_WIDE_INT align) 6496{ 6497 const char *sname; 6498 switch (categorize_decl_for_section (decl, reloc)) 6499 { 6500 case SECCAT_TEXT: 6501 /* We're not supposed to be called on FUNCTION_DECLs. */ 6502 gcc_unreachable (); 6503 case SECCAT_RODATA: 6504 return readonly_data_section; 6505 case SECCAT_RODATA_MERGE_STR: 6506 return mergeable_string_section (decl, align, 0); 6507 case SECCAT_RODATA_MERGE_STR_INIT: 6508 return mergeable_string_section (DECL_INITIAL (decl), align, 0); 6509 case SECCAT_RODATA_MERGE_CONST: 6510 return mergeable_constant_section (DECL_MODE (decl), align, 0); 6511 case SECCAT_SRODATA: 6512 sname = ".sdata2"; 6513 break; 6514 case SECCAT_DATA: 6515 return data_section; 6516 case SECCAT_DATA_REL: 6517 sname = ".data.rel"; 6518 break; 6519 case SECCAT_DATA_REL_LOCAL: 6520 sname = ".data.rel.local"; 6521 break; 6522 case SECCAT_DATA_REL_RO: 6523 sname = ".data.rel.ro"; 6524 break; 6525 case SECCAT_DATA_REL_RO_LOCAL: 6526 sname = ".data.rel.ro.local"; 6527 break; 6528 case SECCAT_SDATA: 6529 sname = ".sdata"; 6530 break; 6531 case SECCAT_TDATA: 6532 sname = ".tdata"; 6533 break; 6534 case SECCAT_BSS: 6535 if (bss_section) 6536 return bss_section; 6537 sname = ".bss"; 6538 break; 6539 case SECCAT_SBSS: 6540 sname = ".sbss"; 6541 break; 6542 case SECCAT_TBSS: 6543 sname = ".tbss"; 6544 break; 6545 default: 6546 gcc_unreachable (); 6547 } 6548 6549 return get_named_section (decl, sname, reloc); 6550} 6551 6552/* Construct a unique section name based on the decl name and the 6553 categorization performed above. */ 6554 6555void 6556default_unique_section (tree decl, int reloc) 6557{ 6558 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */ 6559 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP; 6560 const char *prefix, *name, *linkonce; 6561 char *string; 6562 tree id; 6563 6564 switch (categorize_decl_for_section (decl, reloc)) 6565 { 6566 case SECCAT_TEXT: 6567 prefix = one_only ? ".t" : ".text"; 6568 break; 6569 case SECCAT_RODATA: 6570 case SECCAT_RODATA_MERGE_STR: 6571 case SECCAT_RODATA_MERGE_STR_INIT: 6572 case SECCAT_RODATA_MERGE_CONST: 6573 prefix = one_only ? ".r" : ".rodata"; 6574 break; 6575 case SECCAT_SRODATA: 6576 prefix = one_only ? ".s2" : ".sdata2"; 6577 break; 6578 case SECCAT_DATA: 6579 prefix = one_only ? ".d" : ".data"; 6580 break; 6581 case SECCAT_DATA_REL: 6582 prefix = one_only ? ".d.rel" : ".data.rel"; 6583 break; 6584 case SECCAT_DATA_REL_LOCAL: 6585 prefix = one_only ? ".d.rel.local" : ".data.rel.local"; 6586 break; 6587 case SECCAT_DATA_REL_RO: 6588 prefix = one_only ? ".d.rel.ro" : ".data.rel.ro"; 6589 break; 6590 case SECCAT_DATA_REL_RO_LOCAL: 6591 prefix = one_only ? ".d.rel.ro.local" : ".data.rel.ro.local"; 6592 break; 6593 case SECCAT_SDATA: 6594 prefix = one_only ? ".s" : ".sdata"; 6595 break; 6596 case SECCAT_BSS: 6597 prefix = one_only ? ".b" : ".bss"; 6598 break; 6599 case SECCAT_SBSS: 6600 prefix = one_only ? ".sb" : ".sbss"; 6601 break; 6602 case SECCAT_TDATA: 6603 prefix = one_only ? ".td" : ".tdata"; 6604 break; 6605 case SECCAT_TBSS: 6606 prefix = one_only ? ".tb" : ".tbss"; 6607 break; 6608 default: 6609 gcc_unreachable (); 6610 } 6611 6612 id = DECL_ASSEMBLER_NAME (decl); 6613 ultimate_transparent_alias_target (&id); 6614 name = IDENTIFIER_POINTER (id); 6615 name = targetm.strip_name_encoding (name); 6616 6617 /* If we're using one_only, then there needs to be a .gnu.linkonce 6618 prefix to the section name. */ 6619 linkonce = one_only ? ".gnu.linkonce" : ""; 6620 6621 string = ACONCAT ((linkonce, prefix, ".", name, NULL)); 6622 6623 set_decl_section_name (decl, string); 6624} 6625 6626/* Subroutine of compute_reloc_for_rtx for leaf rtxes. */ 6627 6628static int 6629compute_reloc_for_rtx_1 (const_rtx x) 6630{ 6631 switch (GET_CODE (x)) 6632 { 6633 case SYMBOL_REF: 6634 return SYMBOL_REF_LOCAL_P (x) ? 1 : 2; 6635 case LABEL_REF: 6636 return 1; 6637 default: 6638 return 0; 6639 } 6640} 6641 6642/* Like compute_reloc_for_constant, except for an RTX. The return value 6643 is a mask for which bit 1 indicates a global relocation, and bit 0 6644 indicates a local relocation. */ 6645 6646static int 6647compute_reloc_for_rtx (const_rtx x) 6648{ 6649 switch (GET_CODE (x)) 6650 { 6651 case SYMBOL_REF: 6652 case LABEL_REF: 6653 return compute_reloc_for_rtx_1 (x); 6654 6655 case CONST: 6656 { 6657 int reloc = 0; 6658 subrtx_iterator::array_type array; 6659 FOR_EACH_SUBRTX (iter, array, x, ALL) 6660 reloc |= compute_reloc_for_rtx_1 (*iter); 6661 return reloc; 6662 } 6663 6664 default: 6665 return 0; 6666 } 6667} 6668 6669section * 6670default_select_rtx_section (machine_mode mode ATTRIBUTE_UNUSED, 6671 rtx x, 6672 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED) 6673{ 6674 if (compute_reloc_for_rtx (x) & targetm.asm_out.reloc_rw_mask ()) 6675 return data_section; 6676 else 6677 return readonly_data_section; 6678} 6679 6680section * 6681default_elf_select_rtx_section (machine_mode mode, rtx x, 6682 unsigned HOST_WIDE_INT align) 6683{ 6684 int reloc = compute_reloc_for_rtx (x); 6685 6686 /* ??? Handle small data here somehow. */ 6687 6688 if (reloc & targetm.asm_out.reloc_rw_mask ()) 6689 { 6690 if (reloc == 1) 6691 return get_named_section (NULL, ".data.rel.ro.local", 1); 6692 else 6693 return get_named_section (NULL, ".data.rel.ro", 3); 6694 } 6695 6696 return mergeable_constant_section (mode, align, 0); 6697} 6698 6699/* Set the generally applicable flags on the SYMBOL_REF for EXP. */ 6700 6701void 6702default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED) 6703{ 6704 rtx symbol; 6705 int flags; 6706 6707 /* Careful not to prod global register variables. */ 6708 if (!MEM_P (rtl)) 6709 return; 6710 symbol = XEXP (rtl, 0); 6711 if (GET_CODE (symbol) != SYMBOL_REF) 6712 return; 6713 6714 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO; 6715 if (TREE_CODE (decl) == FUNCTION_DECL) 6716 flags |= SYMBOL_FLAG_FUNCTION; 6717 if (targetm.binds_local_p (decl)) 6718 flags |= SYMBOL_FLAG_LOCAL; 6719 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 6720 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT; 6721 else if (targetm.in_small_data_p (decl)) 6722 flags |= SYMBOL_FLAG_SMALL; 6723 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without 6724 being PUBLIC, the thing *must* be defined in this translation unit. 6725 Prevent this buglet from being propagated into rtl code as well. */ 6726 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)) 6727 flags |= SYMBOL_FLAG_EXTERNAL; 6728 6729 SYMBOL_REF_FLAGS (symbol) = flags; 6730} 6731 6732/* By default, we do nothing for encode_section_info, so we need not 6733 do anything but discard the '*' marker. */ 6734 6735const char * 6736default_strip_name_encoding (const char *str) 6737{ 6738 return str + (*str == '*'); 6739} 6740 6741#ifdef ASM_OUTPUT_DEF 6742/* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the 6743 anchor relative to ".", the current section position. */ 6744 6745void 6746default_asm_output_anchor (rtx symbol) 6747{ 6748 char buffer[100]; 6749 6750 sprintf (buffer, "*. + " HOST_WIDE_INT_PRINT_DEC, 6751 SYMBOL_REF_BLOCK_OFFSET (symbol)); 6752 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer); 6753} 6754#endif 6755 6756/* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */ 6757 6758bool 6759default_use_anchors_for_symbol_p (const_rtx symbol) 6760{ 6761 section *sect; 6762 tree decl; 6763 6764 /* Don't use anchors for mergeable sections. The linker might move 6765 the objects around. */ 6766 sect = SYMBOL_REF_BLOCK (symbol)->sect; 6767 if (sect->common.flags & SECTION_MERGE) 6768 return false; 6769 6770 /* Don't use anchors for small data sections. The small data register 6771 acts as an anchor for such sections. */ 6772 if (sect->common.flags & SECTION_SMALL) 6773 return false; 6774 6775 decl = SYMBOL_REF_DECL (symbol); 6776 if (decl && DECL_P (decl)) 6777 { 6778 /* Don't use section anchors for decls that might be defined or 6779 usurped by other modules. */ 6780 if (TREE_PUBLIC (decl) && !decl_binds_to_current_def_p (decl)) 6781 return false; 6782 6783 /* Don't use section anchors for decls that will be placed in a 6784 small data section. */ 6785 /* ??? Ideally, this check would be redundant with the SECTION_SMALL 6786 one above. The problem is that we only use SECTION_SMALL for 6787 sections that should be marked as small in the section directive. */ 6788 if (targetm.in_small_data_p (decl)) 6789 return false; 6790 } 6791 return true; 6792} 6793 6794/* Return true when RESOLUTION indicate that symbol will be bound to the 6795 definition provided by current .o file. */ 6796 6797static bool 6798resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution) 6799{ 6800 return (resolution == LDPR_PREVAILING_DEF 6801 || resolution == LDPR_PREVAILING_DEF_IRONLY_EXP 6802 || resolution == LDPR_PREVAILING_DEF_IRONLY); 6803} 6804 6805/* Return true when RESOLUTION indicate that symbol will be bound locally 6806 within current executable or DSO. */ 6807 6808static bool 6809resolution_local_p (enum ld_plugin_symbol_resolution resolution) 6810{ 6811 return (resolution == LDPR_PREVAILING_DEF 6812 || resolution == LDPR_PREVAILING_DEF_IRONLY 6813 || resolution == LDPR_PREVAILING_DEF_IRONLY_EXP 6814 || resolution == LDPR_PREEMPTED_REG 6815 || resolution == LDPR_PREEMPTED_IR 6816 || resolution == LDPR_RESOLVED_IR 6817 || resolution == LDPR_RESOLVED_EXEC); 6818} 6819 6820/* COMMON_LOCAL_P is true means that the linker can guarantee that an 6821 uninitialized common symbol in the executable will still be defined 6822 (through COPY relocation) in the executable. */ 6823 6824bool 6825default_binds_local_p_3 (const_tree exp, bool shlib, bool weak_dominate, 6826 bool extern_protected_data, bool common_local_p) 6827{ 6828 /* A non-decl is an entry in the constant pool. */ 6829 if (!DECL_P (exp)) 6830 return true; 6831 6832 /* Weakrefs may not bind locally, even though the weakref itself is always 6833 static and therefore local. Similarly, the resolver for ifunc functions 6834 might resolve to a non-local function. 6835 FIXME: We can resolve the weakref case more curefuly by looking at the 6836 weakref alias. */ 6837 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)) 6838 || (TREE_CODE (exp) == FUNCTION_DECL 6839 && lookup_attribute ("ifunc", DECL_ATTRIBUTES (exp)))) 6840 return false; 6841 6842 /* Static variables are always local. */ 6843 if (! TREE_PUBLIC (exp)) 6844 return true; 6845 6846 /* With resolution file in hand, take look into resolutions. 6847 We can't just return true for resolved_locally symbols, 6848 because dynamic linking might overwrite symbols 6849 in shared libraries. */ 6850 bool resolved_locally = false; 6851 6852 bool uninited_common = (DECL_COMMON (exp) 6853 && (DECL_INITIAL (exp) == NULL 6854 || (!in_lto_p 6855 && DECL_INITIAL (exp) == error_mark_node))); 6856 6857 /* A non-external variable is defined locally only if it isn't 6858 uninitialized COMMON variable or common_local_p is true. */ 6859 bool defined_locally = (!DECL_EXTERNAL (exp) 6860 && (!uninited_common || common_local_p)); 6861 if (symtab_node *node = symtab_node::get (exp)) 6862 { 6863 if (node->in_other_partition) 6864 defined_locally = true; 6865 if (resolution_to_local_definition_p (node->resolution)) 6866 defined_locally = resolved_locally = true; 6867 else if (resolution_local_p (node->resolution)) 6868 resolved_locally = true; 6869 } 6870 if (defined_locally && weak_dominate && !shlib) 6871 resolved_locally = true; 6872 6873 /* Undefined weak symbols are never defined locally. */ 6874 if (DECL_WEAK (exp) && !defined_locally) 6875 return false; 6876 6877 /* A symbol is local if the user has said explicitly that it will be, 6878 or if we have a definition for the symbol. We cannot infer visibility 6879 for undefined symbols. */ 6880 if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT 6881 && (TREE_CODE (exp) == FUNCTION_DECL 6882 || !extern_protected_data 6883 || DECL_VISIBILITY (exp) != VISIBILITY_PROTECTED) 6884 && (DECL_VISIBILITY_SPECIFIED (exp) || defined_locally)) 6885 return true; 6886 6887 /* If PIC, then assume that any global name can be overridden by 6888 symbols resolved from other modules. */ 6889 if (shlib) 6890 return false; 6891 6892 /* Variables defined outside this object might not be local. */ 6893 if (DECL_EXTERNAL (exp) && !resolved_locally) 6894 return false; 6895 6896 /* Non-dominant weak symbols are not defined locally. */ 6897 if (DECL_WEAK (exp) && !resolved_locally) 6898 return false; 6899 6900 /* Uninitialized COMMON variable may be unified with symbols 6901 resolved from other modules. */ 6902 if (uninited_common && !resolved_locally) 6903 return false; 6904 6905 /* Otherwise we're left with initialized (or non-common) global data 6906 which is of necessity defined locally. */ 6907 return true; 6908} 6909 6910/* Assume ELF-ish defaults, since that's pretty much the most liberal 6911 wrt cross-module name binding. */ 6912 6913bool 6914default_binds_local_p (const_tree exp) 6915{ 6916 return default_binds_local_p_3 (exp, flag_shlib != 0, true, false, false); 6917} 6918 6919/* Similar to default_binds_local_p, but common symbol may be local and 6920 extern protected data is non-local. */ 6921 6922bool 6923default_binds_local_p_2 (const_tree exp) 6924{ 6925 return default_binds_local_p_3 (exp, flag_shlib != 0, true, true, 6926 !flag_pic); 6927} 6928 6929bool 6930default_binds_local_p_1 (const_tree exp, int shlib) 6931{ 6932 return default_binds_local_p_3 (exp, shlib != 0, false, false, false); 6933} 6934 6935/* Return true when references to DECL must bind to current definition in 6936 final executable. 6937 6938 The condition is usually equivalent to whether the function binds to the 6939 current module (shared library or executable), that is to binds_local_p. 6940 We use this fact to avoid need for another target hook and implement 6941 the logic using binds_local_p and just special cases where 6942 decl_binds_to_current_def_p is stronger than binds_local_p. In particular 6943 the weak definitions (that can be overwritten at linktime by other 6944 definition from different object file) and when resolution info is available 6945 we simply use the knowledge passed to us by linker plugin. */ 6946bool 6947decl_binds_to_current_def_p (const_tree decl) 6948{ 6949 gcc_assert (DECL_P (decl)); 6950 if (!targetm.binds_local_p (decl)) 6951 return false; 6952 if (!TREE_PUBLIC (decl)) 6953 return true; 6954 6955 /* When resolution is available, just use it. */ 6956 if (symtab_node *node = symtab_node::get (decl)) 6957 { 6958 if (node->resolution != LDPR_UNKNOWN) 6959 return resolution_to_local_definition_p (node->resolution); 6960 } 6961 6962 /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks 6963 binds locally but still can be overwritten), DECL_COMMON (can be merged 6964 with a non-common definition somewhere in the same module) or 6965 DECL_EXTERNAL. 6966 This rely on fact that binds_local_p behave as decl_replaceable_p 6967 for all other declaration types. */ 6968 if (DECL_WEAK (decl)) 6969 return false; 6970 if (DECL_COMMON (decl) 6971 && (DECL_INITIAL (decl) == NULL 6972 || (!in_lto_p && DECL_INITIAL (decl) == error_mark_node))) 6973 return false; 6974 if (DECL_EXTERNAL (decl)) 6975 return false; 6976 return true; 6977} 6978 6979/* A replaceable function or variable is one which may be replaced 6980 at link-time with an entirely different definition, provided that the 6981 replacement has the same type. For example, functions declared 6982 with __attribute__((weak)) on most systems are replaceable. 6983 6984 COMDAT functions are not replaceable, since all definitions of the 6985 function must be equivalent. It is important that COMDAT functions 6986 not be treated as replaceable so that use of C++ template 6987 instantiations is not penalized. */ 6988 6989bool 6990decl_replaceable_p (tree decl) 6991{ 6992 gcc_assert (DECL_P (decl)); 6993 if (!TREE_PUBLIC (decl) || DECL_COMDAT (decl)) 6994 return false; 6995 if (!flag_semantic_interposition 6996 && !DECL_WEAK (decl)) 6997 return false; 6998 return !decl_binds_to_current_def_p (decl); 6999} 7000 7001/* Default function to output code that will globalize a label. A 7002 target must define GLOBAL_ASM_OP or provide its own function to 7003 globalize a label. */ 7004#ifdef GLOBAL_ASM_OP 7005void 7006default_globalize_label (FILE * stream, const char *name) 7007{ 7008 fputs (GLOBAL_ASM_OP, stream); 7009 assemble_name (stream, name); 7010 putc ('\n', stream); 7011} 7012#endif /* GLOBAL_ASM_OP */ 7013 7014/* Default function to output code that will globalize a declaration. */ 7015void 7016default_globalize_decl_name (FILE * stream, tree decl) 7017{ 7018 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); 7019 targetm.asm_out.globalize_label (stream, name); 7020} 7021 7022/* Default function to output a label for unwind information. The 7023 default is to do nothing. A target that needs nonlocal labels for 7024 unwind information must provide its own function to do this. */ 7025void 7026default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED, 7027 tree decl ATTRIBUTE_UNUSED, 7028 int for_eh ATTRIBUTE_UNUSED, 7029 int empty ATTRIBUTE_UNUSED) 7030{ 7031} 7032 7033/* Default function to output a label to divide up the exception table. 7034 The default is to do nothing. A target that needs/wants to divide 7035 up the table must provide it's own function to do this. */ 7036void 7037default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED) 7038{ 7039} 7040 7041/* This is how to output an internal numbered label where PREFIX is 7042 the class of label and LABELNO is the number within the class. */ 7043 7044void 7045default_generate_internal_label (char *buf, const char *prefix, 7046 unsigned long labelno) 7047{ 7048 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno); 7049} 7050 7051/* This is how to output an internal numbered label where PREFIX is 7052 the class of label and LABELNO is the number within the class. */ 7053 7054void 7055default_internal_label (FILE *stream, const char *prefix, 7056 unsigned long labelno) 7057{ 7058 char *const buf = (char *) alloca (40 + strlen (prefix)); 7059 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno); 7060 ASM_OUTPUT_INTERNAL_LABEL (stream, buf); 7061} 7062 7063 7064/* The default implementation of ASM_DECLARE_CONSTANT_NAME. */ 7065 7066void 7067default_asm_declare_constant_name (FILE *file, const char *name, 7068 const_tree exp ATTRIBUTE_UNUSED, 7069 HOST_WIDE_INT size ATTRIBUTE_UNUSED) 7070{ 7071 assemble_label (file, name); 7072} 7073 7074/* This is the default behavior at the beginning of a file. It's 7075 controlled by two other target-hook toggles. */ 7076void 7077default_file_start (void) 7078{ 7079 if (targetm.asm_file_start_app_off 7080 && !(flag_verbose_asm || flag_debug_asm || flag_dump_rtl_in_asm)) 7081 fputs (ASM_APP_OFF, asm_out_file); 7082 7083 if (targetm.asm_file_start_file_directive) 7084 { 7085 /* LTO produced units have no meaningful main_input_filename. */ 7086 if (in_lto_p) 7087 output_file_directive (asm_out_file, "<artificial>"); 7088 else 7089 output_file_directive (asm_out_file, main_input_filename); 7090 } 7091} 7092 7093/* This is a generic routine suitable for use as TARGET_ASM_FILE_END 7094 which emits a special section directive used to indicate whether or 7095 not this object file needs an executable stack. This is primarily 7096 a GNU extension to ELF but could be used on other targets. */ 7097 7098int trampolines_created; 7099 7100void 7101file_end_indicate_exec_stack (void) 7102{ 7103 unsigned int flags = SECTION_DEBUG; 7104 if (trampolines_created) 7105 flags |= SECTION_CODE; 7106 7107 switch_to_section (get_section (".note.GNU-stack", flags, NULL)); 7108} 7109 7110/* Emit a special section directive to indicate that this object file 7111 was compiled with -fsplit-stack. This is used to let the linker 7112 detect calls between split-stack code and non-split-stack code, so 7113 that it can modify the split-stack code to allocate a sufficiently 7114 large stack. We emit another special section if there are any 7115 functions in this file which have the no_split_stack attribute, to 7116 prevent the linker from warning about being unable to convert the 7117 functions if they call non-split-stack code. */ 7118 7119void 7120file_end_indicate_split_stack (void) 7121{ 7122 if (flag_split_stack) 7123 { 7124 switch_to_section (get_section (".note.GNU-split-stack", SECTION_DEBUG, 7125 NULL)); 7126 if (saw_no_split_stack) 7127 switch_to_section (get_section (".note.GNU-no-split-stack", 7128 SECTION_DEBUG, NULL)); 7129 } 7130} 7131 7132/* Output DIRECTIVE (a C string) followed by a newline. This is used as 7133 a get_unnamed_section callback. */ 7134 7135void 7136output_section_asm_op (const void *directive) 7137{ 7138 fprintf (asm_out_file, "%s\n", (const char *) directive); 7139} 7140 7141/* Emit assembly code to switch to section NEW_SECTION. Do nothing if 7142 the current section is NEW_SECTION. */ 7143 7144void 7145switch_to_section (section *new_section) 7146{ 7147 if (in_section == new_section) 7148 return; 7149 7150 if (new_section->common.flags & SECTION_FORGET) 7151 in_section = NULL; 7152 else 7153 in_section = new_section; 7154 7155 switch (SECTION_STYLE (new_section)) 7156 { 7157 case SECTION_NAMED: 7158 targetm.asm_out.named_section (new_section->named.name, 7159 new_section->named.common.flags, 7160 new_section->named.decl); 7161 break; 7162 7163 case SECTION_UNNAMED: 7164 new_section->unnamed.callback (new_section->unnamed.data); 7165 break; 7166 7167 case SECTION_NOSWITCH: 7168 gcc_unreachable (); 7169 break; 7170 } 7171 7172 new_section->common.flags |= SECTION_DECLARED; 7173} 7174 7175/* If block symbol SYMBOL has not yet been assigned an offset, place 7176 it at the end of its block. */ 7177 7178void 7179place_block_symbol (rtx symbol) 7180{ 7181 unsigned HOST_WIDE_INT size, mask, offset; 7182 struct constant_descriptor_rtx *desc; 7183 unsigned int alignment; 7184 struct object_block *block; 7185 tree decl; 7186 7187 gcc_assert (SYMBOL_REF_BLOCK (symbol)); 7188 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0) 7189 return; 7190 7191 /* Work out the symbol's size and alignment. */ 7192 if (CONSTANT_POOL_ADDRESS_P (symbol)) 7193 { 7194 desc = SYMBOL_REF_CONSTANT (symbol); 7195 alignment = desc->align; 7196 size = GET_MODE_SIZE (desc->mode); 7197 } 7198 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol)) 7199 { 7200 decl = SYMBOL_REF_DECL (symbol); 7201 gcc_checking_assert (DECL_IN_CONSTANT_POOL (decl)); 7202 alignment = DECL_ALIGN (decl); 7203 size = get_constant_size (DECL_INITIAL (decl)); 7204 if ((flag_sanitize & SANITIZE_ADDRESS) 7205 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST 7206 && asan_protect_global (DECL_INITIAL (decl))) 7207 size += asan_red_zone_size (size); 7208 } 7209 else 7210 { 7211 struct symtab_node *snode; 7212 decl = SYMBOL_REF_DECL (symbol); 7213 7214 snode = symtab_node::get (decl); 7215 if (snode->alias) 7216 { 7217 rtx target = DECL_RTL (snode->ultimate_alias_target ()->decl); 7218 7219 gcc_assert (MEM_P (target) 7220 && GET_CODE (XEXP (target, 0)) == SYMBOL_REF 7221 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (target, 0))); 7222 target = XEXP (target, 0); 7223 place_block_symbol (target); 7224 SYMBOL_REF_BLOCK_OFFSET (symbol) = SYMBOL_REF_BLOCK_OFFSET (target); 7225 return; 7226 } 7227 alignment = get_variable_align (decl); 7228 size = tree_to_uhwi (DECL_SIZE_UNIT (decl)); 7229 if ((flag_sanitize & SANITIZE_ADDRESS) 7230 && asan_protect_global (decl)) 7231 { 7232 size += asan_red_zone_size (size); 7233 alignment = MAX (alignment, 7234 ASAN_RED_ZONE_SIZE * BITS_PER_UNIT); 7235 } 7236 } 7237 7238 /* Calculate the object's offset from the start of the block. */ 7239 block = SYMBOL_REF_BLOCK (symbol); 7240 mask = alignment / BITS_PER_UNIT - 1; 7241 offset = (block->size + mask) & ~mask; 7242 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset; 7243 7244 /* Record the block's new alignment and size. */ 7245 block->alignment = MAX (block->alignment, alignment); 7246 block->size = offset + size; 7247 7248 vec_safe_push (block->objects, symbol); 7249} 7250 7251/* Return the anchor that should be used to address byte offset OFFSET 7252 from the first object in BLOCK. MODEL is the TLS model used 7253 to access it. */ 7254 7255rtx 7256get_section_anchor (struct object_block *block, HOST_WIDE_INT offset, 7257 enum tls_model model) 7258{ 7259 char label[100]; 7260 unsigned int begin, middle, end; 7261 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta; 7262 rtx anchor; 7263 7264 /* Work out the anchor's offset. Use an offset of 0 for the first 7265 anchor so that we don't pessimize the case where we take the address 7266 of a variable at the beginning of the block. This is particularly 7267 useful when a block has only one variable assigned to it. 7268 7269 We try to place anchors RANGE bytes apart, so there can then be 7270 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of 7271 a ptr_mode offset. With some target settings, the lowest such 7272 anchor might be out of range for the lowest ptr_mode offset; 7273 likewise the highest anchor for the highest offset. Use anchors 7274 at the extreme ends of the ptr_mode range in such cases. 7275 7276 All arithmetic uses unsigned integers in order to avoid 7277 signed overflow. */ 7278 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset; 7279 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset; 7280 range = max_offset - min_offset + 1; 7281 if (range == 0) 7282 offset = 0; 7283 else 7284 { 7285 bias = HOST_WIDE_INT_1U << (GET_MODE_BITSIZE (ptr_mode) - 1); 7286 if (offset < 0) 7287 { 7288 delta = -(unsigned HOST_WIDE_INT) offset + max_offset; 7289 delta -= delta % range; 7290 if (delta > bias) 7291 delta = bias; 7292 offset = (HOST_WIDE_INT) (-delta); 7293 } 7294 else 7295 { 7296 delta = (unsigned HOST_WIDE_INT) offset - min_offset; 7297 delta -= delta % range; 7298 if (delta > bias - 1) 7299 delta = bias - 1; 7300 offset = (HOST_WIDE_INT) delta; 7301 } 7302 } 7303 7304 /* Do a binary search to see if there's already an anchor we can use. 7305 Set BEGIN to the new anchor's index if not. */ 7306 begin = 0; 7307 end = vec_safe_length (block->anchors); 7308 while (begin != end) 7309 { 7310 middle = (end + begin) / 2; 7311 anchor = (*block->anchors)[middle]; 7312 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset) 7313 end = middle; 7314 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset) 7315 begin = middle + 1; 7316 else if (SYMBOL_REF_TLS_MODEL (anchor) > model) 7317 end = middle; 7318 else if (SYMBOL_REF_TLS_MODEL (anchor) < model) 7319 begin = middle + 1; 7320 else 7321 return anchor; 7322 } 7323 7324 /* Create a new anchor with a unique label. */ 7325 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++); 7326 anchor = create_block_symbol (ggc_strdup (label), block, offset); 7327 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR; 7328 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT; 7329 7330 /* Insert it at index BEGIN. */ 7331 vec_safe_insert (block->anchors, begin, anchor); 7332 return anchor; 7333} 7334 7335/* Output the objects in BLOCK. */ 7336 7337static void 7338output_object_block (struct object_block *block) 7339{ 7340 struct constant_descriptor_rtx *desc; 7341 unsigned int i; 7342 HOST_WIDE_INT offset; 7343 tree decl; 7344 rtx symbol; 7345 7346 if (!block->objects) 7347 return; 7348 7349 /* Switch to the section and make sure that the first byte is 7350 suitably aligned. */ 7351 switch_to_section (block->sect); 7352 assemble_align (block->alignment); 7353 7354 /* Define the values of all anchors relative to the current section 7355 position. */ 7356 FOR_EACH_VEC_SAFE_ELT (block->anchors, i, symbol) 7357 targetm.asm_out.output_anchor (symbol); 7358 7359 /* Output the objects themselves. */ 7360 offset = 0; 7361 FOR_EACH_VEC_ELT (*block->objects, i, symbol) 7362 { 7363 /* Move to the object's offset, padding with zeros if necessary. */ 7364 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset); 7365 offset = SYMBOL_REF_BLOCK_OFFSET (symbol); 7366 if (CONSTANT_POOL_ADDRESS_P (symbol)) 7367 { 7368 desc = SYMBOL_REF_CONSTANT (symbol); 7369 output_constant_pool_1 (desc, 1); 7370 offset += GET_MODE_SIZE (desc->mode); 7371 } 7372 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol)) 7373 { 7374 HOST_WIDE_INT size; 7375 decl = SYMBOL_REF_DECL (symbol); 7376 assemble_constant_contents 7377 (DECL_INITIAL (decl), XSTR (symbol, 0), DECL_ALIGN (decl)); 7378 7379 size = get_constant_size (DECL_INITIAL (decl)); 7380 offset += size; 7381 if ((flag_sanitize & SANITIZE_ADDRESS) 7382 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST 7383 && asan_protect_global (DECL_INITIAL (decl))) 7384 { 7385 size = asan_red_zone_size (size); 7386 assemble_zeros (size); 7387 offset += size; 7388 } 7389 } 7390 else 7391 { 7392 HOST_WIDE_INT size; 7393 decl = SYMBOL_REF_DECL (symbol); 7394 assemble_variable_contents (decl, XSTR (symbol, 0), false); 7395 size = tree_to_uhwi (DECL_SIZE_UNIT (decl)); 7396 offset += size; 7397 if ((flag_sanitize & SANITIZE_ADDRESS) 7398 && asan_protect_global (decl)) 7399 { 7400 size = asan_red_zone_size (size); 7401 assemble_zeros (size); 7402 offset += size; 7403 } 7404 } 7405 } 7406} 7407 7408/* A htab_traverse callback used to call output_object_block for 7409 each member of object_block_htab. */ 7410 7411int 7412output_object_block_htab (object_block **slot, void *) 7413{ 7414 output_object_block (*slot); 7415 return 1; 7416} 7417 7418/* Output the definitions of all object_blocks. */ 7419 7420void 7421output_object_blocks (void) 7422{ 7423 object_block_htab->traverse<void *, output_object_block_htab> (NULL); 7424} 7425 7426/* This function provides a possible implementation of the 7427 TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered 7428 by -frecord-gcc-switches it creates a new mergeable, string section in the 7429 assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which 7430 contains the switches in ASCII format. 7431 7432 FIXME: This code does not correctly handle double quote characters 7433 that appear inside strings, (it strips them rather than preserving them). 7434 FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL 7435 characters - instead it treats them as sub-string separators. Since 7436 we want to emit NUL strings terminators into the object file we have to use 7437 ASM_OUTPUT_SKIP. */ 7438 7439int 7440elf_record_gcc_switches (print_switch_type type, const char * name) 7441{ 7442 switch (type) 7443 { 7444 case SWITCH_TYPE_PASSED: 7445 ASM_OUTPUT_ASCII (asm_out_file, name, strlen (name)); 7446 ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1); 7447 break; 7448 7449 case SWITCH_TYPE_DESCRIPTIVE: 7450 if (name == NULL) 7451 { 7452 /* Distinguish between invocations where name is NULL. */ 7453 static bool started = false; 7454 7455 if (!started) 7456 { 7457 section * sec; 7458 7459 sec = get_section (targetm.asm_out.record_gcc_switches_section, 7460 SECTION_DEBUG 7461 | SECTION_MERGE 7462 | SECTION_STRINGS 7463 | (SECTION_ENTSIZE & 1), 7464 NULL); 7465 switch_to_section (sec); 7466 started = true; 7467 } 7468 } 7469 7470 default: 7471 break; 7472 } 7473 7474 /* The return value is currently ignored by the caller, but must be 0. 7475 For -fverbose-asm the return value would be the number of characters 7476 emitted into the assembler file. */ 7477 return 0; 7478} 7479 7480/* Emit text to declare externally defined symbols. It is needed to 7481 properly support non-default visibility. */ 7482void 7483default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED, 7484 tree decl, 7485 const char *name ATTRIBUTE_UNUSED) 7486{ 7487 /* We output the name if and only if TREE_SYMBOL_REFERENCED is 7488 set in order to avoid putting out names that are never really 7489 used. Always output visibility specified in the source. */ 7490 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) 7491 && (DECL_VISIBILITY_SPECIFIED (decl) 7492 || targetm.binds_local_p (decl))) 7493 maybe_assemble_visibility (decl); 7494} 7495 7496/* The default hook for TARGET_ASM_OUTPUT_SOURCE_FILENAME. */ 7497 7498void 7499default_asm_output_source_filename (FILE *file, const char *name) 7500{ 7501#ifdef ASM_OUTPUT_SOURCE_FILENAME 7502 ASM_OUTPUT_SOURCE_FILENAME (file, name); 7503#else 7504 fprintf (file, "\t.file\t"); 7505 output_quoted_string (file, name); 7506 putc ('\n', file); 7507#endif 7508} 7509 7510/* Output a file name in the form wanted by System V. */ 7511 7512void 7513output_file_directive (FILE *asm_file, const char *input_name) 7514{ 7515 int len; 7516 const char *na; 7517 7518 if (input_name == NULL) 7519 input_name = "<stdin>"; 7520 else 7521 input_name = remap_debug_filename (input_name); 7522 7523 len = strlen (input_name); 7524 na = input_name + len; 7525 7526 /* NA gets INPUT_NAME sans directory names. */ 7527 while (na > input_name) 7528 { 7529 if (IS_DIR_SEPARATOR (na[-1])) 7530 break; 7531 na--; 7532 } 7533 7534 targetm.asm_out.output_source_filename (asm_file, na); 7535} 7536 7537/* Create a DEBUG_EXPR_DECL / DEBUG_EXPR pair from RTL expression 7538 EXP. */ 7539rtx 7540make_debug_expr_from_rtl (const_rtx exp) 7541{ 7542 tree ddecl = make_node (DEBUG_EXPR_DECL), type; 7543 machine_mode mode = GET_MODE (exp); 7544 rtx dval; 7545 7546 DECL_ARTIFICIAL (ddecl) = 1; 7547 if (REG_P (exp) && REG_EXPR (exp)) 7548 type = TREE_TYPE (REG_EXPR (exp)); 7549 else if (MEM_P (exp) && MEM_EXPR (exp)) 7550 type = TREE_TYPE (MEM_EXPR (exp)); 7551 else 7552 type = NULL_TREE; 7553 if (type && TYPE_MODE (type) == mode) 7554 TREE_TYPE (ddecl) = type; 7555 else 7556 TREE_TYPE (ddecl) = lang_hooks.types.type_for_mode (mode, 1); 7557 DECL_MODE (ddecl) = mode; 7558 dval = gen_rtx_DEBUG_EXPR (mode); 7559 DEBUG_EXPR_TREE_DECL (dval) = ddecl; 7560 SET_DECL_RTL (ddecl, dval); 7561 return dval; 7562} 7563 7564#ifdef ELF_ASCII_ESCAPES 7565/* Default ASM_OUTPUT_LIMITED_STRING for ELF targets. */ 7566 7567void 7568default_elf_asm_output_limited_string (FILE *f, const char *s) 7569{ 7570 int escape; 7571 unsigned char c; 7572 7573 fputs (STRING_ASM_OP, f); 7574 putc ('"', f); 7575 while (*s != '\0') 7576 { 7577 c = *s; 7578 escape = ELF_ASCII_ESCAPES[c]; 7579 switch (escape) 7580 { 7581 case 0: 7582 putc (c, f); 7583 break; 7584 case 1: 7585 /* TODO: Print in hex with fast function, important for -flto. */ 7586 fprintf (f, "\\%03o", c); 7587 break; 7588 default: 7589 putc ('\\', f); 7590 putc (escape, f); 7591 break; 7592 } 7593 s++; 7594 } 7595 putc ('\"', f); 7596 putc ('\n', f); 7597} 7598 7599/* Default ASM_OUTPUT_ASCII for ELF targets. */ 7600 7601void 7602default_elf_asm_output_ascii (FILE *f, const char *s, unsigned int len) 7603{ 7604 const char *limit = s + len; 7605 const char *last_null = NULL; 7606 unsigned bytes_in_chunk = 0; 7607 unsigned char c; 7608 int escape; 7609 7610 for (; s < limit; s++) 7611 { 7612 const char *p; 7613 7614 if (bytes_in_chunk >= 60) 7615 { 7616 putc ('\"', f); 7617 putc ('\n', f); 7618 bytes_in_chunk = 0; 7619 } 7620 7621 if (s > last_null) 7622 { 7623 for (p = s; p < limit && *p != '\0'; p++) 7624 continue; 7625 last_null = p; 7626 } 7627 else 7628 p = last_null; 7629 7630 if (p < limit && (p - s) <= (long) ELF_STRING_LIMIT) 7631 { 7632 if (bytes_in_chunk > 0) 7633 { 7634 putc ('\"', f); 7635 putc ('\n', f); 7636 bytes_in_chunk = 0; 7637 } 7638 7639 default_elf_asm_output_limited_string (f, s); 7640 s = p; 7641 } 7642 else 7643 { 7644 if (bytes_in_chunk == 0) 7645 fputs (ASCII_DATA_ASM_OP "\"", f); 7646 7647 c = *s; 7648 escape = ELF_ASCII_ESCAPES[c]; 7649 switch (escape) 7650 { 7651 case 0: 7652 putc (c, f); 7653 bytes_in_chunk++; 7654 break; 7655 case 1: 7656 /* TODO: Print in hex with fast function, important for -flto. */ 7657 fprintf (f, "\\%03o", c); 7658 bytes_in_chunk += 4; 7659 break; 7660 default: 7661 putc ('\\', f); 7662 putc (escape, f); 7663 bytes_in_chunk += 2; 7664 break; 7665 } 7666 7667 } 7668 } 7669 7670 if (bytes_in_chunk > 0) 7671 { 7672 putc ('\"', f); 7673 putc ('\n', f); 7674 } 7675} 7676#endif 7677 7678static GTY(()) section *elf_init_array_section; 7679static GTY(()) section *elf_fini_array_section; 7680 7681static section * 7682get_elf_initfini_array_priority_section (int priority, 7683 bool constructor_p) 7684{ 7685 section *sec; 7686 if (priority != DEFAULT_INIT_PRIORITY) 7687 { 7688 char buf[18]; 7689 sprintf (buf, "%s.%.5u", 7690 constructor_p ? ".init_array" : ".fini_array", 7691 priority); 7692 sec = get_section (buf, SECTION_WRITE | SECTION_NOTYPE, NULL_TREE); 7693 } 7694 else 7695 { 7696 if (constructor_p) 7697 { 7698 if (elf_init_array_section == NULL) 7699 elf_init_array_section 7700 = get_section (".init_array", 7701 SECTION_WRITE | SECTION_NOTYPE, NULL_TREE); 7702 sec = elf_init_array_section; 7703 } 7704 else 7705 { 7706 if (elf_fini_array_section == NULL) 7707 elf_fini_array_section 7708 = get_section (".fini_array", 7709 SECTION_WRITE | SECTION_NOTYPE, NULL_TREE); 7710 sec = elf_fini_array_section; 7711 } 7712 } 7713 return sec; 7714} 7715 7716/* Use .init_array section for constructors. */ 7717 7718void 7719default_elf_init_array_asm_out_constructor (rtx symbol, int priority) 7720{ 7721 section *sec = get_elf_initfini_array_priority_section (priority, 7722 true); 7723 assemble_addr_to_section (symbol, sec); 7724} 7725 7726/* Use .fini_array section for destructors. */ 7727 7728void 7729default_elf_fini_array_asm_out_destructor (rtx symbol, int priority) 7730{ 7731 section *sec = get_elf_initfini_array_priority_section (priority, 7732 false); 7733 assemble_addr_to_section (symbol, sec); 7734} 7735 7736/* Default TARGET_ASM_OUTPUT_IDENT hook. 7737 7738 This is a bit of a cheat. The real default is a no-op, but this 7739 hook is the default for all targets with a .ident directive. */ 7740 7741void 7742default_asm_output_ident_directive (const char *ident_str) 7743{ 7744 const char *ident_asm_op = "\t.ident\t"; 7745 7746 /* If we are still in the front end, do not write out the string 7747 to asm_out_file. Instead, add a fake top-level asm statement. 7748 This allows the front ends to use this hook without actually 7749 writing to asm_out_file, to handle #ident or Pragma Ident. */ 7750 if (symtab->state == PARSING) 7751 { 7752 char *buf = ACONCAT ((ident_asm_op, "\"", ident_str, "\"\n", NULL)); 7753 symtab->finalize_toplevel_asm (build_string (strlen (buf), buf)); 7754 } 7755 else 7756 fprintf (asm_out_file, "%s\"%s\"\n", ident_asm_op, ident_str); 7757} 7758 7759#include "gt-varasm.h" 7760