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