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