varasm.c revision 169689
1/* Output variables, constants and external declarations, for GNU compiler. 2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 4 Free Software Foundation, Inc. 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ 22 23 24/* This file handles generation of all the assembler code 25 *except* the instructions of a function. 26 This includes declarations of variables and their initial values. 27 28 We also output the assembler code for constants stored in memory 29 and are responsible for combining constants with the same value. */ 30 31#include "config.h" 32#include "system.h" 33#include "coretypes.h" 34#include "tm.h" 35#include "rtl.h" 36#include "tree.h" 37#include "flags.h" 38#include "function.h" 39#include "expr.h" 40#include "hard-reg-set.h" 41#include "regs.h" 42#include "real.h" 43#include "output.h" 44#include "toplev.h" 45#include "hashtab.h" 46#include "c-pragma.h" 47#include "ggc.h" 48#include "langhooks.h" 49#include "tm_p.h" 50#include "debug.h" 51#include "target.h" 52#include "tree-mudflap.h" 53#include "cgraph.h" 54#include "cfglayout.h" 55#include "basic-block.h" 56 57#ifdef XCOFF_DEBUGGING_INFO 58#include "xcoffout.h" /* Needed for external data 59 declarations for e.g. AIX 4.x. */ 60#endif 61 62/* The (assembler) name of the first globally-visible object output. */ 63extern GTY(()) const char *first_global_object_name; 64extern GTY(()) const char *weak_global_object_name; 65 66const char *first_global_object_name; 67const char *weak_global_object_name; 68 69struct addr_const; 70struct constant_descriptor_rtx; 71struct rtx_constant_pool; 72 73struct varasm_status GTY(()) 74{ 75 /* If we're using a per-function constant pool, this is it. */ 76 struct rtx_constant_pool *pool; 77 78 /* Number of tree-constants deferred during the expansion of this 79 function. */ 80 unsigned int deferred_constants; 81}; 82 83#define n_deferred_constants (cfun->varasm->deferred_constants) 84 85/* Number for making the label on the next 86 constant that is stored in memory. */ 87 88static GTY(()) int const_labelno; 89 90/* Carry information from ASM_DECLARE_OBJECT_NAME 91 to ASM_FINISH_DECLARE_OBJECT. */ 92 93int size_directive_output; 94 95/* The last decl for which assemble_variable was called, 96 if it did ASM_DECLARE_OBJECT_NAME. 97 If the last call to assemble_variable didn't do that, 98 this holds 0. */ 99 100tree last_assemble_variable_decl; 101 102/* The following global variable indicates if the first basic block 103 in a function belongs to the cold partition or not. */ 104 105bool first_function_block_is_cold; 106 107/* We give all constants their own alias set. Perhaps redundant with 108 MEM_READONLY_P, but pre-dates it. */ 109 110static HOST_WIDE_INT const_alias_set; 111 112static const char *strip_reg_name (const char *); 113static int contains_pointers_p (tree); 114#ifdef ASM_OUTPUT_EXTERNAL 115static bool incorporeal_function_p (tree); 116#endif 117static void decode_addr_const (tree, struct addr_const *); 118static hashval_t const_desc_hash (const void *); 119static int const_desc_eq (const void *, const void *); 120static hashval_t const_hash_1 (const tree); 121static int compare_constant (const tree, const tree); 122static tree copy_constant (tree); 123static void output_constant_def_contents (rtx); 124static void output_addressed_constants (tree); 125static unsigned HOST_WIDE_INT array_size_for_constructor (tree); 126static unsigned min_align (unsigned, unsigned); 127static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int); 128static void globalize_decl (tree); 129static void maybe_assemble_visibility (tree); 130#ifdef BSS_SECTION_ASM_OP 131#ifdef ASM_OUTPUT_BSS 132static void asm_output_bss (FILE *, tree, const char *, 133 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 134#endif 135#ifdef ASM_OUTPUT_ALIGNED_BSS 136static void asm_output_aligned_bss (FILE *, tree, const char *, 137 unsigned HOST_WIDE_INT, int) 138 ATTRIBUTE_UNUSED; 139#endif 140#endif /* BSS_SECTION_ASM_OP */ 141static void mark_weak (tree); 142static void output_constant_pool (const char *, tree); 143 144/* Well-known sections, each one associated with some sort of *_ASM_OP. */ 145section *text_section; 146section *data_section; 147section *readonly_data_section; 148section *sdata_section; 149section *ctors_section; 150section *dtors_section; 151section *bss_section; 152section *sbss_section; 153 154/* Various forms of common section. All are guaranteed to be nonnull. */ 155section *tls_comm_section; 156section *comm_section; 157section *lcomm_section; 158 159/* A SECTION_NOSWITCH section used for declaring global BSS variables. 160 May be null. */ 161section *bss_noswitch_section; 162 163/* The section that holds the main exception table, when known. The section 164 is set either by the target's init_sections hook or by the first call to 165 switch_to_exception_section. */ 166section *exception_section; 167 168/* The section that holds the DWARF2 frame unwind information, when known. 169 The section is set either by the target's init_sections hook or by the 170 first call to switch_to_eh_frame_section. */ 171section *eh_frame_section; 172 173/* asm_out_file's current section. This is NULL if no section has yet 174 been selected or if we lose track of what the current section is. */ 175section *in_section; 176 177/* True if code for the current function is currently being directed 178 at the cold section. */ 179bool in_cold_section_p; 180 181/* A linked list of all the unnamed sections. */ 182static GTY(()) section *unnamed_sections; 183 184/* Return a nonzero value if DECL has a section attribute. */ 185#ifndef IN_NAMED_SECTION 186#define IN_NAMED_SECTION(DECL) \ 187 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \ 188 && DECL_SECTION_NAME (DECL) != NULL_TREE) 189#endif 190 191/* Hash table of named sections. */ 192static GTY((param_is (section))) htab_t section_htab; 193 194/* A table of object_blocks, indexed by section. */ 195static GTY((param_is (struct object_block))) htab_t object_block_htab; 196 197/* The next number to use for internal anchor labels. */ 198static GTY(()) int anchor_labelno; 199 200/* A pool of constants that can be shared between functions. */ 201static GTY(()) struct rtx_constant_pool *shared_constant_pool; 202 203/* Helper routines for maintaining section_htab. */ 204 205static int 206section_entry_eq (const void *p1, const void *p2) 207{ 208 const section *old = p1; 209 const char *new = p2; 210 211 return strcmp (old->named.name, new) == 0; 212} 213 214static hashval_t 215section_entry_hash (const void *p) 216{ 217 const section *old = p; 218 return htab_hash_string (old->named.name); 219} 220 221/* Return a hash value for section SECT. */ 222 223static hashval_t 224hash_section (section *sect) 225{ 226 if (sect->common.flags & SECTION_NAMED) 227 return htab_hash_string (sect->named.name); 228 return sect->common.flags; 229} 230 231/* Helper routines for maintaining object_block_htab. */ 232 233static int 234object_block_entry_eq (const void *p1, const void *p2) 235{ 236 const struct object_block *old = p1; 237 const section *new = p2; 238 239 return old->sect == new; 240} 241 242static hashval_t 243object_block_entry_hash (const void *p) 244{ 245 const struct object_block *old = p; 246 return hash_section (old->sect); 247} 248 249/* Return a new unnamed section with the given fields. */ 250 251section * 252get_unnamed_section (unsigned int flags, void (*callback) (const void *), 253 const void *data) 254{ 255 section *sect; 256 257 sect = ggc_alloc (sizeof (struct unnamed_section)); 258 sect->unnamed.common.flags = flags | SECTION_UNNAMED; 259 sect->unnamed.callback = callback; 260 sect->unnamed.data = data; 261 sect->unnamed.next = unnamed_sections; 262 263 unnamed_sections = sect; 264 return sect; 265} 266 267/* Return a SECTION_NOSWITCH section with the given fields. */ 268 269static section * 270get_noswitch_section (unsigned int flags, noswitch_section_callback callback) 271{ 272 section *sect; 273 274 sect = ggc_alloc (sizeof (struct unnamed_section)); 275 sect->noswitch.common.flags = flags | SECTION_NOSWITCH; 276 sect->noswitch.callback = callback; 277 278 return sect; 279} 280 281/* Return the named section structure associated with NAME. Create 282 a new section with the given fields if no such structure exists. */ 283 284section * 285get_section (const char *name, unsigned int flags, tree decl) 286{ 287 section *sect, **slot; 288 289 slot = (section **) 290 htab_find_slot_with_hash (section_htab, name, 291 htab_hash_string (name), INSERT); 292 flags |= SECTION_NAMED; 293 if (*slot == NULL) 294 { 295 sect = ggc_alloc (sizeof (struct named_section)); 296 sect->named.common.flags = flags; 297 sect->named.name = ggc_strdup (name); 298 sect->named.decl = decl; 299 *slot = sect; 300 } 301 else 302 { 303 sect = *slot; 304 if ((sect->common.flags & ~SECTION_DECLARED) != flags 305 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0) 306 { 307 /* Sanity check user variables for flag changes. */ 308 if (decl == 0) 309 decl = sect->named.decl; 310 gcc_assert (decl); 311 error ("%+D causes a section type conflict", decl); 312 } 313 } 314 return sect; 315} 316 317/* Return true if the current compilation mode benefits from having 318 objects grouped into blocks. */ 319 320static bool 321use_object_blocks_p (void) 322{ 323 return flag_section_anchors; 324} 325 326/* Return the object_block structure for section SECT. Create a new 327 structure if we haven't created one already. Return null if SECT 328 itself is null. */ 329 330static struct object_block * 331get_block_for_section (section *sect) 332{ 333 struct object_block *block; 334 void **slot; 335 336 if (sect == NULL) 337 return NULL; 338 339 slot = htab_find_slot_with_hash (object_block_htab, sect, 340 hash_section (sect), INSERT); 341 block = (struct object_block *) *slot; 342 if (block == NULL) 343 { 344 block = (struct object_block *) 345 ggc_alloc_cleared (sizeof (struct object_block)); 346 block->sect = sect; 347 *slot = block; 348 } 349 return block; 350} 351 352/* Create a symbol with label LABEL and place it at byte offset 353 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset 354 is not yet known. LABEL must be a garbage-collected string. */ 355 356static rtx 357create_block_symbol (const char *label, struct object_block *block, 358 HOST_WIDE_INT offset) 359{ 360 rtx symbol; 361 unsigned int size; 362 363 /* Create the extended SYMBOL_REF. */ 364 size = RTX_HDR_SIZE + sizeof (struct block_symbol); 365 symbol = ggc_alloc_zone (size, &rtl_zone); 366 367 /* Initialize the normal SYMBOL_REF fields. */ 368 memset (symbol, 0, size); 369 PUT_CODE (symbol, SYMBOL_REF); 370 PUT_MODE (symbol, Pmode); 371 XSTR (symbol, 0) = label; 372 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO; 373 374 /* Initialize the block_symbol stuff. */ 375 SYMBOL_REF_BLOCK (symbol) = block; 376 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset; 377 378 return symbol; 379} 380 381static void 382initialize_cold_section_name (void) 383{ 384 const char *stripped_name; 385 char *name, *buffer; 386 tree dsn; 387 388 gcc_assert (cfun && current_function_decl); 389 if (cfun->unlikely_text_section_name) 390 return; 391 392 dsn = DECL_SECTION_NAME (current_function_decl); 393 if (flag_function_sections && dsn) 394 { 395 name = alloca (TREE_STRING_LENGTH (dsn) + 1); 396 memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1); 397 398 stripped_name = targetm.strip_name_encoding (name); 399 400 buffer = ACONCAT ((stripped_name, "_unlikely", NULL)); 401 cfun->unlikely_text_section_name = ggc_strdup (buffer); 402 } 403 else 404 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; 405} 406 407/* Tell assembler to switch to unlikely-to-be-executed text section. */ 408 409section * 410unlikely_text_section (void) 411{ 412 if (cfun) 413 { 414 if (!cfun->unlikely_text_section_name) 415 initialize_cold_section_name (); 416 417 return get_named_section (NULL, cfun->unlikely_text_section_name, 0); 418 } 419 else 420 return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0); 421} 422 423/* When called within a function context, return true if the function 424 has been assigned a cold text section and if SECT is that section. 425 When called outside a function context, return true if SECT is the 426 default cold section. */ 427 428bool 429unlikely_text_section_p (section *sect) 430{ 431 const char *name; 432 433 if (cfun) 434 name = cfun->unlikely_text_section_name; 435 else 436 name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; 437 438 return (name 439 && sect 440 && SECTION_STYLE (sect) == SECTION_NAMED 441 && strcmp (name, sect->named.name) == 0); 442} 443 444/* Return a section with a particular name and with whatever SECTION_* 445 flags section_type_flags deems appropriate. The name of the section 446 is taken from NAME if nonnull, otherwise it is taken from DECL's 447 DECL_SECTION_NAME. DECL is the decl associated with the section 448 (see the section comment for details) and RELOC is as for 449 section_type_flags. */ 450 451section * 452get_named_section (tree decl, const char *name, int reloc) 453{ 454 unsigned int flags; 455 456 gcc_assert (!decl || DECL_P (decl)); 457 if (name == NULL) 458 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl)); 459 460 flags = targetm.section_type_flags (decl, name, reloc); 461 462 return get_section (name, flags, decl); 463} 464 465/* If required, set DECL_SECTION_NAME to a unique name. */ 466 467void 468resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED, 469 int flag_function_or_data_sections) 470{ 471 if (DECL_SECTION_NAME (decl) == NULL_TREE 472 && targetm.have_named_sections 473 && (flag_function_or_data_sections 474 || DECL_ONE_ONLY (decl))) 475 targetm.asm_out.unique_section (decl, reloc); 476} 477 478#ifdef BSS_SECTION_ASM_OP 479 480#ifdef ASM_OUTPUT_BSS 481 482/* Utility function for ASM_OUTPUT_BSS for targets to use if 483 they don't support alignments in .bss. 484 ??? It is believed that this function will work in most cases so such 485 support is localized here. */ 486 487static void 488asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED, 489 const char *name, 490 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 491 unsigned HOST_WIDE_INT rounded) 492{ 493 targetm.asm_out.globalize_label (file, name); 494 switch_to_section (bss_section); 495#ifdef ASM_DECLARE_OBJECT_NAME 496 last_assemble_variable_decl = decl; 497 ASM_DECLARE_OBJECT_NAME (file, name, decl); 498#else 499 /* Standard thing is just output label for the object. */ 500 ASM_OUTPUT_LABEL (file, name); 501#endif /* ASM_DECLARE_OBJECT_NAME */ 502 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1); 503} 504 505#endif 506 507#ifdef ASM_OUTPUT_ALIGNED_BSS 508 509/* Utility function for targets to use in implementing 510 ASM_OUTPUT_ALIGNED_BSS. 511 ??? It is believed that this function will work in most cases so such 512 support is localized here. */ 513 514static void 515asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED, 516 const char *name, unsigned HOST_WIDE_INT size, 517 int align) 518{ 519 switch_to_section (bss_section); 520 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); 521#ifdef ASM_DECLARE_OBJECT_NAME 522 last_assemble_variable_decl = decl; 523 ASM_DECLARE_OBJECT_NAME (file, name, decl); 524#else 525 /* Standard thing is just output label for the object. */ 526 ASM_OUTPUT_LABEL (file, name); 527#endif /* ASM_DECLARE_OBJECT_NAME */ 528 ASM_OUTPUT_SKIP (file, size ? size : 1); 529} 530 531#endif 532 533#endif /* BSS_SECTION_ASM_OP */ 534 535#ifndef USE_SELECT_SECTION_FOR_FUNCTIONS 536/* Return the hot section for function DECL. Return text_section for 537 null DECLs. */ 538 539static section * 540hot_function_section (tree decl) 541{ 542 if (decl != NULL_TREE 543 && DECL_SECTION_NAME (decl) != NULL_TREE 544 && targetm.have_named_sections) 545 return get_named_section (decl, NULL, 0); 546 else 547 return text_section; 548} 549#endif 550 551/* Return the section for function DECL. 552 553 If DECL is NULL_TREE, return the text section. We can be passed 554 NULL_TREE under some circumstances by dbxout.c at least. */ 555 556section * 557function_section (tree decl) 558{ 559 int reloc = 0; 560 561 if (first_function_block_is_cold) 562 reloc = 1; 563 564#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS 565 if (decl != NULL_TREE 566 && DECL_SECTION_NAME (decl) != NULL_TREE) 567 return reloc ? unlikely_text_section () 568 : get_named_section (decl, NULL, 0); 569 else 570 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl)); 571#else 572 return reloc ? unlikely_text_section () : hot_function_section (decl); 573#endif 574} 575 576section * 577current_function_section (void) 578{ 579#ifdef USE_SELECT_SECTION_FOR_FUNCTIONS 580 if (current_function_decl != NULL_TREE 581 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE) 582 return in_cold_section_p ? unlikely_text_section () 583 : get_named_section (current_function_decl, 584 NULL, 0); 585 else 586 return targetm.asm_out.select_section (current_function_decl, 587 in_cold_section_p, 588 DECL_ALIGN (current_function_decl)); 589#else 590 return (in_cold_section_p 591 ? unlikely_text_section () 592 : hot_function_section (current_function_decl)); 593#endif 594} 595 596/* Return the read-only data section associated with function DECL. */ 597 598section * 599default_function_rodata_section (tree decl) 600{ 601 if (decl != NULL_TREE && DECL_SECTION_NAME (decl)) 602 { 603 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl)); 604 605 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP) 606 { 607 size_t len = strlen (name) + 3; 608 char* rname = alloca (len); 609 610 strcpy (rname, ".rodata"); 611 strcat (rname, name + 5); 612 return get_section (rname, SECTION_LINKONCE, decl); 613 } 614 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */ 615 else if (DECL_ONE_ONLY (decl) 616 && strncmp (name, ".gnu.linkonce.t.", 16) == 0) 617 { 618 size_t len = strlen (name) + 1; 619 char *rname = alloca (len); 620 621 memcpy (rname, name, len); 622 rname[14] = 'r'; 623 return get_section (rname, SECTION_LINKONCE, decl); 624 } 625 /* For .text.foo we want to use .rodata.foo. */ 626 else if (flag_function_sections && flag_data_sections 627 && strncmp (name, ".text.", 6) == 0) 628 { 629 size_t len = strlen (name) + 1; 630 char *rname = alloca (len + 2); 631 632 memcpy (rname, ".rodata", 7); 633 memcpy (rname + 7, name + 5, len - 5); 634 return get_section (rname, 0, decl); 635 } 636 } 637 638 return readonly_data_section; 639} 640 641/* Return the read-only data section associated with function DECL 642 for targets where that section should be always the single 643 readonly data section. */ 644 645section * 646default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED) 647{ 648 return readonly_data_section; 649} 650 651/* Return the section to use for string merging. */ 652 653static section * 654mergeable_string_section (tree decl ATTRIBUTE_UNUSED, 655 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED, 656 unsigned int flags ATTRIBUTE_UNUSED) 657{ 658 HOST_WIDE_INT len; 659 660 if (HAVE_GAS_SHF_MERGE && flag_merge_constants 661 && TREE_CODE (decl) == STRING_CST 662 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 663 && align <= 256 664 && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0 665 && TREE_STRING_LENGTH (decl) >= len) 666 { 667 enum machine_mode mode; 668 unsigned int modesize; 669 const char *str; 670 HOST_WIDE_INT i; 671 int j, unit; 672 char name[30]; 673 674 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl))); 675 modesize = GET_MODE_BITSIZE (mode); 676 if (modesize >= 8 && modesize <= 256 677 && (modesize & (modesize - 1)) == 0) 678 { 679 if (align < modesize) 680 align = modesize; 681 682 str = TREE_STRING_POINTER (decl); 683 unit = GET_MODE_SIZE (mode); 684 685 /* Check for embedded NUL characters. */ 686 for (i = 0; i < len; i += unit) 687 { 688 for (j = 0; j < unit; j++) 689 if (str[i + j] != '\0') 690 break; 691 if (j == unit) 692 break; 693 } 694 if (i == len - unit) 695 { 696 sprintf (name, ".rodata.str%d.%d", modesize / 8, 697 (int) (align / 8)); 698 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS; 699 return get_section (name, flags, NULL); 700 } 701 } 702 } 703 704 return readonly_data_section; 705} 706 707/* Return the section to use for constant merging. */ 708 709section * 710mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED, 711 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED, 712 unsigned int flags ATTRIBUTE_UNUSED) 713{ 714 unsigned int modesize = GET_MODE_BITSIZE (mode); 715 716 if (HAVE_GAS_SHF_MERGE && flag_merge_constants 717 && mode != VOIDmode 718 && mode != BLKmode 719 && modesize <= align 720 && align >= 8 721 && align <= 256 722 && (align & (align - 1)) == 0) 723 { 724 char name[24]; 725 726 sprintf (name, ".rodata.cst%d", (int) (align / 8)); 727 flags |= (align / 8) | SECTION_MERGE; 728 return get_section (name, flags, NULL); 729 } 730 return readonly_data_section; 731} 732 733/* Given NAME, a putative register name, discard any customary prefixes. */ 734 735static const char * 736strip_reg_name (const char *name) 737{ 738#ifdef REGISTER_PREFIX 739 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX))) 740 name += strlen (REGISTER_PREFIX); 741#endif 742 if (name[0] == '%' || name[0] == '#') 743 name++; 744 return name; 745} 746 747/* The user has asked for a DECL to have a particular name. Set (or 748 change) it in such a way that we don't prefix an underscore to 749 it. */ 750void 751set_user_assembler_name (tree decl, const char *name) 752{ 753 char *starred = alloca (strlen (name) + 2); 754 starred[0] = '*'; 755 strcpy (starred + 1, name); 756 change_decl_assembler_name (decl, get_identifier (starred)); 757 SET_DECL_RTL (decl, NULL_RTX); 758} 759 760/* Decode an `asm' spec for a declaration as a register name. 761 Return the register number, or -1 if nothing specified, 762 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized, 763 or -3 if ASMSPEC is `cc' and is not recognized, 764 or -4 if ASMSPEC is `memory' and is not recognized. 765 Accept an exact spelling or a decimal number. 766 Prefixes such as % are optional. */ 767 768int 769decode_reg_name (const char *asmspec) 770{ 771 if (asmspec != 0) 772 { 773 int i; 774 775 /* Get rid of confusing prefixes. */ 776 asmspec = strip_reg_name (asmspec); 777 778 /* Allow a decimal number as a "register name". */ 779 for (i = strlen (asmspec) - 1; i >= 0; i--) 780 if (! ISDIGIT (asmspec[i])) 781 break; 782 if (asmspec[0] != 0 && i < 0) 783 { 784 i = atoi (asmspec); 785 if (i < FIRST_PSEUDO_REGISTER && i >= 0) 786 return i; 787 else 788 return -2; 789 } 790 791 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 792 if (reg_names[i][0] 793 && ! strcmp (asmspec, strip_reg_name (reg_names[i]))) 794 return i; 795 796#ifdef ADDITIONAL_REGISTER_NAMES 797 { 798 static const struct { const char *const name; const int number; } table[] 799 = ADDITIONAL_REGISTER_NAMES; 800 801 for (i = 0; i < (int) ARRAY_SIZE (table); i++) 802 if (table[i].name[0] 803 && ! strcmp (asmspec, table[i].name)) 804 return table[i].number; 805 } 806#endif /* ADDITIONAL_REGISTER_NAMES */ 807 808 if (!strcmp (asmspec, "memory")) 809 return -4; 810 811 if (!strcmp (asmspec, "cc")) 812 return -3; 813 814 return -2; 815 } 816 817 return -1; 818} 819 820/* Return true if DECL's initializer is suitable for a BSS section. */ 821 822static bool 823bss_initializer_p (tree decl) 824{ 825 return (DECL_INITIAL (decl) == NULL 826 || DECL_INITIAL (decl) == error_mark_node 827 || (flag_zero_initialized_in_bss 828 /* Leave constant zeroes in .rodata so they 829 can be shared. */ 830 && !TREE_READONLY (decl) 831 && initializer_zerop (DECL_INITIAL (decl)))); 832} 833 834/* Compute the alignment of variable specified by DECL. 835 DONT_OUTPUT_DATA is from assemble_variable. */ 836 837void 838align_variable (tree decl, bool dont_output_data) 839{ 840 unsigned int align = DECL_ALIGN (decl); 841 842 /* In the case for initialing an array whose length isn't specified, 843 where we have not yet been able to do the layout, 844 figure out the proper alignment now. */ 845 if (dont_output_data && DECL_SIZE (decl) == 0 846 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 847 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl)))); 848 849 /* Some object file formats have a maximum alignment which they support. 850 In particular, a.out format supports a maximum alignment of 4. */ 851 if (align > MAX_OFILE_ALIGNMENT) 852 { 853 warning (0, "alignment of %q+D is greater than maximum object " 854 "file alignment. Using %d", decl, 855 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT); 856 align = MAX_OFILE_ALIGNMENT; 857 } 858 859 /* On some machines, it is good to increase alignment sometimes. */ 860 if (! DECL_USER_ALIGN (decl)) 861 { 862#ifdef DATA_ALIGNMENT 863 align = DATA_ALIGNMENT (TREE_TYPE (decl), align); 864#endif 865#ifdef CONSTANT_ALIGNMENT 866 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node) 867 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align); 868#endif 869 } 870 871 /* Reset the alignment in case we have made it tighter, so we can benefit 872 from it in get_pointer_alignment. */ 873 DECL_ALIGN (decl) = align; 874} 875 876/* Return the section into which the given VAR_DECL or CONST_DECL 877 should be placed. PREFER_NOSWITCH_P is true if a noswitch 878 section should be used wherever possible. */ 879 880static section * 881get_variable_section (tree decl, bool prefer_noswitch_p) 882{ 883 int reloc; 884 885 /* If the decl has been given an explicit section name, then it 886 isn't common, and shouldn't be handled as such. */ 887 if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL) 888 { 889 if (DECL_THREAD_LOCAL_P (decl)) 890 return tls_comm_section; 891 if (TREE_PUBLIC (decl) && bss_initializer_p (decl)) 892 return comm_section; 893 } 894 895 if (DECL_INITIAL (decl) == error_mark_node) 896 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0; 897 else if (DECL_INITIAL (decl)) 898 reloc = compute_reloc_for_constant (DECL_INITIAL (decl)); 899 else 900 reloc = 0; 901 902 resolve_unique_section (decl, reloc, flag_data_sections); 903 if (IN_NAMED_SECTION (decl)) 904 return get_named_section (decl, NULL, reloc); 905 906 if (!DECL_THREAD_LOCAL_P (decl) 907 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections) 908 && bss_initializer_p (decl)) 909 { 910 if (!TREE_PUBLIC (decl)) 911 return lcomm_section; 912 if (bss_noswitch_section) 913 return bss_noswitch_section; 914 } 915 916 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl)); 917} 918 919/* Return the block into which object_block DECL should be placed. */ 920 921static struct object_block * 922get_block_for_decl (tree decl) 923{ 924 section *sect; 925 926 if (TREE_CODE (decl) == VAR_DECL) 927 { 928 /* The object must be defined in this translation unit. */ 929 if (DECL_EXTERNAL (decl)) 930 return NULL; 931 932 /* There's no point using object blocks for something that is 933 isolated by definition. */ 934 if (DECL_ONE_ONLY (decl)) 935 return NULL; 936 } 937 938 /* We can only calculate block offsets if the decl has a known 939 constant size. */ 940 if (DECL_SIZE_UNIT (decl) == NULL) 941 return NULL; 942 if (!host_integerp (DECL_SIZE_UNIT (decl), 1)) 943 return NULL; 944 945 /* Find out which section should contain DECL. We cannot put it into 946 an object block if it requires a standalone definition. */ 947 if (TREE_CODE (decl) == VAR_DECL) 948 align_variable (decl, 0); 949 sect = get_variable_section (decl, true); 950 if (SECTION_STYLE (sect) == SECTION_NOSWITCH) 951 return NULL; 952 953 return get_block_for_section (sect); 954} 955 956/* Make sure block symbol SYMBOL is in block BLOCK. */ 957 958static void 959change_symbol_block (rtx symbol, struct object_block *block) 960{ 961 if (block != SYMBOL_REF_BLOCK (symbol)) 962 { 963 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0); 964 SYMBOL_REF_BLOCK (symbol) = block; 965 } 966} 967 968/* Return true if it is possible to put DECL in an object_block. */ 969 970static bool 971use_blocks_for_decl_p (tree decl) 972{ 973 /* Only data DECLs can be placed into object blocks. */ 974 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL) 975 return false; 976 977 /* Detect decls created by dw2_force_const_mem. Such decls are 978 special because DECL_INITIAL doesn't specify the decl's true value. 979 dw2_output_indirect_constants will instead call assemble_variable 980 with dont_output_data set to 1 and then print the contents itself. */ 981 if (DECL_INITIAL (decl) == decl) 982 return false; 983 984 /* If this decl is an alias, then we don't want to emit a definition. */ 985 if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl))) 986 return false; 987 988 return true; 989} 990 991/* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should 992 have static storage duration. In other words, it should not be an 993 automatic variable, including PARM_DECLs. 994 995 There is, however, one exception: this function handles variables 996 explicitly placed in a particular register by the user. 997 998 This is never called for PARM_DECL nodes. */ 999 1000void 1001make_decl_rtl (tree decl) 1002{ 1003 const char *name = 0; 1004 int reg_number; 1005 rtx x; 1006 1007 /* Check that we are not being given an automatic variable. */ 1008 gcc_assert (TREE_CODE (decl) != PARM_DECL 1009 && TREE_CODE (decl) != RESULT_DECL); 1010 1011 /* A weak alias has TREE_PUBLIC set but not the other bits. */ 1012 gcc_assert (TREE_CODE (decl) != VAR_DECL 1013 || TREE_STATIC (decl) 1014 || TREE_PUBLIC (decl) 1015 || DECL_EXTERNAL (decl) 1016 || DECL_REGISTER (decl)); 1017 1018 /* And that we were not given a type or a label. */ 1019 gcc_assert (TREE_CODE (decl) != TYPE_DECL 1020 && TREE_CODE (decl) != LABEL_DECL); 1021 1022 /* For a duplicate declaration, we can be called twice on the 1023 same DECL node. Don't discard the RTL already made. */ 1024 if (DECL_RTL_SET_P (decl)) 1025 { 1026 /* If the old RTL had the wrong mode, fix the mode. */ 1027 x = DECL_RTL (decl); 1028 if (GET_MODE (x) != DECL_MODE (decl)) 1029 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0)); 1030 1031 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)) 1032 return; 1033 1034 /* ??? Another way to do this would be to maintain a hashed 1035 table of such critters. Instead of adding stuff to a DECL 1036 to give certain attributes to it, we could use an external 1037 hash map from DECL to set of attributes. */ 1038 1039 /* Let the target reassign the RTL if it wants. 1040 This is necessary, for example, when one machine specific 1041 decl attribute overrides another. */ 1042 targetm.encode_section_info (decl, DECL_RTL (decl), false); 1043 1044 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based 1045 on the new decl information. */ 1046 if (MEM_P (x) 1047 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF 1048 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0))) 1049 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl)); 1050 1051 /* Make this function static known to the mudflap runtime. */ 1052 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL) 1053 mudflap_enqueue_decl (decl); 1054 1055 return; 1056 } 1057 1058 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 1059 1060 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL 1061 && DECL_REGISTER (decl)) 1062 { 1063 error ("register name not specified for %q+D", decl); 1064 } 1065 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)) 1066 { 1067 const char *asmspec = name+1; 1068 reg_number = decode_reg_name (asmspec); 1069 /* First detect errors in declaring global registers. */ 1070 if (reg_number == -1) 1071 error ("register name not specified for %q+D", decl); 1072 else if (reg_number < 0) 1073 error ("invalid register name for %q+D", decl); 1074 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode) 1075 error ("data type of %q+D isn%'t suitable for a register", 1076 decl); 1077 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl)))) 1078 error ("register specified for %q+D isn%'t suitable for data type", 1079 decl); 1080 /* Now handle properly declared static register variables. */ 1081 else 1082 { 1083 int nregs; 1084 1085 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl)) 1086 { 1087 DECL_INITIAL (decl) = 0; 1088 error ("global register variable has initial value"); 1089 } 1090 if (TREE_THIS_VOLATILE (decl)) 1091 warning (OPT_Wvolatile_register_var, 1092 "optimization may eliminate reads and/or " 1093 "writes to register variables"); 1094 1095 /* If the user specified one of the eliminables registers here, 1096 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable 1097 confused with that register and be eliminated. This usage is 1098 somewhat suspect... */ 1099 1100 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number)); 1101 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number; 1102 REG_USERVAR_P (DECL_RTL (decl)) = 1; 1103 1104 if (TREE_STATIC (decl)) 1105 { 1106 /* Make this register global, so not usable for anything 1107 else. */ 1108#ifdef ASM_DECLARE_REGISTER_GLOBAL 1109 name = IDENTIFIER_POINTER (DECL_NAME (decl)); 1110 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name); 1111#endif 1112 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)]; 1113 while (nregs > 0) 1114 globalize_reg (reg_number + --nregs); 1115 } 1116 1117 /* As a register variable, it has no section. */ 1118 return; 1119 } 1120 } 1121 /* Now handle ordinary static variables and functions (in memory). 1122 Also handle vars declared register invalidly. */ 1123 else if (name[0] == '*') 1124 { 1125#ifdef REGISTER_PREFIX 1126 if (strlen (REGISTER_PREFIX) != 0) 1127 { 1128 reg_number = decode_reg_name (name); 1129 if (reg_number >= 0 || reg_number == -3) 1130 error ("register name given for non-register variable %q+D", decl); 1131 } 1132#endif 1133 } 1134 1135 /* Specifying a section attribute on a variable forces it into a 1136 non-.bss section, and thus it cannot be common. */ 1137 if (TREE_CODE (decl) == VAR_DECL 1138 && DECL_SECTION_NAME (decl) != NULL_TREE 1139 && DECL_INITIAL (decl) == NULL_TREE 1140 && DECL_COMMON (decl)) 1141 DECL_COMMON (decl) = 0; 1142 1143 /* Variables can't be both common and weak. */ 1144 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl)) 1145 DECL_COMMON (decl) = 0; 1146 1147 if (use_object_blocks_p () && use_blocks_for_decl_p (decl)) 1148 x = create_block_symbol (name, get_block_for_decl (decl), -1); 1149 else 1150 x = gen_rtx_SYMBOL_REF (Pmode, name); 1151 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl); 1152 SET_SYMBOL_REF_DECL (x, decl); 1153 1154 x = gen_rtx_MEM (DECL_MODE (decl), x); 1155 if (TREE_CODE (decl) != FUNCTION_DECL) 1156 set_mem_attributes (x, decl, 1); 1157 SET_DECL_RTL (decl, x); 1158 1159 /* Optionally set flags or add text to the name to record information 1160 such as that it is a function name. 1161 If the name is changed, the macro ASM_OUTPUT_LABELREF 1162 will have to know how to strip this information. */ 1163 targetm.encode_section_info (decl, DECL_RTL (decl), true); 1164 1165 /* Make this function static known to the mudflap runtime. */ 1166 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL) 1167 mudflap_enqueue_decl (decl); 1168} 1169 1170/* Output a string of literal assembler code 1171 for an `asm' keyword used between functions. */ 1172 1173void 1174assemble_asm (tree string) 1175{ 1176 app_enable (); 1177 1178 if (TREE_CODE (string) == ADDR_EXPR) 1179 string = TREE_OPERAND (string, 0); 1180 1181 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string)); 1182} 1183 1184/* Record an element in the table of global destructors. SYMBOL is 1185 a SYMBOL_REF of the function to be called; PRIORITY is a number 1186 between 0 and MAX_INIT_PRIORITY. */ 1187 1188void 1189default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED, 1190 int priority ATTRIBUTE_UNUSED) 1191{ 1192#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO 1193 /* Tell GNU LD that this is part of the static destructor set. 1194 This will work for any system that uses stabs, most usefully 1195 aout systems. */ 1196 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */); 1197 dbxout_stab_value_label (XSTR (symbol, 0)); 1198#else 1199 sorry ("global destructors not supported on this target"); 1200#endif 1201} 1202 1203void 1204default_named_section_asm_out_destructor (rtx symbol, int priority) 1205{ 1206 const char *section = ".dtors"; 1207 char buf[16]; 1208 1209 /* ??? This only works reliably with the GNU linker. */ 1210 if (priority != DEFAULT_INIT_PRIORITY) 1211 { 1212 sprintf (buf, ".dtors.%.5u", 1213 /* Invert the numbering so the linker puts us in the proper 1214 order; constructors are run from right to left, and the 1215 linker sorts in increasing order. */ 1216 MAX_INIT_PRIORITY - priority); 1217 section = buf; 1218 } 1219 1220 switch_to_section (get_section (section, SECTION_WRITE, NULL)); 1221 assemble_align (POINTER_SIZE); 1222 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); 1223} 1224 1225#ifdef DTORS_SECTION_ASM_OP 1226void 1227default_dtor_section_asm_out_destructor (rtx symbol, 1228 int priority ATTRIBUTE_UNUSED) 1229{ 1230 switch_to_section (dtors_section); 1231 assemble_align (POINTER_SIZE); 1232 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); 1233} 1234#endif 1235 1236/* Likewise for global constructors. */ 1237 1238void 1239default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED, 1240 int priority ATTRIBUTE_UNUSED) 1241{ 1242#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO 1243 /* Tell GNU LD that this is part of the static destructor set. 1244 This will work for any system that uses stabs, most usefully 1245 aout systems. */ 1246 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */); 1247 dbxout_stab_value_label (XSTR (symbol, 0)); 1248#else 1249 sorry ("global constructors not supported on this target"); 1250#endif 1251} 1252 1253void 1254default_named_section_asm_out_constructor (rtx symbol, int priority) 1255{ 1256 const char *section = ".ctors"; 1257 char buf[16]; 1258 1259 /* ??? This only works reliably with the GNU linker. */ 1260 if (priority != DEFAULT_INIT_PRIORITY) 1261 { 1262 sprintf (buf, ".ctors.%.5u", 1263 /* Invert the numbering so the linker puts us in the proper 1264 order; constructors are run from right to left, and the 1265 linker sorts in increasing order. */ 1266 MAX_INIT_PRIORITY - priority); 1267 section = buf; 1268 } 1269 1270 switch_to_section (get_section (section, SECTION_WRITE, NULL)); 1271 assemble_align (POINTER_SIZE); 1272 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); 1273} 1274 1275#ifdef CTORS_SECTION_ASM_OP 1276void 1277default_ctor_section_asm_out_constructor (rtx symbol, 1278 int priority ATTRIBUTE_UNUSED) 1279{ 1280 switch_to_section (ctors_section); 1281 assemble_align (POINTER_SIZE); 1282 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1); 1283} 1284#endif 1285 1286/* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with 1287 a nonzero value if the constant pool should be output before the 1288 start of the function, or a zero value if the pool should output 1289 after the end of the function. The default is to put it before the 1290 start. */ 1291 1292#ifndef CONSTANT_POOL_BEFORE_FUNCTION 1293#define CONSTANT_POOL_BEFORE_FUNCTION 1 1294#endif 1295 1296/* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going 1297 to be output to assembler. 1298 Set first_global_object_name and weak_global_object_name as appropriate. */ 1299 1300void 1301notice_global_symbol (tree decl) 1302{ 1303 const char **type = &first_global_object_name; 1304 1305 if (first_global_object_name 1306 || !TREE_PUBLIC (decl) 1307 || DECL_EXTERNAL (decl) 1308 || !DECL_NAME (decl) 1309 || (TREE_CODE (decl) != FUNCTION_DECL 1310 && (TREE_CODE (decl) != VAR_DECL 1311 || (DECL_COMMON (decl) 1312 && (DECL_INITIAL (decl) == 0 1313 || DECL_INITIAL (decl) == error_mark_node)))) 1314 || !MEM_P (DECL_RTL (decl))) 1315 return; 1316 1317 /* We win when global object is found, but it is useful to know about weak 1318 symbol as well so we can produce nicer unique names. */ 1319 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl)) 1320 type = &weak_global_object_name; 1321 1322 if (!*type) 1323 { 1324 const char *p; 1325 const char *name; 1326 rtx decl_rtl = DECL_RTL (decl); 1327 1328 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0)); 1329 name = ggc_strdup (p); 1330 1331 *type = name; 1332 } 1333} 1334 1335/* Output assembler code for the constant pool of a function and associated 1336 with defining the name of the function. DECL describes the function. 1337 NAME is the function's name. For the constant pool, we use the current 1338 constant pool data. */ 1339 1340void 1341assemble_start_function (tree decl, const char *fnname) 1342{ 1343 int align; 1344 char tmp_label[100]; 1345 bool hot_label_written = false; 1346 1347 cfun->unlikely_text_section_name = NULL; 1348 1349 first_function_block_is_cold = false; 1350 if (flag_reorder_blocks_and_partition) 1351 { 1352 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno); 1353 cfun->hot_section_label = ggc_strdup (tmp_label); 1354 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno); 1355 cfun->cold_section_label = ggc_strdup (tmp_label); 1356 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno); 1357 cfun->hot_section_end_label = ggc_strdup (tmp_label); 1358 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno); 1359 cfun->cold_section_end_label = ggc_strdup (tmp_label); 1360 const_labelno++; 1361 } 1362 else 1363 { 1364 cfun->hot_section_label = NULL; 1365 cfun->cold_section_label = NULL; 1366 cfun->hot_section_end_label = NULL; 1367 cfun->cold_section_end_label = NULL; 1368 } 1369 1370 /* The following code does not need preprocessing in the assembler. */ 1371 1372 app_disable (); 1373 1374 if (CONSTANT_POOL_BEFORE_FUNCTION) 1375 output_constant_pool (fnname, decl); 1376 1377 resolve_unique_section (decl, 0, flag_function_sections); 1378 1379 /* Make sure the not and cold text (code) sections are properly 1380 aligned. This is necessary here in the case where the function 1381 has both hot and cold sections, because we don't want to re-set 1382 the alignment when the section switch happens mid-function. */ 1383 1384 if (flag_reorder_blocks_and_partition) 1385 { 1386 switch_to_section (unlikely_text_section ()); 1387 assemble_align (FUNCTION_BOUNDARY); 1388 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label); 1389 1390 /* When the function starts with a cold section, we need to explicitly 1391 align the hot section and write out the hot section label. 1392 But if the current function is a thunk, we do not have a CFG. */ 1393 if (!current_function_is_thunk 1394 && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION) 1395 { 1396 switch_to_section (text_section); 1397 assemble_align (FUNCTION_BOUNDARY); 1398 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label); 1399 hot_label_written = true; 1400 first_function_block_is_cold = true; 1401 } 1402 } 1403 else if (DECL_SECTION_NAME (decl)) 1404 { 1405 /* Calls to function_section rely on first_function_block_is_cold 1406 being accurate. The first block may be cold even if we aren't 1407 doing partitioning, if the entire function was decided by 1408 choose_function_section (predict.c) to be cold. */ 1409 1410 initialize_cold_section_name (); 1411 1412 if (cfun->unlikely_text_section_name 1413 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), 1414 cfun->unlikely_text_section_name) == 0) 1415 first_function_block_is_cold = true; 1416 } 1417 1418 in_cold_section_p = first_function_block_is_cold; 1419 1420 /* Switch to the correct text section for the start of the function. */ 1421 1422 switch_to_section (function_section (decl)); 1423 if (flag_reorder_blocks_and_partition 1424 && !hot_label_written) 1425 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label); 1426 1427 /* Tell assembler to move to target machine's alignment for functions. */ 1428 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT); 1429 if (align < force_align_functions_log) 1430 align = force_align_functions_log; 1431 if (align > 0) 1432 { 1433 ASM_OUTPUT_ALIGN (asm_out_file, align); 1434 } 1435 1436 /* Handle a user-specified function alignment. 1437 Note that we still need to align to FUNCTION_BOUNDARY, as above, 1438 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */ 1439 if (align_functions_log > align 1440 && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED) 1441 { 1442#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN 1443 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file, 1444 align_functions_log, align_functions - 1); 1445#else 1446 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log); 1447#endif 1448 } 1449 1450#ifdef ASM_OUTPUT_FUNCTION_PREFIX 1451 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname); 1452#endif 1453 1454 (*debug_hooks->begin_function) (decl); 1455 1456 /* Make function name accessible from other files, if appropriate. */ 1457 1458 if (TREE_PUBLIC (decl)) 1459 { 1460 notice_global_symbol (decl); 1461 1462 globalize_decl (decl); 1463 1464 maybe_assemble_visibility (decl); 1465 } 1466 1467 if (DECL_PRESERVE_P (decl)) 1468 targetm.asm_out.mark_decl_preserved (fnname); 1469 1470 /* Do any machine/system dependent processing of the function name. */ 1471#ifdef ASM_DECLARE_FUNCTION_NAME 1472 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl); 1473#else 1474 /* Standard thing is just output label for the function. */ 1475 ASM_OUTPUT_LABEL (asm_out_file, fnname); 1476#endif /* ASM_DECLARE_FUNCTION_NAME */ 1477} 1478 1479/* Output assembler code associated with defining the size of the 1480 function. DECL describes the function. NAME is the function's name. */ 1481 1482void 1483assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED) 1484{ 1485#ifdef ASM_DECLARE_FUNCTION_SIZE 1486 /* We could have switched section in the middle of the function. */ 1487 if (flag_reorder_blocks_and_partition) 1488 switch_to_section (function_section (decl)); 1489 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl); 1490#endif 1491 if (! CONSTANT_POOL_BEFORE_FUNCTION) 1492 { 1493 output_constant_pool (fnname, decl); 1494 switch_to_section (function_section (decl)); /* need to switch back */ 1495 } 1496 /* Output labels for end of hot/cold text sections (to be used by 1497 debug info.) */ 1498 if (flag_reorder_blocks_and_partition) 1499 { 1500 section *save_text_section; 1501 1502 save_text_section = in_section; 1503 switch_to_section (unlikely_text_section ()); 1504 ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label); 1505 if (first_function_block_is_cold) 1506 switch_to_section (text_section); 1507 else 1508 switch_to_section (function_section (decl)); 1509 ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label); 1510 switch_to_section (save_text_section); 1511 } 1512} 1513 1514/* Assemble code to leave SIZE bytes of zeros. */ 1515 1516void 1517assemble_zeros (unsigned HOST_WIDE_INT size) 1518{ 1519 /* Do no output if -fsyntax-only. */ 1520 if (flag_syntax_only) 1521 return; 1522 1523#ifdef ASM_NO_SKIP_IN_TEXT 1524 /* The `space' pseudo in the text section outputs nop insns rather than 0s, 1525 so we must output 0s explicitly in the text section. */ 1526 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0) 1527 { 1528 unsigned HOST_WIDE_INT i; 1529 for (i = 0; i < size; i++) 1530 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1); 1531 } 1532 else 1533#endif 1534 if (size > 0) 1535 ASM_OUTPUT_SKIP (asm_out_file, size); 1536} 1537 1538/* Assemble an alignment pseudo op for an ALIGN-bit boundary. */ 1539 1540void 1541assemble_align (int align) 1542{ 1543 if (align > BITS_PER_UNIT) 1544 { 1545 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT)); 1546 } 1547} 1548 1549/* Assemble a string constant with the specified C string as contents. */ 1550 1551void 1552assemble_string (const char *p, int size) 1553{ 1554 int pos = 0; 1555 int maximum = 2000; 1556 1557 /* If the string is very long, split it up. */ 1558 1559 while (pos < size) 1560 { 1561 int thissize = size - pos; 1562 if (thissize > maximum) 1563 thissize = maximum; 1564 1565 ASM_OUTPUT_ASCII (asm_out_file, p, thissize); 1566 1567 pos += thissize; 1568 p += thissize; 1569 } 1570} 1571 1572 1573/* A noswitch_section_callback for lcomm_section. */ 1574 1575static bool 1576emit_local (tree decl ATTRIBUTE_UNUSED, 1577 const char *name ATTRIBUTE_UNUSED, 1578 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1579 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1580{ 1581#if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL 1582 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, 1583 size, DECL_ALIGN (decl)); 1584 return true; 1585#elif defined ASM_OUTPUT_ALIGNED_LOCAL 1586 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl)); 1587 return true; 1588#else 1589 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); 1590 return false; 1591#endif 1592} 1593 1594/* A noswitch_section_callback for bss_noswitch_section. */ 1595 1596#if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS 1597static bool 1598emit_bss (tree decl ATTRIBUTE_UNUSED, 1599 const char *name ATTRIBUTE_UNUSED, 1600 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1601 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1602{ 1603#if defined ASM_OUTPUT_ALIGNED_BSS 1604 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl)); 1605 return true; 1606#else 1607 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded); 1608 return false; 1609#endif 1610} 1611#endif 1612 1613/* A noswitch_section_callback for comm_section. */ 1614 1615static bool 1616emit_common (tree decl ATTRIBUTE_UNUSED, 1617 const char *name ATTRIBUTE_UNUSED, 1618 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1619 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1620{ 1621#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON 1622 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, 1623 size, DECL_ALIGN (decl)); 1624 return true; 1625#elif defined ASM_OUTPUT_ALIGNED_COMMON 1626 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl)); 1627 return true; 1628#else 1629 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded); 1630 return false; 1631#endif 1632} 1633 1634/* A noswitch_section_callback for tls_comm_section. */ 1635 1636static bool 1637emit_tls_common (tree decl ATTRIBUTE_UNUSED, 1638 const char *name ATTRIBUTE_UNUSED, 1639 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED, 1640 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED) 1641{ 1642#ifdef ASM_OUTPUT_TLS_COMMON 1643 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size); 1644 return true; 1645#else 1646 sorry ("thread-local COMMON data not implemented"); 1647 return true; 1648#endif 1649} 1650 1651/* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT. 1652 NAME is the name of DECL's SYMBOL_REF. */ 1653 1654static void 1655assemble_noswitch_variable (tree decl, const char *name, section *sect) 1656{ 1657 unsigned HOST_WIDE_INT size, rounded; 1658 1659 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1); 1660 rounded = size; 1661 1662 /* Don't allocate zero bytes of common, 1663 since that means "undefined external" in the linker. */ 1664 if (size == 0) 1665 rounded = 1; 1666 1667 /* Round size up to multiple of BIGGEST_ALIGNMENT bits 1668 so that each uninitialized object starts on such a boundary. */ 1669 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1; 1670 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 1671 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 1672 1673 if (!sect->noswitch.callback (decl, name, size, rounded) 1674 && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded) 1675 warning (0, "requested alignment for %q+D is greater than " 1676 "implemented alignment of %wu", decl, rounded); 1677} 1678 1679/* A subroutine of assemble_variable. Output the label and contents of 1680 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA 1681 is as for assemble_variable. */ 1682 1683static void 1684assemble_variable_contents (tree decl, const char *name, 1685 bool dont_output_data) 1686{ 1687 /* Do any machine/system dependent processing of the object. */ 1688#ifdef ASM_DECLARE_OBJECT_NAME 1689 last_assemble_variable_decl = decl; 1690 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl); 1691#else 1692 /* Standard thing is just output label for the object. */ 1693 ASM_OUTPUT_LABEL (asm_out_file, name); 1694#endif /* ASM_DECLARE_OBJECT_NAME */ 1695 1696 if (!dont_output_data) 1697 { 1698 if (DECL_INITIAL (decl) 1699 && DECL_INITIAL (decl) != error_mark_node 1700 && !initializer_zerop (DECL_INITIAL (decl))) 1701 /* Output the actual data. */ 1702 output_constant (DECL_INITIAL (decl), 1703 tree_low_cst (DECL_SIZE_UNIT (decl), 1), 1704 DECL_ALIGN (decl)); 1705 else 1706 /* Leave space for it. */ 1707 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1)); 1708 } 1709} 1710 1711/* Assemble everything that is needed for a variable or function declaration. 1712 Not used for automatic variables, and not used for function definitions. 1713 Should not be called for variables of incomplete structure type. 1714 1715 TOP_LEVEL is nonzero if this variable has file scope. 1716 AT_END is nonzero if this is the special handling, at end of compilation, 1717 to define things that have had only tentative definitions. 1718 DONT_OUTPUT_DATA if nonzero means don't actually output the 1719 initial value (that will be done by the caller). */ 1720 1721void 1722assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, 1723 int at_end ATTRIBUTE_UNUSED, int dont_output_data) 1724{ 1725 const char *name; 1726 rtx decl_rtl, symbol; 1727 section *sect; 1728 1729 if (lang_hooks.decls.prepare_assemble_variable) 1730 lang_hooks.decls.prepare_assemble_variable (decl); 1731 1732 last_assemble_variable_decl = 0; 1733 1734 /* Normally no need to say anything here for external references, 1735 since assemble_external is called by the language-specific code 1736 when a declaration is first seen. */ 1737 1738 if (DECL_EXTERNAL (decl)) 1739 return; 1740 1741 /* Output no assembler code for a function declaration. 1742 Only definitions of functions output anything. */ 1743 1744 if (TREE_CODE (decl) == FUNCTION_DECL) 1745 return; 1746 1747 /* Do nothing for global register variables. */ 1748 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl))) 1749 { 1750 TREE_ASM_WRITTEN (decl) = 1; 1751 return; 1752 } 1753 1754 /* If type was incomplete when the variable was declared, 1755 see if it is complete now. */ 1756 1757 if (DECL_SIZE (decl) == 0) 1758 layout_decl (decl, 0); 1759 1760 /* Still incomplete => don't allocate it; treat the tentative defn 1761 (which is what it must have been) as an `extern' reference. */ 1762 1763 if (!dont_output_data && DECL_SIZE (decl) == 0) 1764 { 1765 error ("storage size of %q+D isn%'t known", decl); 1766 TREE_ASM_WRITTEN (decl) = 1; 1767 return; 1768 } 1769 1770 /* The first declaration of a variable that comes through this function 1771 decides whether it is global (in C, has external linkage) 1772 or local (in C, has internal linkage). So do nothing more 1773 if this function has already run. */ 1774 1775 if (TREE_ASM_WRITTEN (decl)) 1776 return; 1777 1778 /* Make sure targetm.encode_section_info is invoked before we set 1779 ASM_WRITTEN. */ 1780 decl_rtl = DECL_RTL (decl); 1781 1782 TREE_ASM_WRITTEN (decl) = 1; 1783 1784 /* Do no output if -fsyntax-only. */ 1785 if (flag_syntax_only) 1786 return; 1787 1788 app_disable (); 1789 1790 if (! dont_output_data 1791 && ! host_integerp (DECL_SIZE_UNIT (decl), 1)) 1792 { 1793 error ("size of variable %q+D is too large", decl); 1794 return; 1795 } 1796 1797 gcc_assert (MEM_P (decl_rtl)); 1798 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF); 1799 symbol = XEXP (decl_rtl, 0); 1800 name = XSTR (symbol, 0); 1801 if (TREE_PUBLIC (decl) && DECL_NAME (decl)) 1802 notice_global_symbol (decl); 1803 1804 /* Compute the alignment of this data. */ 1805 1806 align_variable (decl, dont_output_data); 1807 set_mem_align (decl_rtl, DECL_ALIGN (decl)); 1808 1809 if (TREE_PUBLIC (decl)) 1810 maybe_assemble_visibility (decl); 1811 1812 if (DECL_PRESERVE_P (decl)) 1813 targetm.asm_out.mark_decl_preserved (name); 1814 1815 /* First make the assembler name(s) global if appropriate. */ 1816 sect = get_variable_section (decl, false); 1817 if (TREE_PUBLIC (decl) 1818 && DECL_NAME (decl) 1819 && (sect->common.flags & SECTION_COMMON) == 0) 1820 globalize_decl (decl); 1821 1822 /* Output any data that we will need to use the address of. */ 1823 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node) 1824 output_addressed_constants (DECL_INITIAL (decl)); 1825 1826 /* dbxout.c needs to know this. */ 1827 if (sect && (sect->common.flags & SECTION_CODE) != 0) 1828 DECL_IN_TEXT_SECTION (decl) = 1; 1829 1830 /* If the decl is part of an object_block, make sure that the decl 1831 has been positioned within its block, but do not write out its 1832 definition yet. output_object_blocks will do that later. */ 1833 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol)) 1834 { 1835 gcc_assert (!dont_output_data); 1836 place_block_symbol (symbol); 1837 } 1838 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH) 1839 assemble_noswitch_variable (decl, name, sect); 1840 else 1841 { 1842 switch_to_section (sect); 1843 if (DECL_ALIGN (decl) > BITS_PER_UNIT) 1844 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl))); 1845 assemble_variable_contents (decl, name, dont_output_data); 1846 } 1847} 1848 1849/* Return 1 if type TYPE contains any pointers. */ 1850 1851static int 1852contains_pointers_p (tree type) 1853{ 1854 switch (TREE_CODE (type)) 1855 { 1856 case POINTER_TYPE: 1857 case REFERENCE_TYPE: 1858 /* I'm not sure whether OFFSET_TYPE needs this treatment, 1859 so I'll play safe and return 1. */ 1860 case OFFSET_TYPE: 1861 return 1; 1862 1863 case RECORD_TYPE: 1864 case UNION_TYPE: 1865 case QUAL_UNION_TYPE: 1866 { 1867 tree fields; 1868 /* For a type that has fields, see if the fields have pointers. */ 1869 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields)) 1870 if (TREE_CODE (fields) == FIELD_DECL 1871 && contains_pointers_p (TREE_TYPE (fields))) 1872 return 1; 1873 return 0; 1874 } 1875 1876 case ARRAY_TYPE: 1877 /* An array type contains pointers if its element type does. */ 1878 return contains_pointers_p (TREE_TYPE (type)); 1879 1880 default: 1881 return 0; 1882 } 1883} 1884 1885/* In unit-at-a-time mode, we delay assemble_external processing until 1886 the compilation unit is finalized. This is the best we can do for 1887 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay 1888 it all the way to final. See PR 17982 for further discussion. */ 1889static GTY(()) tree pending_assemble_externals; 1890 1891#ifdef ASM_OUTPUT_EXTERNAL 1892/* True if DECL is a function decl for which no out-of-line copy exists. 1893 It is assumed that DECL's assembler name has been set. */ 1894 1895static bool 1896incorporeal_function_p (tree decl) 1897{ 1898 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) 1899 { 1900 const char *name; 1901 1902 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 1903 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA) 1904 return true; 1905 1906 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 1907 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0) 1908 return true; 1909 } 1910 return false; 1911} 1912 1913/* Actually do the tests to determine if this is necessary, and invoke 1914 ASM_OUTPUT_EXTERNAL. */ 1915static void 1916assemble_external_real (tree decl) 1917{ 1918 rtx rtl = DECL_RTL (decl); 1919 1920 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF 1921 && !SYMBOL_REF_USED (XEXP (rtl, 0)) 1922 && !incorporeal_function_p (decl)) 1923 { 1924 /* Some systems do require some output. */ 1925 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1; 1926 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0)); 1927 } 1928} 1929#endif 1930 1931void 1932process_pending_assemble_externals (void) 1933{ 1934#ifdef ASM_OUTPUT_EXTERNAL 1935 tree list; 1936 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list)) 1937 assemble_external_real (TREE_VALUE (list)); 1938 1939 pending_assemble_externals = 0; 1940#endif 1941} 1942 1943/* Output something to declare an external symbol to the assembler. 1944 (Most assemblers don't need this, so we normally output nothing.) 1945 Do nothing if DECL is not external. */ 1946 1947void 1948assemble_external (tree decl ATTRIBUTE_UNUSED) 1949{ 1950 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the 1951 main body of this code is only rarely exercised. To provide some 1952 testing, on all platforms, we make sure that the ASM_OUT_FILE is 1953 open. If it's not, we should not be calling this function. */ 1954 gcc_assert (asm_out_file); 1955 1956#ifdef ASM_OUTPUT_EXTERNAL 1957 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl)) 1958 return; 1959 1960 if (flag_unit_at_a_time) 1961 pending_assemble_externals = tree_cons (0, decl, 1962 pending_assemble_externals); 1963 else 1964 assemble_external_real (decl); 1965#endif 1966} 1967 1968/* Similar, for calling a library function FUN. */ 1969 1970void 1971assemble_external_libcall (rtx fun) 1972{ 1973 /* Declare library function name external when first used, if nec. */ 1974 if (! SYMBOL_REF_USED (fun)) 1975 { 1976 SYMBOL_REF_USED (fun) = 1; 1977 targetm.asm_out.external_libcall (fun); 1978 } 1979} 1980 1981/* Assemble a label named NAME. */ 1982 1983void 1984assemble_label (const char *name) 1985{ 1986 ASM_OUTPUT_LABEL (asm_out_file, name); 1987} 1988 1989/* Set the symbol_referenced flag for ID. */ 1990void 1991mark_referenced (tree id) 1992{ 1993 TREE_SYMBOL_REFERENCED (id) = 1; 1994} 1995 1996/* Set the symbol_referenced flag for DECL and notify callgraph. */ 1997void 1998mark_decl_referenced (tree decl) 1999{ 2000 if (TREE_CODE (decl) == FUNCTION_DECL) 2001 { 2002 /* Extern inline functions don't become needed when referenced. 2003 If we know a method will be emitted in other TU and no new 2004 functions can be marked reachable, just use the external 2005 definition. */ 2006 struct cgraph_node *node = cgraph_node (decl); 2007 if (!DECL_EXTERNAL (decl) 2008 && (!node->local.vtable_method || !cgraph_global_info_ready 2009 || !node->local.finalized)) 2010 cgraph_mark_needed_node (node); 2011 } 2012 else if (TREE_CODE (decl) == VAR_DECL) 2013 { 2014 struct cgraph_varpool_node *node = cgraph_varpool_node (decl); 2015 cgraph_varpool_mark_needed_node (node); 2016 /* C++ frontend use mark_decl_references to force COMDAT variables 2017 to be output that might appear dead otherwise. */ 2018 node->force_output = true; 2019 } 2020 /* else do nothing - we can get various sorts of CST nodes here, 2021 which do not need to be marked. */ 2022} 2023 2024 2025/* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS 2026 until we find an identifier that is not itself a transparent alias. 2027 Modify the alias passed to it by reference (and all aliases on the 2028 way to the ultimate target), such that they do not have to be 2029 followed again, and return the ultimate target of the alias 2030 chain. */ 2031 2032static inline tree 2033ultimate_transparent_alias_target (tree *alias) 2034{ 2035 tree target = *alias; 2036 2037 if (IDENTIFIER_TRANSPARENT_ALIAS (target)) 2038 { 2039 gcc_assert (TREE_CHAIN (target)); 2040 target = ultimate_transparent_alias_target (&TREE_CHAIN (target)); 2041 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target) 2042 && ! TREE_CHAIN (target)); 2043 *alias = target; 2044 } 2045 2046 return target; 2047} 2048 2049/* Output to FILE (an assembly file) a reference to NAME. If NAME 2050 starts with a *, the rest of NAME is output verbatim. Otherwise 2051 NAME is transformed in a target-specific way (usually by the 2052 addition of an underscore). */ 2053 2054void 2055assemble_name_raw (FILE *file, const char *name) 2056{ 2057 if (name[0] == '*') 2058 fputs (&name[1], file); 2059 else 2060 ASM_OUTPUT_LABELREF (file, name); 2061} 2062 2063/* Like assemble_name_raw, but should be used when NAME might refer to 2064 an entity that is also represented as a tree (like a function or 2065 variable). If NAME does refer to such an entity, that entity will 2066 be marked as referenced. */ 2067 2068void 2069assemble_name (FILE *file, const char *name) 2070{ 2071 const char *real_name; 2072 tree id; 2073 2074 real_name = targetm.strip_name_encoding (name); 2075 2076 id = maybe_get_identifier (real_name); 2077 if (id) 2078 { 2079 tree id_orig = id; 2080 2081 mark_referenced (id); 2082 ultimate_transparent_alias_target (&id); 2083 if (id != id_orig) 2084 name = IDENTIFIER_POINTER (id); 2085 gcc_assert (! TREE_CHAIN (id)); 2086 } 2087 2088 assemble_name_raw (file, name); 2089} 2090 2091/* Allocate SIZE bytes writable static space with a gensym name 2092 and return an RTX to refer to its address. */ 2093 2094rtx 2095assemble_static_space (unsigned HOST_WIDE_INT size) 2096{ 2097 char name[12]; 2098 const char *namestring; 2099 rtx x; 2100 2101 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno); 2102 ++const_labelno; 2103 namestring = ggc_strdup (name); 2104 2105 x = gen_rtx_SYMBOL_REF (Pmode, namestring); 2106 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL; 2107 2108#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL 2109 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size, 2110 BIGGEST_ALIGNMENT); 2111#else 2112#ifdef ASM_OUTPUT_ALIGNED_LOCAL 2113 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT); 2114#else 2115 { 2116 /* Round size up to multiple of BIGGEST_ALIGNMENT bits 2117 so that each uninitialized object starts on such a boundary. */ 2118 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */ 2119 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED 2120 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1) 2121 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 2122 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 2123 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); 2124 } 2125#endif 2126#endif 2127 return x; 2128} 2129 2130/* Assemble the static constant template for function entry trampolines. 2131 This is done at most once per compilation. 2132 Returns an RTX for the address of the template. */ 2133 2134static GTY(()) rtx initial_trampoline; 2135 2136#ifdef TRAMPOLINE_TEMPLATE 2137rtx 2138assemble_trampoline_template (void) 2139{ 2140 char label[256]; 2141 const char *name; 2142 int align; 2143 rtx symbol; 2144 2145 if (initial_trampoline) 2146 return initial_trampoline; 2147 2148 /* By default, put trampoline templates in read-only data section. */ 2149 2150#ifdef TRAMPOLINE_SECTION 2151 switch_to_section (TRAMPOLINE_SECTION); 2152#else 2153 switch_to_section (readonly_data_section); 2154#endif 2155 2156 /* Write the assembler code to define one. */ 2157 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT); 2158 if (align > 0) 2159 { 2160 ASM_OUTPUT_ALIGN (asm_out_file, align); 2161 } 2162 2163 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0); 2164 TRAMPOLINE_TEMPLATE (asm_out_file); 2165 2166 /* Record the rtl to refer to it. */ 2167 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0); 2168 name = ggc_strdup (label); 2169 symbol = gen_rtx_SYMBOL_REF (Pmode, name); 2170 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL; 2171 2172 initial_trampoline = gen_rtx_MEM (BLKmode, symbol); 2173 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT); 2174 2175 return initial_trampoline; 2176} 2177#endif 2178 2179/* A and B are either alignments or offsets. Return the minimum alignment 2180 that may be assumed after adding the two together. */ 2181 2182static inline unsigned 2183min_align (unsigned int a, unsigned int b) 2184{ 2185 return (a | b) & -(a | b); 2186} 2187 2188/* Return the assembler directive for creating a given kind of integer 2189 object. SIZE is the number of bytes in the object and ALIGNED_P 2190 indicates whether it is known to be aligned. Return NULL if the 2191 assembly dialect has no such directive. 2192 2193 The returned string should be printed at the start of a new line and 2194 be followed immediately by the object's initial value. */ 2195 2196const char * 2197integer_asm_op (int size, int aligned_p) 2198{ 2199 struct asm_int_op *ops; 2200 2201 if (aligned_p) 2202 ops = &targetm.asm_out.aligned_op; 2203 else 2204 ops = &targetm.asm_out.unaligned_op; 2205 2206 switch (size) 2207 { 2208 case 1: 2209 return targetm.asm_out.byte_op; 2210 case 2: 2211 return ops->hi; 2212 case 4: 2213 return ops->si; 2214 case 8: 2215 return ops->di; 2216 case 16: 2217 return ops->ti; 2218 default: 2219 return NULL; 2220 } 2221} 2222 2223/* Use directive OP to assemble an integer object X. Print OP at the 2224 start of the line, followed immediately by the value of X. */ 2225 2226void 2227assemble_integer_with_op (const char *op, rtx x) 2228{ 2229 fputs (op, asm_out_file); 2230 output_addr_const (asm_out_file, x); 2231 fputc ('\n', asm_out_file); 2232} 2233 2234/* The default implementation of the asm_out.integer target hook. */ 2235 2236bool 2237default_assemble_integer (rtx x ATTRIBUTE_UNUSED, 2238 unsigned int size ATTRIBUTE_UNUSED, 2239 int aligned_p ATTRIBUTE_UNUSED) 2240{ 2241 const char *op = integer_asm_op (size, aligned_p); 2242 /* Avoid GAS bugs for large values. Specifically negative values whose 2243 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */ 2244 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT) 2245 return false; 2246 return op && (assemble_integer_with_op (op, x), true); 2247} 2248 2249/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is 2250 the alignment of the integer in bits. Return 1 if we were able to output 2251 the constant, otherwise 0. We must be able to output the constant, 2252 if FORCE is nonzero. */ 2253 2254bool 2255assemble_integer (rtx x, unsigned int size, unsigned int align, int force) 2256{ 2257 int aligned_p; 2258 2259 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT)); 2260 2261 /* See if the target hook can handle this kind of object. */ 2262 if (targetm.asm_out.integer (x, size, aligned_p)) 2263 return true; 2264 2265 /* If the object is a multi-byte one, try splitting it up. Split 2266 it into words it if is multi-word, otherwise split it into bytes. */ 2267 if (size > 1) 2268 { 2269 enum machine_mode omode, imode; 2270 unsigned int subalign; 2271 unsigned int subsize, i; 2272 2273 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1; 2274 subalign = MIN (align, subsize * BITS_PER_UNIT); 2275 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0); 2276 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); 2277 2278 for (i = 0; i < size; i += subsize) 2279 { 2280 rtx partial = simplify_subreg (omode, x, imode, i); 2281 if (!partial || !assemble_integer (partial, subsize, subalign, 0)) 2282 break; 2283 } 2284 if (i == size) 2285 return true; 2286 2287 /* If we've printed some of it, but not all of it, there's no going 2288 back now. */ 2289 gcc_assert (!i); 2290 } 2291 2292 gcc_assert (!force); 2293 2294 return false; 2295} 2296 2297void 2298assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align) 2299{ 2300 long data[4] = {0, 0, 0, 0}; 2301 int i; 2302 int bitsize, nelts, nunits, units_per; 2303 2304 /* This is hairy. We have a quantity of known size. real_to_target 2305 will put it into an array of *host* longs, 32 bits per element 2306 (even if long is more than 32 bits). We need to determine the 2307 number of array elements that are occupied (nelts) and the number 2308 of *target* min-addressable units that will be occupied in the 2309 object file (nunits). We cannot assume that 32 divides the 2310 mode's bitsize (size * BITS_PER_UNIT) evenly. 2311 2312 size * BITS_PER_UNIT is used here to make sure that padding bits 2313 (which might appear at either end of the value; real_to_target 2314 will include the padding bits in its output array) are included. */ 2315 2316 nunits = GET_MODE_SIZE (mode); 2317 bitsize = nunits * BITS_PER_UNIT; 2318 nelts = CEIL (bitsize, 32); 2319 units_per = 32 / BITS_PER_UNIT; 2320 2321 real_to_target (data, &d, mode); 2322 2323 /* Put out the first word with the specified alignment. */ 2324 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1); 2325 nunits -= units_per; 2326 2327 /* Subsequent words need only 32-bit alignment. */ 2328 align = min_align (align, 32); 2329 2330 for (i = 1; i < nelts; i++) 2331 { 2332 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1); 2333 nunits -= units_per; 2334 } 2335} 2336 2337/* Given an expression EXP with a constant value, 2338 reduce it to the sum of an assembler symbol and an integer. 2339 Store them both in the structure *VALUE. 2340 EXP must be reducible. */ 2341 2342struct addr_const GTY(()) 2343{ 2344 rtx base; 2345 HOST_WIDE_INT offset; 2346}; 2347 2348static void 2349decode_addr_const (tree exp, struct addr_const *value) 2350{ 2351 tree target = TREE_OPERAND (exp, 0); 2352 int offset = 0; 2353 rtx x; 2354 2355 while (1) 2356 { 2357 if (TREE_CODE (target) == COMPONENT_REF 2358 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0)) 2359 2360 { 2361 offset += int_byte_position (TREE_OPERAND (target, 1)); 2362 target = TREE_OPERAND (target, 0); 2363 } 2364 else if (TREE_CODE (target) == ARRAY_REF 2365 || TREE_CODE (target) == ARRAY_RANGE_REF) 2366 { 2367 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1) 2368 * tree_low_cst (TREE_OPERAND (target, 1), 0)); 2369 target = TREE_OPERAND (target, 0); 2370 } 2371 else 2372 break; 2373 } 2374 2375 switch (TREE_CODE (target)) 2376 { 2377 case VAR_DECL: 2378 case FUNCTION_DECL: 2379 x = DECL_RTL (target); 2380 break; 2381 2382 case LABEL_DECL: 2383 x = gen_rtx_MEM (FUNCTION_MODE, 2384 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target))); 2385 break; 2386 2387 case REAL_CST: 2388 case STRING_CST: 2389 case COMPLEX_CST: 2390 case CONSTRUCTOR: 2391 case INTEGER_CST: 2392 x = output_constant_def (target, 1); 2393 break; 2394 2395 default: 2396 gcc_unreachable (); 2397 } 2398 2399 gcc_assert (MEM_P (x)); 2400 x = XEXP (x, 0); 2401 2402 value->base = x; 2403 value->offset = offset; 2404} 2405 2406/* Uniquize all constants that appear in memory. 2407 Each constant in memory thus far output is recorded 2408 in `const_desc_table'. */ 2409 2410struct constant_descriptor_tree GTY(()) 2411{ 2412 /* A MEM for the constant. */ 2413 rtx rtl; 2414 2415 /* The value of the constant. */ 2416 tree value; 2417 2418 /* Hash of value. Computing the hash from value each time 2419 hashfn is called can't work properly, as that means recursive 2420 use of the hash table during hash table expansion. */ 2421 hashval_t hash; 2422}; 2423 2424static GTY((param_is (struct constant_descriptor_tree))) 2425 htab_t const_desc_htab; 2426 2427static struct constant_descriptor_tree * build_constant_desc (tree); 2428static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int); 2429 2430/* Compute a hash code for a constant expression. */ 2431 2432static hashval_t 2433const_desc_hash (const void *ptr) 2434{ 2435 return ((struct constant_descriptor_tree *)ptr)->hash; 2436} 2437 2438static hashval_t 2439const_hash_1 (const tree exp) 2440{ 2441 const char *p; 2442 hashval_t hi; 2443 int len, i; 2444 enum tree_code code = TREE_CODE (exp); 2445 2446 /* Either set P and LEN to the address and len of something to hash and 2447 exit the switch or return a value. */ 2448 2449 switch (code) 2450 { 2451 case INTEGER_CST: 2452 p = (char *) &TREE_INT_CST (exp); 2453 len = sizeof TREE_INT_CST (exp); 2454 break; 2455 2456 case REAL_CST: 2457 return real_hash (TREE_REAL_CST_PTR (exp)); 2458 2459 case STRING_CST: 2460 p = TREE_STRING_POINTER (exp); 2461 len = TREE_STRING_LENGTH (exp); 2462 break; 2463 2464 case COMPLEX_CST: 2465 return (const_hash_1 (TREE_REALPART (exp)) * 5 2466 + const_hash_1 (TREE_IMAGPART (exp))); 2467 2468 case CONSTRUCTOR: 2469 { 2470 unsigned HOST_WIDE_INT idx; 2471 tree value; 2472 2473 hi = 5 + int_size_in_bytes (TREE_TYPE (exp)); 2474 2475 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value) 2476 if (value) 2477 hi = hi * 603 + const_hash_1 (value); 2478 2479 return hi; 2480 } 2481 2482 case ADDR_EXPR: 2483 case FDESC_EXPR: 2484 { 2485 struct addr_const value; 2486 2487 decode_addr_const (exp, &value); 2488 switch (GET_CODE (value.base)) 2489 { 2490 case SYMBOL_REF: 2491 /* Don't hash the address of the SYMBOL_REF; 2492 only use the offset and the symbol name. */ 2493 hi = value.offset; 2494 p = XSTR (value.base, 0); 2495 for (i = 0; p[i] != 0; i++) 2496 hi = ((hi * 613) + (unsigned) (p[i])); 2497 break; 2498 2499 case LABEL_REF: 2500 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13; 2501 break; 2502 2503 default: 2504 gcc_unreachable (); 2505 } 2506 } 2507 return hi; 2508 2509 case PLUS_EXPR: 2510 case MINUS_EXPR: 2511 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9 2512 + const_hash_1 (TREE_OPERAND (exp, 1))); 2513 2514 case NOP_EXPR: 2515 case CONVERT_EXPR: 2516 case NON_LVALUE_EXPR: 2517 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2; 2518 2519 default: 2520 /* A language specific constant. Just hash the code. */ 2521 return code; 2522 } 2523 2524 /* Compute hashing function. */ 2525 hi = len; 2526 for (i = 0; i < len; i++) 2527 hi = ((hi * 613) + (unsigned) (p[i])); 2528 2529 return hi; 2530} 2531 2532/* Wrapper of compare_constant, for the htab interface. */ 2533static int 2534const_desc_eq (const void *p1, const void *p2) 2535{ 2536 const struct constant_descriptor_tree *c1 = p1; 2537 const struct constant_descriptor_tree *c2 = p2; 2538 if (c1->hash != c2->hash) 2539 return 0; 2540 return compare_constant (c1->value, c2->value); 2541} 2542 2543/* Compare t1 and t2, and return 1 only if they are known to result in 2544 the same bit pattern on output. */ 2545 2546static int 2547compare_constant (const tree t1, const tree t2) 2548{ 2549 enum tree_code typecode; 2550 2551 if (t1 == NULL_TREE) 2552 return t2 == NULL_TREE; 2553 if (t2 == NULL_TREE) 2554 return 0; 2555 2556 if (TREE_CODE (t1) != TREE_CODE (t2)) 2557 return 0; 2558 2559 switch (TREE_CODE (t1)) 2560 { 2561 case INTEGER_CST: 2562 /* Integer constants are the same only if the same width of type. */ 2563 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) 2564 return 0; 2565 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))) 2566 return 0; 2567 return tree_int_cst_equal (t1, t2); 2568 2569 case REAL_CST: 2570 /* Real constants are the same only if the same width of type. */ 2571 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2))) 2572 return 0; 2573 2574 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 2575 2576 case STRING_CST: 2577 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))) 2578 return 0; 2579 2580 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 2581 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 2582 TREE_STRING_LENGTH (t1))); 2583 2584 case COMPLEX_CST: 2585 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2)) 2586 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2))); 2587 2588 case CONSTRUCTOR: 2589 { 2590 VEC(constructor_elt, gc) *v1, *v2; 2591 unsigned HOST_WIDE_INT idx; 2592 2593 typecode = TREE_CODE (TREE_TYPE (t1)); 2594 if (typecode != TREE_CODE (TREE_TYPE (t2))) 2595 return 0; 2596 2597 if (typecode == ARRAY_TYPE) 2598 { 2599 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1)); 2600 /* For arrays, check that the sizes all match. */ 2601 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)) 2602 || size_1 == -1 2603 || size_1 != int_size_in_bytes (TREE_TYPE (t2))) 2604 return 0; 2605 } 2606 else 2607 { 2608 /* For record and union constructors, require exact type 2609 equality. */ 2610 if (TREE_TYPE (t1) != TREE_TYPE (t2)) 2611 return 0; 2612 } 2613 2614 v1 = CONSTRUCTOR_ELTS (t1); 2615 v2 = CONSTRUCTOR_ELTS (t2); 2616 if (VEC_length (constructor_elt, v1) 2617 != VEC_length (constructor_elt, v2)) 2618 return 0; 2619 2620 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) 2621 { 2622 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx); 2623 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx); 2624 2625 /* Check that each value is the same... */ 2626 if (!compare_constant (c1->value, c2->value)) 2627 return 0; 2628 /* ... and that they apply to the same fields! */ 2629 if (typecode == ARRAY_TYPE) 2630 { 2631 if (!compare_constant (c1->index, c2->index)) 2632 return 0; 2633 } 2634 else 2635 { 2636 if (c1->index != c2->index) 2637 return 0; 2638 } 2639 } 2640 2641 return 1; 2642 } 2643 2644 case ADDR_EXPR: 2645 case FDESC_EXPR: 2646 { 2647 struct addr_const value1, value2; 2648 2649 decode_addr_const (t1, &value1); 2650 decode_addr_const (t2, &value2); 2651 return (value1.offset == value2.offset 2652 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0); 2653 } 2654 2655 case PLUS_EXPR: 2656 case MINUS_EXPR: 2657 case RANGE_EXPR: 2658 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)) 2659 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); 2660 2661 case NOP_EXPR: 2662 case CONVERT_EXPR: 2663 case NON_LVALUE_EXPR: 2664 case VIEW_CONVERT_EXPR: 2665 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 2666 2667 default: 2668 { 2669 tree nt1, nt2; 2670 nt1 = lang_hooks.expand_constant (t1); 2671 nt2 = lang_hooks.expand_constant (t2); 2672 if (nt1 != t1 || nt2 != t2) 2673 return compare_constant (nt1, nt2); 2674 else 2675 return 0; 2676 } 2677 } 2678 2679 gcc_unreachable (); 2680} 2681 2682/* Make a copy of the whole tree structure for a constant. This 2683 handles the same types of nodes that compare_constant handles. */ 2684 2685static tree 2686copy_constant (tree exp) 2687{ 2688 switch (TREE_CODE (exp)) 2689 { 2690 case ADDR_EXPR: 2691 /* For ADDR_EXPR, we do not want to copy the decl whose address 2692 is requested. We do want to copy constants though. */ 2693 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0))) 2694 return build1 (TREE_CODE (exp), TREE_TYPE (exp), 2695 copy_constant (TREE_OPERAND (exp, 0))); 2696 else 2697 return copy_node (exp); 2698 2699 case INTEGER_CST: 2700 case REAL_CST: 2701 case STRING_CST: 2702 return copy_node (exp); 2703 2704 case COMPLEX_CST: 2705 return build_complex (TREE_TYPE (exp), 2706 copy_constant (TREE_REALPART (exp)), 2707 copy_constant (TREE_IMAGPART (exp))); 2708 2709 case PLUS_EXPR: 2710 case MINUS_EXPR: 2711 return build2 (TREE_CODE (exp), TREE_TYPE (exp), 2712 copy_constant (TREE_OPERAND (exp, 0)), 2713 copy_constant (TREE_OPERAND (exp, 1))); 2714 2715 case NOP_EXPR: 2716 case CONVERT_EXPR: 2717 case NON_LVALUE_EXPR: 2718 case VIEW_CONVERT_EXPR: 2719 return build1 (TREE_CODE (exp), TREE_TYPE (exp), 2720 copy_constant (TREE_OPERAND (exp, 0))); 2721 2722 case CONSTRUCTOR: 2723 { 2724 tree copy = copy_node (exp); 2725 VEC(constructor_elt, gc) *v; 2726 unsigned HOST_WIDE_INT idx; 2727 tree purpose, value; 2728 2729 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt, 2730 CONSTRUCTOR_ELTS (exp))); 2731 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value) 2732 { 2733 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL); 2734 ce->index = purpose; 2735 ce->value = copy_constant (value); 2736 } 2737 CONSTRUCTOR_ELTS (copy) = v; 2738 return copy; 2739 } 2740 2741 default: 2742 { 2743 tree t = lang_hooks.expand_constant (exp); 2744 2745 gcc_assert (t != exp); 2746 return copy_constant (t); 2747 } 2748 } 2749} 2750 2751/* Return the alignment of constant EXP in bits. */ 2752 2753static unsigned int 2754get_constant_alignment (tree exp) 2755{ 2756 unsigned int align; 2757 2758 align = TYPE_ALIGN (TREE_TYPE (exp)); 2759#ifdef CONSTANT_ALIGNMENT 2760 align = CONSTANT_ALIGNMENT (exp, align); 2761#endif 2762 return align; 2763} 2764 2765/* Return the section into which constant EXP should be placed. */ 2766 2767static section * 2768get_constant_section (tree exp) 2769{ 2770 if (IN_NAMED_SECTION (exp)) 2771 return get_named_section (exp, NULL, compute_reloc_for_constant (exp)); 2772 else 2773 return targetm.asm_out.select_section (exp, 2774 compute_reloc_for_constant (exp), 2775 get_constant_alignment (exp)); 2776} 2777 2778/* Return the size of constant EXP in bytes. */ 2779 2780static HOST_WIDE_INT 2781get_constant_size (tree exp) 2782{ 2783 HOST_WIDE_INT size; 2784 2785 size = int_size_in_bytes (TREE_TYPE (exp)); 2786 if (TREE_CODE (exp) == STRING_CST) 2787 size = MAX (TREE_STRING_LENGTH (exp), size); 2788 return size; 2789} 2790 2791/* Subroutine of output_constant_def: 2792 No constant equal to EXP is known to have been output. 2793 Make a constant descriptor to enter EXP in the hash table. 2794 Assign the label number and construct RTL to refer to the 2795 constant's location in memory. 2796 Caller is responsible for updating the hash table. */ 2797 2798static struct constant_descriptor_tree * 2799build_constant_desc (tree exp) 2800{ 2801 rtx symbol; 2802 rtx rtl; 2803 char label[256]; 2804 int labelno; 2805 struct constant_descriptor_tree *desc; 2806 2807 desc = ggc_alloc (sizeof (*desc)); 2808 desc->value = copy_constant (exp); 2809 2810 /* Propagate marked-ness to copied constant. */ 2811 if (flag_mudflap && mf_marked_p (exp)) 2812 mf_mark (desc->value); 2813 2814 /* Create a string containing the label name, in LABEL. */ 2815 labelno = const_labelno++; 2816 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno); 2817 2818 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */ 2819 if (use_object_blocks_p ()) 2820 { 2821 section *sect = get_constant_section (exp); 2822 symbol = create_block_symbol (ggc_strdup (label), 2823 get_block_for_section (sect), -1); 2824 } 2825 else 2826 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)); 2827 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL; 2828 SET_SYMBOL_REF_DECL (symbol, desc->value); 2829 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1; 2830 2831 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol); 2832 set_mem_attributes (rtl, exp, 1); 2833 set_mem_alias_set (rtl, 0); 2834 set_mem_alias_set (rtl, const_alias_set); 2835 2836 /* Set flags or add text to the name to record information, such as 2837 that it is a local symbol. If the name is changed, the macro 2838 ASM_OUTPUT_LABELREF will have to know how to strip this 2839 information. This call might invalidate our local variable 2840 SYMBOL; we can't use it afterward. */ 2841 2842 targetm.encode_section_info (exp, rtl, true); 2843 2844 desc->rtl = rtl; 2845 2846 return desc; 2847} 2848 2849/* Return an rtx representing a reference to constant data in memory 2850 for the constant expression EXP. 2851 2852 If assembler code for such a constant has already been output, 2853 return an rtx to refer to it. 2854 Otherwise, output such a constant in memory 2855 and generate an rtx for it. 2856 2857 If DEFER is nonzero, this constant can be deferred and output only 2858 if referenced in the function after all optimizations. 2859 2860 `const_desc_table' records which constants already have label strings. */ 2861 2862rtx 2863output_constant_def (tree exp, int defer) 2864{ 2865 struct constant_descriptor_tree *desc; 2866 struct constant_descriptor_tree key; 2867 void **loc; 2868 2869 /* Look up EXP in the table of constant descriptors. If we didn't find 2870 it, create a new one. */ 2871 key.value = exp; 2872 key.hash = const_hash_1 (exp); 2873 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT); 2874 2875 desc = *loc; 2876 if (desc == 0) 2877 { 2878 desc = build_constant_desc (exp); 2879 desc->hash = key.hash; 2880 *loc = desc; 2881 } 2882 2883 maybe_output_constant_def_contents (desc, defer); 2884 return desc->rtl; 2885} 2886 2887/* Subroutine of output_constant_def: Decide whether or not we need to 2888 output the constant DESC now, and if so, do it. */ 2889static void 2890maybe_output_constant_def_contents (struct constant_descriptor_tree *desc, 2891 int defer) 2892{ 2893 rtx symbol = XEXP (desc->rtl, 0); 2894 tree exp = desc->value; 2895 2896 if (flag_syntax_only) 2897 return; 2898 2899 if (TREE_ASM_WRITTEN (exp)) 2900 /* Already output; don't do it again. */ 2901 return; 2902 2903 /* We can always defer constants as long as the context allows 2904 doing so. */ 2905 if (defer) 2906 { 2907 /* Increment n_deferred_constants if it exists. It needs to be at 2908 least as large as the number of constants actually referred to 2909 by the function. If it's too small we'll stop looking too early 2910 and fail to emit constants; if it's too large we'll only look 2911 through the entire function when we could have stopped earlier. */ 2912 if (cfun) 2913 n_deferred_constants++; 2914 return; 2915 } 2916 2917 output_constant_def_contents (symbol); 2918} 2919 2920/* Subroutine of output_constant_def_contents. Output the definition 2921 of constant EXP, which is pointed to by label LABEL. ALIGN is the 2922 constant's alignment in bits. */ 2923 2924static void 2925assemble_constant_contents (tree exp, const char *label, unsigned int align) 2926{ 2927 HOST_WIDE_INT size; 2928 2929 size = get_constant_size (exp); 2930 2931 /* Do any machine/system dependent processing of the constant. */ 2932#ifdef ASM_DECLARE_CONSTANT_NAME 2933 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size); 2934#else 2935 /* Standard thing is just output label for the constant. */ 2936 ASM_OUTPUT_LABEL (asm_out_file, label); 2937#endif /* ASM_DECLARE_CONSTANT_NAME */ 2938 2939 /* Output the value of EXP. */ 2940 output_constant (exp, size, align); 2941} 2942 2943/* We must output the constant data referred to by SYMBOL; do so. */ 2944 2945static void 2946output_constant_def_contents (rtx symbol) 2947{ 2948 tree exp = SYMBOL_REF_DECL (symbol); 2949 unsigned int align; 2950 2951 /* Make sure any other constants whose addresses appear in EXP 2952 are assigned label numbers. */ 2953 output_addressed_constants (exp); 2954 2955 /* We are no longer deferring this constant. */ 2956 TREE_ASM_WRITTEN (exp) = 1; 2957 2958 /* If the constant is part of an object block, make sure that the 2959 decl has been positioned within its block, but do not write out 2960 its definition yet. output_object_blocks will do that later. */ 2961 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol)) 2962 place_block_symbol (symbol); 2963 else 2964 { 2965 switch_to_section (get_constant_section (exp)); 2966 align = get_constant_alignment (exp); 2967 if (align > BITS_PER_UNIT) 2968 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT)); 2969 assemble_constant_contents (exp, XSTR (symbol, 0), align); 2970 } 2971 if (flag_mudflap) 2972 mudflap_enqueue_constant (exp); 2973} 2974 2975/* Look up EXP in the table of constant descriptors. Return the rtl 2976 if it has been emitted, else null. */ 2977 2978rtx 2979lookup_constant_def (tree exp) 2980{ 2981 struct constant_descriptor_tree *desc; 2982 struct constant_descriptor_tree key; 2983 2984 key.value = exp; 2985 key.hash = const_hash_1 (exp); 2986 desc = htab_find_with_hash (const_desc_htab, &key, key.hash); 2987 2988 return (desc ? desc->rtl : NULL_RTX); 2989} 2990 2991/* Used in the hash tables to avoid outputting the same constant 2992 twice. Unlike 'struct constant_descriptor_tree', RTX constants 2993 are output once per function, not once per file. */ 2994/* ??? Only a few targets need per-function constant pools. Most 2995 can use one per-file pool. Should add a targetm bit to tell the 2996 difference. */ 2997 2998struct rtx_constant_pool GTY(()) 2999{ 3000 /* Pointers to first and last constant in pool, as ordered by offset. */ 3001 struct constant_descriptor_rtx *first; 3002 struct constant_descriptor_rtx *last; 3003 3004 /* Hash facility for making memory-constants from constant rtl-expressions. 3005 It is used on RISC machines where immediate integer arguments and 3006 constant addresses are restricted so that such constants must be stored 3007 in memory. */ 3008 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab; 3009 3010 /* Current offset in constant pool (does not include any 3011 machine-specific header). */ 3012 HOST_WIDE_INT offset; 3013}; 3014 3015struct constant_descriptor_rtx GTY((chain_next ("%h.next"))) 3016{ 3017 struct constant_descriptor_rtx *next; 3018 rtx mem; 3019 rtx sym; 3020 rtx constant; 3021 HOST_WIDE_INT offset; 3022 hashval_t hash; 3023 enum machine_mode mode; 3024 unsigned int align; 3025 int labelno; 3026 int mark; 3027}; 3028 3029/* Hash and compare functions for const_rtx_htab. */ 3030 3031static hashval_t 3032const_desc_rtx_hash (const void *ptr) 3033{ 3034 const struct constant_descriptor_rtx *desc = ptr; 3035 return desc->hash; 3036} 3037 3038static int 3039const_desc_rtx_eq (const void *a, const void *b) 3040{ 3041 const struct constant_descriptor_rtx *x = a; 3042 const struct constant_descriptor_rtx *y = b; 3043 3044 if (x->mode != y->mode) 3045 return 0; 3046 return rtx_equal_p (x->constant, y->constant); 3047} 3048 3049/* This is the worker function for const_rtx_hash, called via for_each_rtx. */ 3050 3051static int 3052const_rtx_hash_1 (rtx *xp, void *data) 3053{ 3054 unsigned HOST_WIDE_INT hwi; 3055 enum machine_mode mode; 3056 enum rtx_code code; 3057 hashval_t h, *hp; 3058 rtx x; 3059 3060 x = *xp; 3061 code = GET_CODE (x); 3062 mode = GET_MODE (x); 3063 h = (hashval_t) code * 1048573 + mode; 3064 3065 switch (code) 3066 { 3067 case CONST_INT: 3068 hwi = INTVAL (x); 3069 fold_hwi: 3070 { 3071 const int shift = sizeof (hashval_t) * CHAR_BIT; 3072 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t); 3073 int i; 3074 3075 h ^= (hashval_t) hwi; 3076 for (i = 1; i < n; ++i) 3077 { 3078 hwi >>= shift; 3079 h ^= (hashval_t) hwi; 3080 } 3081 } 3082 break; 3083 3084 case CONST_DOUBLE: 3085 if (mode == VOIDmode) 3086 { 3087 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x); 3088 goto fold_hwi; 3089 } 3090 else 3091 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x)); 3092 break; 3093 3094 case CONST_VECTOR: 3095 { 3096 int i; 3097 for (i = XVECLEN (x, 0); i-- > 0; ) 3098 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data); 3099 } 3100 break; 3101 3102 case SYMBOL_REF: 3103 h ^= htab_hash_string (XSTR (x, 0)); 3104 break; 3105 3106 case LABEL_REF: 3107 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0)); 3108 break; 3109 3110 case UNSPEC: 3111 case UNSPEC_VOLATILE: 3112 h = h * 251 + XINT (x, 1); 3113 break; 3114 3115 default: 3116 break; 3117 } 3118 3119 hp = data; 3120 *hp = *hp * 509 + h; 3121 return 0; 3122} 3123 3124/* Compute a hash value for X, which should be a constant. */ 3125 3126static hashval_t 3127const_rtx_hash (rtx x) 3128{ 3129 hashval_t h = 0; 3130 for_each_rtx (&x, const_rtx_hash_1, &h); 3131 return h; 3132} 3133 3134 3135/* Create and return a new rtx constant pool. */ 3136 3137static struct rtx_constant_pool * 3138create_constant_pool (void) 3139{ 3140 struct rtx_constant_pool *pool; 3141 3142 pool = ggc_alloc (sizeof (struct rtx_constant_pool)); 3143 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash, 3144 const_desc_rtx_eq, NULL); 3145 pool->first = NULL; 3146 pool->last = NULL; 3147 pool->offset = 0; 3148 return pool; 3149} 3150 3151/* Initialize constant pool hashing for a new function. */ 3152 3153void 3154init_varasm_status (struct function *f) 3155{ 3156 struct varasm_status *p; 3157 3158 p = ggc_alloc (sizeof (struct varasm_status)); 3159 f->varasm = p; 3160 3161 p->pool = create_constant_pool (); 3162 p->deferred_constants = 0; 3163} 3164 3165/* Given a MINUS expression, simplify it if both sides 3166 include the same symbol. */ 3167 3168rtx 3169simplify_subtraction (rtx x) 3170{ 3171 rtx r = simplify_rtx (x); 3172 return r ? r : x; 3173} 3174 3175/* Given a constant rtx X, make (or find) a memory constant for its value 3176 and return a MEM rtx to refer to it in memory. */ 3177 3178rtx 3179force_const_mem (enum machine_mode mode, rtx x) 3180{ 3181 struct constant_descriptor_rtx *desc, tmp; 3182 struct rtx_constant_pool *pool; 3183 char label[256]; 3184 rtx def, symbol; 3185 hashval_t hash; 3186 unsigned int align; 3187 void **slot; 3188 3189 /* If we're not allowed to drop X into the constant pool, don't. */ 3190 if (targetm.cannot_force_const_mem (x)) 3191 return NULL_RTX; 3192 3193 /* Record that this function has used a constant pool entry. */ 3194 current_function_uses_const_pool = 1; 3195 3196 /* Decide which pool to use. */ 3197 pool = (targetm.use_blocks_for_constant_p (mode, x) 3198 ? shared_constant_pool 3199 : cfun->varasm->pool); 3200 3201 /* Lookup the value in the hashtable. */ 3202 tmp.constant = x; 3203 tmp.mode = mode; 3204 hash = const_rtx_hash (x); 3205 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT); 3206 desc = *slot; 3207 3208 /* If the constant was already present, return its memory. */ 3209 if (desc) 3210 return copy_rtx (desc->mem); 3211 3212 /* Otherwise, create a new descriptor. */ 3213 desc = ggc_alloc (sizeof (*desc)); 3214 *slot = desc; 3215 3216 /* Align the location counter as required by EXP's data type. */ 3217 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode); 3218#ifdef CONSTANT_ALIGNMENT 3219 { 3220 tree type = lang_hooks.types.type_for_mode (mode, 0); 3221 if (type != NULL_TREE) 3222 align = CONSTANT_ALIGNMENT (make_tree (type, x), align); 3223 } 3224#endif 3225 3226 pool->offset += (align / BITS_PER_UNIT) - 1; 3227 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1); 3228 3229 desc->next = NULL; 3230 desc->constant = tmp.constant; 3231 desc->offset = pool->offset; 3232 desc->hash = hash; 3233 desc->mode = mode; 3234 desc->align = align; 3235 desc->labelno = const_labelno; 3236 desc->mark = 0; 3237 3238 pool->offset += GET_MODE_SIZE (mode); 3239 if (pool->last) 3240 pool->last->next = desc; 3241 else 3242 pool->first = pool->last = desc; 3243 pool->last = desc; 3244 3245 /* Create a string containing the label name, in LABEL. */ 3246 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno); 3247 ++const_labelno; 3248 3249 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to 3250 the constants pool. */ 3251 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x)) 3252 { 3253 section *sect = targetm.asm_out.select_rtx_section (mode, x, align); 3254 symbol = create_block_symbol (ggc_strdup (label), 3255 get_block_for_section (sect), -1); 3256 } 3257 else 3258 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)); 3259 desc->sym = symbol; 3260 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL; 3261 CONSTANT_POOL_ADDRESS_P (symbol) = 1; 3262 SET_SYMBOL_REF_CONSTANT (symbol, desc); 3263 3264 /* Construct the MEM. */ 3265 desc->mem = def = gen_const_mem (mode, symbol); 3266 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); 3267 set_mem_align (def, align); 3268 3269 /* If we're dropping a label to the constant pool, make sure we 3270 don't delete it. */ 3271 if (GET_CODE (x) == LABEL_REF) 3272 LABEL_PRESERVE_P (XEXP (x, 0)) = 1; 3273 3274 return copy_rtx (def); 3275} 3276 3277/* Given a constant pool SYMBOL_REF, return the corresponding constant. */ 3278 3279rtx 3280get_pool_constant (rtx addr) 3281{ 3282 return SYMBOL_REF_CONSTANT (addr)->constant; 3283} 3284 3285/* Given a constant pool SYMBOL_REF, return the corresponding constant 3286 and whether it has been output or not. */ 3287 3288rtx 3289get_pool_constant_mark (rtx addr, bool *pmarked) 3290{ 3291 struct constant_descriptor_rtx *desc; 3292 3293 desc = SYMBOL_REF_CONSTANT (addr); 3294 *pmarked = (desc->mark != 0); 3295 return desc->constant; 3296} 3297 3298/* Similar, return the mode. */ 3299 3300enum machine_mode 3301get_pool_mode (rtx addr) 3302{ 3303 return SYMBOL_REF_CONSTANT (addr)->mode; 3304} 3305 3306/* Return the size of the constant pool. */ 3307 3308int 3309get_pool_size (void) 3310{ 3311 return cfun->varasm->pool->offset; 3312} 3313 3314/* Worker function for output_constant_pool_1. Emit assembly for X 3315 in MODE with known alignment ALIGN. */ 3316 3317static void 3318output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align) 3319{ 3320 switch (GET_MODE_CLASS (mode)) 3321 { 3322 case MODE_FLOAT: 3323 case MODE_DECIMAL_FLOAT: 3324 { 3325 REAL_VALUE_TYPE r; 3326 3327 gcc_assert (GET_CODE (x) == CONST_DOUBLE); 3328 REAL_VALUE_FROM_CONST_DOUBLE (r, x); 3329 assemble_real (r, mode, align); 3330 break; 3331 } 3332 3333 case MODE_INT: 3334 case MODE_PARTIAL_INT: 3335 assemble_integer (x, GET_MODE_SIZE (mode), align, 1); 3336 break; 3337 3338 case MODE_VECTOR_FLOAT: 3339 case MODE_VECTOR_INT: 3340 { 3341 int i, units; 3342 enum machine_mode submode = GET_MODE_INNER (mode); 3343 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode)); 3344 3345 gcc_assert (GET_CODE (x) == CONST_VECTOR); 3346 units = CONST_VECTOR_NUNITS (x); 3347 3348 for (i = 0; i < units; i++) 3349 { 3350 rtx elt = CONST_VECTOR_ELT (x, i); 3351 output_constant_pool_2 (submode, elt, i ? subalign : align); 3352 } 3353 } 3354 break; 3355 3356 default: 3357 gcc_unreachable (); 3358 } 3359} 3360 3361/* Worker function for output_constant_pool. Emit constant DESC, 3362 giving it ALIGN bits of alignment. */ 3363 3364static void 3365output_constant_pool_1 (struct constant_descriptor_rtx *desc, 3366 unsigned int align) 3367{ 3368 rtx x, tmp; 3369 3370 x = desc->constant; 3371 3372 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF) 3373 whose CODE_LABEL has been deleted. This can occur if a jump table 3374 is eliminated by optimization. If so, write a constant of zero 3375 instead. Note that this can also happen by turning the 3376 CODE_LABEL into a NOTE. */ 3377 /* ??? This seems completely and utterly wrong. Certainly it's 3378 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper 3379 functioning even with INSN_DELETED_P and friends. */ 3380 3381 tmp = x; 3382 switch (GET_CODE (x)) 3383 { 3384 case CONST: 3385 if (GET_CODE (XEXP (x, 0)) != PLUS 3386 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF) 3387 break; 3388 tmp = XEXP (XEXP (x, 0), 0); 3389 /* FALLTHRU */ 3390 3391 case LABEL_REF: 3392 tmp = XEXP (x, 0); 3393 gcc_assert (!INSN_DELETED_P (tmp)); 3394 gcc_assert (!NOTE_P (tmp) 3395 || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED); 3396 break; 3397 3398 default: 3399 break; 3400 } 3401 3402#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY 3403 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode, 3404 align, desc->labelno, done); 3405#endif 3406 3407 assemble_align (align); 3408 3409 /* Output the label. */ 3410 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno); 3411 3412 /* Output the data. */ 3413 output_constant_pool_2 (desc->mode, x, align); 3414 3415 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS 3416 sections have proper size. */ 3417 if (align > GET_MODE_BITSIZE (desc->mode) 3418 && in_section 3419 && (in_section->common.flags & SECTION_MERGE)) 3420 assemble_align (align); 3421 3422#ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY 3423 done: 3424#endif 3425 return; 3426} 3427 3428/* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers 3429 to as used. Emit referenced deferred strings. This function can 3430 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */ 3431 3432static int 3433mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED) 3434{ 3435 rtx x = *current_rtx; 3436 3437 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF) 3438 return 0; 3439 3440 if (CONSTANT_POOL_ADDRESS_P (x)) 3441 { 3442 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x); 3443 if (desc->mark == 0) 3444 { 3445 desc->mark = 1; 3446 for_each_rtx (&desc->constant, mark_constant, NULL); 3447 } 3448 } 3449 else if (TREE_CONSTANT_POOL_ADDRESS_P (x)) 3450 { 3451 tree exp = SYMBOL_REF_DECL (x); 3452 if (!TREE_ASM_WRITTEN (exp)) 3453 { 3454 n_deferred_constants--; 3455 output_constant_def_contents (x); 3456 } 3457 } 3458 3459 return -1; 3460} 3461 3462/* Look through appropriate parts of INSN, marking all entries in the 3463 constant pool which are actually being used. Entries that are only 3464 referenced by other constants are also marked as used. Emit 3465 deferred strings that are used. */ 3466 3467static void 3468mark_constants (rtx insn) 3469{ 3470 if (!INSN_P (insn)) 3471 return; 3472 3473 /* Insns may appear inside a SEQUENCE. Only check the patterns of 3474 insns, not any notes that may be attached. We don't want to mark 3475 a constant just because it happens to appear in a REG_EQUIV note. */ 3476 if (GET_CODE (PATTERN (insn)) == SEQUENCE) 3477 { 3478 rtx seq = PATTERN (insn); 3479 int i, n = XVECLEN (seq, 0); 3480 for (i = 0; i < n; ++i) 3481 { 3482 rtx subinsn = XVECEXP (seq, 0, i); 3483 if (INSN_P (subinsn)) 3484 for_each_rtx (&PATTERN (subinsn), mark_constant, NULL); 3485 } 3486 } 3487 else 3488 for_each_rtx (&PATTERN (insn), mark_constant, NULL); 3489} 3490 3491/* Look through the instructions for this function, and mark all the 3492 entries in POOL which are actually being used. Emit deferred constants 3493 which have indeed been used. */ 3494 3495static void 3496mark_constant_pool (void) 3497{ 3498 rtx insn, link; 3499 3500 if (!current_function_uses_const_pool && n_deferred_constants == 0) 3501 return; 3502 3503 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 3504 mark_constants (insn); 3505 3506 for (link = current_function_epilogue_delay_list; 3507 link; 3508 link = XEXP (link, 1)) 3509 mark_constants (XEXP (link, 0)); 3510} 3511 3512/* Write all the constants in POOL. */ 3513 3514static void 3515output_constant_pool_contents (struct rtx_constant_pool *pool) 3516{ 3517 struct constant_descriptor_rtx *desc; 3518 3519 for (desc = pool->first; desc ; desc = desc->next) 3520 if (desc->mark) 3521 { 3522 /* If the constant is part of an object_block, make sure that 3523 the constant has been positioned within its block, but do not 3524 write out its definition yet. output_object_blocks will do 3525 that later. */ 3526 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym) 3527 && SYMBOL_REF_BLOCK (desc->sym)) 3528 place_block_symbol (desc->sym); 3529 else 3530 { 3531 switch_to_section (targetm.asm_out.select_rtx_section 3532 (desc->mode, desc->constant, desc->align)); 3533 output_constant_pool_1 (desc, desc->align); 3534 } 3535 } 3536} 3537 3538/* Mark all constants that are used in the current function, then write 3539 out the function's private constant pool. */ 3540 3541static void 3542output_constant_pool (const char *fnname ATTRIBUTE_UNUSED, 3543 tree fndecl ATTRIBUTE_UNUSED) 3544{ 3545 struct rtx_constant_pool *pool = cfun->varasm->pool; 3546 3547 /* It is possible for gcc to call force_const_mem and then to later 3548 discard the instructions which refer to the constant. In such a 3549 case we do not need to output the constant. */ 3550 mark_constant_pool (); 3551 3552#ifdef ASM_OUTPUT_POOL_PROLOGUE 3553 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset); 3554#endif 3555 3556 output_constant_pool_contents (pool); 3557 3558#ifdef ASM_OUTPUT_POOL_EPILOGUE 3559 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset); 3560#endif 3561} 3562 3563/* Write the contents of the shared constant pool. */ 3564 3565void 3566output_shared_constant_pool (void) 3567{ 3568 output_constant_pool_contents (shared_constant_pool); 3569} 3570 3571/* Determine what kind of relocations EXP may need. */ 3572 3573int 3574compute_reloc_for_constant (tree exp) 3575{ 3576 int reloc = 0, reloc2; 3577 tree tem; 3578 3579 /* Give the front-end a chance to convert VALUE to something that 3580 looks more like a constant to the back-end. */ 3581 exp = lang_hooks.expand_constant (exp); 3582 3583 switch (TREE_CODE (exp)) 3584 { 3585 case ADDR_EXPR: 3586 case FDESC_EXPR: 3587 /* Go inside any operations that get_inner_reference can handle and see 3588 if what's inside is a constant: no need to do anything here for 3589 addresses of variables or functions. */ 3590 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem); 3591 tem = TREE_OPERAND (tem, 0)) 3592 ; 3593 3594 if (TREE_PUBLIC (tem)) 3595 reloc |= 2; 3596 else 3597 reloc |= 1; 3598 break; 3599 3600 case PLUS_EXPR: 3601 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 3602 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1)); 3603 break; 3604 3605 case MINUS_EXPR: 3606 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 3607 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1)); 3608 /* The difference of two local labels is computable at link time. */ 3609 if (reloc == 1 && reloc2 == 1) 3610 reloc = 0; 3611 else 3612 reloc |= reloc2; 3613 break; 3614 3615 case NOP_EXPR: 3616 case CONVERT_EXPR: 3617 case NON_LVALUE_EXPR: 3618 case VIEW_CONVERT_EXPR: 3619 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0)); 3620 break; 3621 3622 case CONSTRUCTOR: 3623 { 3624 unsigned HOST_WIDE_INT idx; 3625 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem) 3626 if (tem != 0) 3627 reloc |= compute_reloc_for_constant (tem); 3628 } 3629 break; 3630 3631 default: 3632 break; 3633 } 3634 return reloc; 3635} 3636 3637/* Find all the constants whose addresses are referenced inside of EXP, 3638 and make sure assembler code with a label has been output for each one. 3639 Indicate whether an ADDR_EXPR has been encountered. */ 3640 3641static void 3642output_addressed_constants (tree exp) 3643{ 3644 tree tem; 3645 3646 /* Give the front-end a chance to convert VALUE to something that 3647 looks more like a constant to the back-end. */ 3648 exp = lang_hooks.expand_constant (exp); 3649 3650 switch (TREE_CODE (exp)) 3651 { 3652 case ADDR_EXPR: 3653 case FDESC_EXPR: 3654 /* Go inside any operations that get_inner_reference can handle and see 3655 if what's inside is a constant: no need to do anything here for 3656 addresses of variables or functions. */ 3657 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem); 3658 tem = TREE_OPERAND (tem, 0)) 3659 ; 3660 3661 /* If we have an initialized CONST_DECL, retrieve the initializer. */ 3662 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem)) 3663 tem = DECL_INITIAL (tem); 3664 3665 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR) 3666 output_constant_def (tem, 0); 3667 break; 3668 3669 case PLUS_EXPR: 3670 case MINUS_EXPR: 3671 output_addressed_constants (TREE_OPERAND (exp, 1)); 3672 /* Fall through. */ 3673 3674 case NOP_EXPR: 3675 case CONVERT_EXPR: 3676 case NON_LVALUE_EXPR: 3677 case VIEW_CONVERT_EXPR: 3678 output_addressed_constants (TREE_OPERAND (exp, 0)); 3679 break; 3680 3681 case CONSTRUCTOR: 3682 { 3683 unsigned HOST_WIDE_INT idx; 3684 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem) 3685 if (tem != 0) 3686 output_addressed_constants (tem); 3687 } 3688 break; 3689 3690 default: 3691 break; 3692 } 3693} 3694 3695/* Whether a constructor CTOR is a valid static constant initializer if all 3696 its elements are. This used to be internal to initializer_constant_valid_p 3697 and has been exposed to let other functions like categorize_ctor_elements 3698 evaluate the property while walking a constructor for other purposes. */ 3699 3700bool 3701constructor_static_from_elts_p (tree ctor) 3702{ 3703 return (TREE_CONSTANT (ctor) 3704 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE 3705 || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE) 3706 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (ctor))); 3707} 3708 3709/* Return nonzero if VALUE is a valid constant-valued expression 3710 for use in initializing a static variable; one that can be an 3711 element of a "constant" initializer. 3712 3713 Return null_pointer_node if the value is absolute; 3714 if it is relocatable, return the variable that determines the relocation. 3715 We assume that VALUE has been folded as much as possible; 3716 therefore, we do not need to check for such things as 3717 arithmetic-combinations of integers. */ 3718 3719tree 3720initializer_constant_valid_p (tree value, tree endtype) 3721{ 3722 /* Give the front-end a chance to convert VALUE to something that 3723 looks more like a constant to the back-end. */ 3724 value = lang_hooks.expand_constant (value); 3725 3726 switch (TREE_CODE (value)) 3727 { 3728 case CONSTRUCTOR: 3729 if (constructor_static_from_elts_p (value)) 3730 { 3731 unsigned HOST_WIDE_INT idx; 3732 tree elt; 3733 bool absolute = true; 3734 3735 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt) 3736 { 3737 tree reloc; 3738 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt)); 3739 if (!reloc) 3740 return NULL_TREE; 3741 if (reloc != null_pointer_node) 3742 absolute = false; 3743 } 3744 /* For a non-absolute relocation, there is no single 3745 variable that can be "the variable that determines the 3746 relocation." */ 3747 return absolute ? null_pointer_node : error_mark_node; 3748 } 3749 3750 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE; 3751 3752 case INTEGER_CST: 3753 case VECTOR_CST: 3754 case REAL_CST: 3755 case STRING_CST: 3756 case COMPLEX_CST: 3757 return null_pointer_node; 3758 3759 case ADDR_EXPR: 3760 case FDESC_EXPR: 3761 value = staticp (TREE_OPERAND (value, 0)); 3762 if (value) 3763 { 3764 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to 3765 be a constant, this is old-skool offsetof-like nonsense. */ 3766 if (TREE_CODE (value) == INDIRECT_REF 3767 && TREE_CONSTANT (TREE_OPERAND (value, 0))) 3768 return null_pointer_node; 3769 /* Taking the address of a nested function involves a trampoline. */ 3770 if (TREE_CODE (value) == FUNCTION_DECL 3771 && ((decl_function_context (value) 3772 && !DECL_NO_STATIC_CHAIN (value)) 3773 || DECL_DLLIMPORT_P (value))) 3774 return NULL_TREE; 3775 /* "&{...}" requires a temporary to hold the constructed 3776 object. */ 3777 if (TREE_CODE (value) == CONSTRUCTOR) 3778 return NULL_TREE; 3779 } 3780 return value; 3781 3782 case VIEW_CONVERT_EXPR: 3783 case NON_LVALUE_EXPR: 3784 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype); 3785 3786 case CONVERT_EXPR: 3787 case NOP_EXPR: 3788 { 3789 tree src; 3790 tree src_type; 3791 tree dest_type; 3792 3793 src = TREE_OPERAND (value, 0); 3794 src_type = TREE_TYPE (src); 3795 dest_type = TREE_TYPE (value); 3796 3797 /* Allow conversions between pointer types, floating-point 3798 types, and offset types. */ 3799 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)) 3800 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type)) 3801 || (TREE_CODE (dest_type) == OFFSET_TYPE 3802 && TREE_CODE (src_type) == OFFSET_TYPE)) 3803 return initializer_constant_valid_p (src, endtype); 3804 3805 /* Allow length-preserving conversions between integer types. */ 3806 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type) 3807 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type))) 3808 return initializer_constant_valid_p (src, endtype); 3809 3810 /* Allow conversions between other integer types only if 3811 explicit value. */ 3812 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)) 3813 { 3814 tree inner = initializer_constant_valid_p (src, endtype); 3815 if (inner == null_pointer_node) 3816 return null_pointer_node; 3817 break; 3818 } 3819 3820 /* Allow (int) &foo provided int is as wide as a pointer. */ 3821 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type) 3822 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))) 3823 return initializer_constant_valid_p (src, endtype); 3824 3825 /* Likewise conversions from int to pointers, but also allow 3826 conversions from 0. */ 3827 if ((POINTER_TYPE_P (dest_type) 3828 || TREE_CODE (dest_type) == OFFSET_TYPE) 3829 && INTEGRAL_TYPE_P (src_type)) 3830 { 3831 if (TREE_CODE (src) == INTEGER_CST 3832 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)) 3833 return null_pointer_node; 3834 if (integer_zerop (src)) 3835 return null_pointer_node; 3836 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type)) 3837 return initializer_constant_valid_p (src, endtype); 3838 } 3839 3840 /* Allow conversions to struct or union types if the value 3841 inside is okay. */ 3842 if (TREE_CODE (dest_type) == RECORD_TYPE 3843 || TREE_CODE (dest_type) == UNION_TYPE) 3844 return initializer_constant_valid_p (src, endtype); 3845 } 3846 break; 3847 3848 case PLUS_EXPR: 3849 if (! INTEGRAL_TYPE_P (endtype) 3850 || TYPE_PRECISION (endtype) >= POINTER_SIZE) 3851 { 3852 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0), 3853 endtype); 3854 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1), 3855 endtype); 3856 /* If either term is absolute, use the other terms relocation. */ 3857 if (valid0 == null_pointer_node) 3858 return valid1; 3859 if (valid1 == null_pointer_node) 3860 return valid0; 3861 } 3862 break; 3863 3864 case MINUS_EXPR: 3865 if (! INTEGRAL_TYPE_P (endtype) 3866 || TYPE_PRECISION (endtype) >= POINTER_SIZE) 3867 { 3868 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0), 3869 endtype); 3870 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1), 3871 endtype); 3872 /* Win if second argument is absolute. */ 3873 if (valid1 == null_pointer_node) 3874 return valid0; 3875 /* Win if both arguments have the same relocation. 3876 Then the value is absolute. */ 3877 if (valid0 == valid1 && valid0 != 0) 3878 return null_pointer_node; 3879 3880 /* Since GCC guarantees that string constants are unique in the 3881 generated code, a subtraction between two copies of the same 3882 constant string is absolute. */ 3883 if (valid0 && TREE_CODE (valid0) == STRING_CST 3884 && valid1 && TREE_CODE (valid1) == STRING_CST 3885 && operand_equal_p (valid0, valid1, 1)) 3886 return null_pointer_node; 3887 } 3888 3889 /* Support narrowing differences. */ 3890 if (INTEGRAL_TYPE_P (endtype)) 3891 { 3892 tree op0, op1; 3893 3894 op0 = TREE_OPERAND (value, 0); 3895 op1 = TREE_OPERAND (value, 1); 3896 3897 /* Like STRIP_NOPS except allow the operand mode to widen. 3898 This works around a feature of fold that simplifies 3899 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory 3900 that the narrower operation is cheaper. */ 3901 3902 while (TREE_CODE (op0) == NOP_EXPR 3903 || TREE_CODE (op0) == CONVERT_EXPR 3904 || TREE_CODE (op0) == NON_LVALUE_EXPR) 3905 { 3906 tree inner = TREE_OPERAND (op0, 0); 3907 if (inner == error_mark_node 3908 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) 3909 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))) 3910 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) 3911 break; 3912 op0 = inner; 3913 } 3914 3915 while (TREE_CODE (op1) == NOP_EXPR 3916 || TREE_CODE (op1) == CONVERT_EXPR 3917 || TREE_CODE (op1) == NON_LVALUE_EXPR) 3918 { 3919 tree inner = TREE_OPERAND (op1, 0); 3920 if (inner == error_mark_node 3921 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner))) 3922 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1))) 3923 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner))))) 3924 break; 3925 op1 = inner; 3926 } 3927 3928 op0 = initializer_constant_valid_p (op0, endtype); 3929 op1 = initializer_constant_valid_p (op1, endtype); 3930 3931 /* Both initializers must be known. */ 3932 if (op0 && op1) 3933 { 3934 if (op0 == op1) 3935 return null_pointer_node; 3936 3937 /* Support differences between labels. */ 3938 if (TREE_CODE (op0) == LABEL_DECL 3939 && TREE_CODE (op1) == LABEL_DECL) 3940 return null_pointer_node; 3941 3942 if (TREE_CODE (op0) == STRING_CST 3943 && TREE_CODE (op1) == STRING_CST 3944 && operand_equal_p (op0, op1, 1)) 3945 return null_pointer_node; 3946 } 3947 } 3948 break; 3949 3950 default: 3951 break; 3952 } 3953 3954 return 0; 3955} 3956 3957/* Output assembler code for constant EXP to FILE, with no label. 3958 This includes the pseudo-op such as ".int" or ".byte", and a newline. 3959 Assumes output_addressed_constants has been done on EXP already. 3960 3961 Generate exactly SIZE bytes of assembler data, padding at the end 3962 with zeros if necessary. SIZE must always be specified. 3963 3964 SIZE is important for structure constructors, 3965 since trailing members may have been omitted from the constructor. 3966 It is also important for initialization of arrays from string constants 3967 since the full length of the string constant might not be wanted. 3968 It is also needed for initialization of unions, where the initializer's 3969 type is just one member, and that may not be as long as the union. 3970 3971 There a case in which we would fail to output exactly SIZE bytes: 3972 for a structure constructor that wants to produce more than SIZE bytes. 3973 But such constructors will never be generated for any possible input. 3974 3975 ALIGN is the alignment of the data in bits. */ 3976 3977void 3978output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) 3979{ 3980 enum tree_code code; 3981 unsigned HOST_WIDE_INT thissize; 3982 3983 /* Some front-ends use constants other than the standard language-independent 3984 varieties, but which may still be output directly. Give the front-end a 3985 chance to convert EXP to a language-independent representation. */ 3986 exp = lang_hooks.expand_constant (exp); 3987 3988 if (size == 0 || flag_syntax_only) 3989 return; 3990 3991 /* See if we're trying to initialize a pointer in a non-default mode 3992 to the address of some declaration somewhere. If the target says 3993 the mode is valid for pointers, assume the target has a way of 3994 resolving it. */ 3995 if (TREE_CODE (exp) == NOP_EXPR 3996 && POINTER_TYPE_P (TREE_TYPE (exp)) 3997 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp)))) 3998 { 3999 tree saved_type = TREE_TYPE (exp); 4000 4001 /* Peel off any intermediate conversions-to-pointer for valid 4002 pointer modes. */ 4003 while (TREE_CODE (exp) == NOP_EXPR 4004 && POINTER_TYPE_P (TREE_TYPE (exp)) 4005 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp)))) 4006 exp = TREE_OPERAND (exp, 0); 4007 4008 /* If what we're left with is the address of something, we can 4009 convert the address to the final type and output it that 4010 way. */ 4011 if (TREE_CODE (exp) == ADDR_EXPR) 4012 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0)); 4013 /* Likewise for constant ints. */ 4014 else if (TREE_CODE (exp) == INTEGER_CST) 4015 exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp), 4016 TREE_INT_CST_HIGH (exp)); 4017 4018 } 4019 4020 /* Eliminate any conversions since we'll be outputting the underlying 4021 constant. */ 4022 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR 4023 || TREE_CODE (exp) == NON_LVALUE_EXPR 4024 || TREE_CODE (exp) == VIEW_CONVERT_EXPR) 4025 { 4026 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp)); 4027 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0))); 4028 4029 /* Make sure eliminating the conversion is really a no-op, except with 4030 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and 4031 union types to allow for Ada unchecked unions. */ 4032 if (type_size > op_size 4033 && TREE_CODE (exp) != VIEW_CONVERT_EXPR 4034 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE) 4035 /* Keep the conversion. */ 4036 break; 4037 else 4038 exp = TREE_OPERAND (exp, 0); 4039 } 4040 4041 code = TREE_CODE (TREE_TYPE (exp)); 4042 thissize = int_size_in_bytes (TREE_TYPE (exp)); 4043 4044 /* Give the front end another chance to expand constants. */ 4045 exp = lang_hooks.expand_constant (exp); 4046 4047 /* Allow a constructor with no elements for any data type. 4048 This means to fill the space with zeros. */ 4049 if (TREE_CODE (exp) == CONSTRUCTOR 4050 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp))) 4051 { 4052 assemble_zeros (size); 4053 return; 4054 } 4055 4056 if (TREE_CODE (exp) == FDESC_EXPR) 4057 { 4058#ifdef ASM_OUTPUT_FDESC 4059 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0); 4060 tree decl = TREE_OPERAND (exp, 0); 4061 ASM_OUTPUT_FDESC (asm_out_file, decl, part); 4062#else 4063 gcc_unreachable (); 4064#endif 4065 return; 4066 } 4067 4068 /* Now output the underlying data. If we've handling the padding, return. 4069 Otherwise, break and ensure SIZE is the size written. */ 4070 switch (code) 4071 { 4072 case BOOLEAN_TYPE: 4073 case INTEGER_TYPE: 4074 case ENUMERAL_TYPE: 4075 case POINTER_TYPE: 4076 case REFERENCE_TYPE: 4077 case OFFSET_TYPE: 4078 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode, 4079 EXPAND_INITIALIZER), 4080 MIN (size, thissize), align, 0)) 4081 error ("initializer for integer value is too complicated"); 4082 break; 4083 4084 case REAL_TYPE: 4085 if (TREE_CODE (exp) != REAL_CST) 4086 error ("initializer for floating value is not a floating constant"); 4087 4088 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align); 4089 break; 4090 4091 case COMPLEX_TYPE: 4092 output_constant (TREE_REALPART (exp), thissize / 2, align); 4093 output_constant (TREE_IMAGPART (exp), thissize / 2, 4094 min_align (align, BITS_PER_UNIT * (thissize / 2))); 4095 break; 4096 4097 case ARRAY_TYPE: 4098 case VECTOR_TYPE: 4099 switch (TREE_CODE (exp)) 4100 { 4101 case CONSTRUCTOR: 4102 output_constructor (exp, size, align); 4103 return; 4104 case STRING_CST: 4105 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp), 4106 size); 4107 assemble_string (TREE_STRING_POINTER (exp), thissize); 4108 break; 4109 4110 case VECTOR_CST: 4111 { 4112 int elt_size; 4113 tree link; 4114 unsigned int nalign; 4115 enum machine_mode inner; 4116 4117 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp))); 4118 nalign = MIN (align, GET_MODE_ALIGNMENT (inner)); 4119 4120 elt_size = GET_MODE_SIZE (inner); 4121 4122 link = TREE_VECTOR_CST_ELTS (exp); 4123 output_constant (TREE_VALUE (link), elt_size, align); 4124 thissize = elt_size; 4125 while ((link = TREE_CHAIN (link)) != NULL) 4126 { 4127 output_constant (TREE_VALUE (link), elt_size, nalign); 4128 thissize += elt_size; 4129 } 4130 break; 4131 } 4132 default: 4133 gcc_unreachable (); 4134 } 4135 break; 4136 4137 case RECORD_TYPE: 4138 case UNION_TYPE: 4139 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR); 4140 output_constructor (exp, size, align); 4141 return; 4142 4143 case ERROR_MARK: 4144 return; 4145 4146 default: 4147 gcc_unreachable (); 4148 } 4149 4150 if (size > thissize) 4151 assemble_zeros (size - thissize); 4152} 4153 4154 4155/* Subroutine of output_constructor, used for computing the size of 4156 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array 4157 type with an unspecified upper bound. */ 4158 4159static unsigned HOST_WIDE_INT 4160array_size_for_constructor (tree val) 4161{ 4162 tree max_index, i; 4163 unsigned HOST_WIDE_INT cnt; 4164 tree index, value, tmp; 4165 4166 /* This code used to attempt to handle string constants that are not 4167 arrays of single-bytes, but nothing else does, so there's no point in 4168 doing it here. */ 4169 if (TREE_CODE (val) == STRING_CST) 4170 return TREE_STRING_LENGTH (val); 4171 4172 max_index = NULL_TREE; 4173 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value) 4174 { 4175 if (TREE_CODE (index) == RANGE_EXPR) 4176 index = TREE_OPERAND (index, 1); 4177 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index)) 4178 max_index = index; 4179 } 4180 4181 if (max_index == NULL_TREE) 4182 return 0; 4183 4184 /* Compute the total number of array elements. */ 4185 tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val))); 4186 i = size_binop (MINUS_EXPR, fold_convert (sizetype, max_index), 4187 fold_convert (sizetype, tmp)); 4188 i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1)); 4189 4190 /* Multiply by the array element unit size to find number of bytes. */ 4191 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val)))); 4192 4193 return tree_low_cst (i, 1); 4194} 4195 4196/* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants). 4197 Generate at least SIZE bytes, padding if necessary. */ 4198 4199static void 4200output_constructor (tree exp, unsigned HOST_WIDE_INT size, 4201 unsigned int align) 4202{ 4203 tree type = TREE_TYPE (exp); 4204 tree field = 0; 4205 tree min_index = 0; 4206 /* Number of bytes output or skipped so far. 4207 In other words, current position within the constructor. */ 4208 HOST_WIDE_INT total_bytes = 0; 4209 /* Nonzero means BYTE contains part of a byte, to be output. */ 4210 int byte_buffer_in_use = 0; 4211 int byte = 0; 4212 unsigned HOST_WIDE_INT cnt; 4213 constructor_elt *ce; 4214 4215 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT); 4216 4217 if (TREE_CODE (type) == RECORD_TYPE) 4218 field = TYPE_FIELDS (type); 4219 4220 if (TREE_CODE (type) == ARRAY_TYPE 4221 && TYPE_DOMAIN (type) != 0) 4222 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type)); 4223 4224 /* As LINK goes through the elements of the constant, 4225 FIELD goes through the structure fields, if the constant is a structure. 4226 if the constant is a union, then we override this, 4227 by getting the field from the TREE_LIST element. 4228 But the constant could also be an array. Then FIELD is zero. 4229 4230 There is always a maximum of one element in the chain LINK for unions 4231 (even if the initializer in a source program incorrectly contains 4232 more one). */ 4233 for (cnt = 0; 4234 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce); 4235 cnt++, field = field ? TREE_CHAIN (field) : 0) 4236 { 4237 tree val = ce->value; 4238 tree index = 0; 4239 4240 /* The element in a union constructor specifies the proper field 4241 or index. */ 4242 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE 4243 || TREE_CODE (type) == QUAL_UNION_TYPE) 4244 && ce->index != 0) 4245 field = ce->index; 4246 4247 else if (TREE_CODE (type) == ARRAY_TYPE) 4248 index = ce->index; 4249 4250#ifdef ASM_COMMENT_START 4251 if (field && flag_verbose_asm) 4252 fprintf (asm_out_file, "%s %s:\n", 4253 ASM_COMMENT_START, 4254 DECL_NAME (field) 4255 ? IDENTIFIER_POINTER (DECL_NAME (field)) 4256 : "<anonymous>"); 4257#endif 4258 4259 /* Eliminate the marker that makes a cast not be an lvalue. */ 4260 if (val != 0) 4261 STRIP_NOPS (val); 4262 4263 if (index && TREE_CODE (index) == RANGE_EXPR) 4264 { 4265 unsigned HOST_WIDE_INT fieldsize 4266 = int_size_in_bytes (TREE_TYPE (type)); 4267 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0); 4268 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0); 4269 HOST_WIDE_INT index; 4270 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT); 4271 4272 for (index = lo_index; index <= hi_index; index++) 4273 { 4274 /* Output the element's initial value. */ 4275 if (val == 0) 4276 assemble_zeros (fieldsize); 4277 else 4278 output_constant (val, fieldsize, align2); 4279 4280 /* Count its size. */ 4281 total_bytes += fieldsize; 4282 } 4283 } 4284 else if (field == 0 || !DECL_BIT_FIELD (field)) 4285 { 4286 /* An element that is not a bit-field. */ 4287 4288 unsigned HOST_WIDE_INT fieldsize; 4289 /* Since this structure is static, 4290 we know the positions are constant. */ 4291 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0; 4292 unsigned int align2; 4293 4294 if (index != 0) 4295 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1) 4296 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0))); 4297 4298 /* Output any buffered-up bit-fields preceding this element. */ 4299 if (byte_buffer_in_use) 4300 { 4301 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1); 4302 total_bytes++; 4303 byte_buffer_in_use = 0; 4304 } 4305 4306 /* Advance to offset of this element. 4307 Note no alignment needed in an array, since that is guaranteed 4308 if each element has the proper size. */ 4309 if ((field != 0 || index != 0) && pos != total_bytes) 4310 { 4311 gcc_assert (pos >= total_bytes); 4312 assemble_zeros (pos - total_bytes); 4313 total_bytes = pos; 4314 } 4315 4316 /* Find the alignment of this element. */ 4317 align2 = min_align (align, BITS_PER_UNIT * pos); 4318 4319 /* Determine size this element should occupy. */ 4320 if (field) 4321 { 4322 fieldsize = 0; 4323 4324 /* If this is an array with an unspecified upper bound, 4325 the initializer determines the size. */ 4326 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL, 4327 but we cannot do this until the deprecated support for 4328 initializing zero-length array members is removed. */ 4329 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE 4330 && TYPE_DOMAIN (TREE_TYPE (field)) 4331 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field)))) 4332 { 4333 fieldsize = array_size_for_constructor (val); 4334 /* Given a non-empty initialization, this field had 4335 better be last. */ 4336 gcc_assert (!fieldsize || !TREE_CHAIN (field)); 4337 } 4338 else if (DECL_SIZE_UNIT (field)) 4339 { 4340 /* ??? This can't be right. If the decl size overflows 4341 a host integer we will silently emit no data. */ 4342 if (host_integerp (DECL_SIZE_UNIT (field), 1)) 4343 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1); 4344 } 4345 } 4346 else 4347 fieldsize = int_size_in_bytes (TREE_TYPE (type)); 4348 4349 /* Output the element's initial value. */ 4350 if (val == 0) 4351 assemble_zeros (fieldsize); 4352 else 4353 output_constant (val, fieldsize, align2); 4354 4355 /* Count its size. */ 4356 total_bytes += fieldsize; 4357 } 4358 else if (val != 0 && TREE_CODE (val) != INTEGER_CST) 4359 error ("invalid initial value for member %qs", 4360 IDENTIFIER_POINTER (DECL_NAME (field))); 4361 else 4362 { 4363 /* Element that is a bit-field. */ 4364 4365 HOST_WIDE_INT next_offset = int_bit_position (field); 4366 HOST_WIDE_INT end_offset 4367 = (next_offset + tree_low_cst (DECL_SIZE (field), 1)); 4368 4369 if (val == 0) 4370 val = integer_zero_node; 4371 4372 /* If this field does not start in this (or, next) byte, 4373 skip some bytes. */ 4374 if (next_offset / BITS_PER_UNIT != total_bytes) 4375 { 4376 /* Output remnant of any bit field in previous bytes. */ 4377 if (byte_buffer_in_use) 4378 { 4379 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1); 4380 total_bytes++; 4381 byte_buffer_in_use = 0; 4382 } 4383 4384 /* If still not at proper byte, advance to there. */ 4385 if (next_offset / BITS_PER_UNIT != total_bytes) 4386 { 4387 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes); 4388 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes); 4389 total_bytes = next_offset / BITS_PER_UNIT; 4390 } 4391 } 4392 4393 if (! byte_buffer_in_use) 4394 byte = 0; 4395 4396 /* We must split the element into pieces that fall within 4397 separate bytes, and combine each byte with previous or 4398 following bit-fields. */ 4399 4400 /* next_offset is the offset n fbits from the beginning of 4401 the structure to the next bit of this element to be processed. 4402 end_offset is the offset of the first bit past the end of 4403 this element. */ 4404 while (next_offset < end_offset) 4405 { 4406 int this_time; 4407 int shift; 4408 HOST_WIDE_INT value; 4409 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT; 4410 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT; 4411 4412 /* Advance from byte to byte 4413 within this element when necessary. */ 4414 while (next_byte != total_bytes) 4415 { 4416 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1); 4417 total_bytes++; 4418 byte = 0; 4419 } 4420 4421 /* Number of bits we can process at once 4422 (all part of the same byte). */ 4423 this_time = MIN (end_offset - next_offset, 4424 BITS_PER_UNIT - next_bit); 4425 if (BYTES_BIG_ENDIAN) 4426 { 4427 /* On big-endian machine, take the most significant bits 4428 first (of the bits that are significant) 4429 and put them into bytes from the most significant end. */ 4430 shift = end_offset - next_offset - this_time; 4431 4432 /* Don't try to take a bunch of bits that cross 4433 the word boundary in the INTEGER_CST. We can 4434 only select bits from the LOW or HIGH part 4435 not from both. */ 4436 if (shift < HOST_BITS_PER_WIDE_INT 4437 && shift + this_time > HOST_BITS_PER_WIDE_INT) 4438 { 4439 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT; 4440 shift = HOST_BITS_PER_WIDE_INT; 4441 } 4442 4443 /* Now get the bits from the appropriate constant word. */ 4444 if (shift < HOST_BITS_PER_WIDE_INT) 4445 value = TREE_INT_CST_LOW (val); 4446 else 4447 { 4448 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT); 4449 value = TREE_INT_CST_HIGH (val); 4450 shift -= HOST_BITS_PER_WIDE_INT; 4451 } 4452 4453 /* Get the result. This works only when: 4454 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */ 4455 byte |= (((value >> shift) 4456 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1)) 4457 << (BITS_PER_UNIT - this_time - next_bit)); 4458 } 4459 else 4460 { 4461 /* On little-endian machines, 4462 take first the least significant bits of the value 4463 and pack them starting at the least significant 4464 bits of the bytes. */ 4465 shift = next_offset - int_bit_position (field); 4466 4467 /* Don't try to take a bunch of bits that cross 4468 the word boundary in the INTEGER_CST. We can 4469 only select bits from the LOW or HIGH part 4470 not from both. */ 4471 if (shift < HOST_BITS_PER_WIDE_INT 4472 && shift + this_time > HOST_BITS_PER_WIDE_INT) 4473 this_time = (HOST_BITS_PER_WIDE_INT - shift); 4474 4475 /* Now get the bits from the appropriate constant word. */ 4476 if (shift < HOST_BITS_PER_WIDE_INT) 4477 value = TREE_INT_CST_LOW (val); 4478 else 4479 { 4480 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT); 4481 value = TREE_INT_CST_HIGH (val); 4482 shift -= HOST_BITS_PER_WIDE_INT; 4483 } 4484 4485 /* Get the result. This works only when: 4486 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */ 4487 byte |= (((value >> shift) 4488 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1)) 4489 << next_bit); 4490 } 4491 4492 next_offset += this_time; 4493 byte_buffer_in_use = 1; 4494 } 4495 } 4496 } 4497 4498 if (byte_buffer_in_use) 4499 { 4500 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1); 4501 total_bytes++; 4502 } 4503 4504 if ((unsigned HOST_WIDE_INT)total_bytes < size) 4505 assemble_zeros (size - total_bytes); 4506} 4507 4508/* This TREE_LIST contains any weak symbol declarations waiting 4509 to be emitted. */ 4510static GTY(()) tree weak_decls; 4511 4512/* Mark DECL as weak. */ 4513 4514static void 4515mark_weak (tree decl) 4516{ 4517 DECL_WEAK (decl) = 1; 4518 4519 if (DECL_RTL_SET_P (decl) 4520 && MEM_P (DECL_RTL (decl)) 4521 && XEXP (DECL_RTL (decl), 0) 4522 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF) 4523 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1; 4524} 4525 4526/* Merge weak status between NEWDECL and OLDDECL. */ 4527 4528void 4529merge_weak (tree newdecl, tree olddecl) 4530{ 4531 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl)) 4532 { 4533 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK) 4534 { 4535 tree *pwd; 4536 /* We put the NEWDECL on the weak_decls list at some point 4537 and OLDDECL as well. Keep just OLDDECL on the list. */ 4538 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd)) 4539 if (TREE_VALUE (*pwd) == newdecl) 4540 { 4541 *pwd = TREE_CHAIN (*pwd); 4542 break; 4543 } 4544 } 4545 return; 4546 } 4547 4548 if (DECL_WEAK (newdecl)) 4549 { 4550 tree wd; 4551 4552 /* NEWDECL is weak, but OLDDECL is not. */ 4553 4554 /* If we already output the OLDDECL, we're in trouble; we can't 4555 go back and make it weak. This error cannot caught in 4556 declare_weak because the NEWDECL and OLDDECL was not yet 4557 been merged; therefore, TREE_ASM_WRITTEN was not set. */ 4558 if (TREE_ASM_WRITTEN (olddecl)) 4559 error ("weak declaration of %q+D must precede definition", 4560 newdecl); 4561 4562 /* If we've already generated rtl referencing OLDDECL, we may 4563 have done so in a way that will not function properly with 4564 a weak symbol. */ 4565 else if (TREE_USED (olddecl) 4566 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl))) 4567 warning (0, "weak declaration of %q+D after first use results " 4568 "in unspecified behavior", newdecl); 4569 4570 if (SUPPORTS_WEAK) 4571 { 4572 /* We put the NEWDECL on the weak_decls list at some point. 4573 Replace it with the OLDDECL. */ 4574 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd)) 4575 if (TREE_VALUE (wd) == newdecl) 4576 { 4577 TREE_VALUE (wd) = olddecl; 4578 break; 4579 } 4580 /* We may not find the entry on the list. If NEWDECL is a 4581 weak alias, then we will have already called 4582 globalize_decl to remove the entry; in that case, we do 4583 not need to do anything. */ 4584 } 4585 4586 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */ 4587 mark_weak (olddecl); 4588 } 4589 else 4590 /* OLDDECL was weak, but NEWDECL was not explicitly marked as 4591 weak. Just update NEWDECL to indicate that it's weak too. */ 4592 mark_weak (newdecl); 4593} 4594 4595/* Declare DECL to be a weak symbol. */ 4596 4597void 4598declare_weak (tree decl) 4599{ 4600 if (! TREE_PUBLIC (decl)) 4601 error ("weak declaration of %q+D must be public", decl); 4602 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 4603 error ("weak declaration of %q+D must precede definition", decl); 4604 else if (SUPPORTS_WEAK) 4605 { 4606 if (! DECL_WEAK (decl)) 4607 weak_decls = tree_cons (NULL, decl, weak_decls); 4608 } 4609 else 4610 warning (0, "weak declaration of %q+D not supported", decl); 4611 4612 mark_weak (decl); 4613} 4614 4615static void 4616weak_finish_1 (tree decl) 4617{ 4618#if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL) 4619 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 4620#endif 4621 4622 if (! TREE_USED (decl)) 4623 return; 4624 4625#ifdef ASM_WEAKEN_DECL 4626 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL); 4627#else 4628#ifdef ASM_WEAKEN_LABEL 4629 ASM_WEAKEN_LABEL (asm_out_file, name); 4630#else 4631#ifdef ASM_OUTPUT_WEAK_ALIAS 4632 { 4633 static bool warn_once = 0; 4634 if (! warn_once) 4635 { 4636 warning (0, "only weak aliases are supported in this configuration"); 4637 warn_once = 1; 4638 } 4639 return; 4640 } 4641#endif 4642#endif 4643#endif 4644} 4645 4646/* This TREE_LIST contains weakref targets. */ 4647 4648static GTY(()) tree weakref_targets; 4649 4650/* Forward declaration. */ 4651static tree find_decl_and_mark_needed (tree decl, tree target); 4652 4653/* Emit any pending weak declarations. */ 4654 4655void 4656weak_finish (void) 4657{ 4658 tree t; 4659 4660 for (t = weakref_targets; t; t = TREE_CHAIN (t)) 4661 { 4662 tree alias_decl = TREE_PURPOSE (t); 4663 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t)); 4664 4665 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl))) 4666 /* Remove alias_decl from the weak list, but leave entries for 4667 the target alone. */ 4668 target = NULL_TREE; 4669#ifndef ASM_OUTPUT_WEAKREF 4670 else if (! TREE_SYMBOL_REFERENCED (target)) 4671 { 4672 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not 4673 defined, otherwise we and weak_finish_1 would use a 4674 different macros. */ 4675# if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL 4676 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target)); 4677# else 4678 tree decl = find_decl_and_mark_needed (alias_decl, target); 4679 4680 if (! decl) 4681 { 4682 decl = build_decl (TREE_CODE (alias_decl), target, 4683 TREE_TYPE (alias_decl)); 4684 4685 DECL_EXTERNAL (decl) = 1; 4686 TREE_PUBLIC (decl) = 1; 4687 DECL_ARTIFICIAL (decl) = 1; 4688 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl); 4689 TREE_USED (decl) = 1; 4690 } 4691 4692 weak_finish_1 (decl); 4693# endif 4694 } 4695#endif 4696 4697 { 4698 tree *p; 4699 tree t2; 4700 4701 /* Remove the alias and the target from the pending weak list 4702 so that we do not emit any .weak directives for the former, 4703 nor multiple .weak directives for the latter. */ 4704 for (p = &weak_decls; (t2 = *p) ; ) 4705 { 4706 if (TREE_VALUE (t2) == alias_decl 4707 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2))) 4708 *p = TREE_CHAIN (t2); 4709 else 4710 p = &TREE_CHAIN (t2); 4711 } 4712 4713 /* Remove other weakrefs to the same target, to speed things up. */ 4714 for (p = &TREE_CHAIN (t); (t2 = *p) ; ) 4715 { 4716 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2))) 4717 *p = TREE_CHAIN (t2); 4718 else 4719 p = &TREE_CHAIN (t2); 4720 } 4721 } 4722 } 4723 4724 for (t = weak_decls; t; t = TREE_CHAIN (t)) 4725 { 4726 tree decl = TREE_VALUE (t); 4727 4728 weak_finish_1 (decl); 4729 } 4730} 4731 4732/* Emit the assembly bits to indicate that DECL is globally visible. */ 4733 4734static void 4735globalize_decl (tree decl) 4736{ 4737 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0); 4738 4739#if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) 4740 if (DECL_WEAK (decl)) 4741 { 4742 tree *p, t; 4743 4744#ifdef ASM_WEAKEN_DECL 4745 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0); 4746#else 4747 ASM_WEAKEN_LABEL (asm_out_file, name); 4748#endif 4749 4750 /* Remove this function from the pending weak list so that 4751 we do not emit multiple .weak directives for it. */ 4752 for (p = &weak_decls; (t = *p) ; ) 4753 { 4754 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t))) 4755 *p = TREE_CHAIN (t); 4756 else 4757 p = &TREE_CHAIN (t); 4758 } 4759 4760 /* Remove weakrefs to the same target from the pending weakref 4761 list, for the same reason. */ 4762 for (p = &weakref_targets; (t = *p) ; ) 4763 { 4764 if (DECL_ASSEMBLER_NAME (decl) 4765 == ultimate_transparent_alias_target (&TREE_VALUE (t))) 4766 *p = TREE_CHAIN (t); 4767 else 4768 p = &TREE_CHAIN (t); 4769 } 4770 4771 return; 4772 } 4773#elif defined(ASM_MAKE_LABEL_LINKONCE) 4774 if (DECL_ONE_ONLY (decl)) 4775 ASM_MAKE_LABEL_LINKONCE (asm_out_file, name); 4776#endif 4777 4778 targetm.asm_out.globalize_label (asm_out_file, name); 4779} 4780 4781/* We have to be able to tell cgraph about the needed-ness of the target 4782 of an alias. This requires that the decl have been defined. Aliases 4783 that precede their definition have to be queued for later processing. */ 4784 4785typedef struct alias_pair GTY(()) 4786{ 4787 tree decl; 4788 tree target; 4789} alias_pair; 4790 4791/* Define gc'd vector type. */ 4792DEF_VEC_O(alias_pair); 4793DEF_VEC_ALLOC_O(alias_pair,gc); 4794 4795static GTY(()) VEC(alias_pair,gc) *alias_pairs; 4796 4797/* Given an assembly name, find the decl it is associated with. At the 4798 same time, mark it needed for cgraph. */ 4799 4800static tree 4801find_decl_and_mark_needed (tree decl, tree target) 4802{ 4803 struct cgraph_node *fnode = NULL; 4804 struct cgraph_varpool_node *vnode = NULL; 4805 4806 if (TREE_CODE (decl) == FUNCTION_DECL) 4807 { 4808 fnode = cgraph_node_for_asm (target); 4809 if (fnode == NULL) 4810 vnode = cgraph_varpool_node_for_asm (target); 4811 } 4812 else 4813 { 4814 vnode = cgraph_varpool_node_for_asm (target); 4815 if (vnode == NULL) 4816 fnode = cgraph_node_for_asm (target); 4817 } 4818 4819 if (fnode) 4820 { 4821 /* We can't mark function nodes as used after cgraph global info 4822 is finished. This wouldn't generally be necessary, but C++ 4823 virtual table thunks are introduced late in the game and 4824 might seem like they need marking, although in fact they 4825 don't. */ 4826 if (! cgraph_global_info_ready) 4827 cgraph_mark_needed_node (fnode); 4828 return fnode->decl; 4829 } 4830 else if (vnode) 4831 { 4832 cgraph_varpool_mark_needed_node (vnode); 4833 return vnode->decl; 4834 } 4835 else 4836 return NULL_TREE; 4837} 4838 4839/* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF 4840 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose 4841 tree node is DECL to have the value of the tree node TARGET. */ 4842 4843static void 4844do_assemble_alias (tree decl, tree target) 4845{ 4846 if (TREE_ASM_WRITTEN (decl)) 4847 return; 4848 4849 TREE_ASM_WRITTEN (decl) = 1; 4850 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1; 4851 4852 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 4853 { 4854 ultimate_transparent_alias_target (&target); 4855 4856 if (!TREE_SYMBOL_REFERENCED (target)) 4857 weakref_targets = tree_cons (decl, target, weakref_targets); 4858 4859#ifdef ASM_OUTPUT_WEAKREF 4860 ASM_OUTPUT_WEAKREF (asm_out_file, decl, 4861 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 4862 IDENTIFIER_POINTER (target)); 4863#else 4864 if (!SUPPORTS_WEAK) 4865 { 4866 error ("%Jweakref is not supported in this configuration", decl); 4867 return; 4868 } 4869#endif 4870 return; 4871 } 4872 4873#ifdef ASM_OUTPUT_DEF 4874 /* Make name accessible from other files, if appropriate. */ 4875 4876 if (TREE_PUBLIC (decl)) 4877 { 4878 globalize_decl (decl); 4879 maybe_assemble_visibility (decl); 4880 } 4881 4882# ifdef ASM_OUTPUT_DEF_FROM_DECLS 4883 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target); 4884# else 4885 ASM_OUTPUT_DEF (asm_out_file, 4886 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 4887 IDENTIFIER_POINTER (target)); 4888# endif 4889#elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL) 4890 { 4891 const char *name; 4892 tree *p, t; 4893 4894 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 4895# ifdef ASM_WEAKEN_DECL 4896 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target)); 4897# else 4898 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target)); 4899# endif 4900 /* Remove this function from the pending weak list so that 4901 we do not emit multiple .weak directives for it. */ 4902 for (p = &weak_decls; (t = *p) ; ) 4903 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t))) 4904 *p = TREE_CHAIN (t); 4905 else 4906 p = &TREE_CHAIN (t); 4907 4908 /* Remove weakrefs to the same target from the pending weakref 4909 list, for the same reason. */ 4910 for (p = &weakref_targets; (t = *p) ; ) 4911 { 4912 if (DECL_ASSEMBLER_NAME (decl) 4913 == ultimate_transparent_alias_target (&TREE_VALUE (t))) 4914 *p = TREE_CHAIN (t); 4915 else 4916 p = &TREE_CHAIN (t); 4917 } 4918 } 4919#endif 4920} 4921 4922/* First pass of completing pending aliases. Make sure that cgraph knows 4923 which symbols will be required. */ 4924 4925void 4926finish_aliases_1 (void) 4927{ 4928 unsigned i; 4929 alias_pair *p; 4930 4931 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++) 4932 { 4933 tree target_decl; 4934 4935 target_decl = find_decl_and_mark_needed (p->decl, p->target); 4936 if (target_decl == NULL) 4937 { 4938 if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl))) 4939 error ("%q+D aliased to undefined symbol %qs", 4940 p->decl, IDENTIFIER_POINTER (p->target)); 4941 } 4942 else if (DECL_EXTERNAL (target_decl) 4943 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl))) 4944 error ("%q+D aliased to external symbol %qs", 4945 p->decl, IDENTIFIER_POINTER (p->target)); 4946 } 4947} 4948 4949/* Second pass of completing pending aliases. Emit the actual assembly. 4950 This happens at the end of compilation and thus it is assured that the 4951 target symbol has been emitted. */ 4952 4953void 4954finish_aliases_2 (void) 4955{ 4956 unsigned i; 4957 alias_pair *p; 4958 4959 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++) 4960 do_assemble_alias (p->decl, p->target); 4961 4962 VEC_truncate (alias_pair, alias_pairs, 0); 4963} 4964 4965/* Emit an assembler directive to make the symbol for DECL an alias to 4966 the symbol for TARGET. */ 4967 4968void 4969assemble_alias (tree decl, tree target) 4970{ 4971 tree target_decl; 4972 bool is_weakref = false; 4973 4974 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 4975 { 4976 tree alias = DECL_ASSEMBLER_NAME (decl); 4977 4978 is_weakref = true; 4979 4980 ultimate_transparent_alias_target (&target); 4981 4982 if (alias == target) 4983 error ("weakref %q+D ultimately targets itself", decl); 4984 else 4985 { 4986#ifndef ASM_OUTPUT_WEAKREF 4987 IDENTIFIER_TRANSPARENT_ALIAS (alias) = 1; 4988 TREE_CHAIN (alias) = target; 4989#endif 4990 } 4991 if (TREE_PUBLIC (decl)) 4992 error ("weakref %q+D must have static linkage", decl); 4993 } 4994 else 4995 { 4996#if !defined (ASM_OUTPUT_DEF) 4997# if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL) 4998 error ("%Jalias definitions not supported in this configuration", decl); 4999 return; 5000# else 5001 if (!DECL_WEAK (decl)) 5002 { 5003 error ("%Jonly weak aliases are supported in this configuration", decl); 5004 return; 5005 } 5006# endif 5007#endif 5008 } 5009 5010 /* We must force creation of DECL_RTL for debug info generation, even though 5011 we don't use it here. */ 5012 make_decl_rtl (decl); 5013 TREE_USED (decl) = 1; 5014 5015 /* A quirk of the initial implementation of aliases required that the user 5016 add "extern" to all of them. Which is silly, but now historical. Do 5017 note that the symbol is in fact locally defined. */ 5018 if (! is_weakref) 5019 DECL_EXTERNAL (decl) = 0; 5020 5021 /* Allow aliases to aliases. */ 5022 if (TREE_CODE (decl) == FUNCTION_DECL) 5023 cgraph_node (decl)->alias = true; 5024 else 5025 cgraph_varpool_node (decl)->alias = true; 5026 5027 /* If the target has already been emitted, we don't have to queue the 5028 alias. This saves a tad o memory. */ 5029 target_decl = find_decl_and_mark_needed (decl, target); 5030 if (target_decl && TREE_ASM_WRITTEN (target_decl)) 5031 do_assemble_alias (decl, target); 5032 else 5033 { 5034 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL); 5035 p->decl = decl; 5036 p->target = target; 5037 } 5038} 5039 5040/* Emit an assembler directive to set symbol for DECL visibility to 5041 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */ 5042 5043void 5044default_assemble_visibility (tree decl, int vis) 5045{ 5046 static const char * const visibility_types[] = { 5047 NULL, "protected", "hidden", "internal" 5048 }; 5049 5050 const char *name, *type; 5051 5052 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 5053 type = visibility_types[vis]; 5054 5055#ifdef HAVE_GAS_HIDDEN 5056 fprintf (asm_out_file, "\t.%s\t", type); 5057 assemble_name (asm_out_file, name); 5058 fprintf (asm_out_file, "\n"); 5059#else 5060 warning (OPT_Wattributes, "visibility attribute not supported " 5061 "in this configuration; ignored"); 5062#endif 5063} 5064 5065/* A helper function to call assemble_visibility when needed for a decl. */ 5066 5067static void 5068maybe_assemble_visibility (tree decl) 5069{ 5070 enum symbol_visibility vis = DECL_VISIBILITY (decl); 5071 5072 if (vis != VISIBILITY_DEFAULT) 5073 targetm.asm_out.visibility (decl, vis); 5074} 5075 5076/* Returns 1 if the target configuration supports defining public symbols 5077 so that one of them will be chosen at link time instead of generating a 5078 multiply-defined symbol error, whether through the use of weak symbols or 5079 a target-specific mechanism for having duplicates discarded. */ 5080 5081int 5082supports_one_only (void) 5083{ 5084 if (SUPPORTS_ONE_ONLY) 5085 return 1; 5086 return SUPPORTS_WEAK; 5087} 5088 5089/* Set up DECL as a public symbol that can be defined in multiple 5090 translation units without generating a linker error. */ 5091 5092void 5093make_decl_one_only (tree decl) 5094{ 5095 gcc_assert (TREE_CODE (decl) == VAR_DECL 5096 || TREE_CODE (decl) == FUNCTION_DECL); 5097 5098 TREE_PUBLIC (decl) = 1; 5099 5100 if (SUPPORTS_ONE_ONLY) 5101 { 5102#ifdef MAKE_DECL_ONE_ONLY 5103 MAKE_DECL_ONE_ONLY (decl); 5104#endif 5105 DECL_ONE_ONLY (decl) = 1; 5106 } 5107 else if (TREE_CODE (decl) == VAR_DECL 5108 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)) 5109 DECL_COMMON (decl) = 1; 5110 else 5111 { 5112 gcc_assert (SUPPORTS_WEAK); 5113 DECL_WEAK (decl) = 1; 5114 } 5115} 5116 5117void 5118init_varasm_once (void) 5119{ 5120 section_htab = htab_create_ggc (31, section_entry_hash, 5121 section_entry_eq, NULL); 5122 object_block_htab = htab_create_ggc (31, object_block_entry_hash, 5123 object_block_entry_eq, NULL); 5124 const_desc_htab = htab_create_ggc (1009, const_desc_hash, 5125 const_desc_eq, NULL); 5126 5127 const_alias_set = new_alias_set (); 5128 shared_constant_pool = create_constant_pool (); 5129 5130#ifdef TEXT_SECTION_ASM_OP 5131 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op, 5132 TEXT_SECTION_ASM_OP); 5133#endif 5134 5135#ifdef DATA_SECTION_ASM_OP 5136 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op, 5137 DATA_SECTION_ASM_OP); 5138#endif 5139 5140#ifdef SDATA_SECTION_ASM_OP 5141 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op, 5142 SDATA_SECTION_ASM_OP); 5143#endif 5144 5145#ifdef READONLY_DATA_SECTION_ASM_OP 5146 readonly_data_section = get_unnamed_section (0, output_section_asm_op, 5147 READONLY_DATA_SECTION_ASM_OP); 5148#endif 5149 5150#ifdef CTORS_SECTION_ASM_OP 5151 ctors_section = get_unnamed_section (0, output_section_asm_op, 5152 CTORS_SECTION_ASM_OP); 5153#endif 5154 5155#ifdef DTORS_SECTION_ASM_OP 5156 dtors_section = get_unnamed_section (0, output_section_asm_op, 5157 DTORS_SECTION_ASM_OP); 5158#endif 5159 5160#ifdef BSS_SECTION_ASM_OP 5161 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS, 5162 output_section_asm_op, 5163 BSS_SECTION_ASM_OP); 5164#endif 5165 5166#ifdef SBSS_SECTION_ASM_OP 5167 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS, 5168 output_section_asm_op, 5169 SBSS_SECTION_ASM_OP); 5170#endif 5171 5172 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 5173 | SECTION_COMMON, emit_tls_common); 5174 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 5175 | SECTION_COMMON, emit_local); 5176 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS 5177 | SECTION_COMMON, emit_common); 5178 5179#if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS 5180 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS, 5181 emit_bss); 5182#endif 5183 5184 targetm.asm_out.init_sections (); 5185 5186 if (readonly_data_section == NULL) 5187 readonly_data_section = text_section; 5188} 5189 5190enum tls_model 5191decl_default_tls_model (tree decl) 5192{ 5193 enum tls_model kind; 5194 bool is_local; 5195 5196 is_local = targetm.binds_local_p (decl); 5197 if (!flag_shlib) 5198 { 5199 if (is_local) 5200 kind = TLS_MODEL_LOCAL_EXEC; 5201 else 5202 kind = TLS_MODEL_INITIAL_EXEC; 5203 } 5204 5205 /* Local dynamic is inefficient when we're not combining the 5206 parts of the address. */ 5207 else if (optimize && is_local) 5208 kind = TLS_MODEL_LOCAL_DYNAMIC; 5209 else 5210 kind = TLS_MODEL_GLOBAL_DYNAMIC; 5211 if (kind < flag_tls_default) 5212 kind = flag_tls_default; 5213 5214 return kind; 5215} 5216 5217/* Select a set of attributes for section NAME based on the properties 5218 of DECL and whether or not RELOC indicates that DECL's initializer 5219 might contain runtime relocations. 5220 5221 We make the section read-only and executable for a function decl, 5222 read-only for a const data decl, and writable for a non-const data decl. */ 5223 5224unsigned int 5225default_section_type_flags (tree decl, const char *name, int reloc) 5226{ 5227 unsigned int flags; 5228 5229 if (decl && TREE_CODE (decl) == FUNCTION_DECL) 5230 flags = SECTION_CODE; 5231 else if (decl && decl_readonly_section (decl, reloc)) 5232 flags = 0; 5233 else if (current_function_decl 5234 && cfun 5235 && cfun->unlikely_text_section_name 5236 && strcmp (name, cfun->unlikely_text_section_name) == 0) 5237 flags = SECTION_CODE; 5238 else if (!decl 5239 && (!current_function_decl || !cfun) 5240 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0) 5241 flags = SECTION_CODE; 5242 else 5243 flags = SECTION_WRITE; 5244 5245 if (decl && DECL_ONE_ONLY (decl)) 5246 flags |= SECTION_LINKONCE; 5247 5248 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 5249 flags |= SECTION_TLS | SECTION_WRITE; 5250 5251 if (strcmp (name, ".bss") == 0 5252 || strncmp (name, ".bss.", 5) == 0 5253 || strncmp (name, ".gnu.linkonce.b.", 16) == 0 5254 || strcmp (name, ".sbss") == 0 5255 || strncmp (name, ".sbss.", 6) == 0 5256 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0) 5257 flags |= SECTION_BSS; 5258 5259 if (strcmp (name, ".tdata") == 0 5260 || strncmp (name, ".tdata.", 7) == 0 5261 || strncmp (name, ".gnu.linkonce.td.", 17) == 0) 5262 flags |= SECTION_TLS; 5263 5264 if (strcmp (name, ".tbss") == 0 5265 || strncmp (name, ".tbss.", 6) == 0 5266 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0) 5267 flags |= SECTION_TLS | SECTION_BSS; 5268 5269 /* These three sections have special ELF types. They are neither 5270 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't 5271 want to print a section type (@progbits or @nobits). If someone 5272 is silly enough to emit code or TLS variables to one of these 5273 sections, then don't handle them specially. */ 5274 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS)) 5275 && (strcmp (name, ".init_array") == 0 5276 || strcmp (name, ".fini_array") == 0 5277 || strcmp (name, ".preinit_array") == 0)) 5278 flags |= SECTION_NOTYPE; 5279 5280 return flags; 5281} 5282 5283/* Return true if the target supports some form of global BSS, 5284 either through bss_noswitch_section, or by selecting a BSS 5285 section in TARGET_ASM_SELECT_SECTION. */ 5286 5287bool 5288have_global_bss_p (void) 5289{ 5290 return bss_noswitch_section || targetm.have_switchable_bss_sections; 5291} 5292 5293/* Output assembly to switch to section NAME with attribute FLAGS. 5294 Four variants for common object file formats. */ 5295 5296void 5297default_no_named_section (const char *name ATTRIBUTE_UNUSED, 5298 unsigned int flags ATTRIBUTE_UNUSED, 5299 tree decl ATTRIBUTE_UNUSED) 5300{ 5301 /* Some object formats don't support named sections at all. The 5302 front-end should already have flagged this as an error. */ 5303 gcc_unreachable (); 5304} 5305 5306void 5307default_elf_asm_named_section (const char *name, unsigned int flags, 5308 tree decl ATTRIBUTE_UNUSED) 5309{ 5310 char flagchars[10], *f = flagchars; 5311 5312 /* If we have already declared this section, we can use an 5313 abbreviated form to switch back to it -- unless this section is 5314 part of a COMDAT groups, in which case GAS requires the full 5315 declaration every time. */ 5316 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 5317 && (flags & SECTION_DECLARED)) 5318 { 5319 fprintf (asm_out_file, "\t.section\t%s\n", name); 5320 return; 5321 } 5322 5323 if (!(flags & SECTION_DEBUG)) 5324 *f++ = 'a'; 5325 if (flags & SECTION_WRITE) 5326 *f++ = 'w'; 5327 if (flags & SECTION_CODE) 5328 *f++ = 'x'; 5329 if (flags & SECTION_SMALL) 5330 *f++ = 's'; 5331 if (flags & SECTION_MERGE) 5332 *f++ = 'M'; 5333 if (flags & SECTION_STRINGS) 5334 *f++ = 'S'; 5335 if (flags & SECTION_TLS) 5336 *f++ = 'T'; 5337 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 5338 *f++ = 'G'; 5339 *f = '\0'; 5340 5341 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars); 5342 5343 if (!(flags & SECTION_NOTYPE)) 5344 { 5345 const char *type; 5346 const char *format; 5347 5348 if (flags & SECTION_BSS) 5349 type = "nobits"; 5350 else 5351 type = "progbits"; 5352 5353 format = ",@%s"; 5354#ifdef ASM_COMMENT_START 5355 /* On platforms that use "@" as the assembly comment character, 5356 use "%" instead. */ 5357 if (strcmp (ASM_COMMENT_START, "@") == 0) 5358 format = ",%%%s"; 5359#endif 5360 fprintf (asm_out_file, format, type); 5361 5362 if (flags & SECTION_ENTSIZE) 5363 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE); 5364 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE)) 5365 fprintf (asm_out_file, ",%s,comdat", 5366 lang_hooks.decls.comdat_group (decl)); 5367 } 5368 5369 putc ('\n', asm_out_file); 5370} 5371 5372void 5373default_coff_asm_named_section (const char *name, unsigned int flags, 5374 tree decl ATTRIBUTE_UNUSED) 5375{ 5376 char flagchars[8], *f = flagchars; 5377 5378 if (flags & SECTION_WRITE) 5379 *f++ = 'w'; 5380 if (flags & SECTION_CODE) 5381 *f++ = 'x'; 5382 *f = '\0'; 5383 5384 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars); 5385} 5386 5387void 5388default_pe_asm_named_section (const char *name, unsigned int flags, 5389 tree decl) 5390{ 5391 default_coff_asm_named_section (name, flags, decl); 5392 5393 if (flags & SECTION_LINKONCE) 5394 { 5395 /* Functions may have been compiled at various levels of 5396 optimization so we can't use `same_size' here. 5397 Instead, have the linker pick one. */ 5398 fprintf (asm_out_file, "\t.linkonce %s\n", 5399 (flags & SECTION_CODE ? "discard" : "same_size")); 5400 } 5401} 5402 5403/* The lame default section selector. */ 5404 5405section * 5406default_select_section (tree decl, int reloc, 5407 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED) 5408{ 5409 if (DECL_P (decl)) 5410 { 5411 if (decl_readonly_section (decl, reloc)) 5412 return readonly_data_section; 5413 } 5414 else if (TREE_CODE (decl) == CONSTRUCTOR) 5415 { 5416 if (! ((flag_pic && reloc) 5417 || !TREE_READONLY (decl) 5418 || TREE_SIDE_EFFECTS (decl) 5419 || !TREE_CONSTANT (decl))) 5420 return readonly_data_section; 5421 } 5422 else if (TREE_CODE (decl) == STRING_CST) 5423 return readonly_data_section; 5424 else if (! (flag_pic && reloc)) 5425 return readonly_data_section; 5426 5427 return data_section; 5428} 5429 5430enum section_category 5431categorize_decl_for_section (tree decl, int reloc) 5432{ 5433 enum section_category ret; 5434 5435 if (TREE_CODE (decl) == FUNCTION_DECL) 5436 return SECCAT_TEXT; 5437 else if (TREE_CODE (decl) == STRING_CST) 5438 { 5439 if (flag_mudflap) /* or !flag_merge_constants */ 5440 return SECCAT_RODATA; 5441 else 5442 return SECCAT_RODATA_MERGE_STR; 5443 } 5444 else if (TREE_CODE (decl) == VAR_DECL) 5445 { 5446 if (bss_initializer_p (decl)) 5447 ret = SECCAT_BSS; 5448 else if (! TREE_READONLY (decl) 5449 || TREE_SIDE_EFFECTS (decl) 5450 || ! TREE_CONSTANT (DECL_INITIAL (decl))) 5451 { 5452 /* Here the reloc_rw_mask is not testing whether the section should 5453 be read-only or not, but whether the dynamic link will have to 5454 do something. If so, we wish to segregate the data in order to 5455 minimize cache misses inside the dynamic linker. */ 5456 if (reloc & targetm.asm_out.reloc_rw_mask ()) 5457 ret = reloc == 1 ? SECCAT_DATA_REL_LOCAL : SECCAT_DATA_REL; 5458 else 5459 ret = SECCAT_DATA; 5460 } 5461 else if (reloc & targetm.asm_out.reloc_rw_mask ()) 5462 ret = reloc == 1 ? SECCAT_DATA_REL_RO_LOCAL : SECCAT_DATA_REL_RO; 5463 else if (reloc || flag_merge_constants < 2) 5464 /* C and C++ don't allow different variables to share the same 5465 location. -fmerge-all-constants allows even that (at the 5466 expense of not conforming). */ 5467 ret = SECCAT_RODATA; 5468 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST) 5469 ret = SECCAT_RODATA_MERGE_STR_INIT; 5470 else 5471 ret = SECCAT_RODATA_MERGE_CONST; 5472 } 5473 else if (TREE_CODE (decl) == CONSTRUCTOR) 5474 { 5475 if ((reloc & targetm.asm_out.reloc_rw_mask ()) 5476 || TREE_SIDE_EFFECTS (decl) 5477 || ! TREE_CONSTANT (decl)) 5478 ret = SECCAT_DATA; 5479 else 5480 ret = SECCAT_RODATA; 5481 } 5482 else 5483 ret = SECCAT_RODATA; 5484 5485 /* There are no read-only thread-local sections. */ 5486 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 5487 { 5488 /* Note that this would be *just* SECCAT_BSS, except that there's 5489 no concept of a read-only thread-local-data section. */ 5490 if (ret == SECCAT_BSS 5491 || (flag_zero_initialized_in_bss 5492 && initializer_zerop (DECL_INITIAL (decl)))) 5493 ret = SECCAT_TBSS; 5494 else 5495 ret = SECCAT_TDATA; 5496 } 5497 5498 /* If the target uses small data sections, select it. */ 5499 else if (targetm.in_small_data_p (decl)) 5500 { 5501 if (ret == SECCAT_BSS) 5502 ret = SECCAT_SBSS; 5503 else if (targetm.have_srodata_section && ret == SECCAT_RODATA) 5504 ret = SECCAT_SRODATA; 5505 else 5506 ret = SECCAT_SDATA; 5507 } 5508 5509 return ret; 5510} 5511 5512bool 5513decl_readonly_section (tree decl, int reloc) 5514{ 5515 switch (categorize_decl_for_section (decl, reloc)) 5516 { 5517 case SECCAT_RODATA: 5518 case SECCAT_RODATA_MERGE_STR: 5519 case SECCAT_RODATA_MERGE_STR_INIT: 5520 case SECCAT_RODATA_MERGE_CONST: 5521 case SECCAT_SRODATA: 5522 return true; 5523 break; 5524 default: 5525 return false; 5526 break; 5527 } 5528} 5529 5530/* Select a section based on the above categorization. */ 5531 5532section * 5533default_elf_select_section (tree decl, int reloc, 5534 unsigned HOST_WIDE_INT align) 5535{ 5536 const char *sname; 5537 switch (categorize_decl_for_section (decl, reloc)) 5538 { 5539 case SECCAT_TEXT: 5540 /* We're not supposed to be called on FUNCTION_DECLs. */ 5541 gcc_unreachable (); 5542 case SECCAT_RODATA: 5543 return readonly_data_section; 5544 case SECCAT_RODATA_MERGE_STR: 5545 return mergeable_string_section (decl, align, 0); 5546 case SECCAT_RODATA_MERGE_STR_INIT: 5547 return mergeable_string_section (DECL_INITIAL (decl), align, 0); 5548 case SECCAT_RODATA_MERGE_CONST: 5549 return mergeable_constant_section (DECL_MODE (decl), align, 0); 5550 case SECCAT_SRODATA: 5551 sname = ".sdata2"; 5552 break; 5553 case SECCAT_DATA: 5554 return data_section; 5555 case SECCAT_DATA_REL: 5556 sname = ".data.rel"; 5557 break; 5558 case SECCAT_DATA_REL_LOCAL: 5559 sname = ".data.rel.local"; 5560 break; 5561 case SECCAT_DATA_REL_RO: 5562 sname = ".data.rel.ro"; 5563 break; 5564 case SECCAT_DATA_REL_RO_LOCAL: 5565 sname = ".data.rel.ro.local"; 5566 break; 5567 case SECCAT_SDATA: 5568 sname = ".sdata"; 5569 break; 5570 case SECCAT_TDATA: 5571 sname = ".tdata"; 5572 break; 5573 case SECCAT_BSS: 5574 if (bss_section) 5575 return bss_section; 5576 sname = ".bss"; 5577 break; 5578 case SECCAT_SBSS: 5579 sname = ".sbss"; 5580 break; 5581 case SECCAT_TBSS: 5582 sname = ".tbss"; 5583 break; 5584 default: 5585 gcc_unreachable (); 5586 } 5587 5588 if (!DECL_P (decl)) 5589 decl = NULL_TREE; 5590 return get_named_section (decl, sname, reloc); 5591} 5592 5593/* Construct a unique section name based on the decl name and the 5594 categorization performed above. */ 5595 5596void 5597default_unique_section (tree decl, int reloc) 5598{ 5599 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */ 5600 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP; 5601 const char *prefix, *name; 5602 size_t nlen, plen; 5603 char *string; 5604 5605 switch (categorize_decl_for_section (decl, reloc)) 5606 { 5607 case SECCAT_TEXT: 5608 prefix = one_only ? ".gnu.linkonce.t." : ".text."; 5609 break; 5610 case SECCAT_RODATA: 5611 case SECCAT_RODATA_MERGE_STR: 5612 case SECCAT_RODATA_MERGE_STR_INIT: 5613 case SECCAT_RODATA_MERGE_CONST: 5614 prefix = one_only ? ".gnu.linkonce.r." : ".rodata."; 5615 break; 5616 case SECCAT_SRODATA: 5617 prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2."; 5618 break; 5619 case SECCAT_DATA: 5620 prefix = one_only ? ".gnu.linkonce.d." : ".data."; 5621 break; 5622 case SECCAT_DATA_REL: 5623 prefix = one_only ? ".gnu.linkonce.d.rel." : ".data.rel."; 5624 break; 5625 case SECCAT_DATA_REL_LOCAL: 5626 prefix = one_only ? ".gnu.linkonce.d.rel.local." : ".data.rel.local."; 5627 break; 5628 case SECCAT_DATA_REL_RO: 5629 prefix = one_only ? ".gnu.linkonce.d.rel.ro." : ".data.rel.ro."; 5630 break; 5631 case SECCAT_DATA_REL_RO_LOCAL: 5632 prefix = one_only ? ".gnu.linkonce.d.rel.ro.local." 5633 : ".data.rel.ro.local."; 5634 break; 5635 case SECCAT_SDATA: 5636 prefix = one_only ? ".gnu.linkonce.s." : ".sdata."; 5637 break; 5638 case SECCAT_BSS: 5639 prefix = one_only ? ".gnu.linkonce.b." : ".bss."; 5640 break; 5641 case SECCAT_SBSS: 5642 prefix = one_only ? ".gnu.linkonce.sb." : ".sbss."; 5643 break; 5644 case SECCAT_TDATA: 5645 prefix = one_only ? ".gnu.linkonce.td." : ".tdata."; 5646 break; 5647 case SECCAT_TBSS: 5648 prefix = one_only ? ".gnu.linkonce.tb." : ".tbss."; 5649 break; 5650 default: 5651 gcc_unreachable (); 5652 } 5653 plen = strlen (prefix); 5654 5655 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 5656 name = targetm.strip_name_encoding (name); 5657 nlen = strlen (name); 5658 5659 string = alloca (nlen + plen + 1); 5660 memcpy (string, prefix, plen); 5661 memcpy (string + plen, name, nlen + 1); 5662 5663 DECL_SECTION_NAME (decl) = build_string (nlen + plen, string); 5664} 5665 5666/* Like compute_reloc_for_constant, except for an RTX. The return value 5667 is a mask for which bit 1 indicates a global relocation, and bit 0 5668 indicates a local relocation. */ 5669 5670static int 5671compute_reloc_for_rtx_1 (rtx *xp, void *data) 5672{ 5673 int *preloc = data; 5674 rtx x = *xp; 5675 5676 switch (GET_CODE (x)) 5677 { 5678 case SYMBOL_REF: 5679 *preloc |= SYMBOL_REF_LOCAL_P (x) ? 1 : 2; 5680 break; 5681 case LABEL_REF: 5682 *preloc |= 1; 5683 break; 5684 default: 5685 break; 5686 } 5687 5688 return 0; 5689} 5690 5691static int 5692compute_reloc_for_rtx (rtx x) 5693{ 5694 int reloc; 5695 5696 switch (GET_CODE (x)) 5697 { 5698 case CONST: 5699 case SYMBOL_REF: 5700 case LABEL_REF: 5701 reloc = 0; 5702 for_each_rtx (&x, compute_reloc_for_rtx_1, &reloc); 5703 return reloc; 5704 5705 default: 5706 return 0; 5707 } 5708} 5709 5710section * 5711default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED, 5712 rtx x, 5713 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED) 5714{ 5715 if (compute_reloc_for_rtx (x) & targetm.asm_out.reloc_rw_mask ()) 5716 return data_section; 5717 else 5718 return readonly_data_section; 5719} 5720 5721section * 5722default_elf_select_rtx_section (enum machine_mode mode, rtx x, 5723 unsigned HOST_WIDE_INT align) 5724{ 5725 int reloc = compute_reloc_for_rtx (x); 5726 5727 /* ??? Handle small data here somehow. */ 5728 5729 if (reloc & targetm.asm_out.reloc_rw_mask ()) 5730 { 5731 if (reloc == 1) 5732 return get_named_section (NULL, ".data.rel.ro.local", 1); 5733 else 5734 return get_named_section (NULL, ".data.rel.ro", 3); 5735 } 5736 5737 return mergeable_constant_section (mode, align, 0); 5738} 5739 5740/* Set the generally applicable flags on the SYMBOL_REF for EXP. */ 5741 5742void 5743default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED) 5744{ 5745 rtx symbol; 5746 int flags; 5747 5748 /* Careful not to prod global register variables. */ 5749 if (!MEM_P (rtl)) 5750 return; 5751 symbol = XEXP (rtl, 0); 5752 if (GET_CODE (symbol) != SYMBOL_REF) 5753 return; 5754 5755 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO; 5756 if (TREE_CODE (decl) == FUNCTION_DECL) 5757 flags |= SYMBOL_FLAG_FUNCTION; 5758 if (targetm.binds_local_p (decl)) 5759 flags |= SYMBOL_FLAG_LOCAL; 5760 if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl)) 5761 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT; 5762 else if (targetm.in_small_data_p (decl)) 5763 flags |= SYMBOL_FLAG_SMALL; 5764 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without 5765 being PUBLIC, the thing *must* be defined in this translation unit. 5766 Prevent this buglet from being propagated into rtl code as well. */ 5767 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)) 5768 flags |= SYMBOL_FLAG_EXTERNAL; 5769 5770 SYMBOL_REF_FLAGS (symbol) = flags; 5771} 5772 5773/* By default, we do nothing for encode_section_info, so we need not 5774 do anything but discard the '*' marker. */ 5775 5776const char * 5777default_strip_name_encoding (const char *str) 5778{ 5779 return str + (*str == '*'); 5780} 5781 5782#ifdef ASM_OUTPUT_DEF 5783/* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the 5784 anchor relative to ".", the current section position. */ 5785 5786void 5787default_asm_output_anchor (rtx symbol) 5788{ 5789 char buffer[100]; 5790 5791 sprintf (buffer, ". + " HOST_WIDE_INT_PRINT_DEC, 5792 SYMBOL_REF_BLOCK_OFFSET (symbol)); 5793 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer); 5794} 5795#endif 5796 5797/* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */ 5798 5799bool 5800default_use_anchors_for_symbol_p (rtx symbol) 5801{ 5802 section *sect; 5803 tree decl; 5804 5805 /* Don't use anchors for mergeable sections. The linker might move 5806 the objects around. */ 5807 sect = SYMBOL_REF_BLOCK (symbol)->sect; 5808 if (sect->common.flags & SECTION_MERGE) 5809 return false; 5810 5811 /* Don't use anchors for small data sections. The small data register 5812 acts as an anchor for such sections. */ 5813 if (sect->common.flags & SECTION_SMALL) 5814 return false; 5815 5816 decl = SYMBOL_REF_DECL (symbol); 5817 if (decl && DECL_P (decl)) 5818 { 5819 /* Don't use section anchors for decls that might be defined by 5820 other modules. */ 5821 if (!targetm.binds_local_p (decl)) 5822 return false; 5823 5824 /* Don't use section anchors for decls that will be placed in a 5825 small data section. */ 5826 /* ??? Ideally, this check would be redundant with the SECTION_SMALL 5827 one above. The problem is that we only use SECTION_SMALL for 5828 sections that should be marked as small in the section directive. */ 5829 if (targetm.in_small_data_p (decl)) 5830 return false; 5831 } 5832 return true; 5833} 5834 5835/* Assume ELF-ish defaults, since that's pretty much the most liberal 5836 wrt cross-module name binding. */ 5837 5838bool 5839default_binds_local_p (tree exp) 5840{ 5841 return default_binds_local_p_1 (exp, flag_shlib); 5842} 5843 5844bool 5845default_binds_local_p_1 (tree exp, int shlib) 5846{ 5847 bool local_p; 5848 5849 /* A non-decl is an entry in the constant pool. */ 5850 if (!DECL_P (exp)) 5851 local_p = true; 5852 /* Weakrefs may not bind locally, even though the weakref itself is 5853 always static and therefore local. */ 5854 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp))) 5855 local_p = false; 5856 /* Static variables are always local. */ 5857 else if (! TREE_PUBLIC (exp)) 5858 local_p = true; 5859 /* A variable is local if the user has said explicitly that it will 5860 be. */ 5861 else if (DECL_VISIBILITY_SPECIFIED (exp) 5862 && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT) 5863 local_p = true; 5864 /* Variables defined outside this object might not be local. */ 5865 else if (DECL_EXTERNAL (exp)) 5866 local_p = false; 5867 /* If defined in this object and visibility is not default, must be 5868 local. */ 5869 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT) 5870 local_p = true; 5871 /* Default visibility weak data can be overridden by a strong symbol 5872 in another module and so are not local. */ 5873 else if (DECL_WEAK (exp)) 5874 local_p = false; 5875 /* If PIC, then assume that any global name can be overridden by 5876 symbols resolved from other modules. */ 5877 else if (shlib) 5878 local_p = false; 5879 /* Uninitialized COMMON variable may be unified with symbols 5880 resolved from other modules. */ 5881 else if (DECL_COMMON (exp) 5882 && (DECL_INITIAL (exp) == NULL 5883 || DECL_INITIAL (exp) == error_mark_node)) 5884 local_p = false; 5885 /* Otherwise we're left with initialized (or non-common) global data 5886 which is of necessity defined locally. */ 5887 else 5888 local_p = true; 5889 5890 return local_p; 5891} 5892 5893/* Determine whether or not a pointer mode is valid. Assume defaults 5894 of ptr_mode or Pmode - can be overridden. */ 5895bool 5896default_valid_pointer_mode (enum machine_mode mode) 5897{ 5898 return (mode == ptr_mode || mode == Pmode); 5899} 5900 5901/* Default function to output code that will globalize a label. A 5902 target must define GLOBAL_ASM_OP or provide its own function to 5903 globalize a label. */ 5904#ifdef GLOBAL_ASM_OP 5905void 5906default_globalize_label (FILE * stream, const char *name) 5907{ 5908 fputs (GLOBAL_ASM_OP, stream); 5909 assemble_name (stream, name); 5910 putc ('\n', stream); 5911} 5912#endif /* GLOBAL_ASM_OP */ 5913 5914/* Default function to output a label for unwind information. The 5915 default is to do nothing. A target that needs nonlocal labels for 5916 unwind information must provide its own function to do this. */ 5917void 5918default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED, 5919 tree decl ATTRIBUTE_UNUSED, 5920 int for_eh ATTRIBUTE_UNUSED, 5921 int empty ATTRIBUTE_UNUSED) 5922{ 5923} 5924 5925/* Default function to output a label to divide up the exception table. 5926 The default is to do nothing. A target that needs/wants to divide 5927 up the table must provide it's own function to do this. */ 5928void 5929default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED) 5930{ 5931} 5932 5933/* This is how to output an internal numbered label where PREFIX is 5934 the class of label and LABELNO is the number within the class. */ 5935 5936void 5937default_internal_label (FILE *stream, const char *prefix, 5938 unsigned long labelno) 5939{ 5940 char *const buf = alloca (40 + strlen (prefix)); 5941 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno); 5942 ASM_OUTPUT_INTERNAL_LABEL (stream, buf); 5943} 5944 5945/* This is the default behavior at the beginning of a file. It's 5946 controlled by two other target-hook toggles. */ 5947void 5948default_file_start (void) 5949{ 5950 if (targetm.file_start_app_off && !flag_verbose_asm) 5951 fputs (ASM_APP_OFF, asm_out_file); 5952 5953 if (targetm.file_start_file_directive) 5954 output_file_directive (asm_out_file, main_input_filename); 5955} 5956 5957/* This is a generic routine suitable for use as TARGET_ASM_FILE_END 5958 which emits a special section directive used to indicate whether or 5959 not this object file needs an executable stack. This is primarily 5960 a GNU extension to ELF but could be used on other targets. */ 5961 5962int trampolines_created; 5963 5964void 5965file_end_indicate_exec_stack (void) 5966{ 5967 unsigned int flags = SECTION_DEBUG; 5968 if (trampolines_created) 5969 flags |= SECTION_CODE; 5970 5971 switch_to_section (get_section (".note.GNU-stack", flags, NULL)); 5972} 5973 5974/* Output DIRECTIVE (a C string) followed by a newline. This is used as 5975 a get_unnamed_section callback. */ 5976 5977void 5978output_section_asm_op (const void *directive) 5979{ 5980 fprintf (asm_out_file, "%s\n", (const char *) directive); 5981} 5982 5983/* Emit assembly code to switch to section NEW_SECTION. Do nothing if 5984 the current section is NEW_SECTION. */ 5985 5986void 5987switch_to_section (section *new_section) 5988{ 5989 if (in_section == new_section) 5990 return; 5991 5992 if (new_section->common.flags & SECTION_FORGET) 5993 in_section = NULL; 5994 else 5995 in_section = new_section; 5996 5997 switch (SECTION_STYLE (new_section)) 5998 { 5999 case SECTION_NAMED: 6000 if (cfun 6001 && !cfun->unlikely_text_section_name 6002 && strcmp (new_section->named.name, 6003 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0) 6004 cfun->unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME; 6005 6006 targetm.asm_out.named_section (new_section->named.name, 6007 new_section->named.common.flags, 6008 new_section->named.decl); 6009 break; 6010 6011 case SECTION_UNNAMED: 6012 new_section->unnamed.callback (new_section->unnamed.data); 6013 break; 6014 6015 case SECTION_NOSWITCH: 6016 gcc_unreachable (); 6017 break; 6018 } 6019 6020 new_section->common.flags |= SECTION_DECLARED; 6021} 6022 6023/* If block symbol SYMBOL has not yet been assigned an offset, place 6024 it at the end of its block. */ 6025 6026void 6027place_block_symbol (rtx symbol) 6028{ 6029 unsigned HOST_WIDE_INT size, mask, offset; 6030 struct constant_descriptor_rtx *desc; 6031 unsigned int alignment; 6032 struct object_block *block; 6033 tree decl; 6034 6035 gcc_assert (SYMBOL_REF_BLOCK (symbol)); 6036 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0) 6037 return; 6038 6039 /* Work out the symbol's size and alignment. */ 6040 if (CONSTANT_POOL_ADDRESS_P (symbol)) 6041 { 6042 desc = SYMBOL_REF_CONSTANT (symbol); 6043 alignment = desc->align; 6044 size = GET_MODE_SIZE (desc->mode); 6045 } 6046 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol)) 6047 { 6048 decl = SYMBOL_REF_DECL (symbol); 6049 alignment = get_constant_alignment (decl); 6050 size = get_constant_size (decl); 6051 } 6052 else 6053 { 6054 decl = SYMBOL_REF_DECL (symbol); 6055 alignment = DECL_ALIGN (decl); 6056 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1); 6057 } 6058 6059 /* Calculate the object's offset from the start of the block. */ 6060 block = SYMBOL_REF_BLOCK (symbol); 6061 mask = alignment / BITS_PER_UNIT - 1; 6062 offset = (block->size + mask) & ~mask; 6063 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset; 6064 6065 /* Record the block's new alignment and size. */ 6066 block->alignment = MAX (block->alignment, alignment); 6067 block->size = offset + size; 6068 6069 VEC_safe_push (rtx, gc, block->objects, symbol); 6070} 6071 6072/* Return the anchor that should be used to address byte offset OFFSET 6073 from the first object in BLOCK. MODEL is the TLS model used 6074 to access it. */ 6075 6076rtx 6077get_section_anchor (struct object_block *block, HOST_WIDE_INT offset, 6078 enum tls_model model) 6079{ 6080 char label[100]; 6081 unsigned int begin, middle, end; 6082 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta; 6083 rtx anchor; 6084 6085 /* Work out the anchor's offset. Use an offset of 0 for the first 6086 anchor so that we don't pessimize the case where we take the address 6087 of a variable at the beginning of the block. This is particularly 6088 useful when a block has only one variable assigned to it. 6089 6090 We try to place anchors RANGE bytes apart, so there can then be 6091 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of 6092 a ptr_mode offset. With some target settings, the lowest such 6093 anchor might be out of range for the lowest ptr_mode offset; 6094 likewise the highest anchor for the highest offset. Use anchors 6095 at the extreme ends of the ptr_mode range in such cases. 6096 6097 All arithmetic uses unsigned integers in order to avoid 6098 signed overflow. */ 6099 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset; 6100 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset; 6101 range = max_offset - min_offset + 1; 6102 if (range == 0) 6103 offset = 0; 6104 else 6105 { 6106 bias = 1 << (GET_MODE_BITSIZE (ptr_mode) - 1); 6107 if (offset < 0) 6108 { 6109 delta = -(unsigned HOST_WIDE_INT) offset + max_offset; 6110 delta -= delta % range; 6111 if (delta > bias) 6112 delta = bias; 6113 offset = (HOST_WIDE_INT) (-delta); 6114 } 6115 else 6116 { 6117 delta = (unsigned HOST_WIDE_INT) offset - min_offset; 6118 delta -= delta % range; 6119 if (delta > bias - 1) 6120 delta = bias - 1; 6121 offset = (HOST_WIDE_INT) delta; 6122 } 6123 } 6124 6125 /* Do a binary search to see if there's already an anchor we can use. 6126 Set BEGIN to the new anchor's index if not. */ 6127 begin = 0; 6128 end = VEC_length (rtx, block->anchors); 6129 while (begin != end) 6130 { 6131 middle = (end + begin) / 2; 6132 anchor = VEC_index (rtx, block->anchors, middle); 6133 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset) 6134 end = middle; 6135 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset) 6136 begin = middle + 1; 6137 else if (SYMBOL_REF_TLS_MODEL (anchor) > model) 6138 end = middle; 6139 else if (SYMBOL_REF_TLS_MODEL (anchor) < model) 6140 begin = middle + 1; 6141 else 6142 return anchor; 6143 } 6144 6145 /* Create a new anchor with a unique label. */ 6146 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++); 6147 anchor = create_block_symbol (ggc_strdup (label), block, offset); 6148 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR; 6149 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT; 6150 6151 /* Insert it at index BEGIN. */ 6152 VEC_safe_insert (rtx, gc, block->anchors, begin, anchor); 6153 return anchor; 6154} 6155 6156/* Output the objects in BLOCK. */ 6157 6158static void 6159output_object_block (struct object_block *block) 6160{ 6161 struct constant_descriptor_rtx *desc; 6162 unsigned int i; 6163 HOST_WIDE_INT offset; 6164 tree decl; 6165 rtx symbol; 6166 6167 if (block->objects == NULL) 6168 return; 6169 6170 /* Switch to the section and make sure that the first byte is 6171 suitably aligned. */ 6172 switch_to_section (block->sect); 6173 assemble_align (block->alignment); 6174 6175 /* Define the values of all anchors relative to the current section 6176 position. */ 6177 for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++) 6178 targetm.asm_out.output_anchor (symbol); 6179 6180 /* Output the objects themselves. */ 6181 offset = 0; 6182 for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++) 6183 { 6184 /* Move to the object's offset, padding with zeros if necessary. */ 6185 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset); 6186 offset = SYMBOL_REF_BLOCK_OFFSET (symbol); 6187 if (CONSTANT_POOL_ADDRESS_P (symbol)) 6188 { 6189 desc = SYMBOL_REF_CONSTANT (symbol); 6190 output_constant_pool_1 (desc, 1); 6191 offset += GET_MODE_SIZE (desc->mode); 6192 } 6193 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol)) 6194 { 6195 decl = SYMBOL_REF_DECL (symbol); 6196 assemble_constant_contents (decl, XSTR (symbol, 0), 6197 get_constant_alignment (decl)); 6198 offset += get_constant_size (decl); 6199 } 6200 else 6201 { 6202 decl = SYMBOL_REF_DECL (symbol); 6203 assemble_variable_contents (decl, XSTR (symbol, 0), false); 6204 offset += tree_low_cst (DECL_SIZE_UNIT (decl), 1); 6205 } 6206 } 6207} 6208 6209/* A htab_traverse callback used to call output_object_block for 6210 each member of object_block_htab. */ 6211 6212static int 6213output_object_block_htab (void **slot, void *data ATTRIBUTE_UNUSED) 6214{ 6215 output_object_block ((struct object_block *) (*slot)); 6216 return 1; 6217} 6218 6219/* Output the definitions of all object_blocks. */ 6220 6221void 6222output_object_blocks (void) 6223{ 6224 htab_traverse (object_block_htab, output_object_block_htab, NULL); 6225} 6226 6227#include "gt-varasm.h" 6228