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