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