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