1 /* Expands front end tree to back end RTL for GNU C-Compiler 2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 3 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 2, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING. If not, write to the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, USA. */ 21 22 23 /* $FreeBSD$ */ 24 25 26 /* This file handles the generation of rtl code from tree structure 27 at the level of the function as a whole. 28 It creates the rtl expressions for parameters and auto variables 29 and has full responsibility for allocating stack slots. 30 31 `expand_function_start' is called at the beginning of a function, 32 before the function body is parsed, and `expand_function_end' is 33 called after parsing the body. 34 35 Call `assign_stack_local' to allocate a stack slot for a local variable. 36 This is usually done during the RTL generation for the function body, 37 but it can also be done in the reload pass when a pseudo-register does 38 not get a hard register. 39 40 Call `put_var_into_stack' when you learn, belatedly, that a variable 41 previously given a pseudo-register must in fact go in the stack. 42 This function changes the DECL_RTL to be a stack slot instead of a reg 43 then scans all the RTL instructions so far generated to correct them. */ 44 45 #include "config.h" 46 #include "system.h" 47 #include "rtl.h" 48 #include "tree.h" 49 #include "flags.h" 50 #include "except.h" 51 #include "function.h" 52 #include "expr.h" 53 #include "libfuncs.h" 54 #include "regs.h" 55 #include "hard-reg-set.h" 56 #include "insn-config.h" 57 #include "recog.h" 58 #include "output.h" 59 #include "basic-block.h" 60 #include "obstack.h" 61 #include "toplev.h" 62 #include "hash.h" 63 #include "ggc.h" 64 #include "tm_p.h" 65 #include "integrate.h" 66 67 #ifndef TRAMPOLINE_ALIGNMENT 68 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY 69 #endif 70 71 #ifndef LOCAL_ALIGNMENT 72 #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT 73 #endif 74 75 /* Some systems use __main in a way incompatible with its use in gcc, in these 76 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to 77 give the same symbol without quotes for an alternative entry point. You 78 must define both, or neither. */ 79 #ifndef NAME__MAIN 80 #define NAME__MAIN "__main" 81 #define SYMBOL__MAIN __main 82 #endif 83 84 /* Round a value to the lowest integer less than it that is a multiple of 85 the required alignment. Avoid using division in case the value is 86 negative. Assume the alignment is a power of two. */ 87 #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) 88 89 /* Similar, but round to the next highest integer that meets the 90 alignment. */ 91 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) 92 93 /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp 94 during rtl generation. If they are different register numbers, this is 95 always true. It may also be true if 96 FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl 97 generation. See fix_lexical_addr for details. */ 98 99 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM 100 #define NEED_SEPARATE_AP 101 #endif 102 103 /* Nonzero if function being compiled doesn't contain any calls 104 (ignoring the prologue and epilogue). This is set prior to 105 local register allocation and is valid for the remaining 106 compiler passes. */ 107 int current_function_is_leaf; 108 109 /* Nonzero if function being compiled doesn't contain any instructions 110 that can throw an exception. This is set prior to final. */ 111 112 int current_function_nothrow; 113 114 /* Nonzero if function being compiled doesn't modify the stack pointer 115 (ignoring the prologue and epilogue). This is only valid after 116 life_analysis has run. */ 117 int current_function_sp_is_unchanging; 118 119 /* Nonzero if the function being compiled is a leaf function which only 120 uses leaf registers. This is valid after reload (specifically after 121 sched2) and is useful only if the port defines LEAF_REGISTERS. */ 122 int current_function_uses_only_leaf_regs; 123 124 /* Nonzero once virtual register instantiation has been done. 125 assign_stack_local uses frame_pointer_rtx when this is nonzero. 126 calls.c:emit_library_call_value_1 uses it to set up 127 post-instantiation libcalls. */ 128 int virtuals_instantiated; 129 130 /* Assign unique numbers to labels generated for profiling. */ 131 static int profile_label_no; 132 133 /* These variables hold pointers to functions to create and destroy 134 target specific, per-function data structures. */ 135 void (*init_machine_status) PARAMS ((struct function *)); 136 void (*free_machine_status) PARAMS ((struct function *)); 137 /* This variable holds a pointer to a function to register any 138 data items in the target specific, per-function data structure 139 that will need garbage collection. */ 140 void (*mark_machine_status) PARAMS ((struct function *)); 141 142 /* Likewise, but for language-specific data. */ 143 void (*init_lang_status) PARAMS ((struct function *)); 144 void (*save_lang_status) PARAMS ((struct function *)); 145 void (*restore_lang_status) PARAMS ((struct function *)); 146 void (*mark_lang_status) PARAMS ((struct function *)); 147 void (*free_lang_status) PARAMS ((struct function *)); 148 149 /* The FUNCTION_DECL for an inline function currently being expanded. */ 150 tree inline_function_decl; 151 152 /* The currently compiled function. */ 153 struct function *cfun = 0; 154 155 /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */ 156 static varray_type prologue; 157 static varray_type epilogue; 158 159 /* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue 160 in this function. */ 161 static varray_type sibcall_epilogue; 162 163 /* In order to evaluate some expressions, such as function calls returning 164 structures in memory, we need to temporarily allocate stack locations. 165 We record each allocated temporary in the following structure. 166 167 Associated with each temporary slot is a nesting level. When we pop up 168 one level, all temporaries associated with the previous level are freed. 169 Normally, all temporaries are freed after the execution of the statement 170 in which they were created. However, if we are inside a ({...}) grouping, 171 the result may be in a temporary and hence must be preserved. If the 172 result could be in a temporary, we preserve it if we can determine which 173 one it is in. If we cannot determine which temporary may contain the 174 result, all temporaries are preserved. A temporary is preserved by 175 pretending it was allocated at the previous nesting level. 176 177 Automatic variables are also assigned temporary slots, at the nesting 178 level where they are defined. They are marked a "kept" so that 179 free_temp_slots will not free them. */ 180 181 struct temp_slot 182 { 183 /* Points to next temporary slot. */ 184 struct temp_slot *next; 185 /* The rtx to used to reference the slot. */ 186 rtx slot; 187 /* The rtx used to represent the address if not the address of the 188 slot above. May be an EXPR_LIST if multiple addresses exist. */ 189 rtx address; 190 /* The alignment (in bits) of the slot. */ 191 unsigned int align; 192 /* The size, in units, of the slot. */ 193 HOST_WIDE_INT size; 194 /* The type of the object in the slot, or zero if it doesn't correspond 195 to a type. We use this to determine whether a slot can be reused. 196 It can be reused if objects of the type of the new slot will always 197 conflict with objects of the type of the old slot. */ 198 tree type; 199 /* The value of `sequence_rtl_expr' when this temporary is allocated. */ 200 tree rtl_expr; 201 /* Non-zero if this temporary is currently in use. */ 202 char in_use; 203 /* Non-zero if this temporary has its address taken. */ 204 char addr_taken; 205 /* Nesting level at which this slot is being used. */ 206 int level; 207 /* Non-zero if this should survive a call to free_temp_slots. */ 208 int keep; 209 /* The offset of the slot from the frame_pointer, including extra space 210 for alignment. This info is for combine_temp_slots. */ 211 HOST_WIDE_INT base_offset; 212 /* The size of the slot, including extra space for alignment. This 213 info is for combine_temp_slots. */ 214 HOST_WIDE_INT full_size; 215 }; 216 217 /* This structure is used to record MEMs or pseudos used to replace VAR, any 218 SUBREGs of VAR, and any MEMs containing VAR as an address. We need to 219 maintain this list in case two operands of an insn were required to match; 220 in that case we must ensure we use the same replacement. */ 221 222 struct fixup_replacement 223 { 224 rtx old; 225 rtx new; 226 struct fixup_replacement *next; 227 }; 228 229 struct insns_for_mem_entry 230 { 231 /* The KEY in HE will be a MEM. */ 232 struct hash_entry he; 233 /* These are the INSNS which reference the MEM. */ 234 rtx insns; 235 }; 236 237 /* Forward declarations. */ 238 239 static rtx assign_stack_local_1 PARAMS ((enum machine_mode, HOST_WIDE_INT, 240 int, struct function *)); 241 static struct temp_slot *find_temp_slot_from_address PARAMS ((rtx)); 242 static void put_reg_into_stack PARAMS ((struct function *, rtx, tree, 243 enum machine_mode, enum machine_mode, 244 int, unsigned int, int, 245 struct hash_table *)); 246 static void schedule_fixup_var_refs PARAMS ((struct function *, rtx, tree, 247 enum machine_mode, 248 struct hash_table *)); 249 static void fixup_var_refs PARAMS ((rtx, enum machine_mode, int, rtx, 250 struct hash_table *)); 251 static struct fixup_replacement 252 *find_fixup_replacement PARAMS ((struct fixup_replacement **, rtx)); 253 static void fixup_var_refs_insns PARAMS ((rtx, rtx, enum machine_mode, 254 int, int, rtx)); 255 static void fixup_var_refs_insns_with_hash 256 PARAMS ((struct hash_table *, rtx, 257 enum machine_mode, int, rtx)); 258 static void fixup_var_refs_insn PARAMS ((rtx, rtx, enum machine_mode, 259 int, int, rtx)); 260 static void fixup_var_refs_1 PARAMS ((rtx, enum machine_mode, rtx *, rtx, 261 struct fixup_replacement **, rtx)); 262 static rtx fixup_memory_subreg PARAMS ((rtx, rtx, enum machine_mode, int)); 263 static rtx walk_fixup_memory_subreg PARAMS ((rtx, rtx, enum machine_mode, 264 int)); 265 static rtx fixup_stack_1 PARAMS ((rtx, rtx)); 266 static void optimize_bit_field PARAMS ((rtx, rtx, rtx *)); 267 static void instantiate_decls PARAMS ((tree, int)); 268 static void instantiate_decls_1 PARAMS ((tree, int)); 269 static void instantiate_decl PARAMS ((rtx, HOST_WIDE_INT, int)); 270 static rtx instantiate_new_reg PARAMS ((rtx, HOST_WIDE_INT *)); 271 static int instantiate_virtual_regs_1 PARAMS ((rtx *, rtx, int)); 272 static void delete_handlers PARAMS ((void)); 273 static void pad_to_arg_alignment PARAMS ((struct args_size *, int, 274 struct args_size *)); 275 #ifndef ARGS_GROW_DOWNWARD 276 static void pad_below PARAMS ((struct args_size *, enum machine_mode, 277 tree)); 278 #endif 279 static rtx round_trampoline_addr PARAMS ((rtx)); 280 static rtx adjust_trampoline_addr PARAMS ((rtx)); 281 static tree *identify_blocks_1 PARAMS ((rtx, tree *, tree *, tree *)); 282 static void reorder_blocks_0 PARAMS ((tree)); 283 static void reorder_blocks_1 PARAMS ((rtx, tree, varray_type *)); 284 static void reorder_fix_fragments PARAMS ((tree)); 285 static tree blocks_nreverse PARAMS ((tree)); 286 static int all_blocks PARAMS ((tree, tree *)); 287 static tree *get_block_vector PARAMS ((tree, int *)); 288 extern tree debug_find_var_in_block_tree PARAMS ((tree, tree)); 289 /* We always define `record_insns' even if its not used so that we 290 can always export `prologue_epilogue_contains'. */ 291 static void record_insns PARAMS ((rtx, varray_type *)) ATTRIBUTE_UNUSED; 292 static int contains PARAMS ((rtx, varray_type)); 293 #ifdef HAVE_return 294 static void emit_return_into_block PARAMS ((basic_block, rtx)); 295 #endif 296 static void put_addressof_into_stack PARAMS ((rtx, struct hash_table *)); 297 static bool purge_addressof_1 PARAMS ((rtx *, rtx, int, int, 298 struct hash_table *)); 299 static void purge_single_hard_subreg_set PARAMS ((rtx)); 300 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) 301 static rtx keep_stack_depressed PARAMS ((rtx)); 302 #endif 303 static int is_addressof PARAMS ((rtx *, void *)); 304 static struct hash_entry *insns_for_mem_newfunc PARAMS ((struct hash_entry *, 305 struct hash_table *, 306 hash_table_key)); 307 static unsigned long insns_for_mem_hash PARAMS ((hash_table_key)); 308 static bool insns_for_mem_comp PARAMS ((hash_table_key, hash_table_key)); 309 static int insns_for_mem_walk PARAMS ((rtx *, void *)); 310 static void compute_insns_for_mem PARAMS ((rtx, rtx, struct hash_table *)); 311 static void mark_function_status PARAMS ((struct function *)); 312 static void maybe_mark_struct_function PARAMS ((void *)); 313 static void prepare_function_start PARAMS ((void)); 314 static void do_clobber_return_reg PARAMS ((rtx, void *)); 315 static void do_use_return_reg PARAMS ((rtx, void *)); 316 317 /* Pointer to chain of `struct function' for containing functions. */ 318 static struct function *outer_function_chain; 319 320 /* Given a function decl for a containing function, 321 return the `struct function' for it. */ 322 323 struct function * 324 find_function_data (decl) 325 tree decl; 326 { 327 struct function *p; 328 329 for (p = outer_function_chain; p; p = p->outer) 330 if (p->decl == decl) 331 return p; 332 333 abort (); 334 } 335 336 /* Save the current context for compilation of a nested function. 337 This is called from language-specific code. The caller should use 338 the save_lang_status callback to save any language-specific state, 339 since this function knows only about language-independent 340 variables. */ 341 342 void 343 push_function_context_to (context) 344 tree context; 345 { 346 struct function *p; 347 348 if (context) 349 { 350 if (context == current_function_decl) 351 cfun->contains_functions = 1; 352 else 353 { 354 struct function *containing = find_function_data (context); 355 containing->contains_functions = 1; 356 } 357 } 358 359 if (cfun == 0) 360 init_dummy_function_start (); 361 p = cfun; 362 363 p->outer = outer_function_chain; 364 outer_function_chain = p; 365 p->fixup_var_refs_queue = 0; 366 367 if (save_lang_status) 368 (*save_lang_status) (p); 369 370 cfun = 0; 371 } 372 373 void 374 push_function_context () 375 { 376 push_function_context_to (current_function_decl); 377 } 378 379 /* Restore the last saved context, at the end of a nested function. 380 This function is called from language-specific code. */ 381 382 void 383 pop_function_context_from (context) 384 tree context ATTRIBUTE_UNUSED; 385 { 386 struct function *p = outer_function_chain; 387 struct var_refs_queue *queue; 388 389 cfun = p; 390 outer_function_chain = p->outer; 391 392 current_function_decl = p->decl; 393 reg_renumber = 0; 394 395 restore_emit_status (p); 396 397 if (restore_lang_status) 398 (*restore_lang_status) (p); 399 400 /* Finish doing put_var_into_stack for any of our variables which became 401 addressable during the nested function. If only one entry has to be 402 fixed up, just do that one. Otherwise, first make a list of MEMs that 403 are not to be unshared. */ 404 if (p->fixup_var_refs_queue == 0) 405 ; 406 else if (p->fixup_var_refs_queue->next == 0) 407 fixup_var_refs (p->fixup_var_refs_queue->modified, 408 p->fixup_var_refs_queue->promoted_mode, 409 p->fixup_var_refs_queue->unsignedp, 410 p->fixup_var_refs_queue->modified, 0); 411 else 412 { 413 rtx list = 0; 414 415 for (queue = p->fixup_var_refs_queue; queue; queue = queue->next) 416 list = gen_rtx_EXPR_LIST (VOIDmode, queue->modified, list); 417 418 for (queue = p->fixup_var_refs_queue; queue; queue = queue->next) 419 fixup_var_refs (queue->modified, queue->promoted_mode, 420 queue->unsignedp, list, 0); 421 422 } 423 424 p->fixup_var_refs_queue = 0; 425 426 /* Reset variables that have known state during rtx generation. */ 427 rtx_equal_function_value_matters = 1; 428 virtuals_instantiated = 0; 429 generating_concat_p = 1; 430 } 431 432 void 433 pop_function_context () 434 { 435 pop_function_context_from (current_function_decl); 436 } 437 438 /* Clear out all parts of the state in F that can safely be discarded 439 after the function has been parsed, but not compiled, to let 440 garbage collection reclaim the memory. */ 441 442 void 443 free_after_parsing (f) 444 struct function *f; 445 { 446 /* f->expr->forced_labels is used by code generation. */ 447 /* f->emit->regno_reg_rtx is used by code generation. */ 448 /* f->varasm is used by code generation. */ 449 /* f->eh->eh_return_stub_label is used by code generation. */ 450 451 if (free_lang_status) 452 (*free_lang_status) (f); 453 free_stmt_status (f); 454 } 455 456 /* Clear out all parts of the state in F that can safely be discarded 457 after the function has been compiled, to let garbage collection 458 reclaim the memory. */ 459 460 void 461 free_after_compilation (f) 462 struct function *f; 463 { 464 free_eh_status (f); 465 free_expr_status (f); 466 free_emit_status (f); 467 free_varasm_status (f); 468 469 if (free_machine_status) 470 (*free_machine_status) (f); 471 472 if (f->x_parm_reg_stack_loc) 473 free (f->x_parm_reg_stack_loc); 474 475 f->x_temp_slots = NULL; 476 f->arg_offset_rtx = NULL; 477 f->return_rtx = NULL; 478 f->internal_arg_pointer = NULL; 479 f->x_nonlocal_labels = NULL; 480 f->x_nonlocal_goto_handler_slots = NULL; 481 f->x_nonlocal_goto_handler_labels = NULL; 482 f->x_nonlocal_goto_stack_level = NULL; 483 f->x_cleanup_label = NULL; 484 f->x_return_label = NULL; 485 f->x_save_expr_regs = NULL; 486 f->x_stack_slot_list = NULL; 487 f->x_rtl_expr_chain = NULL; 488 f->x_tail_recursion_label = NULL; 489 f->x_tail_recursion_reentry = NULL; 490 f->x_arg_pointer_save_area = NULL; 491 f->x_clobber_return_insn = NULL; 492 f->x_context_display = NULL; 493 f->x_trampoline_list = NULL; 494 f->x_parm_birth_insn = NULL; 495 f->x_last_parm_insn = NULL; 496 f->x_parm_reg_stack_loc = NULL; 497 f->fixup_var_refs_queue = NULL; 498 f->original_arg_vector = NULL; 499 f->original_decl_initial = NULL; 500 f->inl_last_parm_insn = NULL; 501 f->epilogue_delay_list = NULL; 502 } 503 504 /* Allocate fixed slots in the stack frame of the current function. */ 505 506 /* Return size needed for stack frame based on slots so far allocated in 507 function F. 508 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; 509 the caller may have to do that. */ 510 511 HOST_WIDE_INT 512 get_func_frame_size (f) 513 struct function *f; 514 { 515 #ifdef FRAME_GROWS_DOWNWARD 516 return -f->x_frame_offset; 517 #else 518 return f->x_frame_offset; 519 #endif 520 } 521 522 /* Return size needed for stack frame based on slots so far allocated. 523 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; 524 the caller may have to do that. */ 525 HOST_WIDE_INT 526 get_frame_size () 527 { 528 return get_func_frame_size (cfun); 529 } 530 531 /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it 532 with machine mode MODE. 533 534 ALIGN controls the amount of alignment for the address of the slot: 535 0 means according to MODE, 536 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, 537 positive specifies alignment boundary in bits. 538 539 We do not round to stack_boundary here. 540 541 FUNCTION specifies the function to allocate in. */ 542 543 static rtx 544 assign_stack_local_1 (mode, size, align, function) 545 enum machine_mode mode; 546 HOST_WIDE_INT size; 547 int align; 548 struct function *function; 549 { 550 rtx x, addr; 551 int bigend_correction = 0; 552 int alignment; 553 int frame_off, frame_alignment, frame_phase; 554 555 if (align == 0) 556 { 557 tree type; 558 559 if (mode == BLKmode) 560 alignment = BIGGEST_ALIGNMENT; 561 else 562 alignment = GET_MODE_ALIGNMENT (mode); 563 564 /* Allow the target to (possibly) increase the alignment of this 565 stack slot. */ 566 type = type_for_mode (mode, 0); 567 if (type) 568 alignment = LOCAL_ALIGNMENT (type, alignment); 569 570 alignment /= BITS_PER_UNIT; 571 } 572 else if (align == -1) 573 { 574 alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; 575 size = CEIL_ROUND (size, alignment); 576 } 577 else 578 alignment = align / BITS_PER_UNIT; 579 580 #ifdef FRAME_GROWS_DOWNWARD 581 function->x_frame_offset -= size; 582 #endif 583 584 /* Ignore alignment we can't do with expected alignment of the boundary. */ 585 if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY) 586 alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 587 588 if (function->stack_alignment_needed < alignment * BITS_PER_UNIT) 589 function->stack_alignment_needed = alignment * BITS_PER_UNIT; 590 591 /* Calculate how many bytes the start of local variables is off from 592 stack alignment. */ 593 frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 594 frame_off = STARTING_FRAME_OFFSET % frame_alignment; 595 frame_phase = frame_off ? frame_alignment - frame_off : 0; 596 597 /* Round frame offset to that alignment. 598 We must be careful here, since FRAME_OFFSET might be negative and 599 division with a negative dividend isn't as well defined as we might 600 like. So we instead assume that ALIGNMENT is a power of two and 601 use logical operations which are unambiguous. */ 602 #ifdef FRAME_GROWS_DOWNWARD 603 function->x_frame_offset = FLOOR_ROUND (function->x_frame_offset - frame_phase, alignment) + frame_phase; 604 #else 605 function->x_frame_offset = CEIL_ROUND (function->x_frame_offset - frame_phase, alignment) + frame_phase; 606 #endif 607 608 /* On a big-endian machine, if we are allocating more space than we will use, 609 use the least significant bytes of those that are allocated. */ 610 if (BYTES_BIG_ENDIAN && mode != BLKmode) 611 bigend_correction = size - GET_MODE_SIZE (mode); 612 613 /* If we have already instantiated virtual registers, return the actual 614 address relative to the frame pointer. */ 615 if (function == cfun && virtuals_instantiated) 616 addr = plus_constant (frame_pointer_rtx, 617 (frame_offset + bigend_correction 618 + STARTING_FRAME_OFFSET)); 619 else 620 addr = plus_constant (virtual_stack_vars_rtx, 621 function->x_frame_offset + bigend_correction); 622 623 #ifndef FRAME_GROWS_DOWNWARD 624 function->x_frame_offset += size; 625 #endif 626 627 x = gen_rtx_MEM (mode, addr); 628 629 function->x_stack_slot_list 630 = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list); 631 632 return x; 633 } 634 635 /* Wrapper around assign_stack_local_1; assign a local stack slot for the 636 current function. */ 637 638 rtx 639 assign_stack_local (mode, size, align) 640 enum machine_mode mode; 641 HOST_WIDE_INT size; 642 int align; 643 { 644 return assign_stack_local_1 (mode, size, align, cfun); 645 } 646 647 /* Allocate a temporary stack slot and record it for possible later 648 reuse. 649 650 MODE is the machine mode to be given to the returned rtx. 651 652 SIZE is the size in units of the space required. We do no rounding here 653 since assign_stack_local will do any required rounding. 654 655 KEEP is 1 if this slot is to be retained after a call to 656 free_temp_slots. Automatic variables for a block are allocated 657 with this flag. KEEP is 2 if we allocate a longer term temporary, 658 whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3 659 if we are to allocate something at an inner level to be treated as 660 a variable in the block (e.g., a SAVE_EXPR). 661 662 TYPE is the type that will be used for the stack slot. */ 663 664 rtx 665 assign_stack_temp_for_type (mode, size, keep, type) 666 enum machine_mode mode; 667 HOST_WIDE_INT size; 668 int keep; 669 tree type; 670 { 671 unsigned int align; 672 struct temp_slot *p, *best_p = 0; 673 rtx slot; 674 675 /* If SIZE is -1 it means that somebody tried to allocate a temporary 676 of a variable size. */ 677 if (size == -1) 678 abort (); 679 680 if (mode == BLKmode) 681 align = BIGGEST_ALIGNMENT; 682 else 683 align = GET_MODE_ALIGNMENT (mode); 684 685 if (! type) 686 type = type_for_mode (mode, 0); 687 688 if (type) 689 align = LOCAL_ALIGNMENT (type, align); 690 691 /* Try to find an available, already-allocated temporary of the proper 692 mode which meets the size and alignment requirements. Choose the 693 smallest one with the closest alignment. */ 694 for (p = temp_slots; p; p = p->next) 695 if (p->align >= align && p->size >= size && GET_MODE (p->slot) == mode 696 && ! p->in_use 697 && objects_must_conflict_p (p->type, type) 698 && (best_p == 0 || best_p->size > p->size 699 || (best_p->size == p->size && best_p->align > p->align))) 700 { 701 if (p->align == align && p->size == size) 702 { 703 best_p = 0; 704 break; 705 } 706 best_p = p; 707 } 708 709 /* Make our best, if any, the one to use. */ 710 if (best_p) 711 { 712 /* If there are enough aligned bytes left over, make them into a new 713 temp_slot so that the extra bytes don't get wasted. Do this only 714 for BLKmode slots, so that we can be sure of the alignment. */ 715 if (GET_MODE (best_p->slot) == BLKmode) 716 { 717 int alignment = best_p->align / BITS_PER_UNIT; 718 HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); 719 720 if (best_p->size - rounded_size >= alignment) 721 { 722 p = (struct temp_slot *) ggc_alloc (sizeof (struct temp_slot)); 723 p->in_use = p->addr_taken = 0; 724 p->size = best_p->size - rounded_size; 725 p->base_offset = best_p->base_offset + rounded_size; 726 p->full_size = best_p->full_size - rounded_size; 727 p->slot = gen_rtx_MEM (BLKmode, 728 plus_constant (XEXP (best_p->slot, 0), 729 rounded_size)); 730 p->align = best_p->align; 731 p->address = 0; 732 p->rtl_expr = 0; 733 p->type = best_p->type; 734 p->next = temp_slots; 735 temp_slots = p; 736 737 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, 738 stack_slot_list); 739 740 best_p->size = rounded_size; 741 best_p->full_size = rounded_size; 742 } 743 } 744 745 p = best_p; 746 } 747 748 /* If we still didn't find one, make a new temporary. */ 749 if (p == 0) 750 { 751 HOST_WIDE_INT frame_offset_old = frame_offset; 752 753 p = (struct temp_slot *) ggc_alloc (sizeof (struct temp_slot)); 754 755 /* We are passing an explicit alignment request to assign_stack_local. 756 One side effect of that is assign_stack_local will not round SIZE 757 to ensure the frame offset remains suitably aligned. 758 759 So for requests which depended on the rounding of SIZE, we go ahead 760 and round it now. We also make sure ALIGNMENT is at least 761 BIGGEST_ALIGNMENT. */ 762 if (mode == BLKmode && align < BIGGEST_ALIGNMENT) 763 abort (); 764 p->slot = assign_stack_local (mode, 765 (mode == BLKmode 766 ? CEIL_ROUND (size, align / BITS_PER_UNIT) 767 : size), 768 align); 769 770 p->align = align; 771 772 /* The following slot size computation is necessary because we don't 773 know the actual size of the temporary slot until assign_stack_local 774 has performed all the frame alignment and size rounding for the 775 requested temporary. Note that extra space added for alignment 776 can be either above or below this stack slot depending on which 777 way the frame grows. We include the extra space if and only if it 778 is above this slot. */ 779 #ifdef FRAME_GROWS_DOWNWARD 780 p->size = frame_offset_old - frame_offset; 781 #else 782 p->size = size; 783 #endif 784 785 /* Now define the fields used by combine_temp_slots. */ 786 #ifdef FRAME_GROWS_DOWNWARD 787 p->base_offset = frame_offset; 788 p->full_size = frame_offset_old - frame_offset; 789 #else 790 p->base_offset = frame_offset_old; 791 p->full_size = frame_offset - frame_offset_old; 792 #endif 793 p->address = 0; 794 p->next = temp_slots; 795 temp_slots = p; 796 } 797 798 p->in_use = 1; 799 p->addr_taken = 0; 800 p->rtl_expr = seq_rtl_expr; 801 p->type = type; 802 803 if (keep == 2) 804 { 805 p->level = target_temp_slot_level; 806 p->keep = 0; 807 } 808 else if (keep == 3) 809 { 810 p->level = var_temp_slot_level; 811 p->keep = 0; 812 } 813 else 814 { 815 p->level = temp_slot_level; 816 p->keep = keep; 817 } 818 819 820 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ 821 slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); 822 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list); 823 824 /* If we know the alias set for the memory that will be used, use 825 it. If there's no TYPE, then we don't know anything about the 826 alias set for the memory. */ 827 set_mem_alias_set (slot, type ? get_alias_set (type) : 0); 828 set_mem_align (slot, align); 829 830 /* If a type is specified, set the relevant flags. */ 831 if (type != 0) 832 { 833 RTX_UNCHANGING_P (slot) = TYPE_READONLY (type); 834 MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type); 835 MEM_SET_IN_STRUCT_P (slot, AGGREGATE_TYPE_P (type)); 836 } 837 838 return slot; 839 } 840 841 /* Allocate a temporary stack slot and record it for possible later 842 reuse. First three arguments are same as in preceding function. */ 843 844 rtx 845 assign_stack_temp (mode, size, keep) 846 enum machine_mode mode; 847 HOST_WIDE_INT size; 848 int keep; 849 { 850 return assign_stack_temp_for_type (mode, size, keep, NULL_TREE); 851 } 852 853 /* Assign a temporary. 854 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl 855 and so that should be used in error messages. In either case, we 856 allocate of the given type. 857 KEEP is as for assign_stack_temp. 858 MEMORY_REQUIRED is 1 if the result must be addressable stack memory; 859 it is 0 if a register is OK. 860 DONT_PROMOTE is 1 if we should not promote values in register 861 to wider modes. */ 862 863 rtx 864 assign_temp (type_or_decl, keep, memory_required, dont_promote) 865 tree type_or_decl; 866 int keep; 867 int memory_required; 868 int dont_promote ATTRIBUTE_UNUSED; 869 { 870 tree type, decl; 871 enum machine_mode mode; 872 #ifndef PROMOTE_FOR_CALL_ONLY 873 int unsignedp; 874 #endif 875 876 if (DECL_P (type_or_decl)) 877 decl = type_or_decl, type = TREE_TYPE (decl); 878 else 879 decl = NULL, type = type_or_decl; 880 881 mode = TYPE_MODE (type); 882 #ifndef PROMOTE_FOR_CALL_ONLY 883 unsignedp = TREE_UNSIGNED (type); 884 #endif 885 886 if (mode == BLKmode || memory_required) 887 { 888 HOST_WIDE_INT size = int_size_in_bytes (type); 889 rtx tmp; 890 891 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid 892 problems with allocating the stack space. */ 893 if (size == 0) 894 size = 1; 895 896 /* Unfortunately, we don't yet know how to allocate variable-sized 897 temporaries. However, sometimes we have a fixed upper limit on 898 the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that 899 instead. This is the case for Chill variable-sized strings. */ 900 if (size == -1 && TREE_CODE (type) == ARRAY_TYPE 901 && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE 902 && host_integerp (TYPE_ARRAY_MAX_SIZE (type), 1)) 903 size = tree_low_cst (TYPE_ARRAY_MAX_SIZE (type), 1); 904 905 /* The size of the temporary may be too large to fit into an integer. */ 906 /* ??? Not sure this should happen except for user silliness, so limit 907 this to things that aren't compiler-generated temporaries. The 908 rest of the time we'll abort in assign_stack_temp_for_type. */ 909 if (decl && size == -1 910 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST) 911 { 912 error_with_decl (decl, "size of variable `%s' is too large"); 913 size = 1; 914 } 915 916 tmp = assign_stack_temp_for_type (mode, size, keep, type); 917 return tmp; 918 } 919 920 #ifndef PROMOTE_FOR_CALL_ONLY 921 if (! dont_promote) 922 mode = promote_mode (type, mode, &unsignedp, 0); 923 #endif 924 925 return gen_reg_rtx (mode); 926 } 927 928 /* Combine temporary stack slots which are adjacent on the stack. 929 930 This allows for better use of already allocated stack space. This is only 931 done for BLKmode slots because we can be sure that we won't have alignment 932 problems in this case. */ 933 934 void 935 combine_temp_slots () 936 { 937 struct temp_slot *p, *q; 938 struct temp_slot *prev_p, *prev_q; 939 int num_slots; 940 941 /* We can't combine slots, because the information about which slot 942 is in which alias set will be lost. */ 943 if (flag_strict_aliasing) 944 return; 945 946 /* If there are a lot of temp slots, don't do anything unless 947 high levels of optimization. */ 948 if (! flag_expensive_optimizations) 949 for (p = temp_slots, num_slots = 0; p; p = p->next, num_slots++) 950 if (num_slots > 100 || (num_slots > 10 && optimize == 0)) 951 return; 952 953 for (p = temp_slots, prev_p = 0; p; p = prev_p ? prev_p->next : temp_slots) 954 { 955 int delete_p = 0; 956 957 if (! p->in_use && GET_MODE (p->slot) == BLKmode) 958 for (q = p->next, prev_q = p; q; q = prev_q->next) 959 { 960 int delete_q = 0; 961 if (! q->in_use && GET_MODE (q->slot) == BLKmode) 962 { 963 if (p->base_offset + p->full_size == q->base_offset) 964 { 965 /* Q comes after P; combine Q into P. */ 966 p->size += q->size; 967 p->full_size += q->full_size; 968 delete_q = 1; 969 } 970 else if (q->base_offset + q->full_size == p->base_offset) 971 { 972 /* P comes after Q; combine P into Q. */ 973 q->size += p->size; 974 q->full_size += p->full_size; 975 delete_p = 1; 976 break; 977 } 978 } 979 /* Either delete Q or advance past it. */ 980 if (delete_q) 981 prev_q->next = q->next; 982 else 983 prev_q = q; 984 } 985 /* Either delete P or advance past it. */ 986 if (delete_p) 987 { 988 if (prev_p) 989 prev_p->next = p->next; 990 else 991 temp_slots = p->next; 992 } 993 else 994 prev_p = p; 995 } 996 } 997 998 /* Find the temp slot corresponding to the object at address X. */ 999 1000 static struct temp_slot * 1001 find_temp_slot_from_address (x) 1002 rtx x; 1003 { 1004 struct temp_slot *p; 1005 rtx next; 1006 1007 for (p = temp_slots; p; p = p->next) 1008 { 1009 if (! p->in_use) 1010 continue; 1011 1012 else if (XEXP (p->slot, 0) == x 1013 || p->address == x 1014 || (GET_CODE (x) == PLUS 1015 && XEXP (x, 0) == virtual_stack_vars_rtx 1016 && GET_CODE (XEXP (x, 1)) == CONST_INT 1017 && INTVAL (XEXP (x, 1)) >= p->base_offset 1018 && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size)) 1019 return p; 1020 1021 else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST) 1022 for (next = p->address; next; next = XEXP (next, 1)) 1023 if (XEXP (next, 0) == x) 1024 return p; 1025 } 1026 1027 /* If we have a sum involving a register, see if it points to a temp 1028 slot. */ 1029 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == REG 1030 && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0) 1031 return p; 1032 else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == REG 1033 && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0) 1034 return p; 1035 1036 return 0; 1037 } 1038 1039 /* Indicate that NEW is an alternate way of referring to the temp slot 1040 that previously was known by OLD. */ 1041 1042 void 1043 update_temp_slot_address (old, new) 1044 rtx old, new; 1045 { 1046 struct temp_slot *p; 1047 1048 if (rtx_equal_p (old, new)) 1049 return; 1050 1051 p = find_temp_slot_from_address (old); 1052 1053 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW 1054 is a register, see if one operand of the PLUS is a temporary 1055 location. If so, NEW points into it. Otherwise, if both OLD and 1056 NEW are a PLUS and if there is a register in common between them. 1057 If so, try a recursive call on those values. */ 1058 if (p == 0) 1059 { 1060 if (GET_CODE (old) != PLUS) 1061 return; 1062 1063 if (GET_CODE (new) == REG) 1064 { 1065 update_temp_slot_address (XEXP (old, 0), new); 1066 update_temp_slot_address (XEXP (old, 1), new); 1067 return; 1068 } 1069 else if (GET_CODE (new) != PLUS) 1070 return; 1071 1072 if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0))) 1073 update_temp_slot_address (XEXP (old, 1), XEXP (new, 1)); 1074 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0))) 1075 update_temp_slot_address (XEXP (old, 0), XEXP (new, 1)); 1076 else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1))) 1077 update_temp_slot_address (XEXP (old, 1), XEXP (new, 0)); 1078 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1))) 1079 update_temp_slot_address (XEXP (old, 0), XEXP (new, 0)); 1080 1081 return; 1082 } 1083 1084 /* Otherwise add an alias for the temp's address. */ 1085 else if (p->address == 0) 1086 p->address = new; 1087 else 1088 { 1089 if (GET_CODE (p->address) != EXPR_LIST) 1090 p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); 1091 1092 p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); 1093 } 1094 } 1095 1096 /* If X could be a reference to a temporary slot, mark the fact that its 1097 address was taken. */ 1098 1099 void 1100 mark_temp_addr_taken (x) 1101 rtx x; 1102 { 1103 struct temp_slot *p; 1104 1105 if (x == 0) 1106 return; 1107 1108 /* If X is not in memory or is at a constant address, it cannot be in 1109 a temporary slot. */ 1110 if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) 1111 return; 1112 1113 p = find_temp_slot_from_address (XEXP (x, 0)); 1114 if (p != 0) 1115 p->addr_taken = 1; 1116 } 1117 1118 /* If X could be a reference to a temporary slot, mark that slot as 1119 belonging to the to one level higher than the current level. If X 1120 matched one of our slots, just mark that one. Otherwise, we can't 1121 easily predict which it is, so upgrade all of them. Kept slots 1122 need not be touched. 1123 1124 This is called when an ({...}) construct occurs and a statement 1125 returns a value in memory. */ 1126 1127 void 1128 preserve_temp_slots (x) 1129 rtx x; 1130 { 1131 struct temp_slot *p = 0; 1132 1133 /* If there is no result, we still might have some objects whose address 1134 were taken, so we need to make sure they stay around. */ 1135 if (x == 0) 1136 { 1137 for (p = temp_slots; p; p = p->next) 1138 if (p->in_use && p->level == temp_slot_level && p->addr_taken) 1139 p->level--; 1140 1141 return; 1142 } 1143 1144 /* If X is a register that is being used as a pointer, see if we have 1145 a temporary slot we know it points to. To be consistent with 1146 the code below, we really should preserve all non-kept slots 1147 if we can't find a match, but that seems to be much too costly. */ 1148 if (GET_CODE (x) == REG && REG_POINTER (x)) 1149 p = find_temp_slot_from_address (x); 1150 1151 /* If X is not in memory or is at a constant address, it cannot be in 1152 a temporary slot, but it can contain something whose address was 1153 taken. */ 1154 if (p == 0 && (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))) 1155 { 1156 for (p = temp_slots; p; p = p->next) 1157 if (p->in_use && p->level == temp_slot_level && p->addr_taken) 1158 p->level--; 1159 1160 return; 1161 } 1162 1163 /* First see if we can find a match. */ 1164 if (p == 0) 1165 p = find_temp_slot_from_address (XEXP (x, 0)); 1166 1167 if (p != 0) 1168 { 1169 /* Move everything at our level whose address was taken to our new 1170 level in case we used its address. */ 1171 struct temp_slot *q; 1172 1173 if (p->level == temp_slot_level) 1174 { 1175 for (q = temp_slots; q; q = q->next) 1176 if (q != p && q->addr_taken && q->level == p->level) 1177 q->level--; 1178 1179 p->level--; 1180 p->addr_taken = 0; 1181 } 1182 return; 1183 } 1184 1185 /* Otherwise, preserve all non-kept slots at this level. */ 1186 for (p = temp_slots; p; p = p->next) 1187 if (p->in_use && p->level == temp_slot_level && ! p->keep) 1188 p->level--; 1189 } 1190 1191 /* X is the result of an RTL_EXPR. If it is a temporary slot associated 1192 with that RTL_EXPR, promote it into a temporary slot at the present 1193 level so it will not be freed when we free slots made in the 1194 RTL_EXPR. */ 1195 1196 void 1197 preserve_rtl_expr_result (x) 1198 rtx x; 1199 { 1200 struct temp_slot *p; 1201 1202 /* If X is not in memory or is at a constant address, it cannot be in 1203 a temporary slot. */ 1204 if (x == 0 || GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) 1205 return; 1206 1207 /* If we can find a match, move it to our level unless it is already at 1208 an upper level. */ 1209 p = find_temp_slot_from_address (XEXP (x, 0)); 1210 if (p != 0) 1211 { 1212 p->level = MIN (p->level, temp_slot_level); 1213 p->rtl_expr = 0; 1214 } 1215 1216 return; 1217 } 1218 1219 /* Free all temporaries used so far. This is normally called at the end 1220 of generating code for a statement. Don't free any temporaries 1221 currently in use for an RTL_EXPR that hasn't yet been emitted. 1222 We could eventually do better than this since it can be reused while 1223 generating the same RTL_EXPR, but this is complex and probably not 1224 worthwhile. */ 1225 1226 void 1227 free_temp_slots () 1228 { 1229 struct temp_slot *p; 1230 1231 for (p = temp_slots; p; p = p->next) 1232 if (p->in_use && p->level == temp_slot_level && ! p->keep 1233 && p->rtl_expr == 0) 1234 p->in_use = 0; 1235 1236 combine_temp_slots (); 1237 } 1238 1239 /* Free all temporary slots used in T, an RTL_EXPR node. */ 1240 1241 void 1242 free_temps_for_rtl_expr (t) 1243 tree t; 1244 { 1245 struct temp_slot *p; 1246 1247 for (p = temp_slots; p; p = p->next) 1248 if (p->rtl_expr == t) 1249 { 1250 /* If this slot is below the current TEMP_SLOT_LEVEL, then it 1251 needs to be preserved. This can happen if a temporary in 1252 the RTL_EXPR was addressed; preserve_temp_slots will move 1253 the temporary into a higher level. */ 1254 if (temp_slot_level <= p->level) 1255 p->in_use = 0; 1256 else 1257 p->rtl_expr = NULL_TREE; 1258 } 1259 1260 combine_temp_slots (); 1261 } 1262 1263 /* Mark all temporaries ever allocated in this function as not suitable 1264 for reuse until the current level is exited. */ 1265 1266 void 1267 mark_all_temps_used () 1268 { 1269 struct temp_slot *p; 1270 1271 for (p = temp_slots; p; p = p->next) 1272 { 1273 p->in_use = p->keep = 1; 1274 p->level = MIN (p->level, temp_slot_level); 1275 } 1276 } 1277 1278 /* Push deeper into the nesting level for stack temporaries. */ 1279 1280 void 1281 push_temp_slots () 1282 { 1283 temp_slot_level++; 1284 } 1285 1286 /* Likewise, but save the new level as the place to allocate variables 1287 for blocks. */ 1288 1289 #if 0 1290 void 1291 push_temp_slots_for_block () 1292 { 1293 push_temp_slots (); 1294 1295 var_temp_slot_level = temp_slot_level; 1296 } 1297 1298 /* Likewise, but save the new level as the place to allocate temporaries 1299 for TARGET_EXPRs. */ 1300 1301 void 1302 push_temp_slots_for_target () 1303 { 1304 push_temp_slots (); 1305 1306 target_temp_slot_level = temp_slot_level; 1307 } 1308 1309 /* Set and get the value of target_temp_slot_level. The only 1310 permitted use of these functions is to save and restore this value. */ 1311 1312 int 1313 get_target_temp_slot_level () 1314 { 1315 return target_temp_slot_level; 1316 } 1317 1318 void 1319 set_target_temp_slot_level (level) 1320 int level; 1321 { 1322 target_temp_slot_level = level; 1323 } 1324 #endif 1325 1326 /* Pop a temporary nesting level. All slots in use in the current level 1327 are freed. */ 1328 1329 void 1330 pop_temp_slots () 1331 { 1332 struct temp_slot *p; 1333 1334 for (p = temp_slots; p; p = p->next) 1335 if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0) 1336 p->in_use = 0; 1337 1338 combine_temp_slots (); 1339 1340 temp_slot_level--; 1341 } 1342 1343 /* Initialize temporary slots. */ 1344 1345 void 1346 init_temp_slots () 1347 { 1348 /* We have not allocated any temporaries yet. */ 1349 temp_slots = 0; 1350 temp_slot_level = 0; 1351 var_temp_slot_level = 0; 1352 target_temp_slot_level = 0; 1353 } 1354 1355 /* Retroactively move an auto variable from a register to a stack slot. 1356 This is done when an address-reference to the variable is seen. */ 1357 1358 void 1359 put_var_into_stack (decl) 1360 tree decl; 1361 { 1362 rtx reg; 1363 enum machine_mode promoted_mode, decl_mode; 1364 struct function *function = 0; 1365 tree context; 1366 int can_use_addressof; 1367 int volatilep = TREE_CODE (decl) != SAVE_EXPR && TREE_THIS_VOLATILE (decl); 1368 int usedp = (TREE_USED (decl) 1369 || (TREE_CODE (decl) != SAVE_EXPR && DECL_INITIAL (decl) != 0)); 1370 1371 context = decl_function_context (decl); 1372 1373 /* Get the current rtl used for this object and its original mode. */ 1374 reg = (TREE_CODE (decl) == SAVE_EXPR 1375 ? SAVE_EXPR_RTL (decl) 1376 : DECL_RTL_IF_SET (decl)); 1377 1378 /* No need to do anything if decl has no rtx yet 1379 since in that case caller is setting TREE_ADDRESSABLE 1380 and a stack slot will be assigned when the rtl is made. */ 1381 if (reg == 0) 1382 return; 1383 1384 /* Get the declared mode for this object. */ 1385 decl_mode = (TREE_CODE (decl) == SAVE_EXPR ? TYPE_MODE (TREE_TYPE (decl)) 1386 : DECL_MODE (decl)); 1387 /* Get the mode it's actually stored in. */ 1388 promoted_mode = GET_MODE (reg); 1389 1390 /* If this variable comes from an outer function, find that 1391 function's saved context. Don't use find_function_data here, 1392 because it might not be in any active function. 1393 FIXME: Is that really supposed to happen? 1394 It does in ObjC at least. */ 1395 if (context != current_function_decl && context != inline_function_decl) 1396 for (function = outer_function_chain; function; function = function->outer) 1397 if (function->decl == context) 1398 break; 1399 1400 /* If this is a variable-size object with a pseudo to address it, 1401 put that pseudo into the stack, if the var is nonlocal. */ 1402 if (TREE_CODE (decl) != SAVE_EXPR && DECL_NONLOCAL (decl) 1403 && GET_CODE (reg) == MEM 1404 && GET_CODE (XEXP (reg, 0)) == REG 1405 && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER) 1406 { 1407 reg = XEXP (reg, 0); 1408 decl_mode = promoted_mode = GET_MODE (reg); 1409 } 1410 1411 can_use_addressof 1412 = (function == 0 1413 && optimize > 0 1414 /* FIXME make it work for promoted modes too */ 1415 && decl_mode == promoted_mode 1416 #ifdef NON_SAVING_SETJMP 1417 && ! (NON_SAVING_SETJMP && current_function_calls_setjmp) 1418 #endif 1419 ); 1420 1421 /* If we can't use ADDRESSOF, make sure we see through one we already 1422 generated. */ 1423 if (! can_use_addressof && GET_CODE (reg) == MEM 1424 && GET_CODE (XEXP (reg, 0)) == ADDRESSOF) 1425 reg = XEXP (XEXP (reg, 0), 0); 1426 1427 /* Now we should have a value that resides in one or more pseudo regs. */ 1428 1429 if (GET_CODE (reg) == REG) 1430 { 1431 /* If this variable lives in the current function and we don't need 1432 to put things in the stack for the sake of setjmp, try to keep it 1433 in a register until we know we actually need the address. */ 1434 if (can_use_addressof) 1435 gen_mem_addressof (reg, decl); 1436 else 1437 put_reg_into_stack (function, reg, TREE_TYPE (decl), promoted_mode, 1438 decl_mode, volatilep, 0, usedp, 0); 1439 } 1440 else if (GET_CODE (reg) == CONCAT) 1441 { 1442 /* A CONCAT contains two pseudos; put them both in the stack. 1443 We do it so they end up consecutive. 1444 We fixup references to the parts only after we fixup references 1445 to the whole CONCAT, lest we do double fixups for the latter 1446 references. */ 1447 enum machine_mode part_mode = GET_MODE (XEXP (reg, 0)); 1448 tree part_type = type_for_mode (part_mode, 0); 1449 rtx lopart = XEXP (reg, 0); 1450 rtx hipart = XEXP (reg, 1); 1451 #ifdef FRAME_GROWS_DOWNWARD 1452 /* Since part 0 should have a lower address, do it second. */ 1453 put_reg_into_stack (function, hipart, part_type, part_mode, 1454 part_mode, volatilep, 0, 0, 0); 1455 put_reg_into_stack (function, lopart, part_type, part_mode, 1456 part_mode, volatilep, 0, 0, 0); 1457 #else 1458 put_reg_into_stack (function, lopart, part_type, part_mode, 1459 part_mode, volatilep, 0, 0, 0); 1460 put_reg_into_stack (function, hipart, part_type, part_mode, 1461 part_mode, volatilep, 0, 0, 0); 1462 #endif 1463 1464 /* Change the CONCAT into a combined MEM for both parts. */ 1465 PUT_CODE (reg, MEM); 1466 MEM_ATTRS (reg) = 0; 1467 1468 /* set_mem_attributes uses DECL_RTL to avoid re-generating of 1469 already computed alias sets. Here we want to re-generate. */ 1470 if (DECL_P (decl)) 1471 SET_DECL_RTL (decl, NULL); 1472 set_mem_attributes (reg, decl, 1); 1473 if (DECL_P (decl)) 1474 SET_DECL_RTL (decl, reg); 1475 1476 /* The two parts are in memory order already. 1477 Use the lower parts address as ours. */ 1478 XEXP (reg, 0) = XEXP (XEXP (reg, 0), 0); 1479 /* Prevent sharing of rtl that might lose. */ 1480 if (GET_CODE (XEXP (reg, 0)) == PLUS) 1481 XEXP (reg, 0) = copy_rtx (XEXP (reg, 0)); 1482 if (usedp) 1483 { 1484 schedule_fixup_var_refs (function, reg, TREE_TYPE (decl), 1485 promoted_mode, 0); 1486 schedule_fixup_var_refs (function, lopart, part_type, part_mode, 0); 1487 schedule_fixup_var_refs (function, hipart, part_type, part_mode, 0); 1488 } 1489 } 1490 else 1491 return; 1492 } 1493 1494 /* Subroutine of put_var_into_stack. This puts a single pseudo reg REG 1495 into the stack frame of FUNCTION (0 means the current function). 1496 DECL_MODE is the machine mode of the user-level data type. 1497 PROMOTED_MODE is the machine mode of the register. 1498 VOLATILE_P is nonzero if this is for a "volatile" decl. 1499 USED_P is nonzero if this reg might have already been used in an insn. */ 1500 1501 static void 1502 put_reg_into_stack (function, reg, type, promoted_mode, decl_mode, volatile_p, 1503 original_regno, used_p, ht) 1504 struct function *function; 1505 rtx reg; 1506 tree type; 1507 enum machine_mode promoted_mode, decl_mode; 1508 int volatile_p; 1509 unsigned int original_regno; 1510 int used_p; 1511 struct hash_table *ht; 1512 { 1513 struct function *func = function ? function : cfun; 1514 rtx new = 0; 1515 unsigned int regno = original_regno; 1516 1517 if (regno == 0) 1518 regno = REGNO (reg); 1519 1520 if (regno < func->x_max_parm_reg) 1521 new = func->x_parm_reg_stack_loc[regno]; 1522 1523 if (new == 0) 1524 new = assign_stack_local_1 (decl_mode, GET_MODE_SIZE (decl_mode), 0, func); 1525 1526 PUT_CODE (reg, MEM); 1527 PUT_MODE (reg, decl_mode); 1528 XEXP (reg, 0) = XEXP (new, 0); 1529 MEM_ATTRS (reg) = 0; 1530 /* `volatil' bit means one thing for MEMs, another entirely for REGs. */ 1531 MEM_VOLATILE_P (reg) = volatile_p; 1532 1533 /* If this is a memory ref that contains aggregate components, 1534 mark it as such for cse and loop optimize. If we are reusing a 1535 previously generated stack slot, then we need to copy the bit in 1536 case it was set for other reasons. For instance, it is set for 1537 __builtin_va_alist. */ 1538 if (type) 1539 { 1540 MEM_SET_IN_STRUCT_P (reg, 1541 AGGREGATE_TYPE_P (type) || MEM_IN_STRUCT_P (new)); 1542 set_mem_alias_set (reg, get_alias_set (type)); 1543 } 1544 1545 if (used_p) 1546 schedule_fixup_var_refs (function, reg, type, promoted_mode, ht); 1547 } 1548 1549 /* Make sure that all refs to the variable, previously made 1550 when it was a register, are fixed up to be valid again. 1551 See function above for meaning of arguments. */ 1552 1553 static void 1554 schedule_fixup_var_refs (function, reg, type, promoted_mode, ht) 1555 struct function *function; 1556 rtx reg; 1557 tree type; 1558 enum machine_mode promoted_mode; 1559 struct hash_table *ht; 1560 { 1561 int unsigned_p = type ? TREE_UNSIGNED (type) : 0; 1562 1563 if (function != 0) 1564 { 1565 struct var_refs_queue *temp; 1566 1567 temp 1568 = (struct var_refs_queue *) ggc_alloc (sizeof (struct var_refs_queue)); 1569 temp->modified = reg; 1570 temp->promoted_mode = promoted_mode; 1571 temp->unsignedp = unsigned_p; 1572 temp->next = function->fixup_var_refs_queue; 1573 function->fixup_var_refs_queue = temp; 1574 } 1575 else 1576 /* Variable is local; fix it up now. */ 1577 fixup_var_refs (reg, promoted_mode, unsigned_p, reg, ht); 1578 } 1579 1580 static void 1581 fixup_var_refs (var, promoted_mode, unsignedp, may_share, ht) 1582 rtx var; 1583 enum machine_mode promoted_mode; 1584 int unsignedp; 1585 struct hash_table *ht; 1586 rtx may_share; 1587 { 1588 tree pending; 1589 rtx first_insn = get_insns (); 1590 struct sequence_stack *stack = seq_stack; 1591 tree rtl_exps = rtl_expr_chain; 1592 1593 /* If there's a hash table, it must record all uses of VAR. */ 1594 if (ht) 1595 { 1596 if (stack != 0) 1597 abort (); 1598 fixup_var_refs_insns_with_hash (ht, var, promoted_mode, unsignedp, 1599 may_share); 1600 return; 1601 } 1602 1603 fixup_var_refs_insns (first_insn, var, promoted_mode, unsignedp, 1604 stack == 0, may_share); 1605 1606 /* Scan all pending sequences too. */ 1607 for (; stack; stack = stack->next) 1608 { 1609 push_to_full_sequence (stack->first, stack->last); 1610 fixup_var_refs_insns (stack->first, var, promoted_mode, unsignedp, 1611 stack->next != 0, may_share); 1612 /* Update remembered end of sequence 1613 in case we added an insn at the end. */ 1614 stack->last = get_last_insn (); 1615 end_sequence (); 1616 } 1617 1618 /* Scan all waiting RTL_EXPRs too. */ 1619 for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending)) 1620 { 1621 rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending)); 1622 if (seq != const0_rtx && seq != 0) 1623 { 1624 push_to_sequence (seq); 1625 fixup_var_refs_insns (seq, var, promoted_mode, unsignedp, 0, 1626 may_share); 1627 end_sequence (); 1628 } 1629 } 1630 } 1631 1632 /* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is 1633 some part of an insn. Return a struct fixup_replacement whose OLD 1634 value is equal to X. Allocate a new structure if no such entry exists. */ 1635 1636 static struct fixup_replacement * 1637 find_fixup_replacement (replacements, x) 1638 struct fixup_replacement **replacements; 1639 rtx x; 1640 { 1641 struct fixup_replacement *p; 1642 1643 /* See if we have already replaced this. */ 1644 for (p = *replacements; p != 0 && ! rtx_equal_p (p->old, x); p = p->next) 1645 ; 1646 1647 if (p == 0) 1648 { 1649 p = (struct fixup_replacement *) xmalloc (sizeof (struct fixup_replacement)); 1650 p->old = x; 1651 p->new = 0; 1652 p->next = *replacements; 1653 *replacements = p; 1654 } 1655 1656 return p; 1657 } 1658 1659 /* Scan the insn-chain starting with INSN for refs to VAR and fix them 1660 up. TOPLEVEL is nonzero if this chain is the main chain of insns 1661 for the current function. MAY_SHARE is either a MEM that is not 1662 to be unshared or a list of them. */ 1663 1664 static void 1665 fixup_var_refs_insns (insn, var, promoted_mode, unsignedp, toplevel, may_share) 1666 rtx insn; 1667 rtx var; 1668 enum machine_mode promoted_mode; 1669 int unsignedp; 1670 int toplevel; 1671 rtx may_share; 1672 { 1673 while (insn) 1674 { 1675 /* fixup_var_refs_insn might modify insn, so save its next 1676 pointer now. */ 1677 rtx next = NEXT_INSN (insn); 1678 1679 /* CALL_PLACEHOLDERs are special; we have to switch into each of 1680 the three sequences they (potentially) contain, and process 1681 them recursively. The CALL_INSN itself is not interesting. */ 1682 1683 if (GET_CODE (insn) == CALL_INSN 1684 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER) 1685 { 1686 int i; 1687 1688 /* Look at the Normal call, sibling call and tail recursion 1689 sequences attached to the CALL_PLACEHOLDER. */ 1690 for (i = 0; i < 3; i++) 1691 { 1692 rtx seq = XEXP (PATTERN (insn), i); 1693 if (seq) 1694 { 1695 push_to_sequence (seq); 1696 fixup_var_refs_insns (seq, var, promoted_mode, unsignedp, 0, 1697 may_share); 1698 XEXP (PATTERN (insn), i) = get_insns (); 1699 end_sequence (); 1700 } 1701 } 1702 } 1703 1704 else if (INSN_P (insn)) 1705 fixup_var_refs_insn (insn, var, promoted_mode, unsignedp, toplevel, 1706 may_share); 1707 1708 insn = next; 1709 } 1710 } 1711 1712 /* Look up the insns which reference VAR in HT and fix them up. Other 1713 arguments are the same as fixup_var_refs_insns. 1714 1715 N.B. No need for special processing of CALL_PLACEHOLDERs here, 1716 because the hash table will point straight to the interesting insn 1717 (inside the CALL_PLACEHOLDER). */ 1718 1719 static void 1720 fixup_var_refs_insns_with_hash (ht, var, promoted_mode, unsignedp, may_share) 1721 struct hash_table *ht; 1722 rtx var; 1723 enum machine_mode promoted_mode; 1724 int unsignedp; 1725 rtx may_share; 1726 { 1727 struct insns_for_mem_entry *ime 1728 = (struct insns_for_mem_entry *) hash_lookup (ht, var, 1729 /*create=*/0, /*copy=*/0); 1730 rtx insn_list; 1731 1732 for (insn_list = ime->insns; insn_list != 0; insn_list = XEXP (insn_list, 1)) 1733 if (INSN_P (XEXP (insn_list, 0))) 1734 fixup_var_refs_insn (XEXP (insn_list, 0), var, promoted_mode, 1735 unsignedp, 1, may_share); 1736 } 1737 1738 1739 /* Per-insn processing by fixup_var_refs_insns(_with_hash). INSN is 1740 the insn under examination, VAR is the variable to fix up 1741 references to, PROMOTED_MODE and UNSIGNEDP describe VAR, and 1742 TOPLEVEL is nonzero if this is the main insn chain for this 1743 function. */ 1744 1745 static void 1746 fixup_var_refs_insn (insn, var, promoted_mode, unsignedp, toplevel, no_share) 1747 rtx insn; 1748 rtx var; 1749 enum machine_mode promoted_mode; 1750 int unsignedp; 1751 int toplevel; 1752 rtx no_share; 1753 { 1754 rtx call_dest = 0; 1755 rtx set, prev, prev_set; 1756 rtx note; 1757 1758 /* Remember the notes in case we delete the insn. */ 1759 note = REG_NOTES (insn); 1760 1761 /* If this is a CLOBBER of VAR, delete it. 1762 1763 If it has a REG_LIBCALL note, delete the REG_LIBCALL 1764 and REG_RETVAL notes too. */ 1765 if (GET_CODE (PATTERN (insn)) == CLOBBER 1766 && (XEXP (PATTERN (insn), 0) == var 1767 || (GET_CODE (XEXP (PATTERN (insn), 0)) == CONCAT 1768 && (XEXP (XEXP (PATTERN (insn), 0), 0) == var 1769 || XEXP (XEXP (PATTERN (insn), 0), 1) == var)))) 1770 { 1771 if ((note = find_reg_note (insn, REG_LIBCALL, NULL_RTX)) != 0) 1772 /* The REG_LIBCALL note will go away since we are going to 1773 turn INSN into a NOTE, so just delete the 1774 corresponding REG_RETVAL note. */ 1775 remove_note (XEXP (note, 0), 1776 find_reg_note (XEXP (note, 0), REG_RETVAL, 1777 NULL_RTX)); 1778 1779 delete_insn (insn); 1780 } 1781 1782 /* The insn to load VAR from a home in the arglist 1783 is now a no-op. When we see it, just delete it. 1784 Similarly if this is storing VAR from a register from which 1785 it was loaded in the previous insn. This will occur 1786 when an ADDRESSOF was made for an arglist slot. */ 1787 else if (toplevel 1788 && (set = single_set (insn)) != 0 1789 && SET_DEST (set) == var 1790 /* If this represents the result of an insn group, 1791 don't delete the insn. */ 1792 && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0 1793 && (rtx_equal_p (SET_SRC (set), var) 1794 || (GET_CODE (SET_SRC (set)) == REG 1795 && (prev = prev_nonnote_insn (insn)) != 0 1796 && (prev_set = single_set (prev)) != 0 1797 && SET_DEST (prev_set) == SET_SRC (set) 1798 && rtx_equal_p (SET_SRC (prev_set), var)))) 1799 { 1800 delete_insn (insn); 1801 } 1802 else 1803 { 1804 struct fixup_replacement *replacements = 0; 1805 rtx next_insn = NEXT_INSN (insn); 1806 1807 if (SMALL_REGISTER_CLASSES) 1808 { 1809 /* If the insn that copies the results of a CALL_INSN 1810 into a pseudo now references VAR, we have to use an 1811 intermediate pseudo since we want the life of the 1812 return value register to be only a single insn. 1813 1814 If we don't use an intermediate pseudo, such things as 1815 address computations to make the address of VAR valid 1816 if it is not can be placed between the CALL_INSN and INSN. 1817 1818 To make sure this doesn't happen, we record the destination 1819 of the CALL_INSN and see if the next insn uses both that 1820 and VAR. */ 1821 1822 if (call_dest != 0 && GET_CODE (insn) == INSN 1823 && reg_mentioned_p (var, PATTERN (insn)) 1824 && reg_mentioned_p (call_dest, PATTERN (insn))) 1825 { 1826 rtx temp = gen_reg_rtx (GET_MODE (call_dest)); 1827 1828 emit_insn_before (gen_move_insn (temp, call_dest), insn); 1829 1830 PATTERN (insn) = replace_rtx (PATTERN (insn), 1831 call_dest, temp); 1832 } 1833 1834 if (GET_CODE (insn) == CALL_INSN 1835 && GET_CODE (PATTERN (insn)) == SET) 1836 call_dest = SET_DEST (PATTERN (insn)); 1837 else if (GET_CODE (insn) == CALL_INSN 1838 && GET_CODE (PATTERN (insn)) == PARALLEL 1839 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET) 1840 call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0)); 1841 else 1842 call_dest = 0; 1843 } 1844 1845 /* See if we have to do anything to INSN now that VAR is in 1846 memory. If it needs to be loaded into a pseudo, use a single 1847 pseudo for the entire insn in case there is a MATCH_DUP 1848 between two operands. We pass a pointer to the head of 1849 a list of struct fixup_replacements. If fixup_var_refs_1 1850 needs to allocate pseudos or replacement MEMs (for SUBREGs), 1851 it will record them in this list. 1852 1853 If it allocated a pseudo for any replacement, we copy into 1854 it here. */ 1855 1856 fixup_var_refs_1 (var, promoted_mode, &PATTERN (insn), insn, 1857 &replacements, no_share); 1858 1859 /* If this is last_parm_insn, and any instructions were output 1860 after it to fix it up, then we must set last_parm_insn to 1861 the last such instruction emitted. */ 1862 if (insn == last_parm_insn) 1863 last_parm_insn = PREV_INSN (next_insn); 1864 1865 while (replacements) 1866 { 1867 struct fixup_replacement *next; 1868 1869 if (GET_CODE (replacements->new) == REG) 1870 { 1871 rtx insert_before; 1872 rtx seq; 1873 1874 /* OLD might be a (subreg (mem)). */ 1875 if (GET_CODE (replacements->old) == SUBREG) 1876 replacements->old 1877 = fixup_memory_subreg (replacements->old, insn, 1878 promoted_mode, 0); 1879 else 1880 replacements->old 1881 = fixup_stack_1 (replacements->old, insn); 1882 1883 insert_before = insn; 1884 1885 /* If we are changing the mode, do a conversion. 1886 This might be wasteful, but combine.c will 1887 eliminate much of the waste. */ 1888 1889 if (GET_MODE (replacements->new) 1890 != GET_MODE (replacements->old)) 1891 { 1892 start_sequence (); 1893 convert_move (replacements->new, 1894 replacements->old, unsignedp); 1895 seq = gen_sequence (); 1896 end_sequence (); 1897 } 1898 else 1899 seq = gen_move_insn (replacements->new, 1900 replacements->old); 1901 1902 emit_insn_before (seq, insert_before); 1903 } 1904 1905 next = replacements->next; 1906 free (replacements); 1907 replacements = next; 1908 } 1909 } 1910 1911 /* Also fix up any invalid exprs in the REG_NOTES of this insn. 1912 But don't touch other insns referred to by reg-notes; 1913 we will get them elsewhere. */ 1914 while (note) 1915 { 1916 if (GET_CODE (note) != INSN_LIST) 1917 XEXP (note, 0) 1918 = walk_fixup_memory_subreg (XEXP (note, 0), insn, 1919 promoted_mode, 1); 1920 note = XEXP (note, 1); 1921 } 1922 } 1923 1924 /* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE. 1925 See if the rtx expression at *LOC in INSN needs to be changed. 1926 1927 REPLACEMENTS is a pointer to a list head that starts out zero, but may 1928 contain a list of original rtx's and replacements. If we find that we need 1929 to modify this insn by replacing a memory reference with a pseudo or by 1930 making a new MEM to implement a SUBREG, we consult that list to see if 1931 we have already chosen a replacement. If none has already been allocated, 1932 we allocate it and update the list. fixup_var_refs_insn will copy VAR 1933 or the SUBREG, as appropriate, to the pseudo. */ 1934 1935 static void 1936 fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements, no_share) 1937 rtx var; 1938 enum machine_mode promoted_mode; 1939 rtx *loc; 1940 rtx insn; 1941 struct fixup_replacement **replacements; 1942 rtx no_share; 1943 { 1944 int i; 1945 rtx x = *loc; 1946 RTX_CODE code = GET_CODE (x); 1947 const char *fmt; 1948 rtx tem, tem1; 1949 struct fixup_replacement *replacement; 1950 1951 switch (code) 1952 { 1953 case ADDRESSOF: 1954 if (XEXP (x, 0) == var) 1955 { 1956 /* Prevent sharing of rtl that might lose. */ 1957 rtx sub = copy_rtx (XEXP (var, 0)); 1958 1959 if (! validate_change (insn, loc, sub, 0)) 1960 { 1961 rtx y = gen_reg_rtx (GET_MODE (sub)); 1962 rtx seq, new_insn; 1963 1964 /* We should be able to replace with a register or all is lost. 1965 Note that we can't use validate_change to verify this, since 1966 we're not caring for replacing all dups simultaneously. */ 1967 if (! validate_replace_rtx (*loc, y, insn)) 1968 abort (); 1969 1970 /* Careful! First try to recognize a direct move of the 1971 value, mimicking how things are done in gen_reload wrt 1972 PLUS. Consider what happens when insn is a conditional 1973 move instruction and addsi3 clobbers flags. */ 1974 1975 start_sequence (); 1976 new_insn = emit_insn (gen_rtx_SET (VOIDmode, y, sub)); 1977 seq = gen_sequence (); 1978 end_sequence (); 1979 1980 if (recog_memoized (new_insn) < 0) 1981 { 1982 /* That failed. Fall back on force_operand and hope. */ 1983 1984 start_sequence (); 1985 sub = force_operand (sub, y); 1986 if (sub != y) 1987 emit_insn (gen_move_insn (y, sub)); 1988 seq = gen_sequence (); 1989 end_sequence (); 1990 } 1991 1992 #ifdef HAVE_cc0 1993 /* Don't separate setter from user. */ 1994 if (PREV_INSN (insn) && sets_cc0_p (PREV_INSN (insn))) 1995 insn = PREV_INSN (insn); 1996 #endif 1997 1998 emit_insn_before (seq, insn); 1999 } 2000 } 2001 return; 2002 2003 case MEM: 2004 if (var == x) 2005 { 2006 /* If we already have a replacement, use it. Otherwise, 2007 try to fix up this address in case it is invalid. */ 2008 2009 replacement = find_fixup_replacement (replacements, var); 2010 if (replacement->new) 2011 { 2012 *loc = replacement->new; 2013 return; 2014 } 2015 2016 *loc = replacement->new = x = fixup_stack_1 (x, insn); 2017 2018 /* Unless we are forcing memory to register or we changed the mode, 2019 we can leave things the way they are if the insn is valid. */ 2020 2021 INSN_CODE (insn) = -1; 2022 if (! flag_force_mem && GET_MODE (x) == promoted_mode 2023 && recog_memoized (insn) >= 0) 2024 return; 2025 2026 *loc = replacement->new = gen_reg_rtx (promoted_mode); 2027 return; 2028 } 2029 2030 /* If X contains VAR, we need to unshare it here so that we update 2031 each occurrence separately. But all identical MEMs in one insn 2032 must be replaced with the same rtx because of the possibility of 2033 MATCH_DUPs. */ 2034 2035 if (reg_mentioned_p (var, x)) 2036 { 2037 replacement = find_fixup_replacement (replacements, x); 2038 if (replacement->new == 0) 2039 replacement->new = copy_most_rtx (x, no_share); 2040 2041 *loc = x = replacement->new; 2042 code = GET_CODE (x); 2043 } 2044 break; 2045 2046 case REG: 2047 case CC0: 2048 case PC: 2049 case CONST_INT: 2050 case CONST: 2051 case SYMBOL_REF: 2052 case LABEL_REF: 2053 case CONST_DOUBLE: 2054 case CONST_VECTOR: 2055 return; 2056 2057 case SIGN_EXTRACT: 2058 case ZERO_EXTRACT: 2059 /* Note that in some cases those types of expressions are altered 2060 by optimize_bit_field, and do not survive to get here. */ 2061 if (XEXP (x, 0) == var 2062 || (GET_CODE (XEXP (x, 0)) == SUBREG 2063 && SUBREG_REG (XEXP (x, 0)) == var)) 2064 { 2065 /* Get TEM as a valid MEM in the mode presently in the insn. 2066 2067 We don't worry about the possibility of MATCH_DUP here; it 2068 is highly unlikely and would be tricky to handle. */ 2069 2070 tem = XEXP (x, 0); 2071 if (GET_CODE (tem) == SUBREG) 2072 { 2073 if (GET_MODE_BITSIZE (GET_MODE (tem)) 2074 > GET_MODE_BITSIZE (GET_MODE (var))) 2075 { 2076 replacement = find_fixup_replacement (replacements, var); 2077 if (replacement->new == 0) 2078 replacement->new = gen_reg_rtx (GET_MODE (var)); 2079 SUBREG_REG (tem) = replacement->new; 2080 2081 /* The following code works only if we have a MEM, so we 2082 need to handle the subreg here. We directly substitute 2083 it assuming that a subreg must be OK here. We already 2084 scheduled a replacement to copy the mem into the 2085 subreg. */ 2086 XEXP (x, 0) = tem; 2087 return; 2088 } 2089 else 2090 tem = fixup_memory_subreg (tem, insn, promoted_mode, 0); 2091 } 2092 else 2093 tem = fixup_stack_1 (tem, insn); 2094 2095 /* Unless we want to load from memory, get TEM into the proper mode 2096 for an extract from memory. This can only be done if the 2097 extract is at a constant position and length. */ 2098 2099 if (! flag_force_mem && GET_CODE (XEXP (x, 1)) == CONST_INT 2100 && GET_CODE (XEXP (x, 2)) == CONST_INT 2101 && ! mode_dependent_address_p (XEXP (tem, 0)) 2102 && ! MEM_VOLATILE_P (tem)) 2103 { 2104 enum machine_mode wanted_mode = VOIDmode; 2105 enum machine_mode is_mode = GET_MODE (tem); 2106 HOST_WIDE_INT pos = INTVAL (XEXP (x, 2)); 2107 2108 if (GET_CODE (x) == ZERO_EXTRACT) 2109 { 2110 enum machine_mode new_mode 2111 = mode_for_extraction (EP_extzv, 1); 2112 if (new_mode != MAX_MACHINE_MODE) 2113 wanted_mode = new_mode; 2114 } 2115 else if (GET_CODE (x) == SIGN_EXTRACT) 2116 { 2117 enum machine_mode new_mode 2118 = mode_for_extraction (EP_extv, 1); 2119 if (new_mode != MAX_MACHINE_MODE) 2120 wanted_mode = new_mode; 2121 } 2122 2123 /* If we have a narrower mode, we can do something. */ 2124 if (wanted_mode != VOIDmode 2125 && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode)) 2126 { 2127 HOST_WIDE_INT offset = pos / BITS_PER_UNIT; 2128 rtx old_pos = XEXP (x, 2); 2129 rtx newmem; 2130 2131 /* If the bytes and bits are counted differently, we 2132 must adjust the offset. */ 2133 if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN) 2134 offset = (GET_MODE_SIZE (is_mode) 2135 - GET_MODE_SIZE (wanted_mode) - offset); 2136 2137 pos %= GET_MODE_BITSIZE (wanted_mode); 2138 2139 newmem = adjust_address_nv (tem, wanted_mode, offset); 2140 2141 /* Make the change and see if the insn remains valid. */ 2142 INSN_CODE (insn) = -1; 2143 XEXP (x, 0) = newmem; 2144 XEXP (x, 2) = GEN_INT (pos); 2145 2146 if (recog_memoized (insn) >= 0) 2147 return; 2148 2149 /* Otherwise, restore old position. XEXP (x, 0) will be 2150 restored later. */ 2151 XEXP (x, 2) = old_pos; 2152 } 2153 } 2154 2155 /* If we get here, the bitfield extract insn can't accept a memory 2156 reference. Copy the input into a register. */ 2157 2158 tem1 = gen_reg_rtx (GET_MODE (tem)); 2159 emit_insn_before (gen_move_insn (tem1, tem), insn); 2160 XEXP (x, 0) = tem1; 2161 return; 2162 } 2163 break; 2164 2165 case SUBREG: 2166 if (SUBREG_REG (x) == var) 2167 { 2168 /* If this is a special SUBREG made because VAR was promoted 2169 from a wider mode, replace it with VAR and call ourself 2170 recursively, this time saying that the object previously 2171 had its current mode (by virtue of the SUBREG). */ 2172 2173 if (SUBREG_PROMOTED_VAR_P (x)) 2174 { 2175 *loc = var; 2176 fixup_var_refs_1 (var, GET_MODE (var), loc, insn, replacements, 2177 no_share); 2178 return; 2179 } 2180 2181 /* If this SUBREG makes VAR wider, it has become a paradoxical 2182 SUBREG with VAR in memory, but these aren't allowed at this 2183 stage of the compilation. So load VAR into a pseudo and take 2184 a SUBREG of that pseudo. */ 2185 if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var))) 2186 { 2187 replacement = find_fixup_replacement (replacements, var); 2188 if (replacement->new == 0) 2189 replacement->new = gen_reg_rtx (promoted_mode); 2190 SUBREG_REG (x) = replacement->new; 2191 return; 2192 } 2193 2194 /* See if we have already found a replacement for this SUBREG. 2195 If so, use it. Otherwise, make a MEM and see if the insn 2196 is recognized. If not, or if we should force MEM into a register, 2197 make a pseudo for this SUBREG. */ 2198 replacement = find_fixup_replacement (replacements, x); 2199 if (replacement->new) 2200 { 2201 *loc = replacement->new; 2202 return; 2203 } 2204 2205 replacement->new = *loc = fixup_memory_subreg (x, insn, 2206 promoted_mode, 0); 2207 2208 INSN_CODE (insn) = -1; 2209 if (! flag_force_mem && recog_memoized (insn) >= 0) 2210 return; 2211 2212 *loc = replacement->new = gen_reg_rtx (GET_MODE (x)); 2213 return; 2214 } 2215 break; 2216 2217 case SET: 2218 /* First do special simplification of bit-field references. */ 2219 if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT 2220 || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT) 2221 optimize_bit_field (x, insn, 0); 2222 if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT 2223 || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT) 2224 optimize_bit_field (x, insn, 0); 2225 2226 /* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object 2227 into a register and then store it back out. */ 2228 if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT 2229 && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG 2230 && SUBREG_REG (XEXP (SET_DEST (x), 0)) == var 2231 && (GET_MODE_SIZE (GET_MODE (XEXP (SET_DEST (x), 0))) 2232 > GET_MODE_SIZE (GET_MODE (var)))) 2233 { 2234 replacement = find_fixup_replacement (replacements, var); 2235 if (replacement->new == 0) 2236 replacement->new = gen_reg_rtx (GET_MODE (var)); 2237 2238 SUBREG_REG (XEXP (SET_DEST (x), 0)) = replacement->new; 2239 emit_insn_after (gen_move_insn (var, replacement->new), insn); 2240 } 2241 2242 /* If SET_DEST is now a paradoxical SUBREG, put the result of this 2243 insn into a pseudo and store the low part of the pseudo into VAR. */ 2244 if (GET_CODE (SET_DEST (x)) == SUBREG 2245 && SUBREG_REG (SET_DEST (x)) == var 2246 && (GET_MODE_SIZE (GET_MODE (SET_DEST (x))) 2247 > GET_MODE_SIZE (GET_MODE (var)))) 2248 { 2249 SET_DEST (x) = tem = gen_reg_rtx (GET_MODE (SET_DEST (x))); 2250 emit_insn_after (gen_move_insn (var, gen_lowpart (GET_MODE (var), 2251 tem)), 2252 insn); 2253 break; 2254 } 2255 2256 { 2257 rtx dest = SET_DEST (x); 2258 rtx src = SET_SRC (x); 2259 rtx outerdest = dest; 2260 2261 while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART 2262 || GET_CODE (dest) == SIGN_EXTRACT 2263 || GET_CODE (dest) == ZERO_EXTRACT) 2264 dest = XEXP (dest, 0); 2265 2266 if (GET_CODE (src) == SUBREG) 2267 src = SUBREG_REG (src); 2268 2269 /* If VAR does not appear at the top level of the SET 2270 just scan the lower levels of the tree. */ 2271 2272 if (src != var && dest != var) 2273 break; 2274 2275 /* We will need to rerecognize this insn. */ 2276 INSN_CODE (insn) = -1; 2277 2278 if (GET_CODE (outerdest) == ZERO_EXTRACT && dest == var 2279 && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE) 2280 { 2281 /* Since this case will return, ensure we fixup all the 2282 operands here. */ 2283 fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 1), 2284 insn, replacements, no_share); 2285 fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 2), 2286 insn, replacements, no_share); 2287 fixup_var_refs_1 (var, promoted_mode, &SET_SRC (x), 2288 insn, replacements, no_share); 2289 2290 tem = XEXP (outerdest, 0); 2291 2292 /* Clean up (SUBREG:SI (MEM:mode ...) 0) 2293 that may appear inside a ZERO_EXTRACT. 2294 This was legitimate when the MEM was a REG. */ 2295 if (GET_CODE (tem) == SUBREG 2296 && SUBREG_REG (tem) == var) 2297 tem = fixup_memory_subreg (tem, insn, promoted_mode, 0); 2298 else 2299 tem = fixup_stack_1 (tem, insn); 2300 2301 if (GET_CODE (XEXP (outerdest, 1)) == CONST_INT 2302 && GET_CODE (XEXP (outerdest, 2)) == CONST_INT 2303 && ! mode_dependent_address_p (XEXP (tem, 0)) 2304 && ! MEM_VOLATILE_P (tem)) 2305 { 2306 enum machine_mode wanted_mode; 2307 enum machine_mode is_mode = GET_MODE (tem); 2308 HOST_WIDE_INT pos = INTVAL (XEXP (outerdest, 2)); 2309 2310 wanted_mode = mode_for_extraction (EP_insv, 0); 2311 2312 /* If we have a narrower mode, we can do something. */ 2313 if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode)) 2314 { 2315 HOST_WIDE_INT offset = pos / BITS_PER_UNIT; 2316 rtx old_pos = XEXP (outerdest, 2); 2317 rtx newmem; 2318 2319 if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN) 2320 offset = (GET_MODE_SIZE (is_mode) 2321 - GET_MODE_SIZE (wanted_mode) - offset); 2322 2323 pos %= GET_MODE_BITSIZE (wanted_mode); 2324 2325 newmem = adjust_address_nv (tem, wanted_mode, offset); 2326 2327 /* Make the change and see if the insn remains valid. */ 2328 INSN_CODE (insn) = -1; 2329 XEXP (outerdest, 0) = newmem; 2330 XEXP (outerdest, 2) = GEN_INT (pos); 2331 2332 if (recog_memoized (insn) >= 0) 2333 return; 2334 2335 /* Otherwise, restore old position. XEXP (x, 0) will be 2336 restored later. */ 2337 XEXP (outerdest, 2) = old_pos; 2338 } 2339 } 2340 2341 /* If we get here, the bit-field store doesn't allow memory 2342 or isn't located at a constant position. Load the value into 2343 a register, do the store, and put it back into memory. */ 2344 2345 tem1 = gen_reg_rtx (GET_MODE (tem)); 2346 emit_insn_before (gen_move_insn (tem1, tem), insn); 2347 emit_insn_after (gen_move_insn (tem, tem1), insn); 2348 XEXP (outerdest, 0) = tem1; 2349 return; 2350 } 2351 2352 /* STRICT_LOW_PART is a no-op on memory references 2353 and it can cause combinations to be unrecognizable, 2354 so eliminate it. */ 2355 2356 if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART) 2357 SET_DEST (x) = XEXP (SET_DEST (x), 0); 2358 2359 /* A valid insn to copy VAR into or out of a register 2360 must be left alone, to avoid an infinite loop here. 2361 If the reference to VAR is by a subreg, fix that up, 2362 since SUBREG is not valid for a memref. 2363 Also fix up the address of the stack slot. 2364 2365 Note that we must not try to recognize the insn until 2366 after we know that we have valid addresses and no 2367 (subreg (mem ...) ...) constructs, since these interfere 2368 with determining the validity of the insn. */ 2369 2370 if ((SET_SRC (x) == var 2371 || (GET_CODE (SET_SRC (x)) == SUBREG 2372 && SUBREG_REG (SET_SRC (x)) == var)) 2373 && (GET_CODE (SET_DEST (x)) == REG 2374 || (GET_CODE (SET_DEST (x)) == SUBREG 2375 && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG)) 2376 && GET_MODE (var) == promoted_mode 2377 && x == single_set (insn)) 2378 { 2379 rtx pat, last; 2380 2381 if (GET_CODE (SET_SRC (x)) == SUBREG 2382 && (GET_MODE_SIZE (GET_MODE (SET_SRC (x))) 2383 > GET_MODE_SIZE (GET_MODE (var)))) 2384 { 2385 /* This (subreg VAR) is now a paradoxical subreg. We need 2386 to replace VAR instead of the subreg. */ 2387 replacement = find_fixup_replacement (replacements, var); 2388 if (replacement->new == NULL_RTX) 2389 replacement->new = gen_reg_rtx (GET_MODE (var)); 2390 SUBREG_REG (SET_SRC (x)) = replacement->new; 2391 } 2392 else 2393 { 2394 replacement = find_fixup_replacement (replacements, SET_SRC (x)); 2395 if (replacement->new) 2396 SET_SRC (x) = replacement->new; 2397 else if (GET_CODE (SET_SRC (x)) == SUBREG) 2398 SET_SRC (x) = replacement->new 2399 = fixup_memory_subreg (SET_SRC (x), insn, promoted_mode, 2400 0); 2401 else 2402 SET_SRC (x) = replacement->new 2403 = fixup_stack_1 (SET_SRC (x), insn); 2404 } 2405 2406 if (recog_memoized (insn) >= 0) 2407 return; 2408 2409 /* INSN is not valid, but we know that we want to 2410 copy SET_SRC (x) to SET_DEST (x) in some way. So 2411 we generate the move and see whether it requires more 2412 than one insn. If it does, we emit those insns and 2413 delete INSN. Otherwise, we an just replace the pattern 2414 of INSN; we have already verified above that INSN has 2415 no other function that to do X. */ 2416 2417 pat = gen_move_insn (SET_DEST (x), SET_SRC (x)); 2418 if (GET_CODE (pat) == SEQUENCE) 2419 { 2420 last = emit_insn_before (pat, insn); 2421 2422 /* INSN might have REG_RETVAL or other important notes, so 2423 we need to store the pattern of the last insn in the 2424 sequence into INSN similarly to the normal case. LAST 2425 should not have REG_NOTES, but we allow them if INSN has 2426 no REG_NOTES. */ 2427 if (REG_NOTES (last) && REG_NOTES (insn)) 2428 abort (); 2429 if (REG_NOTES (last)) 2430 REG_NOTES (insn) = REG_NOTES (last); 2431 PATTERN (insn) = PATTERN (last); 2432 2433 delete_insn (last); 2434 } 2435 else 2436 PATTERN (insn) = pat; 2437 2438 return; 2439 } 2440 2441 if ((SET_DEST (x) == var 2442 || (GET_CODE (SET_DEST (x)) == SUBREG 2443 && SUBREG_REG (SET_DEST (x)) == var)) 2444 && (GET_CODE (SET_SRC (x)) == REG 2445 || (GET_CODE (SET_SRC (x)) == SUBREG 2446 && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG)) 2447 && GET_MODE (var) == promoted_mode 2448 && x == single_set (insn)) 2449 { 2450 rtx pat, last; 2451 2452 if (GET_CODE (SET_DEST (x)) == SUBREG) 2453 SET_DEST (x) = fixup_memory_subreg (SET_DEST (x), insn, 2454 promoted_mode, 0); 2455 else 2456 SET_DEST (x) = fixup_stack_1 (SET_DEST (x), insn); 2457 2458 if (recog_memoized (insn) >= 0) 2459 return; 2460 2461 pat = gen_move_insn (SET_DEST (x), SET_SRC (x)); 2462 if (GET_CODE (pat) == SEQUENCE) 2463 { 2464 last = emit_insn_before (pat, insn); 2465 2466 /* INSN might have REG_RETVAL or other important notes, so 2467 we need to store the pattern of the last insn in the 2468 sequence into INSN similarly to the normal case. LAST 2469 should not have REG_NOTES, but we allow them if INSN has 2470 no REG_NOTES. */ 2471 if (REG_NOTES (last) && REG_NOTES (insn)) 2472 abort (); 2473 if (REG_NOTES (last)) 2474 REG_NOTES (insn) = REG_NOTES (last); 2475 PATTERN (insn) = PATTERN (last); 2476 2477 delete_insn (last); 2478 } 2479 else 2480 PATTERN (insn) = pat; 2481 2482 return; 2483 } 2484 2485 /* Otherwise, storing into VAR must be handled specially 2486 by storing into a temporary and copying that into VAR 2487 with a new insn after this one. Note that this case 2488 will be used when storing into a promoted scalar since 2489 the insn will now have different modes on the input 2490 and output and hence will be invalid (except for the case 2491 of setting it to a constant, which does not need any 2492 change if it is valid). We generate extra code in that case, 2493 but combine.c will eliminate it. */ 2494 2495 if (dest == var) 2496 { 2497 rtx temp; 2498 rtx fixeddest = SET_DEST (x); 2499 enum machine_mode temp_mode; 2500 2501 /* STRICT_LOW_PART can be discarded, around a MEM. */ 2502 if (GET_CODE (fixeddest) == STRICT_LOW_PART) 2503 fixeddest = XEXP (fixeddest, 0); 2504 /* Convert (SUBREG (MEM)) to a MEM in a changed mode. */ 2505 if (GET_CODE (fixeddest) == SUBREG) 2506 { 2507 fixeddest = fixup_memory_subreg (fixeddest, insn, 2508 promoted_mode, 0); 2509 temp_mode = GET_MODE (fixeddest); 2510 } 2511 else 2512 { 2513 fixeddest = fixup_stack_1 (fixeddest, insn); 2514 temp_mode = promoted_mode; 2515 } 2516 2517 temp = gen_reg_rtx (temp_mode); 2518 2519 emit_insn_after (gen_move_insn (fixeddest, 2520 gen_lowpart (GET_MODE (fixeddest), 2521 temp)), 2522 insn); 2523 2524 SET_DEST (x) = temp; 2525 } 2526 } 2527 2528 default: 2529 break; 2530 } 2531 2532 /* Nothing special about this RTX; fix its operands. */ 2533 2534 fmt = GET_RTX_FORMAT (code); 2535 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2536 { 2537 if (fmt[i] == 'e') 2538 fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements, 2539 no_share); 2540 else if (fmt[i] == 'E') 2541 { 2542 int j; 2543 for (j = 0; j < XVECLEN (x, i); j++) 2544 fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j), 2545 insn, replacements, no_share); 2546 } 2547 } 2548 } 2549 2550 /* Previously, X had the form (SUBREG:m1 (REG:PROMOTED_MODE ...)). 2551 The REG was placed on the stack, so X now has the form (SUBREG:m1 2552 (MEM:m2 ...)). 2553 2554 Return an rtx (MEM:m1 newaddr) which is equivalent. If any insns 2555 must be emitted to compute NEWADDR, put them before INSN. 2556 2557 UNCRITICAL nonzero means accept paradoxical subregs. 2558 This is used for subregs found inside REG_NOTES. */ 2559 2560 static rtx 2561 fixup_memory_subreg (x, insn, promoted_mode, uncritical) 2562 rtx x; 2563 rtx insn; 2564 enum machine_mode promoted_mode; 2565 int uncritical; 2566 { 2567 int offset; 2568 rtx mem = SUBREG_REG (x); 2569 rtx addr = XEXP (mem, 0); 2570 enum machine_mode mode = GET_MODE (x); 2571 rtx result; 2572 2573 /* Paradoxical SUBREGs are usually invalid during RTL generation. */ 2574 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (mem)) && ! uncritical) 2575 abort (); 2576 2577 offset = SUBREG_BYTE (x); 2578 if (BYTES_BIG_ENDIAN) 2579 /* If the PROMOTED_MODE is wider than the mode of the MEM, adjust 2580 the offset so that it points to the right location within the 2581 MEM. */ 2582 offset -= (GET_MODE_SIZE (promoted_mode) - GET_MODE_SIZE (GET_MODE (mem))); 2583 2584 if (!flag_force_addr 2585 && memory_address_p (mode, plus_constant (addr, offset))) 2586 /* Shortcut if no insns need be emitted. */ 2587 return adjust_address (mem, mode, offset); 2588 2589 start_sequence (); 2590 result = adjust_address (mem, mode, offset); 2591 emit_insn_before (gen_sequence (), insn); 2592 end_sequence (); 2593 return result; 2594 } 2595 2596 /* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X. 2597 Replace subexpressions of X in place. 2598 If X itself is a (SUBREG (MEM ...) ...), return the replacement expression. 2599 Otherwise return X, with its contents possibly altered. 2600 2601 INSN, PROMOTED_MODE and UNCRITICAL are as for 2602 fixup_memory_subreg. */ 2603 2604 static rtx 2605 walk_fixup_memory_subreg (x, insn, promoted_mode, uncritical) 2606 rtx x; 2607 rtx insn; 2608 enum machine_mode promoted_mode; 2609 int uncritical; 2610 { 2611 enum rtx_code code; 2612 const char *fmt; 2613 int i; 2614 2615 if (x == 0) 2616 return 0; 2617 2618 code = GET_CODE (x); 2619 2620 if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM) 2621 return fixup_memory_subreg (x, insn, promoted_mode, uncritical); 2622 2623 /* Nothing special about this RTX; fix its operands. */ 2624 2625 fmt = GET_RTX_FORMAT (code); 2626 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2627 { 2628 if (fmt[i] == 'e') 2629 XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn, 2630 promoted_mode, uncritical); 2631 else if (fmt[i] == 'E') 2632 { 2633 int j; 2634 for (j = 0; j < XVECLEN (x, i); j++) 2635 XVECEXP (x, i, j) 2636 = walk_fixup_memory_subreg (XVECEXP (x, i, j), insn, 2637 promoted_mode, uncritical); 2638 } 2639 } 2640 return x; 2641 } 2642 2643 /* For each memory ref within X, if it refers to a stack slot 2644 with an out of range displacement, put the address in a temp register 2645 (emitting new insns before INSN to load these registers) 2646 and alter the memory ref to use that register. 2647 Replace each such MEM rtx with a copy, to avoid clobberage. */ 2648 2649 static rtx 2650 fixup_stack_1 (x, insn) 2651 rtx x; 2652 rtx insn; 2653 { 2654 int i; 2655 RTX_CODE code = GET_CODE (x); 2656 const char *fmt; 2657 2658 if (code == MEM) 2659 { 2660 rtx ad = XEXP (x, 0); 2661 /* If we have address of a stack slot but it's not valid 2662 (displacement is too large), compute the sum in a register. */ 2663 if (GET_CODE (ad) == PLUS 2664 && GET_CODE (XEXP (ad, 0)) == REG 2665 && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER 2666 && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER) 2667 || REGNO (XEXP (ad, 0)) == FRAME_POINTER_REGNUM 2668 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM 2669 || REGNO (XEXP (ad, 0)) == HARD_FRAME_POINTER_REGNUM 2670 #endif 2671 || REGNO (XEXP (ad, 0)) == STACK_POINTER_REGNUM 2672 || REGNO (XEXP (ad, 0)) == ARG_POINTER_REGNUM 2673 || XEXP (ad, 0) == current_function_internal_arg_pointer) 2674 && GET_CODE (XEXP (ad, 1)) == CONST_INT) 2675 { 2676 rtx temp, seq; 2677 if (memory_address_p (GET_MODE (x), ad)) 2678 return x; 2679 2680 start_sequence (); 2681 temp = copy_to_reg (ad); 2682 seq = gen_sequence (); 2683 end_sequence (); 2684 emit_insn_before (seq, insn); 2685 return replace_equiv_address (x, temp); 2686 } 2687 return x; 2688 } 2689 2690 fmt = GET_RTX_FORMAT (code); 2691 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2692 { 2693 if (fmt[i] == 'e') 2694 XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn); 2695 else if (fmt[i] == 'E') 2696 { 2697 int j; 2698 for (j = 0; j < XVECLEN (x, i); j++) 2699 XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn); 2700 } 2701 } 2702 return x; 2703 } 2704 2705 /* Optimization: a bit-field instruction whose field 2706 happens to be a byte or halfword in memory 2707 can be changed to a move instruction. 2708 2709 We call here when INSN is an insn to examine or store into a bit-field. 2710 BODY is the SET-rtx to be altered. 2711 2712 EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0. 2713 (Currently this is called only from function.c, and EQUIV_MEM 2714 is always 0.) */ 2715 2716 static void 2717 optimize_bit_field (body, insn, equiv_mem) 2718 rtx body; 2719 rtx insn; 2720 rtx *equiv_mem; 2721 { 2722 rtx bitfield; 2723 int destflag; 2724 rtx seq = 0; 2725 enum machine_mode mode; 2726 2727 if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT 2728 || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT) 2729 bitfield = SET_DEST (body), destflag = 1; 2730 else 2731 bitfield = SET_SRC (body), destflag = 0; 2732 2733 /* First check that the field being stored has constant size and position 2734 and is in fact a byte or halfword suitably aligned. */ 2735 2736 if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT 2737 && GET_CODE (XEXP (bitfield, 2)) == CONST_INT 2738 && ((mode = mode_for_size (INTVAL (XEXP (bitfield, 1)), MODE_INT, 1)) 2739 != BLKmode) 2740 && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0) 2741 { 2742 rtx memref = 0; 2743 2744 /* Now check that the containing word is memory, not a register, 2745 and that it is safe to change the machine mode. */ 2746 2747 if (GET_CODE (XEXP (bitfield, 0)) == MEM) 2748 memref = XEXP (bitfield, 0); 2749 else if (GET_CODE (XEXP (bitfield, 0)) == REG 2750 && equiv_mem != 0) 2751 memref = equiv_mem[REGNO (XEXP (bitfield, 0))]; 2752 else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG 2753 && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM) 2754 memref = SUBREG_REG (XEXP (bitfield, 0)); 2755 else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG 2756 && equiv_mem != 0 2757 && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG) 2758 memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))]; 2759 2760 if (memref 2761 && ! mode_dependent_address_p (XEXP (memref, 0)) 2762 && ! MEM_VOLATILE_P (memref)) 2763 { 2764 /* Now adjust the address, first for any subreg'ing 2765 that we are now getting rid of, 2766 and then for which byte of the word is wanted. */ 2767 2768 HOST_WIDE_INT offset = INTVAL (XEXP (bitfield, 2)); 2769 rtx insns; 2770 2771 /* Adjust OFFSET to count bits from low-address byte. */ 2772 if (BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN) 2773 offset = (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield, 0))) 2774 - offset - INTVAL (XEXP (bitfield, 1))); 2775 2776 /* Adjust OFFSET to count bytes from low-address byte. */ 2777 offset /= BITS_PER_UNIT; 2778 if (GET_CODE (XEXP (bitfield, 0)) == SUBREG) 2779 { 2780 offset += (SUBREG_BYTE (XEXP (bitfield, 0)) 2781 / UNITS_PER_WORD) * UNITS_PER_WORD; 2782 if (BYTES_BIG_ENDIAN) 2783 offset -= (MIN (UNITS_PER_WORD, 2784 GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0)))) 2785 - MIN (UNITS_PER_WORD, 2786 GET_MODE_SIZE (GET_MODE (memref)))); 2787 } 2788 2789 start_sequence (); 2790 memref = adjust_address (memref, mode, offset); 2791 insns = get_insns (); 2792 end_sequence (); 2793 emit_insns_before (insns, insn); 2794 2795 /* Store this memory reference where 2796 we found the bit field reference. */ 2797 2798 if (destflag) 2799 { 2800 validate_change (insn, &SET_DEST (body), memref, 1); 2801 if (! CONSTANT_ADDRESS_P (SET_SRC (body))) 2802 { 2803 rtx src = SET_SRC (body); 2804 while (GET_CODE (src) == SUBREG 2805 && SUBREG_BYTE (src) == 0) 2806 src = SUBREG_REG (src); 2807 if (GET_MODE (src) != GET_MODE (memref)) 2808 src = gen_lowpart (GET_MODE (memref), SET_SRC (body)); 2809 validate_change (insn, &SET_SRC (body), src, 1); 2810 } 2811 else if (GET_MODE (SET_SRC (body)) != VOIDmode 2812 && GET_MODE (SET_SRC (body)) != GET_MODE (memref)) 2813 /* This shouldn't happen because anything that didn't have 2814 one of these modes should have got converted explicitly 2815 and then referenced through a subreg. 2816 This is so because the original bit-field was 2817 handled by agg_mode and so its tree structure had 2818 the same mode that memref now has. */ 2819 abort (); 2820 } 2821 else 2822 { 2823 rtx dest = SET_DEST (body); 2824 2825 while (GET_CODE (dest) == SUBREG 2826 && SUBREG_BYTE (dest) == 0 2827 && (GET_MODE_CLASS (GET_MODE (dest)) 2828 == GET_MODE_CLASS (GET_MODE (SUBREG_REG (dest)))) 2829 && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))) 2830 <= UNITS_PER_WORD)) 2831 dest = SUBREG_REG (dest); 2832 2833 validate_change (insn, &SET_DEST (body), dest, 1); 2834 2835 if (GET_MODE (dest) == GET_MODE (memref)) 2836 validate_change (insn, &SET_SRC (body), memref, 1); 2837 else 2838 { 2839 /* Convert the mem ref to the destination mode. */ 2840 rtx newreg = gen_reg_rtx (GET_MODE (dest)); 2841 2842 start_sequence (); 2843 convert_move (newreg, memref, 2844 GET_CODE (SET_SRC (body)) == ZERO_EXTRACT); 2845 seq = get_insns (); 2846 end_sequence (); 2847 2848 validate_change (insn, &SET_SRC (body), newreg, 1); 2849 } 2850 } 2851 2852 /* See if we can convert this extraction or insertion into 2853 a simple move insn. We might not be able to do so if this 2854 was, for example, part of a PARALLEL. 2855 2856 If we succeed, write out any needed conversions. If we fail, 2857 it is hard to guess why we failed, so don't do anything 2858 special; just let the optimization be suppressed. */ 2859 2860 if (apply_change_group () && seq) 2861 emit_insns_before (seq, insn); 2862 } 2863 } 2864 } 2865 2866 /* These routines are responsible for converting virtual register references 2867 to the actual hard register references once RTL generation is complete. 2868 2869 The following four variables are used for communication between the 2870 routines. They contain the offsets of the virtual registers from their 2871 respective hard registers. */ 2872 2873 static int in_arg_offset; 2874 static int var_offset; 2875 static int dynamic_offset; 2876 static int out_arg_offset; 2877 static int cfa_offset; 2878 2879 /* In most machines, the stack pointer register is equivalent to the bottom 2880 of the stack. */ 2881 2882 #ifndef STACK_POINTER_OFFSET 2883 #define STACK_POINTER_OFFSET 0 2884 #endif 2885 2886 /* If not defined, pick an appropriate default for the offset of dynamically 2887 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, 2888 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ 2889 2890 #ifndef STACK_DYNAMIC_OFFSET 2891 2892 /* The bottom of the stack points to the actual arguments. If 2893 REG_PARM_STACK_SPACE is defined, this includes the space for the register 2894 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, 2895 stack space for register parameters is not pushed by the caller, but 2896 rather part of the fixed stack areas and hence not included in 2897 `current_function_outgoing_args_size'. Nevertheless, we must allow 2898 for it when allocating stack dynamic objects. */ 2899 2900 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) 2901 #define STACK_DYNAMIC_OFFSET(FNDECL) \ 2902 ((ACCUMULATE_OUTGOING_ARGS \ 2903 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\ 2904 + (STACK_POINTER_OFFSET)) \ 2905 2906 #else 2907 #define STACK_DYNAMIC_OFFSET(FNDECL) \ 2908 ((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \ 2909 + (STACK_POINTER_OFFSET)) 2910 #endif 2911 #endif 2912 2913 /* On most machines, the CFA coincides with the first incoming parm. */ 2914 2915 #ifndef ARG_POINTER_CFA_OFFSET 2916 #define ARG_POINTER_CFA_OFFSET(FNDECL) FIRST_PARM_OFFSET (FNDECL) 2917 #endif 2918 2919 /* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had its 2920 address taken. DECL is the decl or SAVE_EXPR for the object stored in the 2921 register, for later use if we do need to force REG into the stack. REG is 2922 overwritten by the MEM like in put_reg_into_stack. */ 2923 2924 rtx 2925 gen_mem_addressof (reg, decl) 2926 rtx reg; 2927 tree decl; 2928 { 2929 rtx r = gen_rtx_ADDRESSOF (Pmode, gen_reg_rtx (GET_MODE (reg)), 2930 REGNO (reg), decl); 2931 2932 /* Calculate this before we start messing with decl's RTL. */ 2933 HOST_WIDE_INT set = decl ? get_alias_set (decl) : 0; 2934 2935 /* If the original REG was a user-variable, then so is the REG whose 2936 address is being taken. Likewise for unchanging. */ 2937 REG_USERVAR_P (XEXP (r, 0)) = REG_USERVAR_P (reg); 2938 RTX_UNCHANGING_P (XEXP (r, 0)) = RTX_UNCHANGING_P (reg); 2939 2940 PUT_CODE (reg, MEM); 2941 MEM_ATTRS (reg) = 0; 2942 XEXP (reg, 0) = r; 2943 2944 if (decl) 2945 { 2946 tree type = TREE_TYPE (decl); 2947 enum machine_mode decl_mode 2948 = (DECL_P (decl) ? DECL_MODE (decl) : TYPE_MODE (TREE_TYPE (decl))); 2949 rtx decl_rtl = (TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl) 2950 : DECL_RTL_IF_SET (decl)); 2951 2952 PUT_MODE (reg, decl_mode); 2953 2954 /* Clear DECL_RTL momentarily so functions below will work 2955 properly, then set it again. */ 2956 if (DECL_P (decl) && decl_rtl == reg) 2957 SET_DECL_RTL (decl, 0); 2958 2959 set_mem_attributes (reg, decl, 1); 2960 set_mem_alias_set (reg, set); 2961 2962 if (DECL_P (decl) && decl_rtl == reg) 2963 SET_DECL_RTL (decl, reg); 2964 2965 if (TREE_USED (decl) || (DECL_P (decl) && DECL_INITIAL (decl) != 0)) 2966 fixup_var_refs (reg, GET_MODE (reg), TREE_UNSIGNED (type), reg, 0); 2967 } 2968 else 2969 fixup_var_refs (reg, GET_MODE (reg), 0, reg, 0); 2970 2971 return reg; 2972 } 2973 2974 /* If DECL has an RTL that is an ADDRESSOF rtx, put it into the stack. */ 2975 2976 void 2977 flush_addressof (decl) 2978 tree decl; 2979 { 2980 if ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL) 2981 && DECL_RTL (decl) != 0 2982 && GET_CODE (DECL_RTL (decl)) == MEM 2983 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF 2984 && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == REG) 2985 put_addressof_into_stack (XEXP (DECL_RTL (decl), 0), 0); 2986 } 2987 2988 /* Force the register pointed to by R, an ADDRESSOF rtx, into the stack. */ 2989 2990 static void 2991 put_addressof_into_stack (r, ht) 2992 rtx r; 2993 struct hash_table *ht; 2994 { 2995 tree decl, type; 2996 int volatile_p, used_p; 2997 2998 rtx reg = XEXP (r, 0); 2999 3000 if (GET_CODE (reg) != REG) 3001 abort (); 3002 3003 decl = ADDRESSOF_DECL (r); 3004 if (decl) 3005 { 3006 type = TREE_TYPE (decl); 3007 volatile_p = (TREE_CODE (decl) != SAVE_EXPR 3008 && TREE_THIS_VOLATILE (decl)); 3009 used_p = (TREE_USED (decl) 3010 || (DECL_P (decl) && DECL_INITIAL (decl) != 0)); 3011 } 3012 else 3013 { 3014 type = NULL_TREE; 3015 volatile_p = 0; 3016 used_p = 1; 3017 } 3018 3019 put_reg_into_stack (0, reg, type, GET_MODE (reg), GET_MODE (reg), 3020 volatile_p, ADDRESSOF_REGNO (r), used_p, ht); 3021 } 3022 3023 /* List of replacements made below in purge_addressof_1 when creating 3024 bitfield insertions. */ 3025 static rtx purge_bitfield_addressof_replacements; 3026 3027 /* List of replacements made below in purge_addressof_1 for patterns 3028 (MEM (ADDRESSOF (REG ...))). The key of the list entry is the 3029 corresponding (ADDRESSOF (REG ...)) and value is a substitution for 3030 the all pattern. List PURGE_BITFIELD_ADDRESSOF_REPLACEMENTS is not 3031 enough in complex cases, e.g. when some field values can be 3032 extracted by usage MEM with narrower mode. */ 3033 static rtx purge_addressof_replacements; 3034 3035 /* Helper function for purge_addressof. See if the rtx expression at *LOC 3036 in INSN needs to be changed. If FORCE, always put any ADDRESSOFs into 3037 the stack. If the function returns FALSE then the replacement could not 3038 be made. */ 3039 3040 static bool 3041 purge_addressof_1 (loc, insn, force, store, ht) 3042 rtx *loc; 3043 rtx insn; 3044 int force, store; 3045 struct hash_table *ht; 3046 { 3047 rtx x; 3048 RTX_CODE code; 3049 int i, j; 3050 const char *fmt; 3051 bool result = true; 3052 3053 /* Re-start here to avoid recursion in common cases. */ 3054 restart: 3055 3056 x = *loc; 3057 if (x == 0) 3058 return true; 3059 3060 code = GET_CODE (x); 3061 3062 /* If we don't return in any of the cases below, we will recurse inside 3063 the RTX, which will normally result in any ADDRESSOF being forced into 3064 memory. */ 3065 if (code == SET) 3066 { 3067 result = purge_addressof_1 (&SET_DEST (x), insn, force, 1, ht); 3068 result &= purge_addressof_1 (&SET_SRC (x), insn, force, 0, ht); 3069 return result; 3070 } 3071 else if (code == ADDRESSOF) 3072 { 3073 rtx sub, insns; 3074 3075 if (GET_CODE (XEXP (x, 0)) != MEM) 3076 { 3077 put_addressof_into_stack (x, ht); 3078 return true; 3079 } 3080 3081 /* We must create a copy of the rtx because it was created by 3082 overwriting a REG rtx which is always shared. */ 3083 sub = copy_rtx (XEXP (XEXP (x, 0), 0)); 3084 if (validate_change (insn, loc, sub, 0) 3085 || validate_replace_rtx (x, sub, insn)) 3086 return true; 3087 3088 start_sequence (); 3089 sub = force_operand (sub, NULL_RTX); 3090 if (! validate_change (insn, loc, sub, 0) 3091 && ! validate_replace_rtx (x, sub, insn)) 3092 abort (); 3093 3094 insns = gen_sequence (); 3095 end_sequence (); 3096 emit_insn_before (insns, insn); 3097 return true; 3098 } 3099 3100 else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force) 3101 { 3102 rtx sub = XEXP (XEXP (x, 0), 0); 3103 3104 if (GET_CODE (sub) == MEM) 3105 sub = adjust_address_nv (sub, GET_MODE (x), 0); 3106 else if (GET_CODE (sub) == REG 3107 && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode)) 3108 ; 3109 else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub)) 3110 { 3111 int size_x, size_sub; 3112 3113 if (!insn) 3114 { 3115 /* When processing REG_NOTES look at the list of 3116 replacements done on the insn to find the register that X 3117 was replaced by. */ 3118 rtx tem; 3119 3120 for (tem = purge_bitfield_addressof_replacements; 3121 tem != NULL_RTX; 3122 tem = XEXP (XEXP (tem, 1), 1)) 3123 if (rtx_equal_p (x, XEXP (tem, 0))) 3124 { 3125 *loc = XEXP (XEXP (tem, 1), 0); 3126 return true; 3127 } 3128 3129 /* See comment for purge_addressof_replacements. */ 3130 for (tem = purge_addressof_replacements; 3131 tem != NULL_RTX; 3132 tem = XEXP (XEXP (tem, 1), 1)) 3133 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0))) 3134 { 3135 rtx z = XEXP (XEXP (tem, 1), 0); 3136 3137 if (GET_MODE (x) == GET_MODE (z) 3138 || (GET_CODE (XEXP (XEXP (tem, 1), 0)) != REG 3139 && GET_CODE (XEXP (XEXP (tem, 1), 0)) != SUBREG)) 3140 abort (); 3141 3142 /* It can happen that the note may speak of things 3143 in a wider (or just different) mode than the 3144 code did. This is especially true of 3145 REG_RETVAL. */ 3146 3147 if (GET_CODE (z) == SUBREG && SUBREG_BYTE (z) == 0) 3148 z = SUBREG_REG (z); 3149 3150 if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD 3151 && (GET_MODE_SIZE (GET_MODE (x)) 3152 > GET_MODE_SIZE (GET_MODE (z)))) 3153 { 3154 /* This can occur as a result in invalid 3155 pointer casts, e.g. float f; ... 3156 *(long long int *)&f. 3157 ??? We could emit a warning here, but 3158 without a line number that wouldn't be 3159 very helpful. */ 3160 z = gen_rtx_SUBREG (GET_MODE (x), z, 0); 3161 } 3162 else 3163 z = gen_lowpart (GET_MODE (x), z); 3164 3165 *loc = z; 3166 return true; 3167 } 3168 3169 /* Sometimes we may not be able to find the replacement. For 3170 example when the original insn was a MEM in a wider mode, 3171 and the note is part of a sign extension of a narrowed 3172 version of that MEM. Gcc testcase compile/990829-1.c can 3173 generate an example of this situation. Rather than complain 3174 we return false, which will prompt our caller to remove the 3175 offending note. */ 3176 return false; 3177 } 3178 3179 size_x = GET_MODE_BITSIZE (GET_MODE (x)); 3180 size_sub = GET_MODE_BITSIZE (GET_MODE (sub)); 3181 3182 /* Don't even consider working with paradoxical subregs, 3183 or the moral equivalent seen here. */ 3184 if (size_x <= size_sub 3185 && int_mode_for_mode (GET_MODE (sub)) != BLKmode) 3186 { 3187 /* Do a bitfield insertion to mirror what would happen 3188 in memory. */ 3189 3190 rtx val, seq; 3191 3192 if (store) 3193 { 3194 rtx p = PREV_INSN (insn); 3195 3196 start_sequence (); 3197 val = gen_reg_rtx (GET_MODE (x)); 3198 if (! validate_change (insn, loc, val, 0)) 3199 { 3200 /* Discard the current sequence and put the 3201 ADDRESSOF on stack. */ 3202 end_sequence (); 3203 goto give_up; 3204 } 3205 seq = gen_sequence (); 3206 end_sequence (); 3207 emit_insn_before (seq, insn); 3208 compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (), 3209 insn, ht); 3210 3211 start_sequence (); 3212 store_bit_field (sub, size_x, 0, GET_MODE (x), 3213 val, GET_MODE_SIZE (GET_MODE (sub))); 3214 3215 /* Make sure to unshare any shared rtl that store_bit_field 3216 might have created. */ 3217 unshare_all_rtl_again (get_insns ()); 3218 3219 seq = gen_sequence (); 3220 end_sequence (); 3221 p = emit_insn_after (seq, insn); 3222 if (NEXT_INSN (insn)) 3223 compute_insns_for_mem (NEXT_INSN (insn), 3224 p ? NEXT_INSN (p) : NULL_RTX, 3225 ht); 3226 } 3227 else 3228 { 3229 rtx p = PREV_INSN (insn); 3230 3231 start_sequence (); 3232 val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX, 3233 GET_MODE (x), GET_MODE (x), 3234 GET_MODE_SIZE (GET_MODE (sub))); 3235 3236 if (! validate_change (insn, loc, val, 0)) 3237 { 3238 /* Discard the current sequence and put the 3239 ADDRESSOF on stack. */ 3240 end_sequence (); 3241 goto give_up; 3242 } 3243 3244 seq = gen_sequence (); 3245 end_sequence (); 3246 emit_insn_before (seq, insn); 3247 compute_insns_for_mem (p ? NEXT_INSN (p) : get_insns (), 3248 insn, ht); 3249 } 3250 3251 /* Remember the replacement so that the same one can be done 3252 on the REG_NOTES. */ 3253 purge_bitfield_addressof_replacements 3254 = gen_rtx_EXPR_LIST (VOIDmode, x, 3255 gen_rtx_EXPR_LIST 3256 (VOIDmode, val, 3257 purge_bitfield_addressof_replacements)); 3258 3259 /* We replaced with a reg -- all done. */ 3260 return true; 3261 } 3262 } 3263 3264 else if (validate_change (insn, loc, sub, 0)) 3265 { 3266 /* Remember the replacement so that the same one can be done 3267 on the REG_NOTES. */ 3268 if (GET_CODE (sub) == REG || GET_CODE (sub) == SUBREG) 3269 { 3270 rtx tem; 3271 3272 for (tem = purge_addressof_replacements; 3273 tem != NULL_RTX; 3274 tem = XEXP (XEXP (tem, 1), 1)) 3275 if (rtx_equal_p (XEXP (x, 0), XEXP (tem, 0))) 3276 { 3277 XEXP (XEXP (tem, 1), 0) = sub; 3278 return true; 3279 } 3280 purge_addressof_replacements 3281 = gen_rtx (EXPR_LIST, VOIDmode, XEXP (x, 0), 3282 gen_rtx_EXPR_LIST (VOIDmode, sub, 3283 purge_addressof_replacements)); 3284 return true; 3285 } 3286 goto restart; 3287 } 3288 } 3289 3290 give_up: 3291 /* Scan all subexpressions. */ 3292 fmt = GET_RTX_FORMAT (code); 3293 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) 3294 { 3295 if (*fmt == 'e') 3296 result &= purge_addressof_1 (&XEXP (x, i), insn, force, 0, ht); 3297 else if (*fmt == 'E') 3298 for (j = 0; j < XVECLEN (x, i); j++) 3299 result &= purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0, ht); 3300 } 3301 3302 return result; 3303 } 3304 3305 /* Return a new hash table entry in HT. */ 3306 3307 static struct hash_entry * 3308 insns_for_mem_newfunc (he, ht, k) 3309 struct hash_entry *he; 3310 struct hash_table *ht; 3311 hash_table_key k ATTRIBUTE_UNUSED; 3312 { 3313 struct insns_for_mem_entry *ifmhe; 3314 if (he) 3315 return he; 3316 3317 ifmhe = ((struct insns_for_mem_entry *) 3318 hash_allocate (ht, sizeof (struct insns_for_mem_entry))); 3319 ifmhe->insns = NULL_RTX; 3320 3321 return &ifmhe->he; 3322 } 3323 3324 /* Return a hash value for K, a REG. */ 3325 3326 static unsigned long 3327 insns_for_mem_hash (k) 3328 hash_table_key k; 3329 { 3330 /* K is really a RTX. Just use the address as the hash value. */ 3331 return (unsigned long) k; 3332 } 3333 3334 /* Return non-zero if K1 and K2 (two REGs) are the same. */ 3335 3336 static bool 3337 insns_for_mem_comp (k1, k2) 3338 hash_table_key k1; 3339 hash_table_key k2; 3340 { 3341 return k1 == k2; 3342 } 3343 3344 struct insns_for_mem_walk_info 3345 { 3346 /* The hash table that we are using to record which INSNs use which 3347 MEMs. */ 3348 struct hash_table *ht; 3349 3350 /* The INSN we are currently processing. */ 3351 rtx insn; 3352 3353 /* Zero if we are walking to find ADDRESSOFs, one if we are walking 3354 to find the insns that use the REGs in the ADDRESSOFs. */ 3355 int pass; 3356 }; 3357 3358 /* Called from compute_insns_for_mem via for_each_rtx. If R is a REG 3359 that might be used in an ADDRESSOF expression, record this INSN in 3360 the hash table given by DATA (which is really a pointer to an 3361 insns_for_mem_walk_info structure). */ 3362 3363 static int 3364 insns_for_mem_walk (r, data) 3365 rtx *r; 3366 void *data; 3367 { 3368 struct insns_for_mem_walk_info *ifmwi 3369 = (struct insns_for_mem_walk_info *) data; 3370 3371 if (ifmwi->pass == 0 && *r && GET_CODE (*r) == ADDRESSOF 3372 && GET_CODE (XEXP (*r, 0)) == REG) 3373 hash_lookup (ifmwi->ht, XEXP (*r, 0), /*create=*/1, /*copy=*/0); 3374 else if (ifmwi->pass == 1 && *r && GET_CODE (*r) == REG) 3375 { 3376 /* Lookup this MEM in the hashtable, creating it if necessary. */ 3377 struct insns_for_mem_entry *ifme 3378 = (struct insns_for_mem_entry *) hash_lookup (ifmwi->ht, 3379 *r, 3380 /*create=*/0, 3381 /*copy=*/0); 3382 3383 /* If we have not already recorded this INSN, do so now. Since 3384 we process the INSNs in order, we know that if we have 3385 recorded it it must be at the front of the list. */ 3386 if (ifme && (!ifme->insns || XEXP (ifme->insns, 0) != ifmwi->insn)) 3387 ifme->insns = gen_rtx_EXPR_LIST (VOIDmode, ifmwi->insn, 3388 ifme->insns); 3389 } 3390 3391 return 0; 3392 } 3393 3394 /* Walk the INSNS, until we reach LAST_INSN, recording which INSNs use 3395 which REGs in HT. */ 3396 3397 static void 3398 compute_insns_for_mem (insns, last_insn, ht) 3399 rtx insns; 3400 rtx last_insn; 3401 struct hash_table *ht; 3402 { 3403 rtx insn; 3404 struct insns_for_mem_walk_info ifmwi; 3405 ifmwi.ht = ht; 3406 3407 for (ifmwi.pass = 0; ifmwi.pass < 2; ++ifmwi.pass) 3408 for (insn = insns; insn != last_insn; insn = NEXT_INSN (insn)) 3409 if (INSN_P (insn)) 3410 { 3411 ifmwi.insn = insn; 3412 for_each_rtx (&insn, insns_for_mem_walk, &ifmwi); 3413 } 3414 } 3415 3416 /* Helper function for purge_addressof called through for_each_rtx. 3417 Returns true iff the rtl is an ADDRESSOF. */ 3418 3419 static int 3420 is_addressof (rtl, data) 3421 rtx *rtl; 3422 void *data ATTRIBUTE_UNUSED; 3423 { 3424 return GET_CODE (*rtl) == ADDRESSOF; 3425 } 3426 3427 /* Eliminate all occurrences of ADDRESSOF from INSNS. Elide any remaining 3428 (MEM (ADDRESSOF)) patterns, and force any needed registers into the 3429 stack. */ 3430 3431 void 3432 purge_addressof (insns) 3433 rtx insns; 3434 { 3435 rtx insn; 3436 struct hash_table ht; 3437 3438 /* When we actually purge ADDRESSOFs, we turn REGs into MEMs. That 3439 requires a fixup pass over the instruction stream to correct 3440 INSNs that depended on the REG being a REG, and not a MEM. But, 3441 these fixup passes are slow. Furthermore, most MEMs are not 3442 mentioned in very many instructions. So, we speed up the process 3443 by pre-calculating which REGs occur in which INSNs; that allows 3444 us to perform the fixup passes much more quickly. */ 3445 hash_table_init (&ht, 3446 insns_for_mem_newfunc, 3447 insns_for_mem_hash, 3448 insns_for_mem_comp); 3449 compute_insns_for_mem (insns, NULL_RTX, &ht); 3450 3451 for (insn = insns; insn; insn = NEXT_INSN (insn)) 3452 if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN 3453 || GET_CODE (insn) == CALL_INSN) 3454 { 3455 if (! purge_addressof_1 (&PATTERN (insn), insn, 3456 asm_noperands (PATTERN (insn)) > 0, 0, &ht)) 3457 /* If we could not replace the ADDRESSOFs in the insn, 3458 something is wrong. */ 3459 abort (); 3460 3461 if (! purge_addressof_1 (®_NOTES (insn), NULL_RTX, 0, 0, &ht)) 3462 { 3463 /* If we could not replace the ADDRESSOFs in the insn's notes, 3464 we can just remove the offending notes instead. */ 3465 rtx note; 3466 3467 for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) 3468 { 3469 /* If we find a REG_RETVAL note then the insn is a libcall. 3470 Such insns must have REG_EQUAL notes as well, in order 3471 for later passes of the compiler to work. So it is not 3472 safe to delete the notes here, and instead we abort. */ 3473 if (REG_NOTE_KIND (note) == REG_RETVAL) 3474 abort (); 3475 if (for_each_rtx (¬e, is_addressof, NULL)) 3476 remove_note (insn, note); 3477 } 3478 } 3479 } 3480 3481 /* Clean up. */ 3482 hash_table_free (&ht); 3483 purge_bitfield_addressof_replacements = 0; 3484 purge_addressof_replacements = 0; 3485 3486 /* REGs are shared. purge_addressof will destructively replace a REG 3487 with a MEM, which creates shared MEMs. 3488 3489 Unfortunately, the children of put_reg_into_stack assume that MEMs 3490 referring to the same stack slot are shared (fixup_var_refs and 3491 the associated hash table code). 3492 3493 So, we have to do another unsharing pass after we have flushed any 3494 REGs that had their address taken into the stack. 3495 3496 It may be worth tracking whether or not we converted any REGs into 3497 MEMs to avoid this overhead when it is not needed. */ 3498 unshare_all_rtl_again (get_insns ()); 3499 } 3500 3501 /* Convert a SET of a hard subreg to a set of the appropriate hard 3502 register. A subroutine of purge_hard_subreg_sets. */ 3503 3504 static void 3505 purge_single_hard_subreg_set (pattern) 3506 rtx pattern; 3507 { 3508 rtx reg = SET_DEST (pattern); 3509 enum machine_mode mode = GET_MODE (SET_DEST (pattern)); 3510 int offset = 0; 3511 3512 if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG 3513 && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER) 3514 { 3515 offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)), 3516 GET_MODE (SUBREG_REG (reg)), 3517 SUBREG_BYTE (reg), 3518 GET_MODE (reg)); 3519 reg = SUBREG_REG (reg); 3520 } 3521 3522 3523 if (GET_CODE (reg) == REG && REGNO (reg) < FIRST_PSEUDO_REGISTER) 3524 { 3525 reg = gen_rtx_REG (mode, REGNO (reg) + offset); 3526 SET_DEST (pattern) = reg; 3527 } 3528 } 3529 3530 /* Eliminate all occurrences of SETs of hard subregs from INSNS. The 3531 only such SETs that we expect to see are those left in because 3532 integrate can't handle sets of parts of a return value register. 3533 3534 We don't use alter_subreg because we only want to eliminate subregs 3535 of hard registers. */ 3536 3537 void 3538 purge_hard_subreg_sets (insn) 3539 rtx insn; 3540 { 3541 for (; insn; insn = NEXT_INSN (insn)) 3542 { 3543 if (INSN_P (insn)) 3544 { 3545 rtx pattern = PATTERN (insn); 3546 switch (GET_CODE (pattern)) 3547 { 3548 case SET: 3549 if (GET_CODE (SET_DEST (pattern)) == SUBREG) 3550 purge_single_hard_subreg_set (pattern); 3551 break; 3552 case PARALLEL: 3553 { 3554 int j; 3555 for (j = XVECLEN (pattern, 0) - 1; j >= 0; j--) 3556 { 3557 rtx inner_pattern = XVECEXP (pattern, 0, j); 3558 if (GET_CODE (inner_pattern) == SET 3559 && GET_CODE (SET_DEST (inner_pattern)) == SUBREG) 3560 purge_single_hard_subreg_set (inner_pattern); 3561 } 3562 } 3563 break; 3564 default: 3565 break; 3566 } 3567 } 3568 } 3569 } 3570 3571 /* Pass through the INSNS of function FNDECL and convert virtual register 3572 references to hard register references. */ 3573 3574 void 3575 instantiate_virtual_regs (fndecl, insns) 3576 tree fndecl; 3577 rtx insns; 3578 { 3579 rtx insn; 3580 unsigned int i; 3581 3582 /* Compute the offsets to use for this function. */ 3583 in_arg_offset = FIRST_PARM_OFFSET (fndecl); 3584 var_offset = STARTING_FRAME_OFFSET; 3585 dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl); 3586 out_arg_offset = STACK_POINTER_OFFSET; 3587 cfa_offset = ARG_POINTER_CFA_OFFSET (fndecl); 3588 3589 /* Scan all variables and parameters of this function. For each that is 3590 in memory, instantiate all virtual registers if the result is a valid 3591 address. If not, we do it later. That will handle most uses of virtual 3592 regs on many machines. */ 3593 instantiate_decls (fndecl, 1); 3594 3595 /* Initialize recognition, indicating that volatile is OK. */ 3596 init_recog (); 3597 3598 /* Scan through all the insns, instantiating every virtual register still 3599 present. */ 3600 for (insn = insns; insn; insn = NEXT_INSN (insn)) 3601 if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN 3602 || GET_CODE (insn) == CALL_INSN) 3603 { 3604 instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1); 3605 instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0); 3606 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */ 3607 if (GET_CODE (insn) == CALL_INSN) 3608 instantiate_virtual_regs_1 (&CALL_INSN_FUNCTION_USAGE (insn), 3609 NULL_RTX, 0); 3610 } 3611 3612 /* Instantiate the stack slots for the parm registers, for later use in 3613 addressof elimination. */ 3614 for (i = 0; i < max_parm_reg; ++i) 3615 if (parm_reg_stack_loc[i]) 3616 instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0); 3617 3618 /* Now instantiate the remaining register equivalences for debugging info. 3619 These will not be valid addresses. */ 3620 instantiate_decls (fndecl, 0); 3621 3622 /* Indicate that, from now on, assign_stack_local should use 3623 frame_pointer_rtx. */ 3624 virtuals_instantiated = 1; 3625 } 3626 3627 /* Scan all decls in FNDECL (both variables and parameters) and instantiate 3628 all virtual registers in their DECL_RTL's. 3629 3630 If VALID_ONLY, do this only if the resulting address is still valid. 3631 Otherwise, always do it. */ 3632 3633 static void 3634 instantiate_decls (fndecl, valid_only) 3635 tree fndecl; 3636 int valid_only; 3637 { 3638 tree decl; 3639 3640 /* Process all parameters of the function. */ 3641 for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl)) 3642 { 3643 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl)); 3644 HOST_WIDE_INT size_rtl; 3645 3646 instantiate_decl (DECL_RTL (decl), size, valid_only); 3647 3648 /* If the parameter was promoted, then the incoming RTL mode may be 3649 larger than the declared type size. We must use the larger of 3650 the two sizes. */ 3651 size_rtl = GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl))); 3652 size = MAX (size_rtl, size); 3653 instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only); 3654 } 3655 3656 /* Now process all variables defined in the function or its subblocks. */ 3657 instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only); 3658 } 3659 3660 /* Subroutine of instantiate_decls: Process all decls in the given 3661 BLOCK node and all its subblocks. */ 3662 3663 static void 3664 instantiate_decls_1 (let, valid_only) 3665 tree let; 3666 int valid_only; 3667 { 3668 tree t; 3669 3670 for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t)) 3671 if (DECL_RTL_SET_P (t)) 3672 instantiate_decl (DECL_RTL (t), 3673 int_size_in_bytes (TREE_TYPE (t)), 3674 valid_only); 3675 3676 /* Process all subblocks. */ 3677 for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t)) 3678 instantiate_decls_1 (t, valid_only); 3679 } 3680 3681 /* Subroutine of the preceding procedures: Given RTL representing a 3682 decl and the size of the object, do any instantiation required. 3683 3684 If VALID_ONLY is non-zero, it means that the RTL should only be 3685 changed if the new address is valid. */ 3686 3687 static void 3688 instantiate_decl (x, size, valid_only) 3689 rtx x; 3690 HOST_WIDE_INT size; 3691 int valid_only; 3692 { 3693 enum machine_mode mode; 3694 rtx addr; 3695 3696 /* If this is not a MEM, no need to do anything. Similarly if the 3697 address is a constant or a register that is not a virtual register. */ 3698 3699 if (x == 0 || GET_CODE (x) != MEM) 3700 return; 3701 3702 addr = XEXP (x, 0); 3703 if (CONSTANT_P (addr) 3704 || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG) 3705 || (GET_CODE (addr) == REG 3706 && (REGNO (addr) < FIRST_VIRTUAL_REGISTER 3707 || REGNO (addr) > LAST_VIRTUAL_REGISTER))) 3708 return; 3709 3710 /* If we should only do this if the address is valid, copy the address. 3711 We need to do this so we can undo any changes that might make the 3712 address invalid. This copy is unfortunate, but probably can't be 3713 avoided. */ 3714 3715 if (valid_only) 3716 addr = copy_rtx (addr); 3717 3718 instantiate_virtual_regs_1 (&addr, NULL_RTX, 0); 3719 3720 if (valid_only && size >= 0) 3721 { 3722 unsigned HOST_WIDE_INT decl_size = size; 3723 3724 /* Now verify that the resulting address is valid for every integer or 3725 floating-point mode up to and including SIZE bytes long. We do this 3726 since the object might be accessed in any mode and frame addresses 3727 are shared. */ 3728 3729 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); 3730 mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size; 3731 mode = GET_MODE_WIDER_MODE (mode)) 3732 if (! memory_address_p (mode, addr)) 3733 return; 3734 3735 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); 3736 mode != VOIDmode && GET_MODE_SIZE (mode) <= decl_size; 3737 mode = GET_MODE_WIDER_MODE (mode)) 3738 if (! memory_address_p (mode, addr)) 3739 return; 3740 } 3741 3742 /* Put back the address now that we have updated it and we either know 3743 it is valid or we don't care whether it is valid. */ 3744 3745 XEXP (x, 0) = addr; 3746 } 3747 3748 /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX 3749 is a virtual register, return the equivalent hard register and set the 3750 offset indirectly through the pointer. Otherwise, return 0. */ 3751 3752 static rtx 3753 instantiate_new_reg (x, poffset) 3754 rtx x; 3755 HOST_WIDE_INT *poffset; 3756 { 3757 rtx new; 3758 HOST_WIDE_INT offset; 3759 3760 if (x == virtual_incoming_args_rtx) 3761 new = arg_pointer_rtx, offset = in_arg_offset; 3762 else if (x == virtual_stack_vars_rtx) 3763 new = frame_pointer_rtx, offset = var_offset; 3764 else if (x == virtual_stack_dynamic_rtx) 3765 new = stack_pointer_rtx, offset = dynamic_offset; 3766 else if (x == virtual_outgoing_args_rtx) 3767 new = stack_pointer_rtx, offset = out_arg_offset; 3768 else if (x == virtual_cfa_rtx) 3769 new = arg_pointer_rtx, offset = cfa_offset; 3770 else 3771 return 0; 3772 3773 *poffset = offset; 3774 return new; 3775 } 3776 3777 /* Given a pointer to a piece of rtx and an optional pointer to the 3778 containing object, instantiate any virtual registers present in it. 3779 3780 If EXTRA_INSNS, we always do the replacement and generate 3781 any extra insns before OBJECT. If it zero, we do nothing if replacement 3782 is not valid. 3783 3784 Return 1 if we either had nothing to do or if we were able to do the 3785 needed replacement. Return 0 otherwise; we only return zero if 3786 EXTRA_INSNS is zero. 3787 3788 We first try some simple transformations to avoid the creation of extra 3789 pseudos. */ 3790 3791 static int 3792 instantiate_virtual_regs_1 (loc, object, extra_insns) 3793 rtx *loc; 3794 rtx object; 3795 int extra_insns; 3796 { 3797 rtx x; 3798 RTX_CODE code; 3799 rtx new = 0; 3800 HOST_WIDE_INT offset = 0; 3801 rtx temp; 3802 rtx seq; 3803 int i, j; 3804 const char *fmt; 3805 3806 /* Re-start here to avoid recursion in common cases. */ 3807 restart: 3808 3809 x = *loc; 3810 if (x == 0) 3811 return 1; 3812 3813 code = GET_CODE (x); 3814 3815 /* Check for some special cases. */ 3816 switch (code) 3817 { 3818 case CONST_INT: 3819 case CONST_DOUBLE: 3820 case CONST_VECTOR: 3821 case CONST: 3822 case SYMBOL_REF: 3823 case CODE_LABEL: 3824 case PC: 3825 case CC0: 3826 case ASM_INPUT: 3827 case ADDR_VEC: 3828 case ADDR_DIFF_VEC: 3829 case RETURN: 3830 return 1; 3831 3832 case SET: 3833 /* We are allowed to set the virtual registers. This means that 3834 the actual register should receive the source minus the 3835 appropriate offset. This is used, for example, in the handling 3836 of non-local gotos. */ 3837 if ((new = instantiate_new_reg (SET_DEST (x), &offset)) != 0) 3838 { 3839 rtx src = SET_SRC (x); 3840 3841 /* We are setting the register, not using it, so the relevant 3842 offset is the negative of the offset to use were we using 3843 the register. */ 3844 offset = - offset; 3845 instantiate_virtual_regs_1 (&src, NULL_RTX, 0); 3846 3847 /* The only valid sources here are PLUS or REG. Just do 3848 the simplest possible thing to handle them. */ 3849 if (GET_CODE (src) != REG && GET_CODE (src) != PLUS) 3850 abort (); 3851 3852 start_sequence (); 3853 if (GET_CODE (src) != REG) 3854 temp = force_operand (src, NULL_RTX); 3855 else 3856 temp = src; 3857 temp = force_operand (plus_constant (temp, offset), NULL_RTX); 3858 seq = get_insns (); 3859 end_sequence (); 3860 3861 emit_insns_before (seq, object); 3862 SET_DEST (x) = new; 3863 3864 if (! validate_change (object, &SET_SRC (x), temp, 0) 3865 || ! extra_insns) 3866 abort (); 3867 3868 return 1; 3869 } 3870 3871 instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns); 3872 loc = &SET_SRC (x); 3873 goto restart; 3874 3875 case PLUS: 3876 /* Handle special case of virtual register plus constant. */ 3877 if (CONSTANT_P (XEXP (x, 1))) 3878 { 3879 rtx old, new_offset; 3880 3881 /* Check for (plus (plus VIRT foo) (const_int)) first. */ 3882 if (GET_CODE (XEXP (x, 0)) == PLUS) 3883 { 3884 if ((new = instantiate_new_reg (XEXP (XEXP (x, 0), 0), &offset))) 3885 { 3886 instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object, 3887 extra_insns); 3888 new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1)); 3889 } 3890 else 3891 { 3892 loc = &XEXP (x, 0); 3893 goto restart; 3894 } 3895 } 3896 3897 #ifdef POINTERS_EXTEND_UNSIGNED 3898 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know 3899 we can commute the PLUS and SUBREG because pointers into the 3900 frame are well-behaved. */ 3901 else if (GET_CODE (XEXP (x, 0)) == SUBREG && GET_MODE (x) == ptr_mode 3902 && GET_CODE (XEXP (x, 1)) == CONST_INT 3903 && 0 != (new 3904 = instantiate_new_reg (SUBREG_REG (XEXP (x, 0)), 3905 &offset)) 3906 && validate_change (object, loc, 3907 plus_constant (gen_lowpart (ptr_mode, 3908 new), 3909 offset 3910 + INTVAL (XEXP (x, 1))), 3911 0)) 3912 return 1; 3913 #endif 3914 else if ((new = instantiate_new_reg (XEXP (x, 0), &offset)) == 0) 3915 { 3916 /* We know the second operand is a constant. Unless the 3917 first operand is a REG (which has been already checked), 3918 it needs to be checked. */ 3919 if (GET_CODE (XEXP (x, 0)) != REG) 3920 { 3921 loc = &XEXP (x, 0); 3922 goto restart; 3923 } 3924 return 1; 3925 } 3926 3927 new_offset = plus_constant (XEXP (x, 1), offset); 3928 3929 /* If the new constant is zero, try to replace the sum with just 3930 the register. */ 3931 if (new_offset == const0_rtx 3932 && validate_change (object, loc, new, 0)) 3933 return 1; 3934 3935 /* Next try to replace the register and new offset. 3936 There are two changes to validate here and we can't assume that 3937 in the case of old offset equals new just changing the register 3938 will yield a valid insn. In the interests of a little efficiency, 3939 however, we only call validate change once (we don't queue up the 3940 changes and then call apply_change_group). */ 3941 3942 old = XEXP (x, 0); 3943 if (offset == 0 3944 ? ! validate_change (object, &XEXP (x, 0), new, 0) 3945 : (XEXP (x, 0) = new, 3946 ! validate_change (object, &XEXP (x, 1), new_offset, 0))) 3947 { 3948 if (! extra_insns) 3949 { 3950 XEXP (x, 0) = old; 3951 return 0; 3952 } 3953 3954 /* Otherwise copy the new constant into a register and replace 3955 constant with that register. */ 3956 temp = gen_reg_rtx (Pmode); 3957 XEXP (x, 0) = new; 3958 if (validate_change (object, &XEXP (x, 1), temp, 0)) 3959 emit_insn_before (gen_move_insn (temp, new_offset), object); 3960 else 3961 { 3962 /* If that didn't work, replace this expression with a 3963 register containing the sum. */ 3964 3965 XEXP (x, 0) = old; 3966 new = gen_rtx_PLUS (Pmode, new, new_offset); 3967 3968 start_sequence (); 3969 temp = force_operand (new, NULL_RTX); 3970 seq = get_insns (); 3971 end_sequence (); 3972 3973 emit_insns_before (seq, object); 3974 if (! validate_change (object, loc, temp, 0) 3975 && ! validate_replace_rtx (x, temp, object)) 3976 abort (); 3977 } 3978 } 3979 3980 return 1; 3981 } 3982 3983 /* Fall through to generic two-operand expression case. */ 3984 case EXPR_LIST: 3985 case CALL: 3986 case COMPARE: 3987 case MINUS: 3988 case MULT: 3989 case DIV: case UDIV: 3990 case MOD: case UMOD: 3991 case AND: case IOR: case XOR: 3992 case ROTATERT: case ROTATE: 3993 case ASHIFTRT: case LSHIFTRT: case ASHIFT: 3994 case NE: case EQ: 3995 case GE: case GT: case GEU: case GTU: 3996 case LE: case LT: case LEU: case LTU: 3997 if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1))) 3998 instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns); 3999 loc = &XEXP (x, 0); 4000 goto restart; 4001 4002 case MEM: 4003 /* Most cases of MEM that convert to valid addresses have already been 4004 handled by our scan of decls. The only special handling we 4005 need here is to make a copy of the rtx to ensure it isn't being 4006 shared if we have to change it to a pseudo. 4007 4008 If the rtx is a simple reference to an address via a virtual register, 4009 it can potentially be shared. In such cases, first try to make it 4010 a valid address, which can also be shared. Otherwise, copy it and 4011 proceed normally. 4012 4013 First check for common cases that need no processing. These are 4014 usually due to instantiation already being done on a previous instance 4015 of a shared rtx. */ 4016 4017 temp = XEXP (x, 0); 4018 if (CONSTANT_ADDRESS_P (temp) 4019 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM 4020 || temp == arg_pointer_rtx 4021 #endif 4022 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM 4023 || temp == hard_frame_pointer_rtx 4024 #endif 4025 || temp == frame_pointer_rtx) 4026 return 1; 4027 4028 if (GET_CODE (temp) == PLUS 4029 && CONSTANT_ADDRESS_P (XEXP (temp, 1)) 4030 && (XEXP (temp, 0) == frame_pointer_rtx 4031 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM 4032 || XEXP (temp, 0) == hard_frame_pointer_rtx 4033 #endif 4034 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM 4035 || XEXP (temp, 0) == arg_pointer_rtx 4036 #endif 4037 )) 4038 return 1; 4039 4040 if (temp == virtual_stack_vars_rtx 4041 || temp == virtual_incoming_args_rtx 4042 || (GET_CODE (temp) == PLUS 4043 && CONSTANT_ADDRESS_P (XEXP (temp, 1)) 4044 && (XEXP (temp, 0) == virtual_stack_vars_rtx 4045 || XEXP (temp, 0) == virtual_incoming_args_rtx))) 4046 { 4047 /* This MEM may be shared. If the substitution can be done without 4048 the need to generate new pseudos, we want to do it in place 4049 so all copies of the shared rtx benefit. The call below will 4050 only make substitutions if the resulting address is still 4051 valid. 4052 4053 Note that we cannot pass X as the object in the recursive call 4054 since the insn being processed may not allow all valid 4055 addresses. However, if we were not passed on object, we can 4056 only modify X without copying it if X will have a valid 4057 address. 4058 4059 ??? Also note that this can still lose if OBJECT is an insn that 4060 has less restrictions on an address that some other insn. 4061 In that case, we will modify the shared address. This case 4062 doesn't seem very likely, though. One case where this could 4063 happen is in the case of a USE or CLOBBER reference, but we 4064 take care of that below. */ 4065 4066 if (instantiate_virtual_regs_1 (&XEXP (x, 0), 4067 object ? object : x, 0)) 4068 return 1; 4069 4070 /* Otherwise make a copy and process that copy. We copy the entire 4071 RTL expression since it might be a PLUS which could also be 4072 shared. */ 4073 *loc = x = copy_rtx (x); 4074 } 4075 4076 /* Fall through to generic unary operation case. */ 4077 case PREFETCH: 4078 case SUBREG: 4079 case STRICT_LOW_PART: 4080 case NEG: case NOT: 4081 case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC: 4082 case SIGN_EXTEND: case ZERO_EXTEND: 4083 case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE: 4084 case FLOAT: case FIX: 4085 case UNSIGNED_FIX: case UNSIGNED_FLOAT: 4086 case ABS: 4087 case SQRT: 4088 case FFS: 4089 /* These case either have just one operand or we know that we need not 4090 check the rest of the operands. */ 4091 loc = &XEXP (x, 0); 4092 goto restart; 4093 4094 case USE: 4095 case CLOBBER: 4096 /* If the operand is a MEM, see if the change is a valid MEM. If not, 4097 go ahead and make the invalid one, but do it to a copy. For a REG, 4098 just make the recursive call, since there's no chance of a problem. */ 4099 4100 if ((GET_CODE (XEXP (x, 0)) == MEM 4101 && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0), 4102 0)) 4103 || (GET_CODE (XEXP (x, 0)) == REG 4104 && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0))) 4105 return 1; 4106 4107 XEXP (x, 0) = copy_rtx (XEXP (x, 0)); 4108 loc = &XEXP (x, 0); 4109 goto restart; 4110 4111 case REG: 4112 /* Try to replace with a PLUS. If that doesn't work, compute the sum 4113 in front of this insn and substitute the temporary. */ 4114 if ((new = instantiate_new_reg (x, &offset)) != 0) 4115 { 4116 temp = plus_constant (new, offset); 4117 if (!validate_change (object, loc, temp, 0)) 4118 { 4119 if (! extra_insns) 4120 return 0; 4121 4122 start_sequence (); 4123 temp = force_operand (temp, NULL_RTX); 4124 seq = get_insns (); 4125 end_sequence (); 4126 4127 emit_insns_before (seq, object); 4128 if (! validate_change (object, loc, temp, 0) 4129 && ! validate_replace_rtx (x, temp, object)) 4130 abort (); 4131 } 4132 } 4133 4134 return 1; 4135 4136 case ADDRESSOF: 4137 if (GET_CODE (XEXP (x, 0)) == REG) 4138 return 1; 4139 4140 else if (GET_CODE (XEXP (x, 0)) == MEM) 4141 { 4142 /* If we have a (addressof (mem ..)), do any instantiation inside 4143 since we know we'll be making the inside valid when we finally 4144 remove the ADDRESSOF. */ 4145 instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0); 4146 return 1; 4147 } 4148 break; 4149 4150 default: 4151 break; 4152 } 4153 4154 /* Scan all subexpressions. */ 4155 fmt = GET_RTX_FORMAT (code); 4156 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) 4157 if (*fmt == 'e') 4158 { 4159 if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns)) 4160 return 0; 4161 } 4162 else if (*fmt == 'E') 4163 for (j = 0; j < XVECLEN (x, i); j++) 4164 if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object, 4165 extra_insns)) 4166 return 0; 4167 4168 return 1; 4169 } 4170 4171 /* Optimization: assuming this function does not receive nonlocal gotos, 4172 delete the handlers for such, as well as the insns to establish 4173 and disestablish them. */ 4174 4175 static void 4176 delete_handlers () 4177 { 4178 rtx insn; 4179 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 4180 { 4181 /* Delete the handler by turning off the flag that would 4182 prevent jump_optimize from deleting it. 4183 Also permit deletion of the nonlocal labels themselves 4184 if nothing local refers to them. */ 4185 if (GET_CODE (insn) == CODE_LABEL) 4186 { 4187 tree t, last_t; 4188 4189 LABEL_PRESERVE_P (insn) = 0; 4190 4191 /* Remove it from the nonlocal_label list, to avoid confusing 4192 flow. */ 4193 for (t = nonlocal_labels, last_t = 0; t; 4194 last_t = t, t = TREE_CHAIN (t)) 4195 if (DECL_RTL (TREE_VALUE (t)) == insn) 4196 break; 4197 if (t) 4198 { 4199 if (! last_t) 4200 nonlocal_labels = TREE_CHAIN (nonlocal_labels); 4201 else 4202 TREE_CHAIN (last_t) = TREE_CHAIN (t); 4203 } 4204 } 4205 if (GET_CODE (insn) == INSN) 4206 { 4207 int can_delete = 0; 4208 rtx t; 4209 for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1)) 4210 if (reg_mentioned_p (t, PATTERN (insn))) 4211 { 4212 can_delete = 1; 4213 break; 4214 } 4215 if (can_delete 4216 || (nonlocal_goto_stack_level != 0 4217 && reg_mentioned_p (nonlocal_goto_stack_level, 4218 PATTERN (insn)))) 4219 delete_related_insns (insn); 4220 } 4221 } 4222 } 4223 4224 int 4225 max_parm_reg_num () 4226 { 4227 return max_parm_reg; 4228 } 4229 4230 /* Return the first insn following those generated by `assign_parms'. */ 4231 4232 rtx 4233 get_first_nonparm_insn () 4234 { 4235 if (last_parm_insn) 4236 return NEXT_INSN (last_parm_insn); 4237 return get_insns (); 4238 } 4239 4240 /* Return the first NOTE_INSN_BLOCK_BEG note in the function. 4241 Crash if there is none. */ 4242 4243 rtx 4244 get_first_block_beg () 4245 { 4246 rtx searcher; 4247 rtx insn = get_first_nonparm_insn (); 4248 4249 for (searcher = insn; searcher; searcher = NEXT_INSN (searcher)) 4250 if (GET_CODE (searcher) == NOTE 4251 && NOTE_LINE_NUMBER (searcher) == NOTE_INSN_BLOCK_BEG) 4252 return searcher; 4253 4254 abort (); /* Invalid call to this function. (See comments above.) */ 4255 return NULL_RTX; 4256 } 4257 4258 /* Return 1 if EXP is an aggregate type (or a value with aggregate type). 4259 This means a type for which function calls must pass an address to the 4260 function or get an address back from the function. 4261 EXP may be a type node or an expression (whose type is tested). */ 4262 4263 int 4264 aggregate_value_p (exp) 4265 tree exp; 4266 { 4267 int i, regno, nregs; 4268 rtx reg; 4269 4270 tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp); 4271 4272 if (TREE_CODE (type) == VOID_TYPE) 4273 return 0; 4274 if (RETURN_IN_MEMORY (type)) 4275 return 1; 4276 /* Types that are TREE_ADDRESSABLE must be constructed in memory, 4277 and thus can't be returned in registers. */ 4278 if (TREE_ADDRESSABLE (type)) 4279 return 1; 4280 if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) 4281 return 1; 4282 /* Make sure we have suitable call-clobbered regs to return 4283 the value in; if not, we must return it in memory. */ 4284 reg = hard_function_value (type, 0, 0); 4285 4286 /* If we have something other than a REG (e.g. a PARALLEL), then assume 4287 it is OK. */ 4288 if (GET_CODE (reg) != REG) 4289 return 0; 4290 4291 regno = REGNO (reg); 4292 nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type)); 4293 for (i = 0; i < nregs; i++) 4294 if (! call_used_regs[regno + i]) 4295 return 1; 4296 return 0; 4297 } 4298 4299 /* Assign RTL expressions to the function's parameters. 4300 This may involve copying them into registers and using 4301 those registers as the RTL for them. */ 4302 4303 void 4304 assign_parms (fndecl) 4305 tree fndecl; 4306 { 4307 tree parm; 4308 rtx entry_parm = 0; 4309 rtx stack_parm = 0; 4310 CUMULATIVE_ARGS args_so_far; 4311 enum machine_mode promoted_mode, passed_mode; 4312 enum machine_mode nominal_mode, promoted_nominal_mode; 4313 int unsignedp; 4314 /* Total space needed so far for args on the stack, 4315 given as a constant and a tree-expression. */ 4316 struct args_size stack_args_size; 4317 tree fntype = TREE_TYPE (fndecl); 4318 tree fnargs = DECL_ARGUMENTS (fndecl); 4319 /* This is used for the arg pointer when referring to stack args. */ 4320 rtx internal_arg_pointer; 4321 /* This is a dummy PARM_DECL that we used for the function result if 4322 the function returns a structure. */ 4323 tree function_result_decl = 0; 4324 #ifdef SETUP_INCOMING_VARARGS 4325 int varargs_setup = 0; 4326 #endif 4327 rtx conversion_insns = 0; 4328 struct args_size alignment_pad; 4329 4330 /* Nonzero if the last arg is named `__builtin_va_alist', 4331 which is used on some machines for old-fashioned non-ANSI varargs.h; 4332 this should be stuck onto the stack as if it had arrived there. */ 4333 int hide_last_arg 4334 = (current_function_varargs 4335 && fnargs 4336 && (parm = tree_last (fnargs)) != 0 4337 && DECL_NAME (parm) 4338 && (! strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 4339 "__builtin_va_alist"))); 4340 4341 /* Nonzero if function takes extra anonymous args. 4342 This means the last named arg must be on the stack 4343 right before the anonymous ones. */ 4344 int stdarg 4345 = (TYPE_ARG_TYPES (fntype) != 0 4346 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) 4347 != void_type_node)); 4348 4349 current_function_stdarg = stdarg; 4350 4351 /* If the reg that the virtual arg pointer will be translated into is 4352 not a fixed reg or is the stack pointer, make a copy of the virtual 4353 arg pointer, and address parms via the copy. The frame pointer is 4354 considered fixed even though it is not marked as such. 4355 4356 The second time through, simply use ap to avoid generating rtx. */ 4357 4358 if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM 4359 || ! (fixed_regs[ARG_POINTER_REGNUM] 4360 || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM))) 4361 internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx); 4362 else 4363 internal_arg_pointer = virtual_incoming_args_rtx; 4364 current_function_internal_arg_pointer = internal_arg_pointer; 4365 4366 stack_args_size.constant = 0; 4367 stack_args_size.var = 0; 4368 4369 /* If struct value address is treated as the first argument, make it so. */ 4370 if (aggregate_value_p (DECL_RESULT (fndecl)) 4371 && ! current_function_returns_pcc_struct 4372 && struct_value_incoming_rtx == 0) 4373 { 4374 tree type = build_pointer_type (TREE_TYPE (fntype)); 4375 4376 function_result_decl = build_decl (PARM_DECL, NULL_TREE, type); 4377 4378 DECL_ARG_TYPE (function_result_decl) = type; 4379 TREE_CHAIN (function_result_decl) = fnargs; 4380 fnargs = function_result_decl; 4381 } 4382 4383 max_parm_reg = LAST_VIRTUAL_REGISTER + 1; 4384 parm_reg_stack_loc = (rtx *) xcalloc (max_parm_reg, sizeof (rtx)); 4385 4386 #ifdef INIT_CUMULATIVE_INCOMING_ARGS 4387 INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX); 4388 #else 4389 INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, 0); 4390 #endif 4391 4392 /* We haven't yet found an argument that we must push and pretend the 4393 caller did. */ 4394 current_function_pretend_args_size = 0; 4395 4396 for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) 4397 { 4398 struct args_size stack_offset; 4399 struct args_size arg_size; 4400 int passed_pointer = 0; 4401 int did_conversion = 0; 4402 tree passed_type = DECL_ARG_TYPE (parm); 4403 tree nominal_type = TREE_TYPE (parm); 4404 int pretend_named; 4405 int last_named = 0, named_arg; 4406 4407 /* Set LAST_NAMED if this is last named arg before last 4408 anonymous args. */ 4409 if (stdarg || current_function_varargs) 4410 { 4411 tree tem; 4412 4413 for (tem = TREE_CHAIN (parm); tem; tem = TREE_CHAIN (tem)) 4414 if (DECL_NAME (tem)) 4415 break; 4416 4417 if (tem == 0) 4418 last_named = 1; 4419 } 4420 /* Set NAMED_ARG if this arg should be treated as a named arg. For 4421 most machines, if this is a varargs/stdarg function, then we treat 4422 the last named arg as if it were anonymous too. */ 4423 named_arg = STRICT_ARGUMENT_NAMING ? 1 : ! last_named; 4424 4425 if (TREE_TYPE (parm) == error_mark_node 4426 /* This can happen after weird syntax errors 4427 or if an enum type is defined among the parms. */ 4428 || TREE_CODE (parm) != PARM_DECL 4429 || passed_type == NULL) 4430 { 4431 SET_DECL_RTL (parm, gen_rtx_MEM (BLKmode, const0_rtx)); 4432 DECL_INCOMING_RTL (parm) = DECL_RTL (parm); 4433 TREE_USED (parm) = 1; 4434 continue; 4435 } 4436 4437 /* For varargs.h function, save info about regs and stack space 4438 used by the individual args, not including the va_alist arg. */ 4439 if (hide_last_arg && last_named) 4440 current_function_args_info = args_so_far; 4441 4442 /* Find mode of arg as it is passed, and mode of arg 4443 as it should be during execution of this function. */ 4444 passed_mode = TYPE_MODE (passed_type); 4445 nominal_mode = TYPE_MODE (nominal_type); 4446 4447 /* If the parm's mode is VOID, its value doesn't matter, 4448 and avoid the usual things like emit_move_insn that could crash. */ 4449 if (nominal_mode == VOIDmode) 4450 { 4451 SET_DECL_RTL (parm, const0_rtx); 4452 DECL_INCOMING_RTL (parm) = DECL_RTL (parm); 4453 continue; 4454 } 4455 4456 /* If the parm is to be passed as a transparent union, use the 4457 type of the first field for the tests below. We have already 4458 verified that the modes are the same. */ 4459 if (DECL_TRANSPARENT_UNION (parm) 4460 || (TREE_CODE (passed_type) == UNION_TYPE 4461 && TYPE_TRANSPARENT_UNION (passed_type))) 4462 passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); 4463 4464 /* See if this arg was passed by invisible reference. It is if 4465 it is an object whose size depends on the contents of the 4466 object itself or if the machine requires these objects be passed 4467 that way. */ 4468 4469 if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST 4470 && contains_placeholder_p (TYPE_SIZE (passed_type))) 4471 || TREE_ADDRESSABLE (passed_type) 4472 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE 4473 || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode, 4474 passed_type, named_arg) 4475 #endif 4476 ) 4477 { 4478 passed_type = nominal_type = build_pointer_type (passed_type); 4479 passed_pointer = 1; 4480 passed_mode = nominal_mode = Pmode; 4481 } 4482 4483 promoted_mode = passed_mode; 4484 4485 #ifdef PROMOTE_FUNCTION_ARGS 4486 /* Compute the mode in which the arg is actually extended to. */ 4487 unsignedp = TREE_UNSIGNED (passed_type); 4488 promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1); 4489 #endif 4490 4491 /* Let machine desc say which reg (if any) the parm arrives in. 4492 0 means it arrives on the stack. */ 4493 #ifdef FUNCTION_INCOMING_ARG 4494 entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, 4495 passed_type, named_arg); 4496 #else 4497 entry_parm = FUNCTION_ARG (args_so_far, promoted_mode, 4498 passed_type, named_arg); 4499 #endif 4500 4501 if (entry_parm == 0) 4502 promoted_mode = passed_mode; 4503 4504 #ifdef SETUP_INCOMING_VARARGS 4505 /* If this is the last named parameter, do any required setup for 4506 varargs or stdargs. We need to know about the case of this being an 4507 addressable type, in which case we skip the registers it 4508 would have arrived in. 4509 4510 For stdargs, LAST_NAMED will be set for two parameters, the one that 4511 is actually the last named, and the dummy parameter. We only 4512 want to do this action once. 4513 4514 Also, indicate when RTL generation is to be suppressed. */ 4515 if (last_named && !varargs_setup) 4516 { 4517 SETUP_INCOMING_VARARGS (args_so_far, promoted_mode, passed_type, 4518 current_function_pretend_args_size, 0); 4519 varargs_setup = 1; 4520 } 4521 #endif 4522 4523 /* Determine parm's home in the stack, 4524 in case it arrives in the stack or we should pretend it did. 4525 4526 Compute the stack position and rtx where the argument arrives 4527 and its size. 4528 4529 There is one complexity here: If this was a parameter that would 4530 have been passed in registers, but wasn't only because it is 4531 __builtin_va_alist, we want locate_and_pad_parm to treat it as if 4532 it came in a register so that REG_PARM_STACK_SPACE isn't skipped. 4533 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 4534 0 as it was the previous time. */ 4535 4536 pretend_named = named_arg || PRETEND_OUTGOING_VARARGS_NAMED; 4537 locate_and_pad_parm (promoted_mode, passed_type, 4538 #ifdef STACK_PARMS_IN_REG_PARM_AREA 4539 1, 4540 #else 4541 #ifdef FUNCTION_INCOMING_ARG 4542 FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, 4543 passed_type, 4544 pretend_named) != 0, 4545 #else 4546 FUNCTION_ARG (args_so_far, promoted_mode, 4547 passed_type, 4548 pretend_named) != 0, 4549 #endif 4550 #endif 4551 fndecl, &stack_args_size, &stack_offset, &arg_size, 4552 &alignment_pad); 4553 4554 { 4555 rtx offset_rtx = ARGS_SIZE_RTX (stack_offset); 4556 4557 if (offset_rtx == const0_rtx) 4558 stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer); 4559 else 4560 stack_parm = gen_rtx_MEM (promoted_mode, 4561 gen_rtx_PLUS (Pmode, 4562 internal_arg_pointer, 4563 offset_rtx)); 4564 4565 set_mem_attributes (stack_parm, parm, 1); 4566 } 4567 4568 /* If this parameter was passed both in registers and in the stack, 4569 use the copy on the stack. */ 4570 if (MUST_PASS_IN_STACK (promoted_mode, passed_type)) 4571 entry_parm = 0; 4572 4573 #ifdef FUNCTION_ARG_PARTIAL_NREGS 4574 /* If this parm was passed part in regs and part in memory, 4575 pretend it arrived entirely in memory 4576 by pushing the register-part onto the stack. 4577 4578 In the special case of a DImode or DFmode that is split, 4579 we could put it together in a pseudoreg directly, 4580 but for now that's not worth bothering with. */ 4581 4582 if (entry_parm) 4583 { 4584 int nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode, 4585 passed_type, named_arg); 4586 4587 if (nregs > 0) 4588 { 4589 current_function_pretend_args_size 4590 = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1) 4591 / (PARM_BOUNDARY / BITS_PER_UNIT) 4592 * (PARM_BOUNDARY / BITS_PER_UNIT)); 4593 4594 /* Handle calls that pass values in multiple non-contiguous 4595 locations. The Irix 6 ABI has examples of this. */ 4596 if (GET_CODE (entry_parm) == PARALLEL) 4597 emit_group_store (validize_mem (stack_parm), entry_parm, 4598 int_size_in_bytes (TREE_TYPE (parm))); 4599 4600 else 4601 move_block_from_reg (REGNO (entry_parm), 4602 validize_mem (stack_parm), nregs, 4603 int_size_in_bytes (TREE_TYPE (parm))); 4604 4605 entry_parm = stack_parm; 4606 } 4607 } 4608 #endif 4609 4610 /* If we didn't decide this parm came in a register, 4611 by default it came on the stack. */ 4612 if (entry_parm == 0) 4613 entry_parm = stack_parm; 4614 4615 /* Record permanently how this parm was passed. */ 4616 DECL_INCOMING_RTL (parm) = entry_parm; 4617 4618 /* If there is actually space on the stack for this parm, 4619 count it in stack_args_size; otherwise set stack_parm to 0 4620 to indicate there is no preallocated stack slot for the parm. */ 4621 4622 if (entry_parm == stack_parm 4623 || (GET_CODE (entry_parm) == PARALLEL 4624 && XEXP (XVECEXP (entry_parm, 0, 0), 0) == NULL_RTX) 4625 #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE) 4626 /* On some machines, even if a parm value arrives in a register 4627 there is still an (uninitialized) stack slot allocated for it. 4628 4629 ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell 4630 whether this parameter already has a stack slot allocated, 4631 because an arg block exists only if current_function_args_size 4632 is larger than some threshold, and we haven't calculated that 4633 yet. So, for now, we just assume that stack slots never exist 4634 in this case. */ 4635 || REG_PARM_STACK_SPACE (fndecl) > 0 4636 #endif 4637 ) 4638 { 4639 stack_args_size.constant += arg_size.constant; 4640 if (arg_size.var) 4641 ADD_PARM_SIZE (stack_args_size, arg_size.var); 4642 } 4643 else 4644 /* No stack slot was pushed for this parm. */ 4645 stack_parm = 0; 4646 4647 /* Update info on where next arg arrives in registers. */ 4648 4649 FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode, 4650 passed_type, named_arg); 4651 4652 /* If we can't trust the parm stack slot to be aligned enough 4653 for its ultimate type, don't use that slot after entry. 4654 We'll make another stack slot, if we need one. */ 4655 { 4656 unsigned int thisparm_boundary 4657 = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type); 4658 4659 if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary) 4660 stack_parm = 0; 4661 } 4662 4663 /* If parm was passed in memory, and we need to convert it on entry, 4664 don't store it back in that same slot. */ 4665 if (entry_parm != 0 4666 && nominal_mode != BLKmode && nominal_mode != passed_mode) 4667 stack_parm = 0; 4668 4669 /* When an argument is passed in multiple locations, we can't 4670 make use of this information, but we can save some copying if 4671 the whole argument is passed in a single register. */ 4672 if (GET_CODE (entry_parm) == PARALLEL 4673 && nominal_mode != BLKmode && passed_mode != BLKmode) 4674 { 4675 int i, len = XVECLEN (entry_parm, 0); 4676 4677 for (i = 0; i < len; i++) 4678 if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX 4679 && GET_CODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) == REG 4680 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) 4681 == passed_mode) 4682 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0) 4683 { 4684 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0); 4685 DECL_INCOMING_RTL (parm) = entry_parm; 4686 break; 4687 } 4688 } 4689 4690 /* ENTRY_PARM is an RTX for the parameter as it arrives, 4691 in the mode in which it arrives. 4692 STACK_PARM is an RTX for a stack slot where the parameter can live 4693 during the function (in case we want to put it there). 4694 STACK_PARM is 0 if no stack slot was pushed for it. 4695 4696 Now output code if necessary to convert ENTRY_PARM to 4697 the type in which this function declares it, 4698 and store that result in an appropriate place, 4699 which may be a pseudo reg, may be STACK_PARM, 4700 or may be a local stack slot if STACK_PARM is 0. 4701 4702 Set DECL_RTL to that place. */ 4703 4704 if (nominal_mode == BLKmode || GET_CODE (entry_parm) == PARALLEL) 4705 { 4706 /* If a BLKmode arrives in registers, copy it to a stack slot. 4707 Handle calls that pass values in multiple non-contiguous 4708 locations. The Irix 6 ABI has examples of this. */ 4709 if (GET_CODE (entry_parm) == REG 4710 || GET_CODE (entry_parm) == PARALLEL) 4711 { 4712 int size_stored 4713 = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)), 4714 UNITS_PER_WORD); 4715 4716 /* Note that we will be storing an integral number of words. 4717 So we have to be careful to ensure that we allocate an 4718 integral number of words. We do this below in the 4719 assign_stack_local if space was not allocated in the argument 4720 list. If it was, this will not work if PARM_BOUNDARY is not 4721 a multiple of BITS_PER_WORD. It isn't clear how to fix this 4722 if it becomes a problem. */ 4723 4724 if (stack_parm == 0) 4725 { 4726 stack_parm 4727 = assign_stack_local (GET_MODE (entry_parm), 4728 size_stored, 0); 4729 set_mem_attributes (stack_parm, parm, 1); 4730 } 4731 4732 else if (PARM_BOUNDARY % BITS_PER_WORD != 0) 4733 abort (); 4734 4735 /* Handle calls that pass values in multiple non-contiguous 4736 locations. The Irix 6 ABI has examples of this. */ 4737 if (GET_CODE (entry_parm) == PARALLEL) 4738 emit_group_store (validize_mem (stack_parm), entry_parm, 4739 int_size_in_bytes (TREE_TYPE (parm))); 4740 else 4741 move_block_from_reg (REGNO (entry_parm), 4742 validize_mem (stack_parm), 4743 size_stored / UNITS_PER_WORD, 4744 int_size_in_bytes (TREE_TYPE (parm))); 4745 } 4746 SET_DECL_RTL (parm, stack_parm); 4747 } 4748 else if (! ((! optimize 4749 && ! DECL_REGISTER (parm)) 4750 || TREE_SIDE_EFFECTS (parm) 4751 /* If -ffloat-store specified, don't put explicit 4752 float variables into registers. */ 4753 || (flag_float_store 4754 && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)) 4755 /* Always assign pseudo to structure return or item passed 4756 by invisible reference. */ 4757 || passed_pointer || parm == function_result_decl) 4758 { 4759 /* Store the parm in a pseudoregister during the function, but we 4760 may need to do it in a wider mode. */ 4761 4762 rtx parmreg; 4763 unsigned int regno, regnoi = 0, regnor = 0; 4764 4765 unsignedp = TREE_UNSIGNED (TREE_TYPE (parm)); 4766 4767 promoted_nominal_mode 4768 = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0); 4769 4770 parmreg = gen_reg_rtx (promoted_nominal_mode); 4771 mark_user_reg (parmreg); 4772 4773 /* If this was an item that we received a pointer to, set DECL_RTL 4774 appropriately. */ 4775 if (passed_pointer) 4776 { 4777 rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)), 4778 parmreg); 4779 set_mem_attributes (x, parm, 1); 4780 SET_DECL_RTL (parm, x); 4781 } 4782 else 4783 { 4784 SET_DECL_RTL (parm, parmreg); 4785 maybe_set_unchanging (DECL_RTL (parm), parm); 4786 } 4787 4788 /* Copy the value into the register. */ 4789 if (nominal_mode != passed_mode 4790 || promoted_nominal_mode != promoted_mode) 4791 { 4792 int save_tree_used; 4793 /* ENTRY_PARM has been converted to PROMOTED_MODE, its 4794 mode, by the caller. We now have to convert it to 4795 NOMINAL_MODE, if different. However, PARMREG may be in 4796 a different mode than NOMINAL_MODE if it is being stored 4797 promoted. 4798 4799 If ENTRY_PARM is a hard register, it might be in a register 4800 not valid for operating in its mode (e.g., an odd-numbered 4801 register for a DFmode). In that case, moves are the only 4802 thing valid, so we can't do a convert from there. This 4803 occurs when the calling sequence allow such misaligned 4804 usages. 4805 4806 In addition, the conversion may involve a call, which could 4807 clobber parameters which haven't been copied to pseudo 4808 registers yet. Therefore, we must first copy the parm to 4809 a pseudo reg here, and save the conversion until after all 4810 parameters have been moved. */ 4811 4812 rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); 4813 4814 emit_move_insn (tempreg, validize_mem (entry_parm)); 4815 4816 push_to_sequence (conversion_insns); 4817 tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp); 4818 4819 if (GET_CODE (tempreg) == SUBREG 4820 && GET_MODE (tempreg) == nominal_mode 4821 && GET_CODE (SUBREG_REG (tempreg)) == REG 4822 && nominal_mode == passed_mode 4823 && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (entry_parm) 4824 && GET_MODE_SIZE (GET_MODE (tempreg)) 4825 < GET_MODE_SIZE (GET_MODE (entry_parm))) 4826 { 4827 /* The argument is already sign/zero extended, so note it 4828 into the subreg. */ 4829 SUBREG_PROMOTED_VAR_P (tempreg) = 1; 4830 SUBREG_PROMOTED_UNSIGNED_P (tempreg) = unsignedp; 4831 } 4832 4833 /* TREE_USED gets set erroneously during expand_assignment. */ 4834 save_tree_used = TREE_USED (parm); 4835 expand_assignment (parm, 4836 make_tree (nominal_type, tempreg), 0, 0); 4837 TREE_USED (parm) = save_tree_used; 4838 conversion_insns = get_insns (); 4839 did_conversion = 1; 4840 end_sequence (); 4841 } 4842 else 4843 emit_move_insn (parmreg, validize_mem (entry_parm)); 4844 4845 /* If we were passed a pointer but the actual value 4846 can safely live in a register, put it in one. */ 4847 if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode 4848 /* If by-reference argument was promoted, demote it. */ 4849 && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm)) 4850 || ! ((! optimize 4851 && ! DECL_REGISTER (parm)) 4852 || TREE_SIDE_EFFECTS (parm) 4853 /* If -ffloat-store specified, don't put explicit 4854 float variables into registers. */ 4855 || (flag_float_store 4856 && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)))) 4857 { 4858 /* We can't use nominal_mode, because it will have been set to 4859 Pmode above. We must use the actual mode of the parm. */ 4860 parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); 4861 mark_user_reg (parmreg); 4862 if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm))) 4863 { 4864 rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm))); 4865 int unsigned_p = TREE_UNSIGNED (TREE_TYPE (parm)); 4866 push_to_sequence (conversion_insns); 4867 emit_move_insn (tempreg, DECL_RTL (parm)); 4868 SET_DECL_RTL (parm, 4869 convert_to_mode (GET_MODE (parmreg), 4870 tempreg, 4871 unsigned_p)); 4872 emit_move_insn (parmreg, DECL_RTL (parm)); 4873 conversion_insns = get_insns(); 4874 did_conversion = 1; 4875 end_sequence (); 4876 } 4877 else 4878 emit_move_insn (parmreg, DECL_RTL (parm)); 4879 SET_DECL_RTL (parm, parmreg); 4880 /* STACK_PARM is the pointer, not the parm, and PARMREG is 4881 now the parm. */ 4882 stack_parm = 0; 4883 } 4884 #ifdef FUNCTION_ARG_CALLEE_COPIES 4885 /* If we are passed an arg by reference and it is our responsibility 4886 to make a copy, do it now. 4887 PASSED_TYPE and PASSED mode now refer to the pointer, not the 4888 original argument, so we must recreate them in the call to 4889 FUNCTION_ARG_CALLEE_COPIES. */ 4890 /* ??? Later add code to handle the case that if the argument isn't 4891 modified, don't do the copy. */ 4892 4893 else if (passed_pointer 4894 && FUNCTION_ARG_CALLEE_COPIES (args_so_far, 4895 TYPE_MODE (DECL_ARG_TYPE (parm)), 4896 DECL_ARG_TYPE (parm), 4897 named_arg) 4898 && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm))) 4899 { 4900 rtx copy; 4901 tree type = DECL_ARG_TYPE (parm); 4902 4903 /* This sequence may involve a library call perhaps clobbering 4904 registers that haven't been copied to pseudos yet. */ 4905 4906 push_to_sequence (conversion_insns); 4907 4908 if (!COMPLETE_TYPE_P (type) 4909 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 4910 /* This is a variable sized object. */ 4911 copy = gen_rtx_MEM (BLKmode, 4912 allocate_dynamic_stack_space 4913 (expr_size (parm), NULL_RTX, 4914 TYPE_ALIGN (type))); 4915 else 4916 copy = assign_stack_temp (TYPE_MODE (type), 4917 int_size_in_bytes (type), 1); 4918 set_mem_attributes (copy, parm, 1); 4919 4920 store_expr (parm, copy, 0); 4921 emit_move_insn (parmreg, XEXP (copy, 0)); 4922 conversion_insns = get_insns (); 4923 did_conversion = 1; 4924 end_sequence (); 4925 } 4926 #endif /* FUNCTION_ARG_CALLEE_COPIES */ 4927 4928 /* In any case, record the parm's desired stack location 4929 in case we later discover it must live in the stack. 4930 4931 If it is a COMPLEX value, store the stack location for both 4932 halves. */ 4933 4934 if (GET_CODE (parmreg) == CONCAT) 4935 regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1))); 4936 else 4937 regno = REGNO (parmreg); 4938 4939 if (regno >= max_parm_reg) 4940 { 4941 rtx *new; 4942 int old_max_parm_reg = max_parm_reg; 4943 4944 /* It's slow to expand this one register at a time, 4945 but it's also rare and we need max_parm_reg to be 4946 precisely correct. */ 4947 max_parm_reg = regno + 1; 4948 new = (rtx *) xrealloc (parm_reg_stack_loc, 4949 max_parm_reg * sizeof (rtx)); 4950 memset ((char *) (new + old_max_parm_reg), 0, 4951 (max_parm_reg - old_max_parm_reg) * sizeof (rtx)); 4952 parm_reg_stack_loc = new; 4953 } 4954 4955 if (GET_CODE (parmreg) == CONCAT) 4956 { 4957 enum machine_mode submode = GET_MODE (XEXP (parmreg, 0)); 4958 4959 regnor = REGNO (gen_realpart (submode, parmreg)); 4960 regnoi = REGNO (gen_imagpart (submode, parmreg)); 4961 4962 if (stack_parm != 0) 4963 { 4964 parm_reg_stack_loc[regnor] 4965 = gen_realpart (submode, stack_parm); 4966 parm_reg_stack_loc[regnoi] 4967 = gen_imagpart (submode, stack_parm); 4968 } 4969 else 4970 { 4971 parm_reg_stack_loc[regnor] = 0; 4972 parm_reg_stack_loc[regnoi] = 0; 4973 } 4974 } 4975 else 4976 parm_reg_stack_loc[REGNO (parmreg)] = stack_parm; 4977 4978 /* Mark the register as eliminable if we did no conversion 4979 and it was copied from memory at a fixed offset, 4980 and the arg pointer was not copied to a pseudo-reg. 4981 If the arg pointer is a pseudo reg or the offset formed 4982 an invalid address, such memory-equivalences 4983 as we make here would screw up life analysis for it. */ 4984 if (nominal_mode == passed_mode 4985 && ! did_conversion 4986 && stack_parm != 0 4987 && GET_CODE (stack_parm) == MEM 4988 && stack_offset.var == 0 4989 && reg_mentioned_p (virtual_incoming_args_rtx, 4990 XEXP (stack_parm, 0))) 4991 { 4992 rtx linsn = get_last_insn (); 4993 rtx sinsn, set; 4994 4995 /* Mark complex types separately. */ 4996 if (GET_CODE (parmreg) == CONCAT) 4997 /* Scan backwards for the set of the real and 4998 imaginary parts. */ 4999 for (sinsn = linsn; sinsn != 0; 5000 sinsn = prev_nonnote_insn (sinsn)) 5001 { 5002 set = single_set (sinsn); 5003 if (set != 0 5004 && SET_DEST (set) == regno_reg_rtx [regnoi]) 5005 REG_NOTES (sinsn) 5006 = gen_rtx_EXPR_LIST (REG_EQUIV, 5007 parm_reg_stack_loc[regnoi], 5008 REG_NOTES (sinsn)); 5009 else if (set != 0 5010 && SET_DEST (set) == regno_reg_rtx [regnor]) 5011 REG_NOTES (sinsn) 5012 = gen_rtx_EXPR_LIST (REG_EQUIV, 5013 parm_reg_stack_loc[regnor], 5014 REG_NOTES (sinsn)); 5015 } 5016 else if ((set = single_set (linsn)) != 0 5017 && SET_DEST (set) == parmreg) 5018 REG_NOTES (linsn) 5019 = gen_rtx_EXPR_LIST (REG_EQUIV, 5020 stack_parm, REG_NOTES (linsn)); 5021 } 5022 5023 /* For pointer data type, suggest pointer register. */ 5024 if (POINTER_TYPE_P (TREE_TYPE (parm))) 5025 mark_reg_pointer (parmreg, 5026 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); 5027 5028 /* If something wants our address, try to use ADDRESSOF. */ 5029 if (TREE_ADDRESSABLE (parm)) 5030 { 5031 /* If we end up putting something into the stack, 5032 fixup_var_refs_insns will need to make a pass over 5033 all the instructions. It looks through the pending 5034 sequences -- but it can't see the ones in the 5035 CONVERSION_INSNS, if they're not on the sequence 5036 stack. So, we go back to that sequence, just so that 5037 the fixups will happen. */ 5038 push_to_sequence (conversion_insns); 5039 put_var_into_stack (parm); 5040 conversion_insns = get_insns (); 5041 end_sequence (); 5042 } 5043 } 5044 else 5045 { 5046 /* Value must be stored in the stack slot STACK_PARM 5047 during function execution. */ 5048 5049 if (promoted_mode != nominal_mode) 5050 { 5051 /* Conversion is required. */ 5052 rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); 5053 5054 emit_move_insn (tempreg, validize_mem (entry_parm)); 5055 5056 push_to_sequence (conversion_insns); 5057 entry_parm = convert_to_mode (nominal_mode, tempreg, 5058 TREE_UNSIGNED (TREE_TYPE (parm))); 5059 if (stack_parm) 5060 /* ??? This may need a big-endian conversion on sparc64. */ 5061 stack_parm = adjust_address (stack_parm, nominal_mode, 0); 5062 5063 conversion_insns = get_insns (); 5064 did_conversion = 1; 5065 end_sequence (); 5066 } 5067 5068 if (entry_parm != stack_parm) 5069 { 5070 if (stack_parm == 0) 5071 { 5072 stack_parm 5073 = assign_stack_local (GET_MODE (entry_parm), 5074 GET_MODE_SIZE (GET_MODE (entry_parm)), 0); 5075 set_mem_attributes (stack_parm, parm, 1); 5076 } 5077 5078 if (promoted_mode != nominal_mode) 5079 { 5080 push_to_sequence (conversion_insns); 5081 emit_move_insn (validize_mem (stack_parm), 5082 validize_mem (entry_parm)); 5083 conversion_insns = get_insns (); 5084 end_sequence (); 5085 } 5086 else 5087 emit_move_insn (validize_mem (stack_parm), 5088 validize_mem (entry_parm)); 5089 } 5090 5091 SET_DECL_RTL (parm, stack_parm); 5092 } 5093 5094 /* If this "parameter" was the place where we are receiving the 5095 function's incoming structure pointer, set up the result. */ 5096 if (parm == function_result_decl) 5097 { 5098 tree result = DECL_RESULT (fndecl); 5099 rtx addr = DECL_RTL (parm); 5100 rtx x; 5101 5102 #ifdef POINTERS_EXTEND_UNSIGNED 5103 if (GET_MODE (addr) != Pmode) 5104 addr = convert_memory_address (Pmode, addr); 5105 #endif 5106 5107 x = gen_rtx_MEM (DECL_MODE (result), addr); 5108 set_mem_attributes (x, result, 1); 5109 SET_DECL_RTL (result, x); 5110 } 5111 5112 if (GET_CODE (DECL_RTL (parm)) == REG) 5113 REGNO_DECL (REGNO (DECL_RTL (parm))) = parm; 5114 else if (GET_CODE (DECL_RTL (parm)) == CONCAT) 5115 { 5116 REGNO_DECL (REGNO (XEXP (DECL_RTL (parm), 0))) = parm; 5117 REGNO_DECL (REGNO (XEXP (DECL_RTL (parm), 1))) = parm; 5118 } 5119 5120 } 5121 5122 /* Output all parameter conversion instructions (possibly including calls) 5123 now that all parameters have been copied out of hard registers. */ 5124 emit_insns (conversion_insns); 5125 5126 last_parm_insn = get_last_insn (); 5127 5128 current_function_args_size = stack_args_size.constant; 5129 5130 /* Adjust function incoming argument size for alignment and 5131 minimum length. */ 5132 5133 #ifdef REG_PARM_STACK_SPACE 5134 #ifndef MAYBE_REG_PARM_STACK_SPACE 5135 current_function_args_size = MAX (current_function_args_size, 5136 REG_PARM_STACK_SPACE (fndecl)); 5137 #endif 5138 #endif 5139 5140 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) 5141 5142 current_function_args_size 5143 = ((current_function_args_size + STACK_BYTES - 1) 5144 / STACK_BYTES) * STACK_BYTES; 5145 5146 #ifdef ARGS_GROW_DOWNWARD 5147 current_function_arg_offset_rtx 5148 = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant) 5149 : expand_expr (size_diffop (stack_args_size.var, 5150 size_int (-stack_args_size.constant)), 5151 NULL_RTX, VOIDmode, 0)); 5152 #else 5153 current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size); 5154 #endif 5155 5156 /* See how many bytes, if any, of its args a function should try to pop 5157 on return. */ 5158 5159 current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl), 5160 current_function_args_size); 5161 5162 /* For stdarg.h function, save info about 5163 regs and stack space used by the named args. */ 5164 5165 if (!hide_last_arg) 5166 current_function_args_info = args_so_far; 5167 5168 /* Set the rtx used for the function return value. Put this in its 5169 own variable so any optimizers that need this information don't have 5170 to include tree.h. Do this here so it gets done when an inlined 5171 function gets output. */ 5172 5173 current_function_return_rtx 5174 = (DECL_RTL_SET_P (DECL_RESULT (fndecl)) 5175 ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX); 5176 5177 /* If scalar return value was computed in a pseudo-reg, or was a named 5178 return value that got dumped to the stack, copy that to the hard 5179 return register. */ 5180 if (DECL_RTL_SET_P (DECL_RESULT (fndecl))) 5181 { 5182 tree decl_result = DECL_RESULT (fndecl); 5183 rtx decl_rtl = DECL_RTL (decl_result); 5184 5185 if (REG_P (decl_rtl) 5186 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER 5187 : DECL_REGISTER (decl_result)) 5188 { 5189 rtx real_decl_rtl; 5190 5191 #ifdef FUNCTION_OUTGOING_VALUE 5192 real_decl_rtl = FUNCTION_OUTGOING_VALUE (TREE_TYPE (decl_result), 5193 fndecl); 5194 #else 5195 real_decl_rtl = FUNCTION_VALUE (TREE_TYPE (decl_result), 5196 fndecl); 5197 #endif 5198 REG_FUNCTION_VALUE_P (real_decl_rtl) = 1; 5199 /* The delay slot scheduler assumes that current_function_return_rtx 5200 holds the hard register containing the return value, not a 5201 temporary pseudo. */ 5202 current_function_return_rtx = real_decl_rtl; 5203 } 5204 } 5205 } 5206 5207 /* Indicate whether REGNO is an incoming argument to the current function 5208 that was promoted to a wider mode. If so, return the RTX for the 5209 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode 5210 that REGNO is promoted from and whether the promotion was signed or 5211 unsigned. */ 5212 5213 #ifdef PROMOTE_FUNCTION_ARGS 5214 5215 rtx 5216 promoted_input_arg (regno, pmode, punsignedp) 5217 unsigned int regno; 5218 enum machine_mode *pmode; 5219 int *punsignedp; 5220 { 5221 tree arg; 5222 5223 for (arg = DECL_ARGUMENTS (current_function_decl); arg; 5224 arg = TREE_CHAIN (arg)) 5225 if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG 5226 && REGNO (DECL_INCOMING_RTL (arg)) == regno 5227 && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg))) 5228 { 5229 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg)); 5230 int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg)); 5231 5232 mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1); 5233 if (mode == GET_MODE (DECL_INCOMING_RTL (arg)) 5234 && mode != DECL_MODE (arg)) 5235 { 5236 *pmode = DECL_MODE (arg); 5237 *punsignedp = unsignedp; 5238 return DECL_INCOMING_RTL (arg); 5239 } 5240 } 5241 5242 return 0; 5243 } 5244 5245 #endif 5246 5247 /* Compute the size and offset from the start of the stacked arguments for a 5248 parm passed in mode PASSED_MODE and with type TYPE. 5249 5250 INITIAL_OFFSET_PTR points to the current offset into the stacked 5251 arguments. 5252 5253 The starting offset and size for this parm are returned in *OFFSET_PTR 5254 and *ARG_SIZE_PTR, respectively. 5255 5256 IN_REGS is non-zero if the argument will be passed in registers. It will 5257 never be set if REG_PARM_STACK_SPACE is not defined. 5258 5259 FNDECL is the function in which the argument was defined. 5260 5261 There are two types of rounding that are done. The first, controlled by 5262 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument 5263 list to be aligned to the specific boundary (in bits). This rounding 5264 affects the initial and starting offsets, but not the argument size. 5265 5266 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, 5267 optionally rounds the size of the parm to PARM_BOUNDARY. The 5268 initial offset is not affected by this rounding, while the size always 5269 is and the starting offset may be. */ 5270 5271 /* offset_ptr will be negative for ARGS_GROW_DOWNWARD case; 5272 initial_offset_ptr is positive because locate_and_pad_parm's 5273 callers pass in the total size of args so far as 5274 initial_offset_ptr. arg_size_ptr is always positive. */ 5275 5276 void 5277 locate_and_pad_parm (passed_mode, type, in_regs, fndecl, 5278 initial_offset_ptr, offset_ptr, arg_size_ptr, 5279 alignment_pad) 5280 enum machine_mode passed_mode; 5281 tree type; 5282 int in_regs ATTRIBUTE_UNUSED; 5283 tree fndecl ATTRIBUTE_UNUSED; 5284 struct args_size *initial_offset_ptr; 5285 struct args_size *offset_ptr; 5286 struct args_size *arg_size_ptr; 5287 struct args_size *alignment_pad; 5288 5289 { 5290 tree sizetree 5291 = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); 5292 enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type); 5293 int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type); 5294 5295 #ifdef REG_PARM_STACK_SPACE 5296 /* If we have found a stack parm before we reach the end of the 5297 area reserved for registers, skip that area. */ 5298 if (! in_regs) 5299 { 5300 int reg_parm_stack_space = 0; 5301 5302 #ifdef MAYBE_REG_PARM_STACK_SPACE 5303 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE; 5304 #else 5305 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); 5306 #endif 5307 if (reg_parm_stack_space > 0) 5308 { 5309 if (initial_offset_ptr->var) 5310 { 5311 initial_offset_ptr->var 5312 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), 5313 ssize_int (reg_parm_stack_space)); 5314 initial_offset_ptr->constant = 0; 5315 } 5316 else if (initial_offset_ptr->constant < reg_parm_stack_space) 5317 initial_offset_ptr->constant = reg_parm_stack_space; 5318 } 5319 } 5320 #endif /* REG_PARM_STACK_SPACE */ 5321 5322 arg_size_ptr->var = 0; 5323 arg_size_ptr->constant = 0; 5324 alignment_pad->var = 0; 5325 alignment_pad->constant = 0; 5326 5327 #ifdef ARGS_GROW_DOWNWARD 5328 if (initial_offset_ptr->var) 5329 { 5330 offset_ptr->constant = 0; 5331 offset_ptr->var = size_binop (MINUS_EXPR, ssize_int (0), 5332 initial_offset_ptr->var); 5333 } 5334 else 5335 { 5336 offset_ptr->constant = -initial_offset_ptr->constant; 5337 offset_ptr->var = 0; 5338 } 5339 if (where_pad != none 5340 && (!host_integerp (sizetree, 1) 5341 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) 5342 sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); 5343 SUB_PARM_SIZE (*offset_ptr, sizetree); 5344 if (where_pad != downward) 5345 pad_to_arg_alignment (offset_ptr, boundary, alignment_pad); 5346 if (initial_offset_ptr->var) 5347 arg_size_ptr->var = size_binop (MINUS_EXPR, 5348 size_binop (MINUS_EXPR, 5349 ssize_int (0), 5350 initial_offset_ptr->var), 5351 offset_ptr->var); 5352 5353 else 5354 arg_size_ptr->constant = (-initial_offset_ptr->constant 5355 - offset_ptr->constant); 5356 5357 #else /* !ARGS_GROW_DOWNWARD */ 5358 if (!in_regs 5359 #ifdef REG_PARM_STACK_SPACE 5360 || REG_PARM_STACK_SPACE (fndecl) > 0 5361 #endif 5362 ) 5363 pad_to_arg_alignment (initial_offset_ptr, boundary, alignment_pad); 5364 *offset_ptr = *initial_offset_ptr; 5365 5366 #ifdef PUSH_ROUNDING 5367 if (passed_mode != BLKmode) 5368 sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); 5369 #endif 5370 5371 /* Pad_below needs the pre-rounded size to know how much to pad below 5372 so this must be done before rounding up. */ 5373 if (where_pad == downward 5374 /* However, BLKmode args passed in regs have their padding done elsewhere. 5375 The stack slot must be able to hold the entire register. */ 5376 && !(in_regs && passed_mode == BLKmode)) 5377 pad_below (offset_ptr, passed_mode, sizetree); 5378 5379 if (where_pad != none 5380 && (!host_integerp (sizetree, 1) 5381 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) 5382 sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); 5383 5384 ADD_PARM_SIZE (*arg_size_ptr, sizetree); 5385 #endif /* ARGS_GROW_DOWNWARD */ 5386 } 5387 5388 /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. 5389 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ 5390 5391 static void 5392 pad_to_arg_alignment (offset_ptr, boundary, alignment_pad) 5393 struct args_size *offset_ptr; 5394 int boundary; 5395 struct args_size *alignment_pad; 5396 { 5397 tree save_var = NULL_TREE; 5398 HOST_WIDE_INT save_constant = 0; 5399 5400 int boundary_in_bytes = boundary / BITS_PER_UNIT; 5401 5402 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 5403 { 5404 save_var = offset_ptr->var; 5405 save_constant = offset_ptr->constant; 5406 } 5407 5408 alignment_pad->var = NULL_TREE; 5409 alignment_pad->constant = 0; 5410 5411 if (boundary > BITS_PER_UNIT) 5412 { 5413 if (offset_ptr->var) 5414 { 5415 offset_ptr->var = 5416 #ifdef ARGS_GROW_DOWNWARD 5417 round_down 5418 #else 5419 round_up 5420 #endif 5421 (ARGS_SIZE_TREE (*offset_ptr), 5422 boundary / BITS_PER_UNIT); 5423 offset_ptr->constant = 0; /*?*/ 5424 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 5425 alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, 5426 save_var); 5427 } 5428 else 5429 { 5430 offset_ptr->constant = 5431 #ifdef ARGS_GROW_DOWNWARD 5432 FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes); 5433 #else 5434 CEIL_ROUND (offset_ptr->constant, boundary_in_bytes); 5435 #endif 5436 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 5437 alignment_pad->constant = offset_ptr->constant - save_constant; 5438 } 5439 } 5440 } 5441 5442 #ifndef ARGS_GROW_DOWNWARD 5443 static void 5444 pad_below (offset_ptr, passed_mode, sizetree) 5445 struct args_size *offset_ptr; 5446 enum machine_mode passed_mode; 5447 tree sizetree; 5448 { 5449 if (passed_mode != BLKmode) 5450 { 5451 if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) 5452 offset_ptr->constant 5453 += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) 5454 / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) 5455 - GET_MODE_SIZE (passed_mode)); 5456 } 5457 else 5458 { 5459 if (TREE_CODE (sizetree) != INTEGER_CST 5460 || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) 5461 { 5462 /* Round the size up to multiple of PARM_BOUNDARY bits. */ 5463 tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); 5464 /* Add it in. */ 5465 ADD_PARM_SIZE (*offset_ptr, s2); 5466 SUB_PARM_SIZE (*offset_ptr, sizetree); 5467 } 5468 } 5469 } 5470 #endif 5471 5472 /* Walk the tree of blocks describing the binding levels within a function 5473 and warn about uninitialized variables. 5474 This is done after calling flow_analysis and before global_alloc 5475 clobbers the pseudo-regs to hard regs. */ 5476 5477 void 5478 uninitialized_vars_warning (block) 5479 tree block; 5480 { 5481 tree decl, sub; 5482 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 5483 { 5484 if (warn_uninitialized 5485 && TREE_CODE (decl) == VAR_DECL 5486 /* These warnings are unreliable for and aggregates 5487 because assigning the fields one by one can fail to convince 5488 flow.c that the entire aggregate was initialized. 5489 Unions are troublesome because members may be shorter. */ 5490 && ! AGGREGATE_TYPE_P (TREE_TYPE (decl)) 5491 && DECL_RTL (decl) != 0 5492 && GET_CODE (DECL_RTL (decl)) == REG 5493 /* Global optimizations can make it difficult to determine if a 5494 particular variable has been initialized. However, a VAR_DECL 5495 with a nonzero DECL_INITIAL had an initializer, so do not 5496 claim it is potentially uninitialized. 5497 5498 We do not care about the actual value in DECL_INITIAL, so we do 5499 not worry that it may be a dangling pointer. */ 5500 && DECL_INITIAL (decl) == NULL_TREE 5501 && regno_uninitialized (REGNO (DECL_RTL (decl)))) 5502 warning_with_decl (decl, 5503 "`%s' might be used uninitialized in this function"); 5504 if (extra_warnings 5505 && TREE_CODE (decl) == VAR_DECL 5506 && DECL_RTL (decl) != 0 5507 && GET_CODE (DECL_RTL (decl)) == REG 5508 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) 5509 warning_with_decl (decl, 5510 "variable `%s' might be clobbered by `longjmp' or `vfork'"); 5511 } 5512 for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) 5513 uninitialized_vars_warning (sub); 5514 } 5515 5516 /* Do the appropriate part of uninitialized_vars_warning 5517 but for arguments instead of local variables. */ 5518 5519 void 5520 setjmp_args_warning () 5521 { 5522 tree decl; 5523 for (decl = DECL_ARGUMENTS (current_function_decl); 5524 decl; decl = TREE_CHAIN (decl)) 5525 if (DECL_RTL (decl) != 0 5526 && GET_CODE (DECL_RTL (decl)) == REG 5527 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) 5528 warning_with_decl (decl, 5529 "argument `%s' might be clobbered by `longjmp' or `vfork'"); 5530 } 5531 5532 /* If this function call setjmp, put all vars into the stack 5533 unless they were declared `register'. */ 5534 5535 void 5536 setjmp_protect (block) 5537 tree block; 5538 { 5539 tree decl, sub; 5540 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 5541 if ((TREE_CODE (decl) == VAR_DECL 5542 || TREE_CODE (decl) == PARM_DECL) 5543 && DECL_RTL (decl) != 0 5544 && (GET_CODE (DECL_RTL (decl)) == REG 5545 || (GET_CODE (DECL_RTL (decl)) == MEM 5546 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF)) 5547 /* If this variable came from an inline function, it must be 5548 that its life doesn't overlap the setjmp. If there was a 5549 setjmp in the function, it would already be in memory. We 5550 must exclude such variable because their DECL_RTL might be 5551 set to strange things such as virtual_stack_vars_rtx. */ 5552 && ! DECL_FROM_INLINE (decl) 5553 && ( 5554 #ifdef NON_SAVING_SETJMP 5555 /* If longjmp doesn't restore the registers, 5556 don't put anything in them. */ 5557 NON_SAVING_SETJMP 5558 || 5559 #endif 5560 ! DECL_REGISTER (decl))) 5561 put_var_into_stack (decl); 5562 for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) 5563 setjmp_protect (sub); 5564 } 5565 5566 /* Like the previous function, but for args instead of local variables. */ 5567 5568 void 5569 setjmp_protect_args () 5570 { 5571 tree decl; 5572 for (decl = DECL_ARGUMENTS (current_function_decl); 5573 decl; decl = TREE_CHAIN (decl)) 5574 if ((TREE_CODE (decl) == VAR_DECL 5575 || TREE_CODE (decl) == PARM_DECL) 5576 && DECL_RTL (decl) != 0 5577 && (GET_CODE (DECL_RTL (decl)) == REG 5578 || (GET_CODE (DECL_RTL (decl)) == MEM 5579 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF)) 5580 && ( 5581 /* If longjmp doesn't restore the registers, 5582 don't put anything in them. */ 5583 #ifdef NON_SAVING_SETJMP 5584 NON_SAVING_SETJMP 5585 || 5586 #endif 5587 ! DECL_REGISTER (decl))) 5588 put_var_into_stack (decl); 5589 } 5590 5591 /* Return the context-pointer register corresponding to DECL, 5592 or 0 if it does not need one. */ 5593 5594 rtx 5595 lookup_static_chain (decl) 5596 tree decl; 5597 { 5598 tree context = decl_function_context (decl); 5599 tree link; 5600 5601 if (context == 0 5602 || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl))) 5603 return 0; 5604 5605 /* We treat inline_function_decl as an alias for the current function 5606 because that is the inline function whose vars, types, etc. 5607 are being merged into the current function. 5608 See expand_inline_function. */ 5609 if (context == current_function_decl || context == inline_function_decl) 5610 return virtual_stack_vars_rtx; 5611 5612 for (link = context_display; link; link = TREE_CHAIN (link)) 5613 if (TREE_PURPOSE (link) == context) 5614 return RTL_EXPR_RTL (TREE_VALUE (link)); 5615 5616 abort (); 5617 } 5618 5619 /* Convert a stack slot address ADDR for variable VAR 5620 (from a containing function) 5621 into an address valid in this function (using a static chain). */ 5622 5623 rtx 5624 fix_lexical_addr (addr, var) 5625 rtx addr; 5626 tree var; 5627 { 5628 rtx basereg; 5629 HOST_WIDE_INT displacement; 5630 tree context = decl_function_context (var); 5631 struct function *fp; 5632 rtx base = 0; 5633 5634 /* If this is the present function, we need not do anything. */ 5635 if (context == current_function_decl || context == inline_function_decl) 5636 return addr; 5637 5638 fp = find_function_data (context); 5639 5640 if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM) 5641 addr = XEXP (XEXP (addr, 0), 0); 5642 5643 /* Decode given address as base reg plus displacement. */ 5644 if (GET_CODE (addr) == REG) 5645 basereg = addr, displacement = 0; 5646 else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT) 5647 basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1)); 5648 else 5649 abort (); 5650 5651 /* We accept vars reached via the containing function's 5652 incoming arg pointer and via its stack variables pointer. */ 5653 if (basereg == fp->internal_arg_pointer) 5654 { 5655 /* If reached via arg pointer, get the arg pointer value 5656 out of that function's stack frame. 5657 5658 There are two cases: If a separate ap is needed, allocate a 5659 slot in the outer function for it and dereference it that way. 5660 This is correct even if the real ap is actually a pseudo. 5661 Otherwise, just adjust the offset from the frame pointer to 5662 compensate. */ 5663 5664 #ifdef NEED_SEPARATE_AP 5665 rtx addr; 5666 5667 addr = get_arg_pointer_save_area (fp); 5668 addr = fix_lexical_addr (XEXP (addr, 0), var); 5669 addr = memory_address (Pmode, addr); 5670 5671 base = gen_rtx_MEM (Pmode, addr); 5672 set_mem_alias_set (base, get_frame_alias_set ()); 5673 base = copy_to_reg (base); 5674 #else 5675 displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET); 5676 base = lookup_static_chain (var); 5677 #endif 5678 } 5679 5680 else if (basereg == virtual_stack_vars_rtx) 5681 { 5682 /* This is the same code as lookup_static_chain, duplicated here to 5683 avoid an extra call to decl_function_context. */ 5684 tree link; 5685 5686 for (link = context_display; link; link = TREE_CHAIN (link)) 5687 if (TREE_PURPOSE (link) == context) 5688 { 5689 base = RTL_EXPR_RTL (TREE_VALUE (link)); 5690 break; 5691 } 5692 } 5693 5694 if (base == 0) 5695 abort (); 5696 5697 /* Use same offset, relative to appropriate static chain or argument 5698 pointer. */ 5699 return plus_constant (base, displacement); 5700 } 5701 5702 /* Return the address of the trampoline for entering nested fn FUNCTION. 5703 If necessary, allocate a trampoline (in the stack frame) 5704 and emit rtl to initialize its contents (at entry to this function). */ 5705 5706 rtx 5707 trampoline_address (function) 5708 tree function; 5709 { 5710 tree link; 5711 tree rtlexp; 5712 rtx tramp; 5713 struct function *fp; 5714 tree fn_context; 5715 5716 /* Find an existing trampoline and return it. */ 5717 for (link = trampoline_list; link; link = TREE_CHAIN (link)) 5718 if (TREE_PURPOSE (link) == function) 5719 return 5720 adjust_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0)); 5721 5722 for (fp = outer_function_chain; fp; fp = fp->outer) 5723 for (link = fp->x_trampoline_list; link; link = TREE_CHAIN (link)) 5724 if (TREE_PURPOSE (link) == function) 5725 { 5726 tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0), 5727 function); 5728 return adjust_trampoline_addr (tramp); 5729 } 5730 5731 /* None exists; we must make one. */ 5732 5733 /* Find the `struct function' for the function containing FUNCTION. */ 5734 fp = 0; 5735 fn_context = decl_function_context (function); 5736 if (fn_context != current_function_decl 5737 && fn_context != inline_function_decl) 5738 fp = find_function_data (fn_context); 5739 5740 /* Allocate run-time space for this trampoline 5741 (usually in the defining function's stack frame). */ 5742 #ifdef ALLOCATE_TRAMPOLINE 5743 tramp = ALLOCATE_TRAMPOLINE (fp); 5744 #else 5745 /* If rounding needed, allocate extra space 5746 to ensure we have TRAMPOLINE_SIZE bytes left after rounding up. */ 5747 #ifdef TRAMPOLINE_ALIGNMENT 5748 #define TRAMPOLINE_REAL_SIZE \ 5749 (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1) 5750 #else 5751 #define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE) 5752 #endif 5753 tramp = assign_stack_local_1 (BLKmode, TRAMPOLINE_REAL_SIZE, 0, 5754 fp ? fp : cfun); 5755 #endif 5756 5757 /* Record the trampoline for reuse and note it for later initialization 5758 by expand_function_end. */ 5759 if (fp != 0) 5760 { 5761 rtlexp = make_node (RTL_EXPR); 5762 RTL_EXPR_RTL (rtlexp) = tramp; 5763 fp->x_trampoline_list = tree_cons (function, rtlexp, 5764 fp->x_trampoline_list); 5765 } 5766 else 5767 { 5768 /* Make the RTL_EXPR node temporary, not momentary, so that the 5769 trampoline_list doesn't become garbage. */ 5770 rtlexp = make_node (RTL_EXPR); 5771 5772 RTL_EXPR_RTL (rtlexp) = tramp; 5773 trampoline_list = tree_cons (function, rtlexp, trampoline_list); 5774 } 5775 5776 tramp = fix_lexical_addr (XEXP (tramp, 0), function); 5777 return adjust_trampoline_addr (tramp); 5778 } 5779 5780 /* Given a trampoline address, 5781 round it to multiple of TRAMPOLINE_ALIGNMENT. */ 5782 5783 static rtx 5784 round_trampoline_addr (tramp) 5785 rtx tramp; 5786 { 5787 #ifdef TRAMPOLINE_ALIGNMENT 5788 /* Round address up to desired boundary. */ 5789 rtx temp = gen_reg_rtx (Pmode); 5790 rtx addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1); 5791 rtx mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT); 5792 5793 temp = expand_simple_binop (Pmode, PLUS, tramp, addend, 5794 temp, 0, OPTAB_LIB_WIDEN); 5795 tramp = expand_simple_binop (Pmode, AND, temp, mask, 5796 temp, 0, OPTAB_LIB_WIDEN); 5797 #endif 5798 return tramp; 5799 } 5800 5801 /* Given a trampoline address, round it then apply any 5802 platform-specific adjustments so that the result can be used for a 5803 function call . */ 5804 5805 static rtx 5806 adjust_trampoline_addr (tramp) 5807 rtx tramp; 5808 { 5809 tramp = round_trampoline_addr (tramp); 5810 #ifdef TRAMPOLINE_ADJUST_ADDRESS 5811 TRAMPOLINE_ADJUST_ADDRESS (tramp); 5812 #endif 5813 return tramp; 5814 } 5815 5816 /* Put all this function's BLOCK nodes including those that are chained 5817 onto the first block into a vector, and return it. 5818 Also store in each NOTE for the beginning or end of a block 5819 the index of that block in the vector. 5820 The arguments are BLOCK, the chain of top-level blocks of the function, 5821 and INSNS, the insn chain of the function. */ 5822 5823 void 5824 identify_blocks () 5825 { 5826 int n_blocks; 5827 tree *block_vector, *last_block_vector; 5828 tree *block_stack; 5829 tree block = DECL_INITIAL (current_function_decl); 5830 5831 if (block == 0) 5832 return; 5833 5834 /* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in 5835 depth-first order. */ 5836 block_vector = get_block_vector (block, &n_blocks); 5837 block_stack = (tree *) xmalloc (n_blocks * sizeof (tree)); 5838 5839 last_block_vector = identify_blocks_1 (get_insns (), 5840 block_vector + 1, 5841 block_vector + n_blocks, 5842 block_stack); 5843 5844 /* If we didn't use all of the subblocks, we've misplaced block notes. */ 5845 /* ??? This appears to happen all the time. Latent bugs elsewhere? */ 5846 if (0 && last_block_vector != block_vector + n_blocks) 5847 abort (); 5848 5849 free (block_vector); 5850 free (block_stack); 5851 } 5852 5853 /* Subroutine of identify_blocks. Do the block substitution on the 5854 insn chain beginning with INSNS. Recurse for CALL_PLACEHOLDER chains. 5855 5856 BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair. 5857 BLOCK_VECTOR is incremented for each block seen. */ 5858 5859 static tree * 5860 identify_blocks_1 (insns, block_vector, end_block_vector, orig_block_stack) 5861 rtx insns; 5862 tree *block_vector; 5863 tree *end_block_vector; 5864 tree *orig_block_stack; 5865 { 5866 rtx insn; 5867 tree *block_stack = orig_block_stack; 5868 5869 for (insn = insns; insn; insn = NEXT_INSN (insn)) 5870 { 5871 if (GET_CODE (insn) == NOTE) 5872 { 5873 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) 5874 { 5875 tree b; 5876 5877 /* If there are more block notes than BLOCKs, something 5878 is badly wrong. */ 5879 if (block_vector == end_block_vector) 5880 abort (); 5881 5882 b = *block_vector++; 5883 NOTE_BLOCK (insn) = b; 5884 *block_stack++ = b; 5885 } 5886 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) 5887 { 5888 /* If there are more NOTE_INSN_BLOCK_ENDs than 5889 NOTE_INSN_BLOCK_BEGs, something is badly wrong. */ 5890 if (block_stack == orig_block_stack) 5891 abort (); 5892 5893 NOTE_BLOCK (insn) = *--block_stack; 5894 } 5895 } 5896 else if (GET_CODE (insn) == CALL_INSN 5897 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER) 5898 { 5899 rtx cp = PATTERN (insn); 5900 5901 block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector, 5902 end_block_vector, block_stack); 5903 if (XEXP (cp, 1)) 5904 block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector, 5905 end_block_vector, block_stack); 5906 if (XEXP (cp, 2)) 5907 block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector, 5908 end_block_vector, block_stack); 5909 } 5910 } 5911 5912 /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs, 5913 something is badly wrong. */ 5914 if (block_stack != orig_block_stack) 5915 abort (); 5916 5917 return block_vector; 5918 } 5919 5920 /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, 5921 and create duplicate blocks. */ 5922 /* ??? Need an option to either create block fragments or to create 5923 abstract origin duplicates of a source block. It really depends 5924 on what optimization has been performed. */ 5925 5926 void 5927 reorder_blocks () 5928 { 5929 tree block = DECL_INITIAL (current_function_decl); 5930 varray_type block_stack; 5931 5932 if (block == NULL_TREE) 5933 return; 5934 5935 VARRAY_TREE_INIT (block_stack, 10, "block_stack"); 5936 5937 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */ 5938 reorder_blocks_0 (block); 5939 5940 /* Prune the old trees away, so that they don't get in the way. */ 5941 BLOCK_SUBBLOCKS (block) = NULL_TREE; 5942 BLOCK_CHAIN (block) = NULL_TREE; 5943 5944 /* Recreate the block tree from the note nesting. */ 5945 reorder_blocks_1 (get_insns (), block, &block_stack); 5946 BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block)); 5947 5948 /* Remove deleted blocks from the block fragment chains. */ 5949 reorder_fix_fragments (block); 5950 5951 VARRAY_FREE (block_stack); 5952 } 5953 5954 /* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */ 5955 5956 static void 5957 reorder_blocks_0 (block) 5958 tree block; 5959 { 5960 while (block) 5961 { 5962 TREE_ASM_WRITTEN (block) = 0; 5963 reorder_blocks_0 (BLOCK_SUBBLOCKS (block)); 5964 block = BLOCK_CHAIN (block); 5965 } 5966 } 5967 5968 static void 5969 reorder_blocks_1 (insns, current_block, p_block_stack) 5970 rtx insns; 5971 tree current_block; 5972 varray_type *p_block_stack; 5973 { 5974 rtx insn; 5975 5976 for (insn = insns; insn; insn = NEXT_INSN (insn)) 5977 { 5978 if (GET_CODE (insn) == NOTE) 5979 { 5980 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) 5981 { 5982 tree block = NOTE_BLOCK (insn); 5983 5984 /* If we have seen this block before, that means it now 5985 spans multiple address regions. Create a new fragment. */ 5986 if (TREE_ASM_WRITTEN (block)) 5987 { 5988 tree new_block = copy_node (block); 5989 tree origin; 5990 5991 origin = (BLOCK_FRAGMENT_ORIGIN (block) 5992 ? BLOCK_FRAGMENT_ORIGIN (block) 5993 : block); 5994 BLOCK_FRAGMENT_ORIGIN (new_block) = origin; 5995 BLOCK_FRAGMENT_CHAIN (new_block) 5996 = BLOCK_FRAGMENT_CHAIN (origin); 5997 BLOCK_FRAGMENT_CHAIN (origin) = new_block; 5998 5999 NOTE_BLOCK (insn) = new_block; 6000 block = new_block; 6001 } 6002 6003 BLOCK_SUBBLOCKS (block) = 0; 6004 TREE_ASM_WRITTEN (block) = 1; 6005 BLOCK_SUPERCONTEXT (block) = current_block; 6006 BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); 6007 BLOCK_SUBBLOCKS (current_block) = block; 6008 current_block = block; 6009 VARRAY_PUSH_TREE (*p_block_stack, block); 6010 } 6011 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) 6012 { 6013 NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack); 6014 VARRAY_POP (*p_block_stack); 6015 BLOCK_SUBBLOCKS (current_block) 6016 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); 6017 current_block = BLOCK_SUPERCONTEXT (current_block); 6018 } 6019 } 6020 else if (GET_CODE (insn) == CALL_INSN 6021 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER) 6022 { 6023 rtx cp = PATTERN (insn); 6024 reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack); 6025 if (XEXP (cp, 1)) 6026 reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack); 6027 if (XEXP (cp, 2)) 6028 reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack); 6029 } 6030 } 6031 } 6032 6033 /* Rationalize BLOCK_FRAGMENT_ORIGIN. If an origin block no longer 6034 appears in the block tree, select one of the fragments to become 6035 the new origin block. */ 6036 6037 static void 6038 reorder_fix_fragments (block) 6039 tree block; 6040 { 6041 while (block) 6042 { 6043 tree dup_origin = BLOCK_FRAGMENT_ORIGIN (block); 6044 tree new_origin = NULL_TREE; 6045 6046 if (dup_origin) 6047 { 6048 if (! TREE_ASM_WRITTEN (dup_origin)) 6049 { 6050 new_origin = BLOCK_FRAGMENT_CHAIN (dup_origin); 6051 6052 /* Find the first of the remaining fragments. There must 6053 be at least one -- the current block. */ 6054 while (! TREE_ASM_WRITTEN (new_origin)) 6055 new_origin = BLOCK_FRAGMENT_CHAIN (new_origin); 6056 BLOCK_FRAGMENT_ORIGIN (new_origin) = NULL_TREE; 6057 } 6058 } 6059 else if (! dup_origin) 6060 new_origin = block; 6061 6062 /* Re-root the rest of the fragments to the new origin. In the 6063 case that DUP_ORIGIN was null, that means BLOCK was the origin 6064 of a chain of fragments and we want to remove those fragments 6065 that didn't make it to the output. */ 6066 if (new_origin) 6067 { 6068 tree *pp = &BLOCK_FRAGMENT_CHAIN (new_origin); 6069 tree chain = *pp; 6070 6071 while (chain) 6072 { 6073 if (TREE_ASM_WRITTEN (chain)) 6074 { 6075 BLOCK_FRAGMENT_ORIGIN (chain) = new_origin; 6076 *pp = chain; 6077 pp = &BLOCK_FRAGMENT_CHAIN (chain); 6078 } 6079 chain = BLOCK_FRAGMENT_CHAIN (chain); 6080 } 6081 *pp = NULL_TREE; 6082 } 6083 6084 reorder_fix_fragments (BLOCK_SUBBLOCKS (block)); 6085 block = BLOCK_CHAIN (block); 6086 } 6087 } 6088 6089 /* Reverse the order of elements in the chain T of blocks, 6090 and return the new head of the chain (old last element). */ 6091 6092 static tree 6093 blocks_nreverse (t) 6094 tree t; 6095 { 6096 tree prev = 0, decl, next; 6097 for (decl = t; decl; decl = next) 6098 { 6099 next = BLOCK_CHAIN (decl); 6100 BLOCK_CHAIN (decl) = prev; 6101 prev = decl; 6102 } 6103 return prev; 6104 } 6105 6106 /* Count the subblocks of the list starting with BLOCK. If VECTOR is 6107 non-NULL, list them all into VECTOR, in a depth-first preorder 6108 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all 6109 blocks. */ 6110 6111 static int 6112 all_blocks (block, vector) 6113 tree block; 6114 tree *vector; 6115 { 6116 int n_blocks = 0; 6117 6118 while (block) 6119 { 6120 TREE_ASM_WRITTEN (block) = 0; 6121 6122 /* Record this block. */ 6123 if (vector) 6124 vector[n_blocks] = block; 6125 6126 ++n_blocks; 6127 6128 /* Record the subblocks, and their subblocks... */ 6129 n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), 6130 vector ? vector + n_blocks : 0); 6131 block = BLOCK_CHAIN (block); 6132 } 6133 6134 return n_blocks; 6135 } 6136 6137 /* Return a vector containing all the blocks rooted at BLOCK. The 6138 number of elements in the vector is stored in N_BLOCKS_P. The 6139 vector is dynamically allocated; it is the caller's responsibility 6140 to call `free' on the pointer returned. */ 6141 6142 static tree * 6143 get_block_vector (block, n_blocks_p) 6144 tree block; 6145 int *n_blocks_p; 6146 { 6147 tree *block_vector; 6148 6149 *n_blocks_p = all_blocks (block, NULL); 6150 block_vector = (tree *) xmalloc (*n_blocks_p * sizeof (tree)); 6151 all_blocks (block, block_vector); 6152 6153 return block_vector; 6154 } 6155 6156 static int next_block_index = 2; 6157 6158 /* Set BLOCK_NUMBER for all the blocks in FN. */ 6159 6160 void 6161 number_blocks (fn) 6162 tree fn; 6163 { 6164 int i; 6165 int n_blocks; 6166 tree *block_vector; 6167 6168 /* For SDB and XCOFF debugging output, we start numbering the blocks 6169 from 1 within each function, rather than keeping a running 6170 count. */ 6171 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 6172 if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) 6173 next_block_index = 1; 6174 #endif 6175 6176 block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks); 6177 6178 /* The top-level BLOCK isn't numbered at all. */ 6179 for (i = 1; i < n_blocks; ++i) 6180 /* We number the blocks from two. */ 6181 BLOCK_NUMBER (block_vector[i]) = next_block_index++; 6182 6183 free (block_vector); 6184 6185 return; 6186 } 6187 6188 /* If VAR is present in a subblock of BLOCK, return the subblock. */ 6189 6190 tree 6191 debug_find_var_in_block_tree (var, block) 6192 tree var; 6193 tree block; 6194 { 6195 tree t; 6196 6197 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) 6198 if (t == var) 6199 return block; 6200 6201 for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t)) 6202 { 6203 tree ret = debug_find_var_in_block_tree (var, t); 6204 if (ret) 6205 return ret; 6206 } 6207 6208 return NULL_TREE; 6209 } 6210 6211 /* Allocate a function structure and reset its contents to the defaults. */ 6212 6213 static void 6214 prepare_function_start () 6215 { 6216 cfun = (struct function *) ggc_alloc_cleared (sizeof (struct function)); 6217 6218 init_stmt_for_function (); 6219 init_eh_for_function (); 6220 6221 cse_not_expected = ! optimize; 6222 6223 /* Caller save not needed yet. */ 6224 caller_save_needed = 0; 6225 6226 /* No stack slots have been made yet. */ 6227 stack_slot_list = 0; 6228 6229 current_function_has_nonlocal_label = 0; 6230 current_function_has_nonlocal_goto = 0; 6231 6232 /* There is no stack slot for handling nonlocal gotos. */ 6233 nonlocal_goto_handler_slots = 0; 6234 nonlocal_goto_stack_level = 0; 6235 6236 /* No labels have been declared for nonlocal use. */ 6237 nonlocal_labels = 0; 6238 nonlocal_goto_handler_labels = 0; 6239 6240 /* No function calls so far in this function. */ 6241 function_call_count = 0; 6242 6243 /* No parm regs have been allocated. 6244 (This is important for output_inline_function.) */ 6245 max_parm_reg = LAST_VIRTUAL_REGISTER + 1; 6246 6247 /* Initialize the RTL mechanism. */ 6248 init_emit (); 6249 6250 /* Initialize the queue of pending postincrement and postdecrements, 6251 and some other info in expr.c. */ 6252 init_expr (); 6253 6254 /* We haven't done register allocation yet. */ 6255 reg_renumber = 0; 6256 6257 init_varasm_status (cfun); 6258 6259 /* Clear out data used for inlining. */ 6260 cfun->inlinable = 0; 6261 cfun->original_decl_initial = 0; 6262 cfun->original_arg_vector = 0; 6263 6264 cfun->stack_alignment_needed = STACK_BOUNDARY; 6265 cfun->preferred_stack_boundary = STACK_BOUNDARY; 6266 6267 /* Set if a call to setjmp is seen. */ 6268 current_function_calls_setjmp = 0; 6269 6270 /* Set if a call to longjmp is seen. */ 6271 current_function_calls_longjmp = 0; 6272 6273 current_function_calls_alloca = 0; 6274 current_function_contains_functions = 0; 6275 current_function_is_leaf = 0; 6276 current_function_nothrow = 0; 6277 current_function_sp_is_unchanging = 0; 6278 current_function_uses_only_leaf_regs = 0; 6279 current_function_has_computed_jump = 0; 6280 current_function_is_thunk = 0; 6281 6282 current_function_returns_pcc_struct = 0; 6283 current_function_returns_struct = 0; 6284 current_function_epilogue_delay_list = 0; 6285 current_function_uses_const_pool = 0; 6286 current_function_uses_pic_offset_table = 0; 6287 current_function_cannot_inline = 0; 6288 6289 /* We have not yet needed to make a label to jump to for tail-recursion. */ 6290 tail_recursion_label = 0; 6291 6292 /* We haven't had a need to make a save area for ap yet. */ 6293 arg_pointer_save_area = 0; 6294 6295 /* No stack slots allocated yet. */ 6296 frame_offset = 0; 6297 6298 /* No SAVE_EXPRs in this function yet. */ 6299 save_expr_regs = 0; 6300 6301 /* No RTL_EXPRs in this function yet. */ 6302 rtl_expr_chain = 0; 6303 6304 /* Set up to allocate temporaries. */ 6305 init_temp_slots (); 6306 6307 /* Indicate that we need to distinguish between the return value of the 6308 present function and the return value of a function being called. */ 6309 rtx_equal_function_value_matters = 1; 6310 6311 /* Indicate that we have not instantiated virtual registers yet. */ 6312 virtuals_instantiated = 0; 6313 6314 /* Indicate that we want CONCATs now. */ 6315 generating_concat_p = 1; 6316 6317 /* Indicate we have no need of a frame pointer yet. */ 6318 frame_pointer_needed = 0; 6319 6320 /* By default assume not varargs or stdarg. */ 6321 current_function_varargs = 0; 6322 current_function_stdarg = 0; 6323 6324 /* We haven't made any trampolines for this function yet. */ 6325 trampoline_list = 0; 6326 6327 init_pending_stack_adjust (); 6328 inhibit_defer_pop = 0; 6329 6330 current_function_outgoing_args_size = 0; 6331 6332 if (init_lang_status) 6333 (*init_lang_status) (cfun); 6334 if (init_machine_status) 6335 (*init_machine_status) (cfun); 6336 } 6337 6338 /* Initialize the rtl expansion mechanism so that we can do simple things 6339 like generate sequences. This is used to provide a context during global 6340 initialization of some passes. */ 6341 void 6342 init_dummy_function_start () 6343 { 6344 prepare_function_start (); 6345 } 6346 6347 /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) 6348 and initialize static variables for generating RTL for the statements 6349 of the function. */ 6350 6351 void 6352 init_function_start (subr, filename, line) 6353 tree subr; 6354 const char *filename; 6355 int line; 6356 { 6357 prepare_function_start (); 6358 6359 current_function_name = (*decl_printable_name) (subr, 2); 6360 cfun->decl = subr; 6361 6362 /* Nonzero if this is a nested function that uses a static chain. */ 6363 6364 current_function_needs_context 6365 = (decl_function_context (current_function_decl) != 0 6366 && ! DECL_NO_STATIC_CHAIN (current_function_decl)); 6367 6368 /* Within function body, compute a type's size as soon it is laid out. */ 6369 immediate_size_expand++; 6370 6371 /* Prevent ever trying to delete the first instruction of a function. 6372 Also tell final how to output a linenum before the function prologue. 6373 Note linenums could be missing, e.g. when compiling a Java .class file. */ 6374 if (line > 0) 6375 emit_line_note (filename, line); 6376 6377 /* Make sure first insn is a note even if we don't want linenums. 6378 This makes sure the first insn will never be deleted. 6379 Also, final expects a note to appear there. */ 6380 emit_note (NULL, NOTE_INSN_DELETED); 6381 6382 /* Set flags used by final.c. */ 6383 if (aggregate_value_p (DECL_RESULT (subr))) 6384 { 6385 #ifdef PCC_STATIC_STRUCT_RETURN 6386 current_function_returns_pcc_struct = 1; 6387 #endif 6388 current_function_returns_struct = 1; 6389 } 6390 6391 /* Warn if this value is an aggregate type, 6392 regardless of which calling convention we are using for it. */ 6393 if (warn_aggregate_return 6394 && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) 6395 warning ("function returns an aggregate"); 6396 6397 current_function_returns_pointer 6398 = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr))); 6399 } 6400 6401 /* Make sure all values used by the optimization passes have sane 6402 defaults. */ 6403 void 6404 init_function_for_compilation () 6405 { 6406 reg_renumber = 0; 6407 6408 /* No prologue/epilogue insns yet. */ 6409 VARRAY_GROW (prologue, 0); 6410 VARRAY_GROW (epilogue, 0); 6411 VARRAY_GROW (sibcall_epilogue, 0); 6412 } 6413 6414 /* Indicate that the current function uses extra args 6415 not explicitly mentioned in the argument list in any fashion. */ 6416 6417 void 6418 mark_varargs () 6419 { 6420 current_function_varargs = 1; 6421 } 6422 6423 /* Expand a call to __main at the beginning of a possible main function. */ 6424 6425 #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main) 6426 #undef HAS_INIT_SECTION 6427 #define HAS_INIT_SECTION 6428 #endif 6429 6430 #ifndef GEN_CALL__MAIN 6431 #define GEN_CALL__MAIN \ 6432 do { \ 6433 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, NAME__MAIN), LCT_NORMAL, \ 6434 VOIDmode, 0); \ 6435 } while (0) 6436 #endif 6437 6438 void 6439 expand_main_function () 6440 { 6441 #ifdef FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN 6442 if (FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN) 6443 { 6444 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 6445 rtx tmp, seq; 6446 6447 start_sequence (); 6448 /* Forcibly align the stack. */ 6449 #ifdef STACK_GROWS_DOWNWARD 6450 tmp = expand_simple_binop (Pmode, AND, stack_pointer_rtx, GEN_INT(-align), 6451 stack_pointer_rtx, 1, OPTAB_WIDEN); 6452 #else 6453 tmp = expand_simple_binop (Pmode, PLUS, stack_pointer_rtx, 6454 GEN_INT (align - 1), NULL_RTX, 1, OPTAB_WIDEN); 6455 tmp = expand_simple_binop (Pmode, AND, tmp, GEN_INT (-align), 6456 stack_pointer_rtx, 1, OPTAB_WIDEN); 6457 #endif 6458 if (tmp != stack_pointer_rtx) 6459 emit_move_insn (stack_pointer_rtx, tmp); 6460 6461 /* Enlist allocate_dynamic_stack_space to pick up the pieces. */ 6462 tmp = force_reg (Pmode, const0_rtx); 6463 allocate_dynamic_stack_space (tmp, NULL_RTX, BIGGEST_ALIGNMENT); 6464 seq = gen_sequence (); 6465 end_sequence (); 6466 6467 for (tmp = get_last_insn (); tmp; tmp = PREV_INSN (tmp)) 6468 if (NOTE_P (tmp) && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_FUNCTION_BEG) 6469 break; 6470 if (tmp) 6471 emit_insn_before (seq, tmp); 6472 else 6473 emit_insn (seq); 6474 } 6475 #endif 6476 6477 #if defined(INVOKE__main) || !defined (HAS_INIT_SECTION) 6478 GEN_CALL__MAIN; 6479 #endif 6480 } 6481 6482 extern struct obstack permanent_obstack; 6483 6484 /* The PENDING_SIZES represent the sizes of variable-sized types. 6485 Create RTL for the various sizes now (using temporary variables), 6486 so that we can refer to the sizes from the RTL we are generating 6487 for the current function. The PENDING_SIZES are a TREE_LIST. The 6488 TREE_VALUE of each node is a SAVE_EXPR. */ 6489 6490 void 6491 expand_pending_sizes (pending_sizes) 6492 tree pending_sizes; 6493 { 6494 tree tem; 6495 6496 /* Evaluate now the sizes of any types declared among the arguments. */ 6497 for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem)) 6498 { 6499 expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0); 6500 /* Flush the queue in case this parameter declaration has 6501 side-effects. */ 6502 emit_queue (); 6503 } 6504 } 6505 6506 /* Start the RTL for a new function, and set variables used for 6507 emitting RTL. 6508 SUBR is the FUNCTION_DECL node. 6509 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with 6510 the function's parameters, which must be run at any return statement. */ 6511 6512 void 6513 expand_function_start (subr, parms_have_cleanups) 6514 tree subr; 6515 int parms_have_cleanups; 6516 { 6517 tree tem; 6518 rtx last_ptr = NULL_RTX; 6519 6520 /* Make sure volatile mem refs aren't considered 6521 valid operands of arithmetic insns. */ 6522 init_recog_no_volatile (); 6523 6524 current_function_instrument_entry_exit 6525 = (flag_instrument_function_entry_exit 6526 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); 6527 6528 current_function_profile 6529 = (profile_flag 6530 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); 6531 6532 current_function_limit_stack 6533 = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr)); 6534 6535 /* If function gets a static chain arg, store it in the stack frame. 6536 Do this first, so it gets the first stack slot offset. */ 6537 if (current_function_needs_context) 6538 { 6539 last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0); 6540 6541 /* Delay copying static chain if it is not a register to avoid 6542 conflicts with regs used for parameters. */ 6543 if (! SMALL_REGISTER_CLASSES 6544 || GET_CODE (static_chain_incoming_rtx) == REG) 6545 emit_move_insn (last_ptr, static_chain_incoming_rtx); 6546 } 6547 6548 /* If the parameters of this function need cleaning up, get a label 6549 for the beginning of the code which executes those cleanups. This must 6550 be done before doing anything with return_label. */ 6551 if (parms_have_cleanups) 6552 cleanup_label = gen_label_rtx (); 6553 else 6554 cleanup_label = 0; 6555 6556 /* Make the label for return statements to jump to. Do not special 6557 case machines with special return instructions -- they will be 6558 handled later during jump, ifcvt, or epilogue creation. */ 6559 return_label = gen_label_rtx (); 6560 6561 /* Initialize rtx used to return the value. */ 6562 /* Do this before assign_parms so that we copy the struct value address 6563 before any library calls that assign parms might generate. */ 6564 6565 /* Decide whether to return the value in memory or in a register. */ 6566 if (aggregate_value_p (DECL_RESULT (subr))) 6567 { 6568 /* Returning something that won't go in a register. */ 6569 rtx value_address = 0; 6570 6571 #ifdef PCC_STATIC_STRUCT_RETURN 6572 if (current_function_returns_pcc_struct) 6573 { 6574 int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); 6575 value_address = assemble_static_space (size); 6576 } 6577 else 6578 #endif 6579 { 6580 /* Expect to be passed the address of a place to store the value. 6581 If it is passed as an argument, assign_parms will take care of 6582 it. */ 6583 if (struct_value_incoming_rtx) 6584 { 6585 value_address = gen_reg_rtx (Pmode); 6586 emit_move_insn (value_address, struct_value_incoming_rtx); 6587 } 6588 } 6589 if (value_address) 6590 { 6591 rtx x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address); 6592 set_mem_attributes (x, DECL_RESULT (subr), 1); 6593 SET_DECL_RTL (DECL_RESULT (subr), x); 6594 } 6595 } 6596 else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) 6597 /* If return mode is void, this decl rtl should not be used. */ 6598 SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX); 6599 else 6600 { 6601 /* Compute the return values into a pseudo reg, which we will copy 6602 into the true return register after the cleanups are done. */ 6603 6604 /* In order to figure out what mode to use for the pseudo, we 6605 figure out what the mode of the eventual return register will 6606 actually be, and use that. */ 6607 rtx hard_reg 6608 = hard_function_value (TREE_TYPE (DECL_RESULT (subr)), 6609 subr, 1); 6610 6611 /* Structures that are returned in registers are not aggregate_value_p, 6612 so we may see a PARALLEL. Don't play pseudo games with this. */ 6613 if (! REG_P (hard_reg)) 6614 SET_DECL_RTL (DECL_RESULT (subr), hard_reg); 6615 else 6616 { 6617 /* Create the pseudo. */ 6618 SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg))); 6619 6620 /* Needed because we may need to move this to memory 6621 in case it's a named return value whose address is taken. */ 6622 DECL_REGISTER (DECL_RESULT (subr)) = 1; 6623 } 6624 } 6625 6626 /* Initialize rtx for parameters and local variables. 6627 In some cases this requires emitting insns. */ 6628 6629 assign_parms (subr); 6630 6631 /* Copy the static chain now if it wasn't a register. The delay is to 6632 avoid conflicts with the parameter passing registers. */ 6633 6634 if (SMALL_REGISTER_CLASSES && current_function_needs_context) 6635 if (GET_CODE (static_chain_incoming_rtx) != REG) 6636 emit_move_insn (last_ptr, static_chain_incoming_rtx); 6637 6638 /* The following was moved from init_function_start. 6639 The move is supposed to make sdb output more accurate. */ 6640 /* Indicate the beginning of the function body, 6641 as opposed to parm setup. */ 6642 emit_note (NULL, NOTE_INSN_FUNCTION_BEG); 6643 6644 if (GET_CODE (get_last_insn ()) != NOTE) 6645 emit_note (NULL, NOTE_INSN_DELETED); 6646 parm_birth_insn = get_last_insn (); 6647 6648 context_display = 0; 6649 if (current_function_needs_context) 6650 { 6651 /* Fetch static chain values for containing functions. */ 6652 tem = decl_function_context (current_function_decl); 6653 /* Copy the static chain pointer into a pseudo. If we have 6654 small register classes, copy the value from memory if 6655 static_chain_incoming_rtx is a REG. */ 6656 if (tem) 6657 { 6658 /* If the static chain originally came in a register, put it back 6659 there, then move it out in the next insn. The reason for 6660 this peculiar code is to satisfy function integration. */ 6661 if (SMALL_REGISTER_CLASSES 6662 && GET_CODE (static_chain_incoming_rtx) == REG) 6663 emit_move_insn (static_chain_incoming_rtx, last_ptr); 6664 last_ptr = copy_to_reg (static_chain_incoming_rtx); 6665 } 6666 6667 while (tem) 6668 { 6669 tree rtlexp = make_node (RTL_EXPR); 6670 6671 RTL_EXPR_RTL (rtlexp) = last_ptr; 6672 context_display = tree_cons (tem, rtlexp, context_display); 6673 tem = decl_function_context (tem); 6674 if (tem == 0) 6675 break; 6676 /* Chain thru stack frames, assuming pointer to next lexical frame 6677 is found at the place we always store it. */ 6678 #ifdef FRAME_GROWS_DOWNWARD 6679 last_ptr = plus_constant (last_ptr, 6680 -(HOST_WIDE_INT) GET_MODE_SIZE (Pmode)); 6681 #endif 6682 last_ptr = gen_rtx_MEM (Pmode, memory_address (Pmode, last_ptr)); 6683 set_mem_alias_set (last_ptr, get_frame_alias_set ()); 6684 last_ptr = copy_to_reg (last_ptr); 6685 6686 /* If we are not optimizing, ensure that we know that this 6687 piece of context is live over the entire function. */ 6688 if (! optimize) 6689 save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr, 6690 save_expr_regs); 6691 } 6692 } 6693 6694 if (current_function_instrument_entry_exit) 6695 { 6696 rtx fun = DECL_RTL (current_function_decl); 6697 if (GET_CODE (fun) == MEM) 6698 fun = XEXP (fun, 0); 6699 else 6700 abort (); 6701 emit_library_call (profile_function_entry_libfunc, LCT_NORMAL, VOIDmode, 6702 2, fun, Pmode, 6703 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, 6704 0, 6705 hard_frame_pointer_rtx), 6706 Pmode); 6707 } 6708 6709 if (current_function_profile) 6710 { 6711 current_function_profile_label_no = profile_label_no++; 6712 #ifdef PROFILE_HOOK 6713 PROFILE_HOOK (current_function_profile_label_no); 6714 #endif 6715 } 6716 6717 /* After the display initializations is where the tail-recursion label 6718 should go, if we end up needing one. Ensure we have a NOTE here 6719 since some things (like trampolines) get placed before this. */ 6720 tail_recursion_reentry = emit_note (NULL, NOTE_INSN_DELETED); 6721 6722 /* Evaluate now the sizes of any types declared among the arguments. */ 6723 expand_pending_sizes (nreverse (get_pending_sizes ())); 6724 6725 /* Make sure there is a line number after the function entry setup code. */ 6726 force_next_line_note (); 6727 } 6728 6729 /* Undo the effects of init_dummy_function_start. */ 6730 void 6731 expand_dummy_function_end () 6732 { 6733 /* End any sequences that failed to be closed due to syntax errors. */ 6734 while (in_sequence_p ()) 6735 end_sequence (); 6736 6737 /* Outside function body, can't compute type's actual size 6738 until next function's body starts. */ 6739 6740 free_after_parsing (cfun); 6741 free_after_compilation (cfun); 6742 cfun = 0; 6743 } 6744 6745 /* Call DOIT for each hard register used as a return value from 6746 the current function. */ 6747 6748 void 6749 diddle_return_value (doit, arg) 6750 void (*doit) PARAMS ((rtx, void *)); 6751 void *arg; 6752 { 6753 rtx outgoing = current_function_return_rtx; 6754 6755 if (! outgoing) 6756 return; 6757 6758 if (GET_CODE (outgoing) == REG) 6759 (*doit) (outgoing, arg); 6760 else if (GET_CODE (outgoing) == PARALLEL) 6761 { 6762 int i; 6763 6764 for (i = 0; i < XVECLEN (outgoing, 0); i++) 6765 { 6766 rtx x = XEXP (XVECEXP (outgoing, 0, i), 0); 6767 6768 if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER) 6769 (*doit) (x, arg); 6770 } 6771 } 6772 } 6773 6774 static void 6775 do_clobber_return_reg (reg, arg) 6776 rtx reg; 6777 void *arg ATTRIBUTE_UNUSED; 6778 { 6779 emit_insn (gen_rtx_CLOBBER (VOIDmode, reg)); 6780 } 6781 6782 void 6783 clobber_return_register () 6784 { 6785 diddle_return_value (do_clobber_return_reg, NULL); 6786 6787 /* In case we do use pseudo to return value, clobber it too. */ 6788 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) 6789 { 6790 tree decl_result = DECL_RESULT (current_function_decl); 6791 rtx decl_rtl = DECL_RTL (decl_result); 6792 if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER) 6793 { 6794 do_clobber_return_reg (decl_rtl, NULL); 6795 } 6796 } 6797 } 6798 6799 static void 6800 do_use_return_reg (reg, arg) 6801 rtx reg; 6802 void *arg ATTRIBUTE_UNUSED; 6803 { 6804 emit_insn (gen_rtx_USE (VOIDmode, reg)); 6805 } 6806 6807 void 6808 use_return_register () 6809 { 6810 diddle_return_value (do_use_return_reg, NULL); 6811 } 6812 6813 /* Generate RTL for the end of the current function. 6814 FILENAME and LINE are the current position in the source file. 6815 6816 It is up to language-specific callers to do cleanups for parameters-- 6817 or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */ 6818 6819 void 6820 expand_function_end (filename, line, end_bindings) 6821 const char *filename; 6822 int line; 6823 int end_bindings; 6824 { 6825 tree link; 6826 rtx clobber_after; 6827 6828 #ifdef TRAMPOLINE_TEMPLATE 6829 static rtx initial_trampoline; 6830 #endif 6831 6832 finish_expr_for_function (); 6833 6834 /* If arg_pointer_save_area was referenced only from a nested 6835 function, we will not have initialized it yet. Do that now. */ 6836 if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init) 6837 get_arg_pointer_save_area (cfun); 6838 6839 #ifdef NON_SAVING_SETJMP 6840 /* Don't put any variables in registers if we call setjmp 6841 on a machine that fails to restore the registers. */ 6842 if (NON_SAVING_SETJMP && current_function_calls_setjmp) 6843 { 6844 if (DECL_INITIAL (current_function_decl) != error_mark_node) 6845 setjmp_protect (DECL_INITIAL (current_function_decl)); 6846 6847 setjmp_protect_args (); 6848 } 6849 #endif 6850 6851 /* Initialize any trampolines required by this function. */ 6852 for (link = trampoline_list; link; link = TREE_CHAIN (link)) 6853 { 6854 tree function = TREE_PURPOSE (link); 6855 rtx context ATTRIBUTE_UNUSED = lookup_static_chain (function); 6856 rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link)); 6857 #ifdef TRAMPOLINE_TEMPLATE 6858 rtx blktramp; 6859 #endif 6860 rtx seq; 6861 6862 #ifdef TRAMPOLINE_TEMPLATE 6863 /* First make sure this compilation has a template for 6864 initializing trampolines. */ 6865 if (initial_trampoline == 0) 6866 { 6867 initial_trampoline 6868 = gen_rtx_MEM (BLKmode, assemble_trampoline_template ()); 6869 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT); 6870 6871 ggc_add_rtx_root (&initial_trampoline, 1); 6872 } 6873 #endif 6874 6875 /* Generate insns to initialize the trampoline. */ 6876 start_sequence (); 6877 tramp = round_trampoline_addr (XEXP (tramp, 0)); 6878 #ifdef TRAMPOLINE_TEMPLATE 6879 blktramp = replace_equiv_address (initial_trampoline, tramp); 6880 emit_block_move (blktramp, initial_trampoline, 6881 GEN_INT (TRAMPOLINE_SIZE)); 6882 #endif 6883 INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context); 6884 seq = get_insns (); 6885 end_sequence (); 6886 6887 /* Put those insns at entry to the containing function (this one). */ 6888 emit_insns_before (seq, tail_recursion_reentry); 6889 } 6890 6891 /* If we are doing stack checking and this function makes calls, 6892 do a stack probe at the start of the function to ensure we have enough 6893 space for another stack frame. */ 6894 if (flag_stack_check && ! STACK_CHECK_BUILTIN) 6895 { 6896 rtx insn, seq; 6897 6898 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 6899 if (GET_CODE (insn) == CALL_INSN) 6900 { 6901 start_sequence (); 6902 probe_stack_range (STACK_CHECK_PROTECT, 6903 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE)); 6904 seq = get_insns (); 6905 end_sequence (); 6906 emit_insns_before (seq, tail_recursion_reentry); 6907 break; 6908 } 6909 } 6910 6911 /* Warn about unused parms if extra warnings were specified. */ 6912 /* Either ``-W -Wunused'' or ``-Wunused-parameter'' enables this 6913 warning. WARN_UNUSED_PARAMETER is negative when set by 6914 -Wunused. */ 6915 if (warn_unused_parameter > 0 6916 || (warn_unused_parameter < 0 && extra_warnings)) 6917 { 6918 tree decl; 6919 6920 for (decl = DECL_ARGUMENTS (current_function_decl); 6921 decl; decl = TREE_CHAIN (decl)) 6922 if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL 6923 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)) 6924 warning_with_decl (decl, "unused parameter `%s'"); 6925 } 6926 6927 /* Delete handlers for nonlocal gotos if nothing uses them. */ 6928 if (nonlocal_goto_handler_slots != 0 6929 && ! current_function_has_nonlocal_label) 6930 delete_handlers (); 6931 6932 /* End any sequences that failed to be closed due to syntax errors. */ 6933 while (in_sequence_p ()) 6934 end_sequence (); 6935 6936 /* Outside function body, can't compute type's actual size 6937 until next function's body starts. */ 6938 immediate_size_expand--; 6939 6940 clear_pending_stack_adjust (); 6941 do_pending_stack_adjust (); 6942 6943 /* Mark the end of the function body. 6944 If control reaches this insn, the function can drop through 6945 without returning a value. */ 6946 emit_note (NULL, NOTE_INSN_FUNCTION_END); 6947 6948 /* Must mark the last line number note in the function, so that the test 6949 coverage code can avoid counting the last line twice. This just tells 6950 the code to ignore the immediately following line note, since there 6951 already exists a copy of this note somewhere above. This line number 6952 note is still needed for debugging though, so we can't delete it. */ 6953 if (flag_test_coverage) 6954 emit_note (NULL, NOTE_INSN_REPEATED_LINE_NUMBER); 6955 6956 /* Output a linenumber for the end of the function. 6957 SDB depends on this. */ 6958 emit_line_note_force (filename, line); 6959 6960 /* Before the return label (if any), clobber the return 6961 registers so that they are not propagated live to the rest of 6962 the function. This can only happen with functions that drop 6963 through; if there had been a return statement, there would 6964 have either been a return rtx, or a jump to the return label. 6965 6966 We delay actual code generation after the current_function_value_rtx 6967 is computed. */ 6968 clobber_after = get_last_insn (); 6969 6970 /* Output the label for the actual return from the function, 6971 if one is expected. This happens either because a function epilogue 6972 is used instead of a return instruction, or because a return was done 6973 with a goto in order to run local cleanups, or because of pcc-style 6974 structure returning. */ 6975 if (return_label) 6976 emit_label (return_label); 6977 6978 /* C++ uses this. */ 6979 if (end_bindings) 6980 expand_end_bindings (0, 0, 0); 6981 6982 if (current_function_instrument_entry_exit) 6983 { 6984 rtx fun = DECL_RTL (current_function_decl); 6985 if (GET_CODE (fun) == MEM) 6986 fun = XEXP (fun, 0); 6987 else 6988 abort (); 6989 emit_library_call (profile_function_exit_libfunc, LCT_NORMAL, VOIDmode, 6990 2, fun, Pmode, 6991 expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, 6992 0, 6993 hard_frame_pointer_rtx), 6994 Pmode); 6995 } 6996 6997 /* Let except.c know where it should emit the call to unregister 6998 the function context for sjlj exceptions. */ 6999 if (flag_exceptions && USING_SJLJ_EXCEPTIONS) 7000 sjlj_emit_function_exit_after (get_last_insn ()); 7001 7002 /* If we had calls to alloca, and this machine needs 7003 an accurate stack pointer to exit the function, 7004 insert some code to save and restore the stack pointer. */ 7005 #ifdef EXIT_IGNORE_STACK 7006 if (! EXIT_IGNORE_STACK) 7007 #endif 7008 if (current_function_calls_alloca) 7009 { 7010 rtx tem = 0; 7011 7012 emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn); 7013 emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX); 7014 } 7015 7016 /* If scalar return value was computed in a pseudo-reg, or was a named 7017 return value that got dumped to the stack, copy that to the hard 7018 return register. */ 7019 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) 7020 { 7021 tree decl_result = DECL_RESULT (current_function_decl); 7022 rtx decl_rtl = DECL_RTL (decl_result); 7023 7024 if (REG_P (decl_rtl) 7025 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER 7026 : DECL_REGISTER (decl_result)) 7027 { 7028 rtx real_decl_rtl = current_function_return_rtx; 7029 7030 /* This should be set in assign_parms. */ 7031 if (! REG_FUNCTION_VALUE_P (real_decl_rtl)) 7032 abort (); 7033 7034 /* If this is a BLKmode structure being returned in registers, 7035 then use the mode computed in expand_return. Note that if 7036 decl_rtl is memory, then its mode may have been changed, 7037 but that current_function_return_rtx has not. */ 7038 if (GET_MODE (real_decl_rtl) == BLKmode) 7039 PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl)); 7040 7041 /* If a named return value dumped decl_return to memory, then 7042 we may need to re-do the PROMOTE_MODE signed/unsigned 7043 extension. */ 7044 if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl)) 7045 { 7046 int unsignedp = TREE_UNSIGNED (TREE_TYPE (decl_result)); 7047 7048 #ifdef PROMOTE_FUNCTION_RETURN 7049 promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl), 7050 &unsignedp, 1); 7051 #endif 7052 7053 convert_move (real_decl_rtl, decl_rtl, unsignedp); 7054 } 7055 else if (GET_CODE (real_decl_rtl) == PARALLEL) 7056 emit_group_load (real_decl_rtl, decl_rtl, 7057 int_size_in_bytes (TREE_TYPE (decl_result))); 7058 else 7059 emit_move_insn (real_decl_rtl, decl_rtl); 7060 } 7061 } 7062 7063 /* If returning a structure, arrange to return the address of the value 7064 in a place where debuggers expect to find it. 7065 7066 If returning a structure PCC style, 7067 the caller also depends on this value. 7068 And current_function_returns_pcc_struct is not necessarily set. */ 7069 if (current_function_returns_struct 7070 || current_function_returns_pcc_struct) 7071 { 7072 rtx value_address 7073 = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0); 7074 tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); 7075 #ifdef FUNCTION_OUTGOING_VALUE 7076 rtx outgoing 7077 = FUNCTION_OUTGOING_VALUE (build_pointer_type (type), 7078 current_function_decl); 7079 #else 7080 rtx outgoing 7081 = FUNCTION_VALUE (build_pointer_type (type), current_function_decl); 7082 #endif 7083 7084 /* Mark this as a function return value so integrate will delete the 7085 assignment and USE below when inlining this function. */ 7086 REG_FUNCTION_VALUE_P (outgoing) = 1; 7087 7088 #ifdef POINTERS_EXTEND_UNSIGNED 7089 /* The address may be ptr_mode and OUTGOING may be Pmode. */ 7090 if (GET_MODE (outgoing) != GET_MODE (value_address)) 7091 value_address = convert_memory_address (GET_MODE (outgoing), 7092 value_address); 7093 #endif 7094 7095 emit_move_insn (outgoing, value_address); 7096 7097 /* Show return register used to hold result (in this case the address 7098 of the result. */ 7099 current_function_return_rtx = outgoing; 7100 } 7101 7102 /* If this is an implementation of throw, do what's necessary to 7103 communicate between __builtin_eh_return and the epilogue. */ 7104 expand_eh_return (); 7105 7106 /* Emit the actual code to clobber return register. */ 7107 { 7108 rtx seq, after; 7109 7110 start_sequence (); 7111 clobber_return_register (); 7112 seq = gen_sequence (); 7113 end_sequence (); 7114 7115 after = emit_insn_after (seq, clobber_after); 7116 7117 if (clobber_after != after) 7118 cfun->x_clobber_return_insn = after; 7119 } 7120 7121 /* ??? This should no longer be necessary since stupid is no longer with 7122 us, but there are some parts of the compiler (eg reload_combine, and 7123 sh mach_dep_reorg) that still try and compute their own lifetime info 7124 instead of using the general framework. */ 7125 use_return_register (); 7126 7127 /* Fix up any gotos that jumped out to the outermost 7128 binding level of the function. 7129 Must follow emitting RETURN_LABEL. */ 7130 7131 /* If you have any cleanups to do at this point, 7132 and they need to create temporary variables, 7133 then you will lose. */ 7134 expand_fixups (get_insns ()); 7135 } 7136 7137 rtx 7138 get_arg_pointer_save_area (f) 7139 struct function *f; 7140 { 7141 rtx ret = f->x_arg_pointer_save_area; 7142 7143 if (! ret) 7144 { 7145 ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f); 7146 f->x_arg_pointer_save_area = ret; 7147 } 7148 7149 if (f == cfun && ! f->arg_pointer_save_area_init) 7150 { 7151 rtx seq; 7152 7153 /* Save the arg pointer at the beginning of the function. The 7154 generated stack slot may not be a valid memory address, so we 7155 have to check it and fix it if necessary. */ 7156 start_sequence (); 7157 emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx); 7158 seq = gen_sequence (); 7159 end_sequence (); 7160 7161 push_topmost_sequence (); 7162 emit_insn_after (seq, get_insns ()); 7163 pop_topmost_sequence (); 7164 } 7165 7166 return ret; 7167 } 7168 7169 /* Extend a vector that records the INSN_UIDs of INSNS (either a 7170 sequence or a single insn). */ 7171 7172 static void 7173 record_insns (insns, vecp) 7174 rtx insns; 7175 varray_type *vecp; 7176 { 7177 if (GET_CODE (insns) == SEQUENCE) 7178 { 7179 int len = XVECLEN (insns, 0); 7180 int i = VARRAY_SIZE (*vecp); 7181 7182 VARRAY_GROW (*vecp, i + len); 7183 while (--len >= 0) 7184 { 7185 VARRAY_INT (*vecp, i) = INSN_UID (XVECEXP (insns, 0, len)); 7186 ++i; 7187 } 7188 } 7189 else 7190 { 7191 int i = VARRAY_SIZE (*vecp); 7192 VARRAY_GROW (*vecp, i + 1); 7193 VARRAY_INT (*vecp, i) = INSN_UID (insns); 7194 } 7195 } 7196 7197 /* Determine how many INSN_UIDs in VEC are part of INSN. */ 7198 7199 static int 7200 contains (insn, vec) 7201 rtx insn; 7202 varray_type vec; 7203 { 7204 int i, j; 7205 7206 if (GET_CODE (insn) == INSN 7207 && GET_CODE (PATTERN (insn)) == SEQUENCE) 7208 { 7209 int count = 0; 7210 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 7211 for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j) 7212 if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j)) 7213 count++; 7214 return count; 7215 } 7216 else 7217 { 7218 for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j) 7219 if (INSN_UID (insn) == VARRAY_INT (vec, j)) 7220 return 1; 7221 } 7222 return 0; 7223 } 7224 7225 int 7226 prologue_epilogue_contains (insn) 7227 rtx insn; 7228 { 7229 if (contains (insn, prologue)) 7230 return 1; 7231 if (contains (insn, epilogue)) 7232 return 1; 7233 return 0; 7234 } 7235 7236 int 7237 sibcall_epilogue_contains (insn) 7238 rtx insn; 7239 { 7240 if (sibcall_epilogue) 7241 return contains (insn, sibcall_epilogue); 7242 return 0; 7243 } 7244 7245 #ifdef HAVE_return 7246 /* Insert gen_return at the end of block BB. This also means updating 7247 block_for_insn appropriately. */ 7248 7249 static void 7250 emit_return_into_block (bb, line_note) 7251 basic_block bb; 7252 rtx line_note; 7253 { 7254 rtx p, end; 7255 7256 p = NEXT_INSN (bb->end); 7257 end = emit_jump_insn_after (gen_return (), bb->end); 7258 if (line_note) 7259 emit_line_note_after (NOTE_SOURCE_FILE (line_note), 7260 NOTE_LINE_NUMBER (line_note), PREV_INSN (bb->end)); 7261 } 7262 #endif /* HAVE_return */ 7263 7264 #if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) 7265 7266 /* These functions convert the epilogue into a variant that does not modify the 7267 stack pointer. This is used in cases where a function returns an object 7268 whose size is not known until it is computed. The called function leaves the 7269 object on the stack, leaves the stack depressed, and returns a pointer to 7270 the object. 7271 7272 What we need to do is track all modifications and references to the stack 7273 pointer, deleting the modifications and changing the references to point to 7274 the location the stack pointer would have pointed to had the modifications 7275 taken place. 7276 7277 These functions need to be portable so we need to make as few assumptions 7278 about the epilogue as we can. However, the epilogue basically contains 7279 three things: instructions to reset the stack pointer, instructions to 7280 reload registers, possibly including the frame pointer, and an 7281 instruction to return to the caller. 7282 7283 If we can't be sure of what a relevant epilogue insn is doing, we abort. 7284 We also make no attempt to validate the insns we make since if they are 7285 invalid, we probably can't do anything valid. The intent is that these 7286 routines get "smarter" as more and more machines start to use them and 7287 they try operating on different epilogues. 7288 7289 We use the following structure to track what the part of the epilogue that 7290 we've already processed has done. We keep two copies of the SP equivalence, 7291 one for use during the insn we are processing and one for use in the next 7292 insn. The difference is because one part of a PARALLEL may adjust SP 7293 and the other may use it. */ 7294 7295 struct epi_info 7296 { 7297 rtx sp_equiv_reg; /* REG that SP is set from, perhaps SP. */ 7298 HOST_WIDE_INT sp_offset; /* Offset from SP_EQUIV_REG of present SP. */ 7299 rtx new_sp_equiv_reg; /* REG to be used at end of insn. */ 7300 HOST_WIDE_INT new_sp_offset; /* Offset to be used at end of insn. */ 7301 rtx equiv_reg_src; /* If nonzero, the value that SP_EQUIV_REG 7302 should be set to once we no longer need 7303 its value. */ 7304 }; 7305 7306 static void handle_epilogue_set PARAMS ((rtx, struct epi_info *)); 7307 static void emit_equiv_load PARAMS ((struct epi_info *)); 7308 7309 /* Modify SEQ, a SEQUENCE that is part of the epilogue, to no modifications 7310 to the stack pointer. Return the new sequence. */ 7311 7312 static rtx 7313 keep_stack_depressed (seq) 7314 rtx seq; 7315 { 7316 int i, j; 7317 struct epi_info info; 7318 7319 /* If the epilogue is just a single instruction, it ust be OK as is. */ 7320 7321 if (GET_CODE (seq) != SEQUENCE) 7322 return seq; 7323 7324 /* Otherwise, start a sequence, initialize the information we have, and 7325 process all the insns we were given. */ 7326 start_sequence (); 7327 7328 info.sp_equiv_reg = stack_pointer_rtx; 7329 info.sp_offset = 0; 7330 info.equiv_reg_src = 0; 7331 7332 for (i = 0; i < XVECLEN (seq, 0); i++) 7333 { 7334 rtx insn = XVECEXP (seq, 0, i); 7335 7336 if (!INSN_P (insn)) 7337 { 7338 add_insn (insn); 7339 continue; 7340 } 7341 7342 /* If this insn references the register that SP is equivalent to and 7343 we have a pending load to that register, we must force out the load 7344 first and then indicate we no longer know what SP's equivalent is. */ 7345 if (info.equiv_reg_src != 0 7346 && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn))) 7347 { 7348 emit_equiv_load (&info); 7349 info.sp_equiv_reg = 0; 7350 } 7351 7352 info.new_sp_equiv_reg = info.sp_equiv_reg; 7353 info.new_sp_offset = info.sp_offset; 7354 7355 /* If this is a (RETURN) and the return address is on the stack, 7356 update the address and change to an indirect jump. */ 7357 if (GET_CODE (PATTERN (insn)) == RETURN 7358 || (GET_CODE (PATTERN (insn)) == PARALLEL 7359 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN)) 7360 { 7361 rtx retaddr = INCOMING_RETURN_ADDR_RTX; 7362 rtx base = 0; 7363 HOST_WIDE_INT offset = 0; 7364 rtx jump_insn, jump_set; 7365 7366 /* If the return address is in a register, we can emit the insn 7367 unchanged. Otherwise, it must be a MEM and we see what the 7368 base register and offset are. In any case, we have to emit any 7369 pending load to the equivalent reg of SP, if any. */ 7370 if (GET_CODE (retaddr) == REG) 7371 { 7372 emit_equiv_load (&info); 7373 add_insn (insn); 7374 continue; 7375 } 7376 else if (GET_CODE (retaddr) == MEM 7377 && GET_CODE (XEXP (retaddr, 0)) == REG) 7378 base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0; 7379 else if (GET_CODE (retaddr) == MEM 7380 && GET_CODE (XEXP (retaddr, 0)) == PLUS 7381 && GET_CODE (XEXP (XEXP (retaddr, 0), 0)) == REG 7382 && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT) 7383 { 7384 base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0))); 7385 offset = INTVAL (XEXP (XEXP (retaddr, 0), 1)); 7386 } 7387 else 7388 abort (); 7389 7390 /* If the base of the location containing the return pointer 7391 is SP, we must update it with the replacement address. Otherwise, 7392 just build the necessary MEM. */ 7393 retaddr = plus_constant (base, offset); 7394 if (base == stack_pointer_rtx) 7395 retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx, 7396 plus_constant (info.sp_equiv_reg, 7397 info.sp_offset)); 7398 7399 retaddr = gen_rtx_MEM (Pmode, retaddr); 7400 7401 /* If there is a pending load to the equivalent register for SP 7402 and we reference that register, we must load our address into 7403 a scratch register and then do that load. */ 7404 if (info.equiv_reg_src 7405 && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr)) 7406 { 7407 unsigned int regno; 7408 rtx reg; 7409 7410 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 7411 if (HARD_REGNO_MODE_OK (regno, Pmode) 7412 && !fixed_regs[regno] 7413 && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno) 7414 && !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start, 7415 regno) 7416 && !refers_to_regno_p (regno, 7417 regno + HARD_REGNO_NREGS (regno, 7418 Pmode), 7419 info.equiv_reg_src, NULL)) 7420 break; 7421 7422 if (regno == FIRST_PSEUDO_REGISTER) 7423 abort (); 7424 7425 reg = gen_rtx_REG (Pmode, regno); 7426 emit_move_insn (reg, retaddr); 7427 retaddr = reg; 7428 } 7429 7430 emit_equiv_load (&info); 7431 jump_insn = emit_jump_insn (gen_indirect_jump (retaddr)); 7432 7433 /* Show the SET in the above insn is a RETURN. */ 7434 jump_set = single_set (jump_insn); 7435 if (jump_set == 0) 7436 abort (); 7437 else 7438 SET_IS_RETURN_P (jump_set) = 1; 7439 } 7440 7441 /* If SP is not mentioned in the pattern and its equivalent register, if 7442 any, is not modified, just emit it. Otherwise, if neither is set, 7443 replace the reference to SP and emit the insn. If none of those are 7444 true, handle each SET individually. */ 7445 else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn)) 7446 && (info.sp_equiv_reg == stack_pointer_rtx 7447 || !reg_set_p (info.sp_equiv_reg, insn))) 7448 add_insn (insn); 7449 else if (! reg_set_p (stack_pointer_rtx, insn) 7450 && (info.sp_equiv_reg == stack_pointer_rtx 7451 || !reg_set_p (info.sp_equiv_reg, insn))) 7452 { 7453 if (! validate_replace_rtx (stack_pointer_rtx, 7454 plus_constant (info.sp_equiv_reg, 7455 info.sp_offset), 7456 insn)) 7457 abort (); 7458 7459 add_insn (insn); 7460 } 7461 else if (GET_CODE (PATTERN (insn)) == SET) 7462 handle_epilogue_set (PATTERN (insn), &info); 7463 else if (GET_CODE (PATTERN (insn)) == PARALLEL) 7464 { 7465 for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++) 7466 if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET) 7467 handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info); 7468 } 7469 else 7470 add_insn (insn); 7471 7472 info.sp_equiv_reg = info.new_sp_equiv_reg; 7473 info.sp_offset = info.new_sp_offset; 7474 } 7475 7476 seq = gen_sequence (); 7477 end_sequence (); 7478 return seq; 7479 } 7480 7481 /* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info 7482 structure that contains information about what we've seen so far. We 7483 process this SET by either updating that data or by emitting one or 7484 more insns. */ 7485 7486 static void 7487 handle_epilogue_set (set, p) 7488 rtx set; 7489 struct epi_info *p; 7490 { 7491 /* First handle the case where we are setting SP. Record what it is being 7492 set from. If unknown, abort. */ 7493 if (reg_set_p (stack_pointer_rtx, set)) 7494 { 7495 if (SET_DEST (set) != stack_pointer_rtx) 7496 abort (); 7497 7498 if (GET_CODE (SET_SRC (set)) == PLUS 7499 && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT) 7500 { 7501 p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0); 7502 p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1)); 7503 } 7504 else 7505 p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0; 7506 7507 /* If we are adjusting SP, we adjust from the old data. */ 7508 if (p->new_sp_equiv_reg == stack_pointer_rtx) 7509 { 7510 p->new_sp_equiv_reg = p->sp_equiv_reg; 7511 p->new_sp_offset += p->sp_offset; 7512 } 7513 7514 if (p->new_sp_equiv_reg == 0 || GET_CODE (p->new_sp_equiv_reg) != REG) 7515 abort (); 7516 7517 return; 7518 } 7519 7520 /* Next handle the case where we are setting SP's equivalent register. 7521 If we already have a value to set it to, abort. We could update, but 7522 there seems little point in handling that case. Note that we have 7523 to allow for the case where we are setting the register set in 7524 the previous part of a PARALLEL inside a single insn. But use the 7525 old offset for any updates within this insn. */ 7526 else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set)) 7527 { 7528 if (!rtx_equal_p (p->new_sp_equiv_reg, SET_DEST (set)) 7529 || p->equiv_reg_src != 0) 7530 abort (); 7531 else 7532 p->equiv_reg_src 7533 = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, 7534 plus_constant (p->sp_equiv_reg, 7535 p->sp_offset)); 7536 } 7537 7538 /* Otherwise, replace any references to SP in the insn to its new value 7539 and emit the insn. */ 7540 else 7541 { 7542 SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, 7543 plus_constant (p->sp_equiv_reg, 7544 p->sp_offset)); 7545 SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx, 7546 plus_constant (p->sp_equiv_reg, 7547 p->sp_offset)); 7548 emit_insn (set); 7549 } 7550 } 7551 7552 /* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */ 7553 7554 static void 7555 emit_equiv_load (p) 7556 struct epi_info *p; 7557 { 7558 if (p->equiv_reg_src != 0) 7559 emit_move_insn (p->sp_equiv_reg, p->equiv_reg_src); 7560 7561 p->equiv_reg_src = 0; 7562 } 7563 #endif 7564 7565 /* Generate the prologue and epilogue RTL if the machine supports it. Thread 7566 this into place with notes indicating where the prologue ends and where 7567 the epilogue begins. Update the basic block information when possible. */ 7568 7569 void 7570 thread_prologue_and_epilogue_insns (f) 7571 rtx f ATTRIBUTE_UNUSED; 7572 { 7573 int inserted = 0; 7574 edge e; 7575 #if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue) 7576 rtx seq; 7577 #endif 7578 #ifdef HAVE_prologue 7579 rtx prologue_end = NULL_RTX; 7580 #endif 7581 #if defined (HAVE_epilogue) || defined(HAVE_return) 7582 rtx epilogue_end = NULL_RTX; 7583 #endif 7584 7585 #ifdef HAVE_prologue 7586 if (HAVE_prologue) 7587 { 7588 start_sequence (); 7589 seq = gen_prologue (); 7590 emit_insn (seq); 7591 7592 /* Retain a map of the prologue insns. */ 7593 if (GET_CODE (seq) != SEQUENCE) 7594 seq = get_insns (); 7595 record_insns (seq, &prologue); 7596 prologue_end = emit_note (NULL, NOTE_INSN_PROLOGUE_END); 7597 7598 seq = gen_sequence (); 7599 end_sequence (); 7600 7601 /* Can't deal with multiple successors of the entry block 7602 at the moment. Function should always have at least one 7603 entry point. */ 7604 if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next) 7605 abort (); 7606 7607 insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ); 7608 inserted = 1; 7609 } 7610 #endif 7611 7612 /* If the exit block has no non-fake predecessors, we don't need 7613 an epilogue. */ 7614 for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) 7615 if ((e->flags & EDGE_FAKE) == 0) 7616 break; 7617 if (e == NULL) 7618 goto epilogue_done; 7619 7620 #ifdef HAVE_return 7621 if (optimize && HAVE_return) 7622 { 7623 /* If we're allowed to generate a simple return instruction, 7624 then by definition we don't need a full epilogue. Examine 7625 the block that falls through to EXIT. If it does not 7626 contain any code, examine its predecessors and try to 7627 emit (conditional) return instructions. */ 7628 7629 basic_block last; 7630 edge e_next; 7631 rtx label; 7632 7633 for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) 7634 if (e->flags & EDGE_FALLTHRU) 7635 break; 7636 if (e == NULL) 7637 goto epilogue_done; 7638 last = e->src; 7639 7640 /* Verify that there are no active instructions in the last block. */ 7641 label = last->end; 7642 while (label && GET_CODE (label) != CODE_LABEL) 7643 { 7644 if (active_insn_p (label)) 7645 break; 7646 label = PREV_INSN (label); 7647 } 7648 7649 if (last->head == label && GET_CODE (label) == CODE_LABEL) 7650 { 7651 rtx epilogue_line_note = NULL_RTX; 7652 7653 /* Locate the line number associated with the closing brace, 7654 if we can find one. */ 7655 for (seq = get_last_insn (); 7656 seq && ! active_insn_p (seq); 7657 seq = PREV_INSN (seq)) 7658 if (GET_CODE (seq) == NOTE && NOTE_LINE_NUMBER (seq) > 0) 7659 { 7660 epilogue_line_note = seq; 7661 break; 7662 } 7663 7664 for (e = last->pred; e; e = e_next) 7665 { 7666 basic_block bb = e->src; 7667 rtx jump; 7668 7669 e_next = e->pred_next; 7670 if (bb == ENTRY_BLOCK_PTR) 7671 continue; 7672 7673 jump = bb->end; 7674 if ((GET_CODE (jump) != JUMP_INSN) || JUMP_LABEL (jump) != label) 7675 continue; 7676 7677 /* If we have an unconditional jump, we can replace that 7678 with a simple return instruction. */ 7679 if (simplejump_p (jump)) 7680 { 7681 emit_return_into_block (bb, epilogue_line_note); 7682 delete_insn (jump); 7683 } 7684 7685 /* If we have a conditional jump, we can try to replace 7686 that with a conditional return instruction. */ 7687 else if (condjump_p (jump)) 7688 { 7689 rtx ret, *loc; 7690 7691 ret = SET_SRC (PATTERN (jump)); 7692 if (GET_CODE (XEXP (ret, 1)) == LABEL_REF) 7693 loc = &XEXP (ret, 1); 7694 else 7695 loc = &XEXP (ret, 2); 7696 ret = gen_rtx_RETURN (VOIDmode); 7697 7698 if (! validate_change (jump, loc, ret, 0)) 7699 continue; 7700 if (JUMP_LABEL (jump)) 7701 LABEL_NUSES (JUMP_LABEL (jump))--; 7702 7703 /* If this block has only one successor, it both jumps 7704 and falls through to the fallthru block, so we can't 7705 delete the edge. */ 7706 if (bb->succ->succ_next == NULL) 7707 continue; 7708 } 7709 else 7710 continue; 7711 7712 /* Fix up the CFG for the successful change we just made. */ 7713 redirect_edge_succ (e, EXIT_BLOCK_PTR); 7714 } 7715 7716 /* Emit a return insn for the exit fallthru block. Whether 7717 this is still reachable will be determined later. */ 7718 7719 emit_barrier_after (last->end); 7720 emit_return_into_block (last, epilogue_line_note); 7721 epilogue_end = last->end; 7722 last->succ->flags &= ~EDGE_FALLTHRU; 7723 goto epilogue_done; 7724 } 7725 } 7726 #endif 7727 #ifdef HAVE_epilogue 7728 if (HAVE_epilogue) 7729 { 7730 /* Find the edge that falls through to EXIT. Other edges may exist 7731 due to RETURN instructions, but those don't need epilogues. 7732 There really shouldn't be a mixture -- either all should have 7733 been converted or none, however... */ 7734 7735 for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) 7736 if (e->flags & EDGE_FALLTHRU) 7737 break; 7738 if (e == NULL) 7739 goto epilogue_done; 7740 7741 start_sequence (); 7742 epilogue_end = emit_note (NULL, NOTE_INSN_EPILOGUE_BEG); 7743 7744 seq = gen_epilogue (); 7745 7746 #ifdef INCOMING_RETURN_ADDR_RTX 7747 /* If this function returns with the stack depressed and we can support 7748 it, massage the epilogue to actually do that. */ 7749 if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE 7750 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl))) 7751 seq = keep_stack_depressed (seq); 7752 #endif 7753 7754 emit_jump_insn (seq); 7755 7756 /* Retain a map of the epilogue insns. */ 7757 if (GET_CODE (seq) != SEQUENCE) 7758 seq = get_insns (); 7759 record_insns (seq, &epilogue); 7760 7761 seq = gen_sequence (); 7762 end_sequence (); 7763 7764 insert_insn_on_edge (seq, e); 7765 inserted = 1; 7766 } 7767 #endif 7768 epilogue_done: 7769 7770 if (inserted) 7771 commit_edge_insertions (); 7772 7773 #ifdef HAVE_sibcall_epilogue 7774 /* Emit sibling epilogues before any sibling call sites. */ 7775 for (e = EXIT_BLOCK_PTR->pred; e; e = e->pred_next) 7776 { 7777 basic_block bb = e->src; 7778 rtx insn = bb->end; 7779 rtx i; 7780 rtx newinsn; 7781 7782 if (GET_CODE (insn) != CALL_INSN 7783 || ! SIBLING_CALL_P (insn)) 7784 continue; 7785 7786 start_sequence (); 7787 seq = gen_sibcall_epilogue (); 7788 end_sequence (); 7789 7790 i = PREV_INSN (insn); 7791 newinsn = emit_insn_before (seq, insn); 7792 7793 /* Retain a map of the epilogue insns. Used in life analysis to 7794 avoid getting rid of sibcall epilogue insns. */ 7795 record_insns (GET_CODE (seq) == SEQUENCE 7796 ? seq : newinsn, &sibcall_epilogue); 7797 } 7798 #endif 7799 7800 #ifdef HAVE_prologue 7801 if (prologue_end) 7802 { 7803 rtx insn, prev; 7804 7805 /* GDB handles `break f' by setting a breakpoint on the first 7806 line note after the prologue. Which means (1) that if 7807 there are line number notes before where we inserted the 7808 prologue we should move them, and (2) we should generate a 7809 note before the end of the first basic block, if there isn't 7810 one already there. 7811 7812 ??? This behaviour is completely broken when dealing with 7813 multiple entry functions. We simply place the note always 7814 into first basic block and let alternate entry points 7815 to be missed. 7816 */ 7817 7818 for (insn = prologue_end; insn; insn = prev) 7819 { 7820 prev = PREV_INSN (insn); 7821 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 7822 { 7823 /* Note that we cannot reorder the first insn in the 7824 chain, since rest_of_compilation relies on that 7825 remaining constant. */ 7826 if (prev == NULL) 7827 break; 7828 reorder_insns (insn, insn, prologue_end); 7829 } 7830 } 7831 7832 /* Find the last line number note in the first block. */ 7833 for (insn = BASIC_BLOCK (0)->end; 7834 insn != prologue_end && insn; 7835 insn = PREV_INSN (insn)) 7836 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 7837 break; 7838 7839 /* If we didn't find one, make a copy of the first line number 7840 we run across. */ 7841 if (! insn) 7842 { 7843 for (insn = next_active_insn (prologue_end); 7844 insn; 7845 insn = PREV_INSN (insn)) 7846 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 7847 { 7848 emit_line_note_after (NOTE_SOURCE_FILE (insn), 7849 NOTE_LINE_NUMBER (insn), 7850 prologue_end); 7851 break; 7852 } 7853 } 7854 } 7855 #endif 7856 #ifdef HAVE_epilogue 7857 if (epilogue_end) 7858 { 7859 rtx insn, next; 7860 7861 /* Similarly, move any line notes that appear after the epilogue. 7862 There is no need, however, to be quite so anal about the existence 7863 of such a note. */ 7864 for (insn = epilogue_end; insn; insn = next) 7865 { 7866 next = NEXT_INSN (insn); 7867 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) 7868 reorder_insns (insn, insn, PREV_INSN (epilogue_end)); 7869 } 7870 } 7871 #endif 7872 } 7873 7874 /* Reposition the prologue-end and epilogue-begin notes after instruction 7875 scheduling and delayed branch scheduling. */ 7876 7877 void 7878 reposition_prologue_and_epilogue_notes (f) 7879 rtx f ATTRIBUTE_UNUSED; 7880 { 7881 #if defined (HAVE_prologue) || defined (HAVE_epilogue) 7882 rtx insn, last, note; 7883 int len; 7884 7885 if ((len = VARRAY_SIZE (prologue)) > 0) 7886 { 7887 last = 0, note = 0; 7888 7889 /* Scan from the beginning until we reach the last prologue insn. 7890 We apparently can't depend on basic_block_{head,end} after 7891 reorg has run. */ 7892 for (insn = f; insn; insn = NEXT_INSN (insn)) 7893 { 7894 if (GET_CODE (insn) == NOTE) 7895 { 7896 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) 7897 note = insn; 7898 } 7899 else if (contains (insn, prologue)) 7900 { 7901 last = insn; 7902 if (--len == 0) 7903 break; 7904 } 7905 } 7906 7907 if (last) 7908 { 7909 rtx next; 7910 7911 /* Find the prologue-end note if we haven't already, and 7912 move it to just after the last prologue insn. */ 7913 if (note == 0) 7914 { 7915 for (note = last; (note = NEXT_INSN (note));) 7916 if (GET_CODE (note) == NOTE 7917 && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END) 7918 break; 7919 } 7920 7921 next = NEXT_INSN (note); 7922 7923 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */ 7924 if (GET_CODE (last) == CODE_LABEL) 7925 last = NEXT_INSN (last); 7926 reorder_insns (note, note, last); 7927 } 7928 } 7929 7930 if ((len = VARRAY_SIZE (epilogue)) > 0) 7931 { 7932 last = 0, note = 0; 7933 7934 /* Scan from the end until we reach the first epilogue insn. 7935 We apparently can't depend on basic_block_{head,end} after 7936 reorg has run. */ 7937 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn)) 7938 { 7939 if (GET_CODE (insn) == NOTE) 7940 { 7941 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG) 7942 note = insn; 7943 } 7944 else if (contains (insn, epilogue)) 7945 { 7946 last = insn; 7947 if (--len == 0) 7948 break; 7949 } 7950 } 7951 7952 if (last) 7953 { 7954 /* Find the epilogue-begin note if we haven't already, and 7955 move it to just before the first epilogue insn. */ 7956 if (note == 0) 7957 { 7958 for (note = insn; (note = PREV_INSN (note));) 7959 if (GET_CODE (note) == NOTE 7960 && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG) 7961 break; 7962 } 7963 7964 if (PREV_INSN (last) != note) 7965 reorder_insns (note, note, PREV_INSN (last)); 7966 } 7967 } 7968 #endif /* HAVE_prologue or HAVE_epilogue */ 7969 } 7970 7971 /* Mark P for GC. */ 7972 7973 static void 7974 mark_function_status (p) 7975 struct function *p; 7976 { 7977 struct var_refs_queue *q; 7978 struct temp_slot *t; 7979 int i; 7980 rtx *r; 7981 7982 if (p == 0) 7983 return; 7984 7985 ggc_mark_rtx (p->arg_offset_rtx); 7986 7987 if (p->x_parm_reg_stack_loc) 7988 for (i = p->x_max_parm_reg, r = p->x_parm_reg_stack_loc; 7989 i > 0; --i, ++r) 7990 ggc_mark_rtx (*r); 7991 7992 ggc_mark_rtx (p->return_rtx); 7993 ggc_mark_rtx (p->x_cleanup_label); 7994 ggc_mark_rtx (p->x_return_label); 7995 ggc_mark_rtx (p->x_save_expr_regs); 7996 ggc_mark_rtx (p->x_stack_slot_list); 7997 ggc_mark_rtx (p->x_parm_birth_insn); 7998 ggc_mark_rtx (p->x_tail_recursion_label); 7999 ggc_mark_rtx (p->x_tail_recursion_reentry); 8000 ggc_mark_rtx (p->internal_arg_pointer); 8001 ggc_mark_rtx (p->x_arg_pointer_save_area); 8002 ggc_mark_tree (p->x_rtl_expr_chain); 8003 ggc_mark_rtx (p->x_last_parm_insn); 8004 ggc_mark_tree (p->x_context_display); 8005 ggc_mark_tree (p->x_trampoline_list); 8006 ggc_mark_rtx (p->epilogue_delay_list); 8007 ggc_mark_rtx (p->x_clobber_return_insn); 8008 8009 for (t = p->x_temp_slots; t != 0; t = t->next) 8010 { 8011 ggc_mark (t); 8012 ggc_mark_rtx (t->slot); 8013 ggc_mark_rtx (t->address); 8014 ggc_mark_tree (t->rtl_expr); 8015 ggc_mark_tree (t->type); 8016 } 8017 8018 for (q = p->fixup_var_refs_queue; q != 0; q = q->next) 8019 { 8020 ggc_mark (q); 8021 ggc_mark_rtx (q->modified); 8022 } 8023 8024 ggc_mark_rtx (p->x_nonlocal_goto_handler_slots); 8025 ggc_mark_rtx (p->x_nonlocal_goto_handler_labels); 8026 ggc_mark_rtx (p->x_nonlocal_goto_stack_level); 8027 ggc_mark_tree (p->x_nonlocal_labels); 8028 8029 mark_hard_reg_initial_vals (p); 8030 } 8031 8032 /* Mark the struct function pointed to by *ARG for GC, if it is not 8033 NULL. This is used to mark the current function and the outer 8034 function chain. */ 8035 8036 static void 8037 maybe_mark_struct_function (arg) 8038 void *arg; 8039 { 8040 struct function *f = *(struct function **) arg; 8041 8042 if (f == 0) 8043 return; 8044 8045 ggc_mark_struct_function (f); 8046 } 8047 8048 /* Mark a struct function * for GC. This is called from ggc-common.c. */ 8049 8050 void 8051 ggc_mark_struct_function (f) 8052 struct function *f; 8053 { 8054 ggc_mark (f); 8055 ggc_mark_tree (f->decl); 8056 8057 mark_function_status (f); 8058 mark_eh_status (f->eh); 8059 mark_stmt_status (f->stmt); 8060 mark_expr_status (f->expr); 8061 mark_emit_status (f->emit); 8062 mark_varasm_status (f->varasm); 8063 8064 if (mark_machine_status) 8065 (*mark_machine_status) (f); 8066 if (mark_lang_status) 8067 (*mark_lang_status) (f); 8068 8069 if (f->original_arg_vector) 8070 ggc_mark_rtvec ((rtvec) f->original_arg_vector); 8071 if (f->original_decl_initial) 8072 ggc_mark_tree (f->original_decl_initial); 8073 if (f->outer) 8074 ggc_mark_struct_function (f->outer); 8075 } 8076 8077 /* Called once, at initialization, to initialize function.c. */ 8078 8079 void 8080 init_function_once () 8081 { 8082 ggc_add_root (&cfun, 1, sizeof cfun, maybe_mark_struct_function); 8083 ggc_add_root (&outer_function_chain, 1, sizeof outer_function_chain, 8084 maybe_mark_struct_function); 8085 8086 VARRAY_INT_INIT (prologue, 0, "prologue"); 8087 VARRAY_INT_INIT (epilogue, 0, "epilogue"); 8088 VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue"); 8089 } 8090