1/* Expands front end tree to back end RTL for GCC. 2 Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4 Free Software Foundation, Inc. 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ 22 23/* $FreeBSD$ */ 24 25/* This file handles the generation of rtl code from tree structure 26 at the level of the function as a whole. 27 It creates the rtl expressions for parameters and auto variables 28 and has full responsibility for allocating stack slots. 29 30 `expand_function_start' is called at the beginning of a function, 31 before the function body is parsed, and `expand_function_end' is 32 called after parsing the body. 33 34 Call `assign_stack_local' to allocate a stack slot for a local variable. 35 This is usually done during the RTL generation for the function body, 36 but it can also be done in the reload pass when a pseudo-register does 37 not get a hard register. */ 38 39#include "config.h" 40#include "system.h" 41#include "coretypes.h" 42#include "tm.h" 43#include "rtl.h" 44#include "tree.h" 45#include "flags.h" 46#include "except.h" 47#include "function.h" 48#include "expr.h" 49#include "optabs.h" 50#include "libfuncs.h" 51#include "regs.h" 52#include "hard-reg-set.h" 53#include "insn-config.h" 54#include "recog.h" 55#include "output.h" 56#include "basic-block.h" 57#include "toplev.h" 58#include "hashtab.h" 59#include "ggc.h" 60#include "tm_p.h" 61#include "integrate.h" 62#include "langhooks.h" 63#include "target.h" 64#include "cfglayout.h" 65#include "tree-gimple.h" 66#include "tree-pass.h" 67#include "predict.h" 68#include "vecprim.h" 69 70#ifndef LOCAL_ALIGNMENT 71#define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT 72#endif 73 74#ifndef STACK_ALIGNMENT_NEEDED 75#define STACK_ALIGNMENT_NEEDED 1 76#endif 77 78#define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) 79 80/* Some systems use __main in a way incompatible with its use in gcc, in these 81 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to 82 give the same symbol without quotes for an alternative entry point. You 83 must define both, or neither. */ 84#ifndef NAME__MAIN 85#define NAME__MAIN "__main" 86#endif 87 88/* Round a value to the lowest integer less than it that is a multiple of 89 the required alignment. Avoid using division in case the value is 90 negative. Assume the alignment is a power of two. */ 91#define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) 92 93/* Similar, but round to the next highest integer that meets the 94 alignment. */ 95#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) 96 97/* Nonzero if function being compiled doesn't contain any calls 98 (ignoring the prologue and epilogue). This is set prior to 99 local register allocation and is valid for the remaining 100 compiler passes. */ 101int current_function_is_leaf; 102 103/* Nonzero if function being compiled doesn't modify the stack pointer 104 (ignoring the prologue and epilogue). This is only valid after 105 life_analysis has run. */ 106int current_function_sp_is_unchanging; 107 108/* Nonzero if the function being compiled is a leaf function which only 109 uses leaf registers. This is valid after reload (specifically after 110 sched2) and is useful only if the port defines LEAF_REGISTERS. */ 111int current_function_uses_only_leaf_regs; 112 113/* Nonzero once virtual register instantiation has been done. 114 assign_stack_local uses frame_pointer_rtx when this is nonzero. 115 calls.c:emit_library_call_value_1 uses it to set up 116 post-instantiation libcalls. */ 117int virtuals_instantiated; 118 119/* Assign unique numbers to labels generated for profiling, debugging, etc. */ 120static GTY(()) int funcdef_no; 121 122/* These variables hold pointers to functions to create and destroy 123 target specific, per-function data structures. */ 124struct machine_function * (*init_machine_status) (void); 125 126/* The currently compiled function. */ 127struct function *cfun = 0; 128 129/* These arrays record the INSN_UIDs of the prologue and epilogue insns. */ 130static VEC(int,heap) *prologue; 131static VEC(int,heap) *epilogue; 132 133/* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue 134 in this function. */ 135static VEC(int,heap) *sibcall_epilogue; 136 137/* In order to evaluate some expressions, such as function calls returning 138 structures in memory, we need to temporarily allocate stack locations. 139 We record each allocated temporary in the following structure. 140 141 Associated with each temporary slot is a nesting level. When we pop up 142 one level, all temporaries associated with the previous level are freed. 143 Normally, all temporaries are freed after the execution of the statement 144 in which they were created. However, if we are inside a ({...}) grouping, 145 the result may be in a temporary and hence must be preserved. If the 146 result could be in a temporary, we preserve it if we can determine which 147 one it is in. If we cannot determine which temporary may contain the 148 result, all temporaries are preserved. A temporary is preserved by 149 pretending it was allocated at the previous nesting level. 150 151 Automatic variables are also assigned temporary slots, at the nesting 152 level where they are defined. They are marked a "kept" so that 153 free_temp_slots will not free them. */ 154 155struct temp_slot GTY(()) 156{ 157 /* Points to next temporary slot. */ 158 struct temp_slot *next; 159 /* Points to previous temporary slot. */ 160 struct temp_slot *prev; 161 162 /* The rtx to used to reference the slot. */ 163 rtx slot; 164 /* The rtx used to represent the address if not the address of the 165 slot above. May be an EXPR_LIST if multiple addresses exist. */ 166 rtx address; 167 /* The alignment (in bits) of the slot. */ 168 unsigned int align; 169 /* The size, in units, of the slot. */ 170 HOST_WIDE_INT size; 171 /* The type of the object in the slot, or zero if it doesn't correspond 172 to a type. We use this to determine whether a slot can be reused. 173 It can be reused if objects of the type of the new slot will always 174 conflict with objects of the type of the old slot. */ 175 tree type; 176 /* Nonzero if this temporary is currently in use. */ 177 char in_use; 178 /* Nonzero if this temporary has its address taken. */ 179 char addr_taken; 180 /* Nesting level at which this slot is being used. */ 181 int level; 182 /* Nonzero if this should survive a call to free_temp_slots. */ 183 int keep; 184 /* The offset of the slot from the frame_pointer, including extra space 185 for alignment. This info is for combine_temp_slots. */ 186 HOST_WIDE_INT base_offset; 187 /* The size of the slot, including extra space for alignment. This 188 info is for combine_temp_slots. */ 189 HOST_WIDE_INT full_size; 190}; 191 192/* Forward declarations. */ 193 194static rtx assign_stack_local_1 (enum machine_mode, HOST_WIDE_INT, int, 195 struct function *); 196static struct temp_slot *find_temp_slot_from_address (rtx); 197static void pad_to_arg_alignment (struct args_size *, int, struct args_size *); 198static void pad_below (struct args_size *, enum machine_mode, tree); 199static void reorder_blocks_1 (rtx, tree, VEC(tree,heap) **); 200static int all_blocks (tree, tree *); 201static tree *get_block_vector (tree, int *); 202extern tree debug_find_var_in_block_tree (tree, tree); 203/* We always define `record_insns' even if it's not used so that we 204 can always export `prologue_epilogue_contains'. */ 205static void record_insns (rtx, VEC(int,heap) **) ATTRIBUTE_UNUSED; 206static int contains (rtx, VEC(int,heap) **); 207#ifdef HAVE_return 208static void emit_return_into_block (basic_block, rtx); 209#endif 210#if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) 211static rtx keep_stack_depressed (rtx); 212#endif 213static void prepare_function_start (tree); 214static void do_clobber_return_reg (rtx, void *); 215static void do_use_return_reg (rtx, void *); 216static void set_insn_locators (rtx, int) ATTRIBUTE_UNUSED; 217 218/* Pointer to chain of `struct function' for containing functions. */ 219struct function *outer_function_chain; 220 221/* Given a function decl for a containing function, 222 return the `struct function' for it. */ 223 224struct function * 225find_function_data (tree decl) 226{ 227 struct function *p; 228 229 for (p = outer_function_chain; p; p = p->outer) 230 if (p->decl == decl) 231 return p; 232 233 gcc_unreachable (); 234} 235 236/* Save the current context for compilation of a nested function. 237 This is called from language-specific code. The caller should use 238 the enter_nested langhook to save any language-specific state, 239 since this function knows only about language-independent 240 variables. */ 241 242void 243push_function_context_to (tree context ATTRIBUTE_UNUSED) 244{ 245 struct function *p; 246 247 if (cfun == 0) 248 init_dummy_function_start (); 249 p = cfun; 250 251 p->outer = outer_function_chain; 252 outer_function_chain = p; 253 254 lang_hooks.function.enter_nested (p); 255 256 cfun = 0; 257} 258 259void 260push_function_context (void) 261{ 262 push_function_context_to (current_function_decl); 263} 264 265/* Restore the last saved context, at the end of a nested function. 266 This function is called from language-specific code. */ 267 268void 269pop_function_context_from (tree context ATTRIBUTE_UNUSED) 270{ 271 struct function *p = outer_function_chain; 272 273 cfun = p; 274 outer_function_chain = p->outer; 275 276 current_function_decl = p->decl; 277 278 lang_hooks.function.leave_nested (p); 279 280 /* Reset variables that have known state during rtx generation. */ 281 virtuals_instantiated = 0; 282 generating_concat_p = 1; 283} 284 285void 286pop_function_context (void) 287{ 288 pop_function_context_from (current_function_decl); 289} 290 291/* Clear out all parts of the state in F that can safely be discarded 292 after the function has been parsed, but not compiled, to let 293 garbage collection reclaim the memory. */ 294 295void 296free_after_parsing (struct function *f) 297{ 298 /* f->expr->forced_labels is used by code generation. */ 299 /* f->emit->regno_reg_rtx is used by code generation. */ 300 /* f->varasm is used by code generation. */ 301 /* f->eh->eh_return_stub_label is used by code generation. */ 302 303 lang_hooks.function.final (f); 304} 305 306/* Clear out all parts of the state in F that can safely be discarded 307 after the function has been compiled, to let garbage collection 308 reclaim the memory. */ 309 310void 311free_after_compilation (struct function *f) 312{ 313 VEC_free (int, heap, prologue); 314 VEC_free (int, heap, epilogue); 315 VEC_free (int, heap, sibcall_epilogue); 316 317 f->eh = NULL; 318 f->expr = NULL; 319 f->emit = NULL; 320 f->varasm = NULL; 321 f->machine = NULL; 322 f->cfg = NULL; 323 324 f->x_avail_temp_slots = NULL; 325 f->x_used_temp_slots = NULL; 326 f->arg_offset_rtx = NULL; 327 f->return_rtx = NULL; 328 f->internal_arg_pointer = NULL; 329 f->x_nonlocal_goto_handler_labels = NULL; 330 f->x_return_label = NULL; 331 f->x_naked_return_label = NULL; 332 f->x_stack_slot_list = NULL; 333 f->x_stack_check_probe_note = NULL; 334 f->x_arg_pointer_save_area = NULL; 335 f->x_parm_birth_insn = NULL; 336 f->epilogue_delay_list = NULL; 337} 338 339/* Allocate fixed slots in the stack frame of the current function. */ 340 341/* Return size needed for stack frame based on slots so far allocated in 342 function F. 343 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; 344 the caller may have to do that. */ 345 346static HOST_WIDE_INT 347get_func_frame_size (struct function *f) 348{ 349 if (FRAME_GROWS_DOWNWARD) 350 return -f->x_frame_offset; 351 else 352 return f->x_frame_offset; 353} 354 355/* Return size needed for stack frame based on slots so far allocated. 356 This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; 357 the caller may have to do that. */ 358 359HOST_WIDE_INT 360get_frame_size (void) 361{ 362 return get_func_frame_size (cfun); 363} 364 365/* Issue an error message and return TRUE if frame OFFSET overflows in 366 the signed target pointer arithmetics for function FUNC. Otherwise 367 return FALSE. */ 368 369bool 370frame_offset_overflow (HOST_WIDE_INT offset, tree func) 371{ 372 unsigned HOST_WIDE_INT size = FRAME_GROWS_DOWNWARD ? -offset : offset; 373 374 if (size > ((unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (Pmode) - 1)) 375 /* Leave room for the fixed part of the frame. */ 376 - 64 * UNITS_PER_WORD) 377 { 378 error ("%Jtotal size of local objects too large", func); 379 return TRUE; 380 } 381 382 return FALSE; 383} 384 385/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it 386 with machine mode MODE. 387 388 ALIGN controls the amount of alignment for the address of the slot: 389 0 means according to MODE, 390 -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, 391 -2 means use BITS_PER_UNIT, 392 positive specifies alignment boundary in bits. 393 394 We do not round to stack_boundary here. 395 396 FUNCTION specifies the function to allocate in. */ 397 398static rtx 399assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align, 400 struct function *function) 401{ 402 rtx x, addr; 403 int bigend_correction = 0; 404 unsigned int alignment; 405 int frame_off, frame_alignment, frame_phase; 406 407 if (align == 0) 408 { 409 tree type; 410 411 if (mode == BLKmode) 412 alignment = BIGGEST_ALIGNMENT; 413 else 414 alignment = GET_MODE_ALIGNMENT (mode); 415 416 /* Allow the target to (possibly) increase the alignment of this 417 stack slot. */ 418 type = lang_hooks.types.type_for_mode (mode, 0); 419 if (type) 420 alignment = LOCAL_ALIGNMENT (type, alignment); 421 422 alignment /= BITS_PER_UNIT; 423 } 424 else if (align == -1) 425 { 426 alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; 427 size = CEIL_ROUND (size, alignment); 428 } 429 else if (align == -2) 430 alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */ 431 else 432 alignment = align / BITS_PER_UNIT; 433 434 if (FRAME_GROWS_DOWNWARD) 435 function->x_frame_offset -= size; 436 437 /* Ignore alignment we can't do with expected alignment of the boundary. */ 438 if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY) 439 alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 440 441 if (function->stack_alignment_needed < alignment * BITS_PER_UNIT) 442 function->stack_alignment_needed = alignment * BITS_PER_UNIT; 443 444 /* Calculate how many bytes the start of local variables is off from 445 stack alignment. */ 446 frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT; 447 frame_off = STARTING_FRAME_OFFSET % frame_alignment; 448 frame_phase = frame_off ? frame_alignment - frame_off : 0; 449 450 /* Round the frame offset to the specified alignment. The default is 451 to always honor requests to align the stack but a port may choose to 452 do its own stack alignment by defining STACK_ALIGNMENT_NEEDED. */ 453 if (STACK_ALIGNMENT_NEEDED 454 || mode != BLKmode 455 || size != 0) 456 { 457 /* We must be careful here, since FRAME_OFFSET might be negative and 458 division with a negative dividend isn't as well defined as we might 459 like. So we instead assume that ALIGNMENT is a power of two and 460 use logical operations which are unambiguous. */ 461 if (FRAME_GROWS_DOWNWARD) 462 function->x_frame_offset 463 = (FLOOR_ROUND (function->x_frame_offset - frame_phase, 464 (unsigned HOST_WIDE_INT) alignment) 465 + frame_phase); 466 else 467 function->x_frame_offset 468 = (CEIL_ROUND (function->x_frame_offset - frame_phase, 469 (unsigned HOST_WIDE_INT) alignment) 470 + frame_phase); 471 } 472 473 /* On a big-endian machine, if we are allocating more space than we will use, 474 use the least significant bytes of those that are allocated. */ 475 if (BYTES_BIG_ENDIAN && mode != BLKmode && GET_MODE_SIZE (mode) < size) 476 bigend_correction = size - GET_MODE_SIZE (mode); 477 478 /* If we have already instantiated virtual registers, return the actual 479 address relative to the frame pointer. */ 480 if (function == cfun && virtuals_instantiated) 481 addr = plus_constant (frame_pointer_rtx, 482 trunc_int_for_mode 483 (frame_offset + bigend_correction 484 + STARTING_FRAME_OFFSET, Pmode)); 485 else 486 addr = plus_constant (virtual_stack_vars_rtx, 487 trunc_int_for_mode 488 (function->x_frame_offset + bigend_correction, 489 Pmode)); 490 491 if (!FRAME_GROWS_DOWNWARD) 492 function->x_frame_offset += size; 493 494 x = gen_rtx_MEM (mode, addr); 495 MEM_NOTRAP_P (x) = 1; 496 497 function->x_stack_slot_list 498 = gen_rtx_EXPR_LIST (VOIDmode, x, function->x_stack_slot_list); 499 500 if (frame_offset_overflow (function->x_frame_offset, function->decl)) 501 function->x_frame_offset = 0; 502 503 return x; 504} 505 506/* Wrapper around assign_stack_local_1; assign a local stack slot for the 507 current function. */ 508 509rtx 510assign_stack_local (enum machine_mode mode, HOST_WIDE_INT size, int align) 511{ 512 return assign_stack_local_1 (mode, size, align, cfun); 513} 514 515 516/* Removes temporary slot TEMP from LIST. */ 517 518static void 519cut_slot_from_list (struct temp_slot *temp, struct temp_slot **list) 520{ 521 if (temp->next) 522 temp->next->prev = temp->prev; 523 if (temp->prev) 524 temp->prev->next = temp->next; 525 else 526 *list = temp->next; 527 528 temp->prev = temp->next = NULL; 529} 530 531/* Inserts temporary slot TEMP to LIST. */ 532 533static void 534insert_slot_to_list (struct temp_slot *temp, struct temp_slot **list) 535{ 536 temp->next = *list; 537 if (*list) 538 (*list)->prev = temp; 539 temp->prev = NULL; 540 *list = temp; 541} 542 543/* Returns the list of used temp slots at LEVEL. */ 544 545static struct temp_slot ** 546temp_slots_at_level (int level) 547{ 548 if (level >= (int) VEC_length (temp_slot_p, used_temp_slots)) 549 { 550 size_t old_length = VEC_length (temp_slot_p, used_temp_slots); 551 temp_slot_p *p; 552 553 VEC_safe_grow (temp_slot_p, gc, used_temp_slots, level + 1); 554 p = VEC_address (temp_slot_p, used_temp_slots); 555 memset (&p[old_length], 0, 556 sizeof (temp_slot_p) * (level + 1 - old_length)); 557 } 558 559 return &(VEC_address (temp_slot_p, used_temp_slots)[level]); 560} 561 562/* Returns the maximal temporary slot level. */ 563 564static int 565max_slot_level (void) 566{ 567 if (!used_temp_slots) 568 return -1; 569 570 return VEC_length (temp_slot_p, used_temp_slots) - 1; 571} 572 573/* Moves temporary slot TEMP to LEVEL. */ 574 575static void 576move_slot_to_level (struct temp_slot *temp, int level) 577{ 578 cut_slot_from_list (temp, temp_slots_at_level (temp->level)); 579 insert_slot_to_list (temp, temp_slots_at_level (level)); 580 temp->level = level; 581} 582 583/* Make temporary slot TEMP available. */ 584 585static void 586make_slot_available (struct temp_slot *temp) 587{ 588 cut_slot_from_list (temp, temp_slots_at_level (temp->level)); 589 insert_slot_to_list (temp, &avail_temp_slots); 590 temp->in_use = 0; 591 temp->level = -1; 592} 593 594/* Allocate a temporary stack slot and record it for possible later 595 reuse. 596 597 MODE is the machine mode to be given to the returned rtx. 598 599 SIZE is the size in units of the space required. We do no rounding here 600 since assign_stack_local will do any required rounding. 601 602 KEEP is 1 if this slot is to be retained after a call to 603 free_temp_slots. Automatic variables for a block are allocated 604 with this flag. KEEP values of 2 or 3 were needed respectively 605 for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs 606 or for SAVE_EXPRs, but they are now unused. 607 608 TYPE is the type that will be used for the stack slot. */ 609 610rtx 611assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, 612 int keep, tree type) 613{ 614 unsigned int align; 615 struct temp_slot *p, *best_p = 0, *selected = NULL, **pp; 616 rtx slot; 617 618 /* If SIZE is -1 it means that somebody tried to allocate a temporary 619 of a variable size. */ 620 gcc_assert (size != -1); 621 622 /* These are now unused. */ 623 gcc_assert (keep <= 1); 624 625 if (mode == BLKmode) 626 align = BIGGEST_ALIGNMENT; 627 else 628 align = GET_MODE_ALIGNMENT (mode); 629 630 if (! type) 631 type = lang_hooks.types.type_for_mode (mode, 0); 632 633 if (type) 634 align = LOCAL_ALIGNMENT (type, align); 635 636 /* Try to find an available, already-allocated temporary of the proper 637 mode which meets the size and alignment requirements. Choose the 638 smallest one with the closest alignment. 639 640 If assign_stack_temp is called outside of the tree->rtl expansion, 641 we cannot reuse the stack slots (that may still refer to 642 VIRTUAL_STACK_VARS_REGNUM). */ 643 if (!virtuals_instantiated) 644 { 645 for (p = avail_temp_slots; p; p = p->next) 646 { 647 if (p->align >= align && p->size >= size 648 && GET_MODE (p->slot) == mode 649 && objects_must_conflict_p (p->type, type) 650 && (best_p == 0 || best_p->size > p->size 651 || (best_p->size == p->size && best_p->align > p->align))) 652 { 653 if (p->align == align && p->size == size) 654 { 655 selected = p; 656 cut_slot_from_list (selected, &avail_temp_slots); 657 best_p = 0; 658 break; 659 } 660 best_p = p; 661 } 662 } 663 } 664 665 /* Make our best, if any, the one to use. */ 666 if (best_p) 667 { 668 selected = best_p; 669 cut_slot_from_list (selected, &avail_temp_slots); 670 671 /* If there are enough aligned bytes left over, make them into a new 672 temp_slot so that the extra bytes don't get wasted. Do this only 673 for BLKmode slots, so that we can be sure of the alignment. */ 674 if (GET_MODE (best_p->slot) == BLKmode) 675 { 676 int alignment = best_p->align / BITS_PER_UNIT; 677 HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); 678 679 if (best_p->size - rounded_size >= alignment) 680 { 681 p = ggc_alloc (sizeof (struct temp_slot)); 682 p->in_use = p->addr_taken = 0; 683 p->size = best_p->size - rounded_size; 684 p->base_offset = best_p->base_offset + rounded_size; 685 p->full_size = best_p->full_size - rounded_size; 686 p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size); 687 p->align = best_p->align; 688 p->address = 0; 689 p->type = best_p->type; 690 insert_slot_to_list (p, &avail_temp_slots); 691 692 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, 693 stack_slot_list); 694 695 best_p->size = rounded_size; 696 best_p->full_size = rounded_size; 697 } 698 } 699 } 700 701 /* If we still didn't find one, make a new temporary. */ 702 if (selected == 0) 703 { 704 HOST_WIDE_INT frame_offset_old = frame_offset; 705 706 p = ggc_alloc (sizeof (struct temp_slot)); 707 708 /* We are passing an explicit alignment request to assign_stack_local. 709 One side effect of that is assign_stack_local will not round SIZE 710 to ensure the frame offset remains suitably aligned. 711 712 So for requests which depended on the rounding of SIZE, we go ahead 713 and round it now. We also make sure ALIGNMENT is at least 714 BIGGEST_ALIGNMENT. */ 715 gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT); 716 p->slot = assign_stack_local (mode, 717 (mode == BLKmode 718 ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT) 719 : size), 720 align); 721 722 p->align = align; 723 724 /* The following slot size computation is necessary because we don't 725 know the actual size of the temporary slot until assign_stack_local 726 has performed all the frame alignment and size rounding for the 727 requested temporary. Note that extra space added for alignment 728 can be either above or below this stack slot depending on which 729 way the frame grows. We include the extra space if and only if it 730 is above this slot. */ 731 if (FRAME_GROWS_DOWNWARD) 732 p->size = frame_offset_old - frame_offset; 733 else 734 p->size = size; 735 736 /* Now define the fields used by combine_temp_slots. */ 737 if (FRAME_GROWS_DOWNWARD) 738 { 739 p->base_offset = frame_offset; 740 p->full_size = frame_offset_old - frame_offset; 741 } 742 else 743 { 744 p->base_offset = frame_offset_old; 745 p->full_size = frame_offset - frame_offset_old; 746 } 747 p->address = 0; 748 749 selected = p; 750 } 751 752 p = selected; 753 p->in_use = 1; 754 p->addr_taken = 0; 755 p->type = type; 756 p->level = temp_slot_level; 757 p->keep = keep; 758 759 pp = temp_slots_at_level (p->level); 760 insert_slot_to_list (p, pp); 761 762 /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ 763 slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); 764 stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list); 765 766 /* If we know the alias set for the memory that will be used, use 767 it. If there's no TYPE, then we don't know anything about the 768 alias set for the memory. */ 769 set_mem_alias_set (slot, type ? get_alias_set (type) : 0); 770 set_mem_align (slot, align); 771 772 /* If a type is specified, set the relevant flags. */ 773 if (type != 0) 774 { 775 MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type); 776 MEM_SET_IN_STRUCT_P (slot, AGGREGATE_TYPE_P (type)); 777 } 778 MEM_NOTRAP_P (slot) = 1; 779 780 return slot; 781} 782 783/* Allocate a temporary stack slot and record it for possible later 784 reuse. First three arguments are same as in preceding function. */ 785 786rtx 787assign_stack_temp (enum machine_mode mode, HOST_WIDE_INT size, int keep) 788{ 789 return assign_stack_temp_for_type (mode, size, keep, NULL_TREE); 790} 791 792/* Assign a temporary. 793 If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl 794 and so that should be used in error messages. In either case, we 795 allocate of the given type. 796 KEEP is as for assign_stack_temp. 797 MEMORY_REQUIRED is 1 if the result must be addressable stack memory; 798 it is 0 if a register is OK. 799 DONT_PROMOTE is 1 if we should not promote values in register 800 to wider modes. */ 801 802rtx 803assign_temp (tree type_or_decl, int keep, int memory_required, 804 int dont_promote ATTRIBUTE_UNUSED) 805{ 806 tree type, decl; 807 enum machine_mode mode; 808#ifdef PROMOTE_MODE 809 int unsignedp; 810#endif 811 812 if (DECL_P (type_or_decl)) 813 decl = type_or_decl, type = TREE_TYPE (decl); 814 else 815 decl = NULL, type = type_or_decl; 816 817 mode = TYPE_MODE (type); 818#ifdef PROMOTE_MODE 819 unsignedp = TYPE_UNSIGNED (type); 820#endif 821 822 if (mode == BLKmode || memory_required) 823 { 824 HOST_WIDE_INT size = int_size_in_bytes (type); 825 rtx tmp; 826 827 /* Zero sized arrays are GNU C extension. Set size to 1 to avoid 828 problems with allocating the stack space. */ 829 if (size == 0) 830 size = 1; 831 832 /* Unfortunately, we don't yet know how to allocate variable-sized 833 temporaries. However, sometimes we can find a fixed upper limit on 834 the size, so try that instead. */ 835 else if (size == -1) 836 size = max_int_size_in_bytes (type); 837 838 /* The size of the temporary may be too large to fit into an integer. */ 839 /* ??? Not sure this should happen except for user silliness, so limit 840 this to things that aren't compiler-generated temporaries. The 841 rest of the time we'll die in assign_stack_temp_for_type. */ 842 if (decl && size == -1 843 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST) 844 { 845 error ("size of variable %q+D is too large", decl); 846 size = 1; 847 } 848 849 tmp = assign_stack_temp_for_type (mode, size, keep, type); 850 return tmp; 851 } 852 853#ifdef PROMOTE_MODE 854 if (! dont_promote) 855 mode = promote_mode (type, mode, &unsignedp, 0); 856#endif 857 858 return gen_reg_rtx (mode); 859} 860 861/* Combine temporary stack slots which are adjacent on the stack. 862 863 This allows for better use of already allocated stack space. This is only 864 done for BLKmode slots because we can be sure that we won't have alignment 865 problems in this case. */ 866 867static void 868combine_temp_slots (void) 869{ 870 struct temp_slot *p, *q, *next, *next_q; 871 int num_slots; 872 873 /* We can't combine slots, because the information about which slot 874 is in which alias set will be lost. */ 875 if (flag_strict_aliasing) 876 return; 877 878 /* If there are a lot of temp slots, don't do anything unless 879 high levels of optimization. */ 880 if (! flag_expensive_optimizations) 881 for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++) 882 if (num_slots > 100 || (num_slots > 10 && optimize == 0)) 883 return; 884 885 for (p = avail_temp_slots; p; p = next) 886 { 887 int delete_p = 0; 888 889 next = p->next; 890 891 if (GET_MODE (p->slot) != BLKmode) 892 continue; 893 894 for (q = p->next; q; q = next_q) 895 { 896 int delete_q = 0; 897 898 next_q = q->next; 899 900 if (GET_MODE (q->slot) != BLKmode) 901 continue; 902 903 if (p->base_offset + p->full_size == q->base_offset) 904 { 905 /* Q comes after P; combine Q into P. */ 906 p->size += q->size; 907 p->full_size += q->full_size; 908 delete_q = 1; 909 } 910 else if (q->base_offset + q->full_size == p->base_offset) 911 { 912 /* P comes after Q; combine P into Q. */ 913 q->size += p->size; 914 q->full_size += p->full_size; 915 delete_p = 1; 916 break; 917 } 918 if (delete_q) 919 cut_slot_from_list (q, &avail_temp_slots); 920 } 921 922 /* Either delete P or advance past it. */ 923 if (delete_p) 924 cut_slot_from_list (p, &avail_temp_slots); 925 } 926} 927 928/* Find the temp slot corresponding to the object at address X. */ 929 930static struct temp_slot * 931find_temp_slot_from_address (rtx x) 932{ 933 struct temp_slot *p; 934 rtx next; 935 int i; 936 937 for (i = max_slot_level (); i >= 0; i--) 938 for (p = *temp_slots_at_level (i); p; p = p->next) 939 { 940 if (XEXP (p->slot, 0) == x 941 || p->address == x 942 || (GET_CODE (x) == PLUS 943 && XEXP (x, 0) == virtual_stack_vars_rtx 944 && GET_CODE (XEXP (x, 1)) == CONST_INT 945 && INTVAL (XEXP (x, 1)) >= p->base_offset 946 && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size)) 947 return p; 948 949 else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST) 950 for (next = p->address; next; next = XEXP (next, 1)) 951 if (XEXP (next, 0) == x) 952 return p; 953 } 954 955 /* If we have a sum involving a register, see if it points to a temp 956 slot. */ 957 if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0)) 958 && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0) 959 return p; 960 else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1)) 961 && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0) 962 return p; 963 964 return 0; 965} 966 967/* Indicate that NEW is an alternate way of referring to the temp slot 968 that previously was known by OLD. */ 969 970void 971update_temp_slot_address (rtx old, rtx new) 972{ 973 struct temp_slot *p; 974 975 if (rtx_equal_p (old, new)) 976 return; 977 978 p = find_temp_slot_from_address (old); 979 980 /* If we didn't find one, see if both OLD is a PLUS. If so, and NEW 981 is a register, see if one operand of the PLUS is a temporary 982 location. If so, NEW points into it. Otherwise, if both OLD and 983 NEW are a PLUS and if there is a register in common between them. 984 If so, try a recursive call on those values. */ 985 if (p == 0) 986 { 987 if (GET_CODE (old) != PLUS) 988 return; 989 990 if (REG_P (new)) 991 { 992 update_temp_slot_address (XEXP (old, 0), new); 993 update_temp_slot_address (XEXP (old, 1), new); 994 return; 995 } 996 else if (GET_CODE (new) != PLUS) 997 return; 998 999 if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0))) 1000 update_temp_slot_address (XEXP (old, 1), XEXP (new, 1)); 1001 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0))) 1002 update_temp_slot_address (XEXP (old, 0), XEXP (new, 1)); 1003 else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1))) 1004 update_temp_slot_address (XEXP (old, 1), XEXP (new, 0)); 1005 else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1))) 1006 update_temp_slot_address (XEXP (old, 0), XEXP (new, 0)); 1007 1008 return; 1009 } 1010 1011 /* Otherwise add an alias for the temp's address. */ 1012 else if (p->address == 0) 1013 p->address = new; 1014 else 1015 { 1016 if (GET_CODE (p->address) != EXPR_LIST) 1017 p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); 1018 1019 p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); 1020 } 1021} 1022 1023/* If X could be a reference to a temporary slot, mark the fact that its 1024 address was taken. */ 1025 1026void 1027mark_temp_addr_taken (rtx x) 1028{ 1029 struct temp_slot *p; 1030 1031 if (x == 0) 1032 return; 1033 1034 /* If X is not in memory or is at a constant address, it cannot be in 1035 a temporary slot. */ 1036 if (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))) 1037 return; 1038 1039 p = find_temp_slot_from_address (XEXP (x, 0)); 1040 if (p != 0) 1041 p->addr_taken = 1; 1042} 1043 1044/* If X could be a reference to a temporary slot, mark that slot as 1045 belonging to the to one level higher than the current level. If X 1046 matched one of our slots, just mark that one. Otherwise, we can't 1047 easily predict which it is, so upgrade all of them. Kept slots 1048 need not be touched. 1049 1050 This is called when an ({...}) construct occurs and a statement 1051 returns a value in memory. */ 1052 1053void 1054preserve_temp_slots (rtx x) 1055{ 1056 struct temp_slot *p = 0, *next; 1057 1058 /* If there is no result, we still might have some objects whose address 1059 were taken, so we need to make sure they stay around. */ 1060 if (x == 0) 1061 { 1062 for (p = *temp_slots_at_level (temp_slot_level); p; p = next) 1063 { 1064 next = p->next; 1065 1066 if (p->addr_taken) 1067 move_slot_to_level (p, temp_slot_level - 1); 1068 } 1069 1070 return; 1071 } 1072 1073 /* If X is a register that is being used as a pointer, see if we have 1074 a temporary slot we know it points to. To be consistent with 1075 the code below, we really should preserve all non-kept slots 1076 if we can't find a match, but that seems to be much too costly. */ 1077 if (REG_P (x) && REG_POINTER (x)) 1078 p = find_temp_slot_from_address (x); 1079 1080 /* If X is not in memory or is at a constant address, it cannot be in 1081 a temporary slot, but it can contain something whose address was 1082 taken. */ 1083 if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0)))) 1084 { 1085 for (p = *temp_slots_at_level (temp_slot_level); p; p = next) 1086 { 1087 next = p->next; 1088 1089 if (p->addr_taken) 1090 move_slot_to_level (p, temp_slot_level - 1); 1091 } 1092 1093 return; 1094 } 1095 1096 /* First see if we can find a match. */ 1097 if (p == 0) 1098 p = find_temp_slot_from_address (XEXP (x, 0)); 1099 1100 if (p != 0) 1101 { 1102 /* Move everything at our level whose address was taken to our new 1103 level in case we used its address. */ 1104 struct temp_slot *q; 1105 1106 if (p->level == temp_slot_level) 1107 { 1108 for (q = *temp_slots_at_level (temp_slot_level); q; q = next) 1109 { 1110 next = q->next; 1111 1112 if (p != q && q->addr_taken) 1113 move_slot_to_level (q, temp_slot_level - 1); 1114 } 1115 1116 move_slot_to_level (p, temp_slot_level - 1); 1117 p->addr_taken = 0; 1118 } 1119 return; 1120 } 1121 1122 /* Otherwise, preserve all non-kept slots at this level. */ 1123 for (p = *temp_slots_at_level (temp_slot_level); p; p = next) 1124 { 1125 next = p->next; 1126 1127 if (!p->keep) 1128 move_slot_to_level (p, temp_slot_level - 1); 1129 } 1130} 1131 1132/* Free all temporaries used so far. This is normally called at the 1133 end of generating code for a statement. */ 1134 1135void 1136free_temp_slots (void) 1137{ 1138 struct temp_slot *p, *next; 1139 1140 for (p = *temp_slots_at_level (temp_slot_level); p; p = next) 1141 { 1142 next = p->next; 1143 1144 if (!p->keep) 1145 make_slot_available (p); 1146 } 1147 1148 combine_temp_slots (); 1149} 1150 1151/* Push deeper into the nesting level for stack temporaries. */ 1152 1153void 1154push_temp_slots (void) 1155{ 1156 temp_slot_level++; 1157} 1158 1159/* Pop a temporary nesting level. All slots in use in the current level 1160 are freed. */ 1161 1162void 1163pop_temp_slots (void) 1164{ 1165 struct temp_slot *p, *next; 1166 1167 for (p = *temp_slots_at_level (temp_slot_level); p; p = next) 1168 { 1169 next = p->next; 1170 make_slot_available (p); 1171 } 1172 1173 combine_temp_slots (); 1174 1175 temp_slot_level--; 1176} 1177 1178/* Initialize temporary slots. */ 1179 1180void 1181init_temp_slots (void) 1182{ 1183 /* We have not allocated any temporaries yet. */ 1184 avail_temp_slots = 0; 1185 used_temp_slots = 0; 1186 temp_slot_level = 0; 1187} 1188 1189/* These routines are responsible for converting virtual register references 1190 to the actual hard register references once RTL generation is complete. 1191 1192 The following four variables are used for communication between the 1193 routines. They contain the offsets of the virtual registers from their 1194 respective hard registers. */ 1195 1196static int in_arg_offset; 1197static int var_offset; 1198static int dynamic_offset; 1199static int out_arg_offset; 1200static int cfa_offset; 1201 1202/* In most machines, the stack pointer register is equivalent to the bottom 1203 of the stack. */ 1204 1205#ifndef STACK_POINTER_OFFSET 1206#define STACK_POINTER_OFFSET 0 1207#endif 1208 1209/* If not defined, pick an appropriate default for the offset of dynamically 1210 allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, 1211 REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ 1212 1213#ifndef STACK_DYNAMIC_OFFSET 1214 1215/* The bottom of the stack points to the actual arguments. If 1216 REG_PARM_STACK_SPACE is defined, this includes the space for the register 1217 parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, 1218 stack space for register parameters is not pushed by the caller, but 1219 rather part of the fixed stack areas and hence not included in 1220 `current_function_outgoing_args_size'. Nevertheless, we must allow 1221 for it when allocating stack dynamic objects. */ 1222 1223#if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) 1224#define STACK_DYNAMIC_OFFSET(FNDECL) \ 1225((ACCUMULATE_OUTGOING_ARGS \ 1226 ? (current_function_outgoing_args_size + REG_PARM_STACK_SPACE (FNDECL)) : 0)\ 1227 + (STACK_POINTER_OFFSET)) \ 1228 1229#else 1230#define STACK_DYNAMIC_OFFSET(FNDECL) \ 1231((ACCUMULATE_OUTGOING_ARGS ? current_function_outgoing_args_size : 0) \ 1232 + (STACK_POINTER_OFFSET)) 1233#endif 1234#endif 1235 1236 1237/* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX 1238 is a virtual register, return the equivalent hard register and set the 1239 offset indirectly through the pointer. Otherwise, return 0. */ 1240 1241static rtx 1242instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) 1243{ 1244 rtx new; 1245 HOST_WIDE_INT offset; 1246 1247 if (x == virtual_incoming_args_rtx) 1248 new = arg_pointer_rtx, offset = in_arg_offset; 1249 else if (x == virtual_stack_vars_rtx) 1250 new = frame_pointer_rtx, offset = var_offset; 1251 else if (x == virtual_stack_dynamic_rtx) 1252 new = stack_pointer_rtx, offset = dynamic_offset; 1253 else if (x == virtual_outgoing_args_rtx) 1254 new = stack_pointer_rtx, offset = out_arg_offset; 1255 else if (x == virtual_cfa_rtx) 1256 { 1257#ifdef FRAME_POINTER_CFA_OFFSET 1258 new = frame_pointer_rtx; 1259#else 1260 new = arg_pointer_rtx; 1261#endif 1262 offset = cfa_offset; 1263 } 1264 else 1265 return NULL_RTX; 1266 1267 *poffset = offset; 1268 return new; 1269} 1270 1271/* A subroutine of instantiate_virtual_regs, called via for_each_rtx. 1272 Instantiate any virtual registers present inside of *LOC. The expression 1273 is simplified, as much as possible, but is not to be considered "valid" 1274 in any sense implied by the target. If any change is made, set CHANGED 1275 to true. */ 1276 1277static int 1278instantiate_virtual_regs_in_rtx (rtx *loc, void *data) 1279{ 1280 HOST_WIDE_INT offset; 1281 bool *changed = (bool *) data; 1282 rtx x, new; 1283 1284 x = *loc; 1285 if (x == 0) 1286 return 0; 1287 1288 switch (GET_CODE (x)) 1289 { 1290 case REG: 1291 new = instantiate_new_reg (x, &offset); 1292 if (new) 1293 { 1294 *loc = plus_constant (new, offset); 1295 if (changed) 1296 *changed = true; 1297 } 1298 return -1; 1299 1300 case PLUS: 1301 new = instantiate_new_reg (XEXP (x, 0), &offset); 1302 if (new) 1303 { 1304 new = plus_constant (new, offset); 1305 *loc = simplify_gen_binary (PLUS, GET_MODE (x), new, XEXP (x, 1)); 1306 if (changed) 1307 *changed = true; 1308 return -1; 1309 } 1310 1311 /* FIXME -- from old code */ 1312 /* If we have (plus (subreg (virtual-reg)) (const_int)), we know 1313 we can commute the PLUS and SUBREG because pointers into the 1314 frame are well-behaved. */ 1315 break; 1316 1317 default: 1318 break; 1319 } 1320 1321 return 0; 1322} 1323 1324/* A subroutine of instantiate_virtual_regs_in_insn. Return true if X 1325 matches the predicate for insn CODE operand OPERAND. */ 1326 1327static int 1328safe_insn_predicate (int code, int operand, rtx x) 1329{ 1330 const struct insn_operand_data *op_data; 1331 1332 if (code < 0) 1333 return true; 1334 1335 op_data = &insn_data[code].operand[operand]; 1336 if (op_data->predicate == NULL) 1337 return true; 1338 1339 return op_data->predicate (x, op_data->mode); 1340} 1341 1342/* A subroutine of instantiate_virtual_regs. Instantiate any virtual 1343 registers present inside of insn. The result will be a valid insn. */ 1344 1345static void 1346instantiate_virtual_regs_in_insn (rtx insn) 1347{ 1348 HOST_WIDE_INT offset; 1349 int insn_code, i; 1350 bool any_change = false; 1351 rtx set, new, x, seq; 1352 1353 /* There are some special cases to be handled first. */ 1354 set = single_set (insn); 1355 if (set) 1356 { 1357 /* We're allowed to assign to a virtual register. This is interpreted 1358 to mean that the underlying register gets assigned the inverse 1359 transformation. This is used, for example, in the handling of 1360 non-local gotos. */ 1361 new = instantiate_new_reg (SET_DEST (set), &offset); 1362 if (new) 1363 { 1364 start_sequence (); 1365 1366 for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL); 1367 x = simplify_gen_binary (PLUS, GET_MODE (new), SET_SRC (set), 1368 GEN_INT (-offset)); 1369 x = force_operand (x, new); 1370 if (x != new) 1371 emit_move_insn (new, x); 1372 1373 seq = get_insns (); 1374 end_sequence (); 1375 1376 emit_insn_before (seq, insn); 1377 delete_insn (insn); 1378 return; 1379 } 1380 1381 /* Handle a straight copy from a virtual register by generating a 1382 new add insn. The difference between this and falling through 1383 to the generic case is avoiding a new pseudo and eliminating a 1384 move insn in the initial rtl stream. */ 1385 new = instantiate_new_reg (SET_SRC (set), &offset); 1386 if (new && offset != 0 1387 && REG_P (SET_DEST (set)) 1388 && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) 1389 { 1390 start_sequence (); 1391 1392 x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, 1393 new, GEN_INT (offset), SET_DEST (set), 1394 1, OPTAB_LIB_WIDEN); 1395 if (x != SET_DEST (set)) 1396 emit_move_insn (SET_DEST (set), x); 1397 1398 seq = get_insns (); 1399 end_sequence (); 1400 1401 emit_insn_before (seq, insn); 1402 delete_insn (insn); 1403 return; 1404 } 1405 1406 extract_insn (insn); 1407 insn_code = INSN_CODE (insn); 1408 1409 /* Handle a plus involving a virtual register by determining if the 1410 operands remain valid if they're modified in place. */ 1411 if (GET_CODE (SET_SRC (set)) == PLUS 1412 && recog_data.n_operands >= 3 1413 && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0) 1414 && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1) 1415 && GET_CODE (recog_data.operand[2]) == CONST_INT 1416 && (new = instantiate_new_reg (recog_data.operand[1], &offset))) 1417 { 1418 offset += INTVAL (recog_data.operand[2]); 1419 1420 /* If the sum is zero, then replace with a plain move. */ 1421 if (offset == 0 1422 && REG_P (SET_DEST (set)) 1423 && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) 1424 { 1425 start_sequence (); 1426 emit_move_insn (SET_DEST (set), new); 1427 seq = get_insns (); 1428 end_sequence (); 1429 1430 emit_insn_before (seq, insn); 1431 delete_insn (insn); 1432 return; 1433 } 1434 1435 x = gen_int_mode (offset, recog_data.operand_mode[2]); 1436 1437 /* Using validate_change and apply_change_group here leaves 1438 recog_data in an invalid state. Since we know exactly what 1439 we want to check, do those two by hand. */ 1440 if (safe_insn_predicate (insn_code, 1, new) 1441 && safe_insn_predicate (insn_code, 2, x)) 1442 { 1443 *recog_data.operand_loc[1] = recog_data.operand[1] = new; 1444 *recog_data.operand_loc[2] = recog_data.operand[2] = x; 1445 any_change = true; 1446 1447 /* Fall through into the regular operand fixup loop in 1448 order to take care of operands other than 1 and 2. */ 1449 } 1450 } 1451 } 1452 else 1453 { 1454 extract_insn (insn); 1455 insn_code = INSN_CODE (insn); 1456 } 1457 1458 /* In the general case, we expect virtual registers to appear only in 1459 operands, and then only as either bare registers or inside memories. */ 1460 for (i = 0; i < recog_data.n_operands; ++i) 1461 { 1462 x = recog_data.operand[i]; 1463 switch (GET_CODE (x)) 1464 { 1465 case MEM: 1466 { 1467 rtx addr = XEXP (x, 0); 1468 bool changed = false; 1469 1470 for_each_rtx (&addr, instantiate_virtual_regs_in_rtx, &changed); 1471 if (!changed) 1472 continue; 1473 1474 start_sequence (); 1475 x = replace_equiv_address (x, addr); 1476 seq = get_insns (); 1477 end_sequence (); 1478 if (seq) 1479 emit_insn_before (seq, insn); 1480 } 1481 break; 1482 1483 case REG: 1484 new = instantiate_new_reg (x, &offset); 1485 if (new == NULL) 1486 continue; 1487 if (offset == 0) 1488 x = new; 1489 else 1490 { 1491 start_sequence (); 1492 1493 /* Careful, special mode predicates may have stuff in 1494 insn_data[insn_code].operand[i].mode that isn't useful 1495 to us for computing a new value. */ 1496 /* ??? Recognize address_operand and/or "p" constraints 1497 to see if (plus new offset) is a valid before we put 1498 this through expand_simple_binop. */ 1499 x = expand_simple_binop (GET_MODE (x), PLUS, new, 1500 GEN_INT (offset), NULL_RTX, 1501 1, OPTAB_LIB_WIDEN); 1502 seq = get_insns (); 1503 end_sequence (); 1504 emit_insn_before (seq, insn); 1505 } 1506 break; 1507 1508 case SUBREG: 1509 new = instantiate_new_reg (SUBREG_REG (x), &offset); 1510 if (new == NULL) 1511 continue; 1512 if (offset != 0) 1513 { 1514 start_sequence (); 1515 new = expand_simple_binop (GET_MODE (new), PLUS, new, 1516 GEN_INT (offset), NULL_RTX, 1517 1, OPTAB_LIB_WIDEN); 1518 seq = get_insns (); 1519 end_sequence (); 1520 emit_insn_before (seq, insn); 1521 } 1522 x = simplify_gen_subreg (recog_data.operand_mode[i], new, 1523 GET_MODE (new), SUBREG_BYTE (x)); 1524 break; 1525 1526 default: 1527 continue; 1528 } 1529 1530 /* At this point, X contains the new value for the operand. 1531 Validate the new value vs the insn predicate. Note that 1532 asm insns will have insn_code -1 here. */ 1533 if (!safe_insn_predicate (insn_code, i, x)) 1534 { 1535 start_sequence (); 1536 x = force_reg (insn_data[insn_code].operand[i].mode, x); 1537 seq = get_insns (); 1538 end_sequence (); 1539 if (seq) 1540 emit_insn_before (seq, insn); 1541 } 1542 1543 *recog_data.operand_loc[i] = recog_data.operand[i] = x; 1544 any_change = true; 1545 } 1546 1547 if (any_change) 1548 { 1549 /* Propagate operand changes into the duplicates. */ 1550 for (i = 0; i < recog_data.n_dups; ++i) 1551 *recog_data.dup_loc[i] 1552 = recog_data.operand[(unsigned)recog_data.dup_num[i]]; 1553 1554 /* Force re-recognition of the instruction for validation. */ 1555 INSN_CODE (insn) = -1; 1556 } 1557 1558 if (asm_noperands (PATTERN (insn)) >= 0) 1559 { 1560 if (!check_asm_operands (PATTERN (insn))) 1561 { 1562 error_for_asm (insn, "impossible constraint in %<asm%>"); 1563 delete_insn (insn); 1564 } 1565 } 1566 else 1567 { 1568 if (recog_memoized (insn) < 0) 1569 fatal_insn_not_found (insn); 1570 } 1571} 1572 1573/* Subroutine of instantiate_decls. Given RTL representing a decl, 1574 do any instantiation required. */ 1575 1576static void 1577instantiate_decl (rtx x) 1578{ 1579 rtx addr; 1580 1581 if (x == 0) 1582 return; 1583 1584 /* If this is a CONCAT, recurse for the pieces. */ 1585 if (GET_CODE (x) == CONCAT) 1586 { 1587 instantiate_decl (XEXP (x, 0)); 1588 instantiate_decl (XEXP (x, 1)); 1589 return; 1590 } 1591 1592 /* If this is not a MEM, no need to do anything. Similarly if the 1593 address is a constant or a register that is not a virtual register. */ 1594 if (!MEM_P (x)) 1595 return; 1596 1597 addr = XEXP (x, 0); 1598 if (CONSTANT_P (addr) 1599 || (REG_P (addr) 1600 && (REGNO (addr) < FIRST_VIRTUAL_REGISTER 1601 || REGNO (addr) > LAST_VIRTUAL_REGISTER))) 1602 return; 1603 1604 for_each_rtx (&XEXP (x, 0), instantiate_virtual_regs_in_rtx, NULL); 1605} 1606 1607/* Helper for instantiate_decls called via walk_tree: Process all decls 1608 in the given DECL_VALUE_EXPR. */ 1609 1610static tree 1611instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) 1612{ 1613 tree t = *tp; 1614 if (! EXPR_P (t)) 1615 { 1616 *walk_subtrees = 0; 1617 if (DECL_P (t) && DECL_RTL_SET_P (t)) 1618 instantiate_decl (DECL_RTL (t)); 1619 } 1620 return NULL; 1621} 1622 1623/* Subroutine of instantiate_decls: Process all decls in the given 1624 BLOCK node and all its subblocks. */ 1625 1626static void 1627instantiate_decls_1 (tree let) 1628{ 1629 tree t; 1630 1631 for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t)) 1632 { 1633 if (DECL_RTL_SET_P (t)) 1634 instantiate_decl (DECL_RTL (t)); 1635 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) 1636 { 1637 tree v = DECL_VALUE_EXPR (t); 1638 walk_tree (&v, instantiate_expr, NULL, NULL); 1639 } 1640 } 1641 1642 /* Process all subblocks. */ 1643 for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t)) 1644 instantiate_decls_1 (t); 1645} 1646 1647/* Scan all decls in FNDECL (both variables and parameters) and instantiate 1648 all virtual registers in their DECL_RTL's. */ 1649 1650static void 1651instantiate_decls (tree fndecl) 1652{ 1653 tree decl; 1654 1655 /* Process all parameters of the function. */ 1656 for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl)) 1657 { 1658 instantiate_decl (DECL_RTL (decl)); 1659 instantiate_decl (DECL_INCOMING_RTL (decl)); 1660 if (DECL_HAS_VALUE_EXPR_P (decl)) 1661 { 1662 tree v = DECL_VALUE_EXPR (decl); 1663 walk_tree (&v, instantiate_expr, NULL, NULL); 1664 } 1665 } 1666 1667 /* Now process all variables defined in the function or its subblocks. */ 1668 instantiate_decls_1 (DECL_INITIAL (fndecl)); 1669} 1670 1671/* Pass through the INSNS of function FNDECL and convert virtual register 1672 references to hard register references. */ 1673 1674static unsigned int 1675instantiate_virtual_regs (void) 1676{ 1677 rtx insn; 1678 1679 /* Compute the offsets to use for this function. */ 1680 in_arg_offset = FIRST_PARM_OFFSET (current_function_decl); 1681 var_offset = STARTING_FRAME_OFFSET; 1682 dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl); 1683 out_arg_offset = STACK_POINTER_OFFSET; 1684#ifdef FRAME_POINTER_CFA_OFFSET 1685 cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl); 1686#else 1687 cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl); 1688#endif 1689 1690 /* Initialize recognition, indicating that volatile is OK. */ 1691 init_recog (); 1692 1693 /* Scan through all the insns, instantiating every virtual register still 1694 present. */ 1695 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 1696 if (INSN_P (insn)) 1697 { 1698 /* These patterns in the instruction stream can never be recognized. 1699 Fortunately, they shouldn't contain virtual registers either. */ 1700 if (GET_CODE (PATTERN (insn)) == USE 1701 || GET_CODE (PATTERN (insn)) == CLOBBER 1702 || GET_CODE (PATTERN (insn)) == ADDR_VEC 1703 || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC 1704 || GET_CODE (PATTERN (insn)) == ASM_INPUT) 1705 continue; 1706 1707 instantiate_virtual_regs_in_insn (insn); 1708 1709 if (INSN_DELETED_P (insn)) 1710 continue; 1711 1712 for_each_rtx (®_NOTES (insn), instantiate_virtual_regs_in_rtx, NULL); 1713 1714 /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */ 1715 if (GET_CODE (insn) == CALL_INSN) 1716 for_each_rtx (&CALL_INSN_FUNCTION_USAGE (insn), 1717 instantiate_virtual_regs_in_rtx, NULL); 1718 } 1719 1720 /* Instantiate the virtual registers in the DECLs for debugging purposes. */ 1721 instantiate_decls (current_function_decl); 1722 1723 /* Indicate that, from now on, assign_stack_local should use 1724 frame_pointer_rtx. */ 1725 virtuals_instantiated = 1; 1726 return 0; 1727} 1728 1729struct tree_opt_pass pass_instantiate_virtual_regs = 1730{ 1731 "vregs", /* name */ 1732 NULL, /* gate */ 1733 instantiate_virtual_regs, /* execute */ 1734 NULL, /* sub */ 1735 NULL, /* next */ 1736 0, /* static_pass_number */ 1737 0, /* tv_id */ 1738 0, /* properties_required */ 1739 0, /* properties_provided */ 1740 0, /* properties_destroyed */ 1741 0, /* todo_flags_start */ 1742 TODO_dump_func, /* todo_flags_finish */ 1743 0 /* letter */ 1744}; 1745 1746 1747/* Return 1 if EXP is an aggregate type (or a value with aggregate type). 1748 This means a type for which function calls must pass an address to the 1749 function or get an address back from the function. 1750 EXP may be a type node or an expression (whose type is tested). */ 1751 1752int 1753aggregate_value_p (tree exp, tree fntype) 1754{ 1755 int i, regno, nregs; 1756 rtx reg; 1757 1758 tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp); 1759 1760 /* DECL node associated with FNTYPE when relevant, which we might need to 1761 check for by-invisible-reference returns, typically for CALL_EXPR input 1762 EXPressions. */ 1763 tree fndecl = NULL_TREE; 1764 1765 if (fntype) 1766 switch (TREE_CODE (fntype)) 1767 { 1768 case CALL_EXPR: 1769 fndecl = get_callee_fndecl (fntype); 1770 fntype = fndecl ? TREE_TYPE (fndecl) : 0; 1771 break; 1772 case FUNCTION_DECL: 1773 fndecl = fntype; 1774 fntype = TREE_TYPE (fndecl); 1775 break; 1776 case FUNCTION_TYPE: 1777 case METHOD_TYPE: 1778 break; 1779 case IDENTIFIER_NODE: 1780 fntype = 0; 1781 break; 1782 default: 1783 /* We don't expect other rtl types here. */ 1784 gcc_unreachable (); 1785 } 1786 1787 if (TREE_CODE (type) == VOID_TYPE) 1788 return 0; 1789 1790 /* If the front end has decided that this needs to be passed by 1791 reference, do so. */ 1792 if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL) 1793 && DECL_BY_REFERENCE (exp)) 1794 return 1; 1795 1796 /* If the EXPression is a CALL_EXPR, honor DECL_BY_REFERENCE set on the 1797 called function RESULT_DECL, meaning the function returns in memory by 1798 invisible reference. This check lets front-ends not set TREE_ADDRESSABLE 1799 on the function type, which used to be the way to request such a return 1800 mechanism but might now be causing troubles at gimplification time if 1801 temporaries with the function type need to be created. */ 1802 if (TREE_CODE (exp) == CALL_EXPR && fndecl && DECL_RESULT (fndecl) 1803 && DECL_BY_REFERENCE (DECL_RESULT (fndecl))) 1804 return 1; 1805 1806 if (targetm.calls.return_in_memory (type, fntype)) 1807 return 1; 1808 /* Types that are TREE_ADDRESSABLE must be constructed in memory, 1809 and thus can't be returned in registers. */ 1810 if (TREE_ADDRESSABLE (type)) 1811 return 1; 1812 if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) 1813 return 1; 1814 /* Make sure we have suitable call-clobbered regs to return 1815 the value in; if not, we must return it in memory. */ 1816 reg = hard_function_value (type, 0, fntype, 0); 1817 1818 /* If we have something other than a REG (e.g. a PARALLEL), then assume 1819 it is OK. */ 1820 if (!REG_P (reg)) 1821 return 0; 1822 1823 regno = REGNO (reg); 1824 nregs = hard_regno_nregs[regno][TYPE_MODE (type)]; 1825 for (i = 0; i < nregs; i++) 1826 if (! call_used_regs[regno + i]) 1827 return 1; 1828 return 0; 1829} 1830 1831/* Return true if we should assign DECL a pseudo register; false if it 1832 should live on the local stack. */ 1833 1834bool 1835use_register_for_decl (tree decl) 1836{ 1837 /* Honor volatile. */ 1838 if (TREE_SIDE_EFFECTS (decl)) 1839 return false; 1840 1841 /* Honor addressability. */ 1842 if (TREE_ADDRESSABLE (decl)) 1843 return false; 1844 1845 /* Only register-like things go in registers. */ 1846 if (DECL_MODE (decl) == BLKmode) 1847 return false; 1848 1849 /* If -ffloat-store specified, don't put explicit float variables 1850 into registers. */ 1851 /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa 1852 propagates values across these stores, and it probably shouldn't. */ 1853 if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl))) 1854 return false; 1855 1856 /* If we're not interested in tracking debugging information for 1857 this decl, then we can certainly put it in a register. */ 1858 if (DECL_IGNORED_P (decl)) 1859 return true; 1860 1861 return (optimize || DECL_REGISTER (decl)); 1862} 1863 1864/* Return true if TYPE should be passed by invisible reference. */ 1865 1866bool 1867pass_by_reference (CUMULATIVE_ARGS *ca, enum machine_mode mode, 1868 tree type, bool named_arg) 1869{ 1870 if (type) 1871 { 1872 /* If this type contains non-trivial constructors, then it is 1873 forbidden for the middle-end to create any new copies. */ 1874 if (TREE_ADDRESSABLE (type)) 1875 return true; 1876 1877 /* GCC post 3.4 passes *all* variable sized types by reference. */ 1878 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1879 return true; 1880 } 1881 1882 return targetm.calls.pass_by_reference (ca, mode, type, named_arg); 1883} 1884 1885/* Return true if TYPE, which is passed by reference, should be callee 1886 copied instead of caller copied. */ 1887 1888bool 1889reference_callee_copied (CUMULATIVE_ARGS *ca, enum machine_mode mode, 1890 tree type, bool named_arg) 1891{ 1892 if (type && TREE_ADDRESSABLE (type)) 1893 return false; 1894 return targetm.calls.callee_copies (ca, mode, type, named_arg); 1895} 1896 1897/* Structures to communicate between the subroutines of assign_parms. 1898 The first holds data persistent across all parameters, the second 1899 is cleared out for each parameter. */ 1900 1901struct assign_parm_data_all 1902{ 1903 CUMULATIVE_ARGS args_so_far; 1904 struct args_size stack_args_size; 1905 tree function_result_decl; 1906 tree orig_fnargs; 1907 rtx conversion_insns; 1908 HOST_WIDE_INT pretend_args_size; 1909 HOST_WIDE_INT extra_pretend_bytes; 1910 int reg_parm_stack_space; 1911}; 1912 1913struct assign_parm_data_one 1914{ 1915 tree nominal_type; 1916 tree passed_type; 1917 rtx entry_parm; 1918 rtx stack_parm; 1919 enum machine_mode nominal_mode; 1920 enum machine_mode passed_mode; 1921 enum machine_mode promoted_mode; 1922 struct locate_and_pad_arg_data locate; 1923 int partial; 1924 BOOL_BITFIELD named_arg : 1; 1925 BOOL_BITFIELD passed_pointer : 1; 1926 BOOL_BITFIELD on_stack : 1; 1927 BOOL_BITFIELD loaded_in_reg : 1; 1928}; 1929 1930/* A subroutine of assign_parms. Initialize ALL. */ 1931 1932static void 1933assign_parms_initialize_all (struct assign_parm_data_all *all) 1934{ 1935 tree fntype; 1936 1937 memset (all, 0, sizeof (*all)); 1938 1939 fntype = TREE_TYPE (current_function_decl); 1940 1941#ifdef INIT_CUMULATIVE_INCOMING_ARGS 1942 INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far, fntype, NULL_RTX); 1943#else 1944 INIT_CUMULATIVE_ARGS (all->args_so_far, fntype, NULL_RTX, 1945 current_function_decl, -1); 1946#endif 1947 1948#ifdef REG_PARM_STACK_SPACE 1949 all->reg_parm_stack_space = REG_PARM_STACK_SPACE (current_function_decl); 1950#endif 1951} 1952 1953/* If ARGS contains entries with complex types, split the entry into two 1954 entries of the component type. Return a new list of substitutions are 1955 needed, else the old list. */ 1956 1957static tree 1958split_complex_args (tree args) 1959{ 1960 tree p; 1961 1962 /* Before allocating memory, check for the common case of no complex. */ 1963 for (p = args; p; p = TREE_CHAIN (p)) 1964 { 1965 tree type = TREE_TYPE (p); 1966 if (TREE_CODE (type) == COMPLEX_TYPE 1967 && targetm.calls.split_complex_arg (type)) 1968 goto found; 1969 } 1970 return args; 1971 1972 found: 1973 args = copy_list (args); 1974 1975 for (p = args; p; p = TREE_CHAIN (p)) 1976 { 1977 tree type = TREE_TYPE (p); 1978 if (TREE_CODE (type) == COMPLEX_TYPE 1979 && targetm.calls.split_complex_arg (type)) 1980 { 1981 tree decl; 1982 tree subtype = TREE_TYPE (type); 1983 bool addressable = TREE_ADDRESSABLE (p); 1984 1985 /* Rewrite the PARM_DECL's type with its component. */ 1986 TREE_TYPE (p) = subtype; 1987 DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p)); 1988 DECL_MODE (p) = VOIDmode; 1989 DECL_SIZE (p) = NULL; 1990 DECL_SIZE_UNIT (p) = NULL; 1991 /* If this arg must go in memory, put it in a pseudo here. 1992 We can't allow it to go in memory as per normal parms, 1993 because the usual place might not have the imag part 1994 adjacent to the real part. */ 1995 DECL_ARTIFICIAL (p) = addressable; 1996 DECL_IGNORED_P (p) = addressable; 1997 TREE_ADDRESSABLE (p) = 0; 1998 layout_decl (p, 0); 1999 2000 /* Build a second synthetic decl. */ 2001 decl = build_decl (PARM_DECL, NULL_TREE, subtype); 2002 DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p); 2003 DECL_ARTIFICIAL (decl) = addressable; 2004 DECL_IGNORED_P (decl) = addressable; 2005 layout_decl (decl, 0); 2006 2007 /* Splice it in; skip the new decl. */ 2008 TREE_CHAIN (decl) = TREE_CHAIN (p); 2009 TREE_CHAIN (p) = decl; 2010 p = decl; 2011 } 2012 } 2013 2014 return args; 2015} 2016 2017/* A subroutine of assign_parms. Adjust the parameter list to incorporate 2018 the hidden struct return argument, and (abi willing) complex args. 2019 Return the new parameter list. */ 2020 2021static tree 2022assign_parms_augmented_arg_list (struct assign_parm_data_all *all) 2023{ 2024 tree fndecl = current_function_decl; 2025 tree fntype = TREE_TYPE (fndecl); 2026 tree fnargs = DECL_ARGUMENTS (fndecl); 2027 2028 /* If struct value address is treated as the first argument, make it so. */ 2029 if (aggregate_value_p (DECL_RESULT (fndecl), fndecl) 2030 && ! current_function_returns_pcc_struct 2031 && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0) 2032 { 2033 tree type = build_pointer_type (TREE_TYPE (fntype)); 2034 tree decl; 2035 2036 decl = build_decl (PARM_DECL, NULL_TREE, type); 2037 DECL_ARG_TYPE (decl) = type; 2038 DECL_ARTIFICIAL (decl) = 1; 2039 DECL_IGNORED_P (decl) = 1; 2040 2041 TREE_CHAIN (decl) = fnargs; 2042 fnargs = decl; 2043 all->function_result_decl = decl; 2044 } 2045 2046 all->orig_fnargs = fnargs; 2047 2048 /* If the target wants to split complex arguments into scalars, do so. */ 2049 if (targetm.calls.split_complex_arg) 2050 fnargs = split_complex_args (fnargs); 2051 2052 return fnargs; 2053} 2054 2055/* A subroutine of assign_parms. Examine PARM and pull out type and mode 2056 data for the parameter. Incorporate ABI specifics such as pass-by- 2057 reference and type promotion. */ 2058 2059static void 2060assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm, 2061 struct assign_parm_data_one *data) 2062{ 2063 tree nominal_type, passed_type; 2064 enum machine_mode nominal_mode, passed_mode, promoted_mode; 2065 2066 memset (data, 0, sizeof (*data)); 2067 2068 /* NAMED_ARG is a mis-nomer. We really mean 'non-varadic'. */ 2069 if (!current_function_stdarg) 2070 data->named_arg = 1; /* No varadic parms. */ 2071 else if (TREE_CHAIN (parm)) 2072 data->named_arg = 1; /* Not the last non-varadic parm. */ 2073 else if (targetm.calls.strict_argument_naming (&all->args_so_far)) 2074 data->named_arg = 1; /* Only varadic ones are unnamed. */ 2075 else 2076 data->named_arg = 0; /* Treat as varadic. */ 2077 2078 nominal_type = TREE_TYPE (parm); 2079 passed_type = DECL_ARG_TYPE (parm); 2080 2081 /* Look out for errors propagating this far. Also, if the parameter's 2082 type is void then its value doesn't matter. */ 2083 if (TREE_TYPE (parm) == error_mark_node 2084 /* This can happen after weird syntax errors 2085 or if an enum type is defined among the parms. */ 2086 || TREE_CODE (parm) != PARM_DECL 2087 || passed_type == NULL 2088 || VOID_TYPE_P (nominal_type)) 2089 { 2090 nominal_type = passed_type = void_type_node; 2091 nominal_mode = passed_mode = promoted_mode = VOIDmode; 2092 goto egress; 2093 } 2094 2095 /* Find mode of arg as it is passed, and mode of arg as it should be 2096 during execution of this function. */ 2097 passed_mode = TYPE_MODE (passed_type); 2098 nominal_mode = TYPE_MODE (nominal_type); 2099 2100 /* If the parm is to be passed as a transparent union, use the type of 2101 the first field for the tests below. We have already verified that 2102 the modes are the same. */ 2103 if (TREE_CODE (passed_type) == UNION_TYPE 2104 && TYPE_TRANSPARENT_UNION (passed_type)) 2105 passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); 2106 2107 /* See if this arg was passed by invisible reference. */ 2108 if (pass_by_reference (&all->args_so_far, passed_mode, 2109 passed_type, data->named_arg)) 2110 { 2111 passed_type = nominal_type = build_pointer_type (passed_type); 2112 data->passed_pointer = true; 2113 passed_mode = nominal_mode = Pmode; 2114 } 2115 2116 /* Find mode as it is passed by the ABI. */ 2117 promoted_mode = passed_mode; 2118 if (targetm.calls.promote_function_args (TREE_TYPE (current_function_decl))) 2119 { 2120 int unsignedp = TYPE_UNSIGNED (passed_type); 2121 promoted_mode = promote_mode (passed_type, promoted_mode, 2122 &unsignedp, 1); 2123 } 2124 2125 egress: 2126 data->nominal_type = nominal_type; 2127 data->passed_type = passed_type; 2128 data->nominal_mode = nominal_mode; 2129 data->passed_mode = passed_mode; 2130 data->promoted_mode = promoted_mode; 2131} 2132 2133/* A subroutine of assign_parms. Invoke setup_incoming_varargs. */ 2134 2135static void 2136assign_parms_setup_varargs (struct assign_parm_data_all *all, 2137 struct assign_parm_data_one *data, bool no_rtl) 2138{ 2139 int varargs_pretend_bytes = 0; 2140 2141 targetm.calls.setup_incoming_varargs (&all->args_so_far, 2142 data->promoted_mode, 2143 data->passed_type, 2144 &varargs_pretend_bytes, no_rtl); 2145 2146 /* If the back-end has requested extra stack space, record how much is 2147 needed. Do not change pretend_args_size otherwise since it may be 2148 nonzero from an earlier partial argument. */ 2149 if (varargs_pretend_bytes > 0) 2150 all->pretend_args_size = varargs_pretend_bytes; 2151} 2152 2153/* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to 2154 the incoming location of the current parameter. */ 2155 2156static void 2157assign_parm_find_entry_rtl (struct assign_parm_data_all *all, 2158 struct assign_parm_data_one *data) 2159{ 2160 HOST_WIDE_INT pretend_bytes = 0; 2161 rtx entry_parm; 2162 bool in_regs; 2163 2164 if (data->promoted_mode == VOIDmode) 2165 { 2166 data->entry_parm = data->stack_parm = const0_rtx; 2167 return; 2168 } 2169 2170#ifdef FUNCTION_INCOMING_ARG 2171 entry_parm = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode, 2172 data->passed_type, data->named_arg); 2173#else 2174 entry_parm = FUNCTION_ARG (all->args_so_far, data->promoted_mode, 2175 data->passed_type, data->named_arg); 2176#endif 2177 2178 if (entry_parm == 0) 2179 data->promoted_mode = data->passed_mode; 2180 2181 /* Determine parm's home in the stack, in case it arrives in the stack 2182 or we should pretend it did. Compute the stack position and rtx where 2183 the argument arrives and its size. 2184 2185 There is one complexity here: If this was a parameter that would 2186 have been passed in registers, but wasn't only because it is 2187 __builtin_va_alist, we want locate_and_pad_parm to treat it as if 2188 it came in a register so that REG_PARM_STACK_SPACE isn't skipped. 2189 In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0 2190 as it was the previous time. */ 2191 in_regs = entry_parm != 0; 2192#ifdef STACK_PARMS_IN_REG_PARM_AREA 2193 in_regs = true; 2194#endif 2195 if (!in_regs && !data->named_arg) 2196 { 2197 if (targetm.calls.pretend_outgoing_varargs_named (&all->args_so_far)) 2198 { 2199 rtx tem; 2200#ifdef FUNCTION_INCOMING_ARG 2201 tem = FUNCTION_INCOMING_ARG (all->args_so_far, data->promoted_mode, 2202 data->passed_type, true); 2203#else 2204 tem = FUNCTION_ARG (all->args_so_far, data->promoted_mode, 2205 data->passed_type, true); 2206#endif 2207 in_regs = tem != NULL; 2208 } 2209 } 2210 2211 /* If this parameter was passed both in registers and in the stack, use 2212 the copy on the stack. */ 2213 if (targetm.calls.must_pass_in_stack (data->promoted_mode, 2214 data->passed_type)) 2215 entry_parm = 0; 2216 2217 if (entry_parm) 2218 { 2219 int partial; 2220 2221 partial = targetm.calls.arg_partial_bytes (&all->args_so_far, 2222 data->promoted_mode, 2223 data->passed_type, 2224 data->named_arg); 2225 data->partial = partial; 2226 2227 /* The caller might already have allocated stack space for the 2228 register parameters. */ 2229 if (partial != 0 && all->reg_parm_stack_space == 0) 2230 { 2231 /* Part of this argument is passed in registers and part 2232 is passed on the stack. Ask the prologue code to extend 2233 the stack part so that we can recreate the full value. 2234 2235 PRETEND_BYTES is the size of the registers we need to store. 2236 CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra 2237 stack space that the prologue should allocate. 2238 2239 Internally, gcc assumes that the argument pointer is aligned 2240 to STACK_BOUNDARY bits. This is used both for alignment 2241 optimizations (see init_emit) and to locate arguments that are 2242 aligned to more than PARM_BOUNDARY bits. We must preserve this 2243 invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to 2244 a stack boundary. */ 2245 2246 /* We assume at most one partial arg, and it must be the first 2247 argument on the stack. */ 2248 gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size); 2249 2250 pretend_bytes = partial; 2251 all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES); 2252 2253 /* We want to align relative to the actual stack pointer, so 2254 don't include this in the stack size until later. */ 2255 all->extra_pretend_bytes = all->pretend_args_size; 2256 } 2257 } 2258 2259 locate_and_pad_parm (data->promoted_mode, data->passed_type, in_regs, 2260 entry_parm ? data->partial : 0, current_function_decl, 2261 &all->stack_args_size, &data->locate); 2262 2263 /* Adjust offsets to include the pretend args. */ 2264 pretend_bytes = all->extra_pretend_bytes - pretend_bytes; 2265 data->locate.slot_offset.constant += pretend_bytes; 2266 data->locate.offset.constant += pretend_bytes; 2267 2268 data->entry_parm = entry_parm; 2269} 2270 2271/* A subroutine of assign_parms. If there is actually space on the stack 2272 for this parm, count it in stack_args_size and return true. */ 2273 2274static bool 2275assign_parm_is_stack_parm (struct assign_parm_data_all *all, 2276 struct assign_parm_data_one *data) 2277{ 2278 /* Trivially true if we've no incoming register. */ 2279 if (data->entry_parm == NULL) 2280 ; 2281 /* Also true if we're partially in registers and partially not, 2282 since we've arranged to drop the entire argument on the stack. */ 2283 else if (data->partial != 0) 2284 ; 2285 /* Also true if the target says that it's passed in both registers 2286 and on the stack. */ 2287 else if (GET_CODE (data->entry_parm) == PARALLEL 2288 && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX) 2289 ; 2290 /* Also true if the target says that there's stack allocated for 2291 all register parameters. */ 2292 else if (all->reg_parm_stack_space > 0) 2293 ; 2294 /* Otherwise, no, this parameter has no ABI defined stack slot. */ 2295 else 2296 return false; 2297 2298 all->stack_args_size.constant += data->locate.size.constant; 2299 if (data->locate.size.var) 2300 ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var); 2301 2302 return true; 2303} 2304 2305/* A subroutine of assign_parms. Given that this parameter is allocated 2306 stack space by the ABI, find it. */ 2307 2308static void 2309assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data) 2310{ 2311 rtx offset_rtx, stack_parm; 2312 unsigned int align, boundary; 2313 2314 /* If we're passing this arg using a reg, make its stack home the 2315 aligned stack slot. */ 2316 if (data->entry_parm) 2317 offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset); 2318 else 2319 offset_rtx = ARGS_SIZE_RTX (data->locate.offset); 2320 2321 stack_parm = current_function_internal_arg_pointer; 2322 if (offset_rtx != const0_rtx) 2323 stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx); 2324 stack_parm = gen_rtx_MEM (data->promoted_mode, stack_parm); 2325 2326 set_mem_attributes (stack_parm, parm, 1); 2327 2328 boundary = data->locate.boundary; 2329 align = BITS_PER_UNIT; 2330 2331 /* If we're padding upward, we know that the alignment of the slot 2332 is FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're 2333 intentionally forcing upward padding. Otherwise we have to come 2334 up with a guess at the alignment based on OFFSET_RTX. */ 2335 if (data->locate.where_pad != downward || data->entry_parm) 2336 align = boundary; 2337 else if (GET_CODE (offset_rtx) == CONST_INT) 2338 { 2339 align = INTVAL (offset_rtx) * BITS_PER_UNIT | boundary; 2340 align = align & -align; 2341 } 2342 set_mem_align (stack_parm, align); 2343 2344 if (data->entry_parm) 2345 set_reg_attrs_for_parm (data->entry_parm, stack_parm); 2346 2347 data->stack_parm = stack_parm; 2348} 2349 2350/* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's 2351 always valid and contiguous. */ 2352 2353static void 2354assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data) 2355{ 2356 rtx entry_parm = data->entry_parm; 2357 rtx stack_parm = data->stack_parm; 2358 2359 /* If this parm was passed part in regs and part in memory, pretend it 2360 arrived entirely in memory by pushing the register-part onto the stack. 2361 In the special case of a DImode or DFmode that is split, we could put 2362 it together in a pseudoreg directly, but for now that's not worth 2363 bothering with. */ 2364 if (data->partial != 0) 2365 { 2366 /* Handle calls that pass values in multiple non-contiguous 2367 locations. The Irix 6 ABI has examples of this. */ 2368 if (GET_CODE (entry_parm) == PARALLEL) 2369 emit_group_store (validize_mem (stack_parm), entry_parm, 2370 data->passed_type, 2371 int_size_in_bytes (data->passed_type)); 2372 else 2373 { 2374 gcc_assert (data->partial % UNITS_PER_WORD == 0); 2375 move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm), 2376 data->partial / UNITS_PER_WORD); 2377 } 2378 2379 entry_parm = stack_parm; 2380 } 2381 2382 /* If we didn't decide this parm came in a register, by default it came 2383 on the stack. */ 2384 else if (entry_parm == NULL) 2385 entry_parm = stack_parm; 2386 2387 /* When an argument is passed in multiple locations, we can't make use 2388 of this information, but we can save some copying if the whole argument 2389 is passed in a single register. */ 2390 else if (GET_CODE (entry_parm) == PARALLEL 2391 && data->nominal_mode != BLKmode 2392 && data->passed_mode != BLKmode) 2393 { 2394 size_t i, len = XVECLEN (entry_parm, 0); 2395 2396 for (i = 0; i < len; i++) 2397 if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX 2398 && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0)) 2399 && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0)) 2400 == data->passed_mode) 2401 && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0) 2402 { 2403 entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0); 2404 break; 2405 } 2406 } 2407 2408 data->entry_parm = entry_parm; 2409} 2410 2411/* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's 2412 always valid and properly aligned. */ 2413 2414static void 2415assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data) 2416{ 2417 rtx stack_parm = data->stack_parm; 2418 2419 /* If we can't trust the parm stack slot to be aligned enough for its 2420 ultimate type, don't use that slot after entry. We'll make another 2421 stack slot, if we need one. */ 2422 if (stack_parm 2423 && ((STRICT_ALIGNMENT 2424 && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)) 2425 || (data->nominal_type 2426 && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm) 2427 && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY))) 2428 stack_parm = NULL; 2429 2430 /* If parm was passed in memory, and we need to convert it on entry, 2431 don't store it back in that same slot. */ 2432 else if (data->entry_parm == stack_parm 2433 && data->nominal_mode != BLKmode 2434 && data->nominal_mode != data->passed_mode) 2435 stack_parm = NULL; 2436 2437 /* If stack protection is in effect for this function, don't leave any 2438 pointers in their passed stack slots. */ 2439 else if (cfun->stack_protect_guard 2440 && (flag_stack_protect == 2 2441 || data->passed_pointer 2442 || POINTER_TYPE_P (data->nominal_type))) 2443 stack_parm = NULL; 2444 2445 data->stack_parm = stack_parm; 2446} 2447 2448/* A subroutine of assign_parms. Return true if the current parameter 2449 should be stored as a BLKmode in the current frame. */ 2450 2451static bool 2452assign_parm_setup_block_p (struct assign_parm_data_one *data) 2453{ 2454 if (data->nominal_mode == BLKmode) 2455 return true; 2456 if (GET_CODE (data->entry_parm) == PARALLEL) 2457 return true; 2458 2459#ifdef BLOCK_REG_PADDING 2460 /* Only assign_parm_setup_block knows how to deal with register arguments 2461 that are padded at the least significant end. */ 2462 if (REG_P (data->entry_parm) 2463 && GET_MODE_SIZE (data->promoted_mode) < UNITS_PER_WORD 2464 && (BLOCK_REG_PADDING (data->passed_mode, data->passed_type, 1) 2465 == (BYTES_BIG_ENDIAN ? upward : downward))) 2466 return true; 2467#endif 2468 2469 return false; 2470} 2471 2472/* A subroutine of assign_parms. Arrange for the parameter to be 2473 present and valid in DATA->STACK_RTL. */ 2474 2475static void 2476assign_parm_setup_block (struct assign_parm_data_all *all, 2477 tree parm, struct assign_parm_data_one *data) 2478{ 2479 rtx entry_parm = data->entry_parm; 2480 rtx stack_parm = data->stack_parm; 2481 HOST_WIDE_INT size; 2482 HOST_WIDE_INT size_stored; 2483 rtx orig_entry_parm = entry_parm; 2484 2485 if (GET_CODE (entry_parm) == PARALLEL) 2486 entry_parm = emit_group_move_into_temps (entry_parm); 2487 2488 /* If we've a non-block object that's nevertheless passed in parts, 2489 reconstitute it in register operations rather than on the stack. */ 2490 if (GET_CODE (entry_parm) == PARALLEL 2491 && data->nominal_mode != BLKmode) 2492 { 2493 rtx elt0 = XEXP (XVECEXP (orig_entry_parm, 0, 0), 0); 2494 2495 if ((XVECLEN (entry_parm, 0) > 1 2496 || hard_regno_nregs[REGNO (elt0)][GET_MODE (elt0)] > 1) 2497 && use_register_for_decl (parm)) 2498 { 2499 rtx parmreg = gen_reg_rtx (data->nominal_mode); 2500 2501 push_to_sequence (all->conversion_insns); 2502 2503 /* For values returned in multiple registers, handle possible 2504 incompatible calls to emit_group_store. 2505 2506 For example, the following would be invalid, and would have to 2507 be fixed by the conditional below: 2508 2509 emit_group_store ((reg:SF), (parallel:DF)) 2510 emit_group_store ((reg:SI), (parallel:DI)) 2511 2512 An example of this are doubles in e500 v2: 2513 (parallel:DF (expr_list (reg:SI) (const_int 0)) 2514 (expr_list (reg:SI) (const_int 4))). */ 2515 if (data->nominal_mode != data->passed_mode) 2516 { 2517 rtx t = gen_reg_rtx (GET_MODE (entry_parm)); 2518 emit_group_store (t, entry_parm, NULL_TREE, 2519 GET_MODE_SIZE (GET_MODE (entry_parm))); 2520 convert_move (parmreg, t, 0); 2521 } 2522 else 2523 emit_group_store (parmreg, entry_parm, data->nominal_type, 2524 int_size_in_bytes (data->nominal_type)); 2525 2526 all->conversion_insns = get_insns (); 2527 end_sequence (); 2528 2529 SET_DECL_RTL (parm, parmreg); 2530 return; 2531 } 2532 } 2533 2534 size = int_size_in_bytes (data->passed_type); 2535 size_stored = CEIL_ROUND (size, UNITS_PER_WORD); 2536 if (stack_parm == 0) 2537 { 2538 DECL_ALIGN (parm) = MAX (DECL_ALIGN (parm), BITS_PER_WORD); 2539 stack_parm = assign_stack_local (BLKmode, size_stored, 2540 DECL_ALIGN (parm)); 2541 if (GET_MODE_SIZE (GET_MODE (entry_parm)) == size) 2542 PUT_MODE (stack_parm, GET_MODE (entry_parm)); 2543 set_mem_attributes (stack_parm, parm, 1); 2544 } 2545 2546 /* If a BLKmode arrives in registers, copy it to a stack slot. Handle 2547 calls that pass values in multiple non-contiguous locations. */ 2548 if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL) 2549 { 2550 rtx mem; 2551 2552 /* Note that we will be storing an integral number of words. 2553 So we have to be careful to ensure that we allocate an 2554 integral number of words. We do this above when we call 2555 assign_stack_local if space was not allocated in the argument 2556 list. If it was, this will not work if PARM_BOUNDARY is not 2557 a multiple of BITS_PER_WORD. It isn't clear how to fix this 2558 if it becomes a problem. Exception is when BLKmode arrives 2559 with arguments not conforming to word_mode. */ 2560 2561 if (data->stack_parm == 0) 2562 ; 2563 else if (GET_CODE (entry_parm) == PARALLEL) 2564 ; 2565 else 2566 gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD)); 2567 2568 mem = validize_mem (stack_parm); 2569 2570 /* Handle values in multiple non-contiguous locations. */ 2571 if (GET_CODE (entry_parm) == PARALLEL) 2572 { 2573 push_to_sequence (all->conversion_insns); 2574 emit_group_store (mem, entry_parm, data->passed_type, size); 2575 all->conversion_insns = get_insns (); 2576 end_sequence (); 2577 } 2578 2579 else if (size == 0) 2580 ; 2581 2582 /* If SIZE is that of a mode no bigger than a word, just use 2583 that mode's store operation. */ 2584 else if (size <= UNITS_PER_WORD) 2585 { 2586 enum machine_mode mode 2587 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0); 2588 2589 if (mode != BLKmode 2590#ifdef BLOCK_REG_PADDING 2591 && (size == UNITS_PER_WORD 2592 || (BLOCK_REG_PADDING (mode, data->passed_type, 1) 2593 != (BYTES_BIG_ENDIAN ? upward : downward))) 2594#endif 2595 ) 2596 { 2597 rtx reg = gen_rtx_REG (mode, REGNO (entry_parm)); 2598 emit_move_insn (change_address (mem, mode, 0), reg); 2599 } 2600 2601 /* Blocks smaller than a word on a BYTES_BIG_ENDIAN 2602 machine must be aligned to the left before storing 2603 to memory. Note that the previous test doesn't 2604 handle all cases (e.g. SIZE == 3). */ 2605 else if (size != UNITS_PER_WORD 2606#ifdef BLOCK_REG_PADDING 2607 && (BLOCK_REG_PADDING (mode, data->passed_type, 1) 2608 == downward) 2609#else 2610 && BYTES_BIG_ENDIAN 2611#endif 2612 ) 2613 { 2614 rtx tem, x; 2615 int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT; 2616 rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm)); 2617 2618 x = expand_shift (LSHIFT_EXPR, word_mode, reg, 2619 build_int_cst (NULL_TREE, by), 2620 NULL_RTX, 1); 2621 tem = change_address (mem, word_mode, 0); 2622 emit_move_insn (tem, x); 2623 } 2624 else 2625 move_block_from_reg (REGNO (entry_parm), mem, 2626 size_stored / UNITS_PER_WORD); 2627 } 2628 else 2629 move_block_from_reg (REGNO (entry_parm), mem, 2630 size_stored / UNITS_PER_WORD); 2631 } 2632 else if (data->stack_parm == 0) 2633 { 2634 push_to_sequence (all->conversion_insns); 2635 emit_block_move (stack_parm, data->entry_parm, GEN_INT (size), 2636 BLOCK_OP_NORMAL); 2637 all->conversion_insns = get_insns (); 2638 end_sequence (); 2639 } 2640 2641 data->stack_parm = stack_parm; 2642 SET_DECL_RTL (parm, stack_parm); 2643} 2644 2645/* A subroutine of assign_parms. Allocate a pseudo to hold the current 2646 parameter. Get it there. Perform all ABI specified conversions. */ 2647 2648static void 2649assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm, 2650 struct assign_parm_data_one *data) 2651{ 2652 rtx parmreg; 2653 enum machine_mode promoted_nominal_mode; 2654 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm)); 2655 bool did_conversion = false; 2656 2657 /* Store the parm in a pseudoregister during the function, but we may 2658 need to do it in a wider mode. */ 2659 2660 /* This is not really promoting for a call. However we need to be 2661 consistent with assign_parm_find_data_types and expand_expr_real_1. */ 2662 promoted_nominal_mode 2663 = promote_mode (data->nominal_type, data->nominal_mode, &unsignedp, 1); 2664 2665 parmreg = gen_reg_rtx (promoted_nominal_mode); 2666 2667 if (!DECL_ARTIFICIAL (parm)) 2668 mark_user_reg (parmreg); 2669 2670 /* If this was an item that we received a pointer to, 2671 set DECL_RTL appropriately. */ 2672 if (data->passed_pointer) 2673 { 2674 rtx x = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->passed_type)), parmreg); 2675 set_mem_attributes (x, parm, 1); 2676 SET_DECL_RTL (parm, x); 2677 } 2678 else 2679 SET_DECL_RTL (parm, parmreg); 2680 2681 /* Copy the value into the register. */ 2682 if (data->nominal_mode != data->passed_mode 2683 || promoted_nominal_mode != data->promoted_mode) 2684 { 2685 int save_tree_used; 2686 2687 /* ENTRY_PARM has been converted to PROMOTED_MODE, its 2688 mode, by the caller. We now have to convert it to 2689 NOMINAL_MODE, if different. However, PARMREG may be in 2690 a different mode than NOMINAL_MODE if it is being stored 2691 promoted. 2692 2693 If ENTRY_PARM is a hard register, it might be in a register 2694 not valid for operating in its mode (e.g., an odd-numbered 2695 register for a DFmode). In that case, moves are the only 2696 thing valid, so we can't do a convert from there. This 2697 occurs when the calling sequence allow such misaligned 2698 usages. 2699 2700 In addition, the conversion may involve a call, which could 2701 clobber parameters which haven't been copied to pseudo 2702 registers yet. Therefore, we must first copy the parm to 2703 a pseudo reg here, and save the conversion until after all 2704 parameters have been moved. */ 2705 2706 rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); 2707 2708 emit_move_insn (tempreg, validize_mem (data->entry_parm)); 2709 2710 push_to_sequence (all->conversion_insns); 2711 tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp); 2712 2713 if (GET_CODE (tempreg) == SUBREG 2714 && GET_MODE (tempreg) == data->nominal_mode 2715 && REG_P (SUBREG_REG (tempreg)) 2716 && data->nominal_mode == data->passed_mode 2717 && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm) 2718 && GET_MODE_SIZE (GET_MODE (tempreg)) 2719 < GET_MODE_SIZE (GET_MODE (data->entry_parm))) 2720 { 2721 /* The argument is already sign/zero extended, so note it 2722 into the subreg. */ 2723 SUBREG_PROMOTED_VAR_P (tempreg) = 1; 2724 SUBREG_PROMOTED_UNSIGNED_SET (tempreg, unsignedp); 2725 } 2726 2727 /* TREE_USED gets set erroneously during expand_assignment. */ 2728 save_tree_used = TREE_USED (parm); 2729 expand_assignment (parm, make_tree (data->nominal_type, tempreg)); 2730 TREE_USED (parm) = save_tree_used; 2731 all->conversion_insns = get_insns (); 2732 end_sequence (); 2733 2734 did_conversion = true; 2735 } 2736 else 2737 emit_move_insn (parmreg, validize_mem (data->entry_parm)); 2738 2739 /* If we were passed a pointer but the actual value can safely live 2740 in a register, put it in one. */ 2741 if (data->passed_pointer 2742 && TYPE_MODE (TREE_TYPE (parm)) != BLKmode 2743 /* If by-reference argument was promoted, demote it. */ 2744 && (TYPE_MODE (TREE_TYPE (parm)) != GET_MODE (DECL_RTL (parm)) 2745 || use_register_for_decl (parm))) 2746 { 2747 /* We can't use nominal_mode, because it will have been set to 2748 Pmode above. We must use the actual mode of the parm. */ 2749 parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); 2750 mark_user_reg (parmreg); 2751 2752 if (GET_MODE (parmreg) != GET_MODE (DECL_RTL (parm))) 2753 { 2754 rtx tempreg = gen_reg_rtx (GET_MODE (DECL_RTL (parm))); 2755 int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm)); 2756 2757 push_to_sequence (all->conversion_insns); 2758 emit_move_insn (tempreg, DECL_RTL (parm)); 2759 tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p); 2760 emit_move_insn (parmreg, tempreg); 2761 all->conversion_insns = get_insns (); 2762 end_sequence (); 2763 2764 did_conversion = true; 2765 } 2766 else 2767 emit_move_insn (parmreg, DECL_RTL (parm)); 2768 2769 SET_DECL_RTL (parm, parmreg); 2770 2771 /* STACK_PARM is the pointer, not the parm, and PARMREG is 2772 now the parm. */ 2773 data->stack_parm = NULL; 2774 } 2775 2776 /* Mark the register as eliminable if we did no conversion and it was 2777 copied from memory at a fixed offset, and the arg pointer was not 2778 copied to a pseudo-reg. If the arg pointer is a pseudo reg or the 2779 offset formed an invalid address, such memory-equivalences as we 2780 make here would screw up life analysis for it. */ 2781 if (data->nominal_mode == data->passed_mode 2782 && !did_conversion 2783 && data->stack_parm != 0 2784 && MEM_P (data->stack_parm) 2785 && data->locate.offset.var == 0 2786 && reg_mentioned_p (virtual_incoming_args_rtx, 2787 XEXP (data->stack_parm, 0))) 2788 { 2789 rtx linsn = get_last_insn (); 2790 rtx sinsn, set; 2791 2792 /* Mark complex types separately. */ 2793 if (GET_CODE (parmreg) == CONCAT) 2794 { 2795 enum machine_mode submode 2796 = GET_MODE_INNER (GET_MODE (parmreg)); 2797 int regnor = REGNO (XEXP (parmreg, 0)); 2798 int regnoi = REGNO (XEXP (parmreg, 1)); 2799 rtx stackr = adjust_address_nv (data->stack_parm, submode, 0); 2800 rtx stacki = adjust_address_nv (data->stack_parm, submode, 2801 GET_MODE_SIZE (submode)); 2802 2803 /* Scan backwards for the set of the real and 2804 imaginary parts. */ 2805 for (sinsn = linsn; sinsn != 0; 2806 sinsn = prev_nonnote_insn (sinsn)) 2807 { 2808 set = single_set (sinsn); 2809 if (set == 0) 2810 continue; 2811 2812 if (SET_DEST (set) == regno_reg_rtx [regnoi]) 2813 REG_NOTES (sinsn) 2814 = gen_rtx_EXPR_LIST (REG_EQUIV, stacki, 2815 REG_NOTES (sinsn)); 2816 else if (SET_DEST (set) == regno_reg_rtx [regnor]) 2817 REG_NOTES (sinsn) 2818 = gen_rtx_EXPR_LIST (REG_EQUIV, stackr, 2819 REG_NOTES (sinsn)); 2820 } 2821 } 2822 else if ((set = single_set (linsn)) != 0 2823 && SET_DEST (set) == parmreg) 2824 REG_NOTES (linsn) 2825 = gen_rtx_EXPR_LIST (REG_EQUIV, 2826 data->stack_parm, REG_NOTES (linsn)); 2827 } 2828 2829 /* For pointer data type, suggest pointer register. */ 2830 if (POINTER_TYPE_P (TREE_TYPE (parm))) 2831 mark_reg_pointer (parmreg, 2832 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); 2833} 2834 2835/* A subroutine of assign_parms. Allocate stack space to hold the current 2836 parameter. Get it there. Perform all ABI specified conversions. */ 2837 2838static void 2839assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm, 2840 struct assign_parm_data_one *data) 2841{ 2842 /* Value must be stored in the stack slot STACK_PARM during function 2843 execution. */ 2844 bool to_conversion = false; 2845 2846 if (data->promoted_mode != data->nominal_mode) 2847 { 2848 /* Conversion is required. */ 2849 rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm)); 2850 2851 emit_move_insn (tempreg, validize_mem (data->entry_parm)); 2852 2853 push_to_sequence (all->conversion_insns); 2854 to_conversion = true; 2855 2856 data->entry_parm = convert_to_mode (data->nominal_mode, tempreg, 2857 TYPE_UNSIGNED (TREE_TYPE (parm))); 2858 2859 if (data->stack_parm) 2860 /* ??? This may need a big-endian conversion on sparc64. */ 2861 data->stack_parm 2862 = adjust_address (data->stack_parm, data->nominal_mode, 0); 2863 } 2864 2865 if (data->entry_parm != data->stack_parm) 2866 { 2867 rtx src, dest; 2868 2869 if (data->stack_parm == 0) 2870 { 2871 data->stack_parm 2872 = assign_stack_local (GET_MODE (data->entry_parm), 2873 GET_MODE_SIZE (GET_MODE (data->entry_parm)), 2874 TYPE_ALIGN (data->passed_type)); 2875 set_mem_attributes (data->stack_parm, parm, 1); 2876 } 2877 2878 dest = validize_mem (data->stack_parm); 2879 src = validize_mem (data->entry_parm); 2880 2881 if (MEM_P (src)) 2882 { 2883 /* Use a block move to handle potentially misaligned entry_parm. */ 2884 if (!to_conversion) 2885 push_to_sequence (all->conversion_insns); 2886 to_conversion = true; 2887 2888 emit_block_move (dest, src, 2889 GEN_INT (int_size_in_bytes (data->passed_type)), 2890 BLOCK_OP_NORMAL); 2891 } 2892 else 2893 emit_move_insn (dest, src); 2894 } 2895 2896 if (to_conversion) 2897 { 2898 all->conversion_insns = get_insns (); 2899 end_sequence (); 2900 } 2901 2902 SET_DECL_RTL (parm, data->stack_parm); 2903} 2904 2905/* A subroutine of assign_parms. If the ABI splits complex arguments, then 2906 undo the frobbing that we did in assign_parms_augmented_arg_list. */ 2907 2908static void 2909assign_parms_unsplit_complex (struct assign_parm_data_all *all, tree fnargs) 2910{ 2911 tree parm; 2912 tree orig_fnargs = all->orig_fnargs; 2913 2914 for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm)) 2915 { 2916 if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE 2917 && targetm.calls.split_complex_arg (TREE_TYPE (parm))) 2918 { 2919 rtx tmp, real, imag; 2920 enum machine_mode inner = GET_MODE_INNER (DECL_MODE (parm)); 2921 2922 real = DECL_RTL (fnargs); 2923 imag = DECL_RTL (TREE_CHAIN (fnargs)); 2924 if (inner != GET_MODE (real)) 2925 { 2926 real = gen_lowpart_SUBREG (inner, real); 2927 imag = gen_lowpart_SUBREG (inner, imag); 2928 } 2929 2930 if (TREE_ADDRESSABLE (parm)) 2931 { 2932 rtx rmem, imem; 2933 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm)); 2934 2935 /* split_complex_arg put the real and imag parts in 2936 pseudos. Move them to memory. */ 2937 tmp = assign_stack_local (DECL_MODE (parm), size, 2938 TYPE_ALIGN (TREE_TYPE (parm))); 2939 set_mem_attributes (tmp, parm, 1); 2940 rmem = adjust_address_nv (tmp, inner, 0); 2941 imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner)); 2942 push_to_sequence (all->conversion_insns); 2943 emit_move_insn (rmem, real); 2944 emit_move_insn (imem, imag); 2945 all->conversion_insns = get_insns (); 2946 end_sequence (); 2947 } 2948 else 2949 tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); 2950 SET_DECL_RTL (parm, tmp); 2951 2952 real = DECL_INCOMING_RTL (fnargs); 2953 imag = DECL_INCOMING_RTL (TREE_CHAIN (fnargs)); 2954 if (inner != GET_MODE (real)) 2955 { 2956 real = gen_lowpart_SUBREG (inner, real); 2957 imag = gen_lowpart_SUBREG (inner, imag); 2958 } 2959 tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag); 2960 set_decl_incoming_rtl (parm, tmp); 2961 fnargs = TREE_CHAIN (fnargs); 2962 } 2963 else 2964 { 2965 SET_DECL_RTL (parm, DECL_RTL (fnargs)); 2966 set_decl_incoming_rtl (parm, DECL_INCOMING_RTL (fnargs)); 2967 2968 /* Set MEM_EXPR to the original decl, i.e. to PARM, 2969 instead of the copy of decl, i.e. FNARGS. */ 2970 if (DECL_INCOMING_RTL (parm) && MEM_P (DECL_INCOMING_RTL (parm))) 2971 set_mem_expr (DECL_INCOMING_RTL (parm), parm); 2972 } 2973 2974 fnargs = TREE_CHAIN (fnargs); 2975 } 2976} 2977 2978/* Assign RTL expressions to the function's parameters. This may involve 2979 copying them into registers and using those registers as the DECL_RTL. */ 2980 2981static void 2982assign_parms (tree fndecl) 2983{ 2984 struct assign_parm_data_all all; 2985 tree fnargs, parm; 2986 2987 current_function_internal_arg_pointer 2988 = targetm.calls.internal_arg_pointer (); 2989 2990 assign_parms_initialize_all (&all); 2991 fnargs = assign_parms_augmented_arg_list (&all); 2992 2993 for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) 2994 { 2995 struct assign_parm_data_one data; 2996 2997 /* Extract the type of PARM; adjust it according to ABI. */ 2998 assign_parm_find_data_types (&all, parm, &data); 2999 3000 /* Early out for errors and void parameters. */ 3001 if (data.passed_mode == VOIDmode) 3002 { 3003 SET_DECL_RTL (parm, const0_rtx); 3004 DECL_INCOMING_RTL (parm) = DECL_RTL (parm); 3005 continue; 3006 } 3007 3008 if (current_function_stdarg && !TREE_CHAIN (parm)) 3009 assign_parms_setup_varargs (&all, &data, false); 3010 3011 /* Find out where the parameter arrives in this function. */ 3012 assign_parm_find_entry_rtl (&all, &data); 3013 3014 /* Find out where stack space for this parameter might be. */ 3015 if (assign_parm_is_stack_parm (&all, &data)) 3016 { 3017 assign_parm_find_stack_rtl (parm, &data); 3018 assign_parm_adjust_entry_rtl (&data); 3019 } 3020 3021 /* Record permanently how this parm was passed. */ 3022 set_decl_incoming_rtl (parm, data.entry_parm); 3023 3024 /* Update info on where next arg arrives in registers. */ 3025 FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode, 3026 data.passed_type, data.named_arg); 3027 3028 assign_parm_adjust_stack_rtl (&data); 3029 3030 if (assign_parm_setup_block_p (&data)) 3031 assign_parm_setup_block (&all, parm, &data); 3032 else if (data.passed_pointer || use_register_for_decl (parm)) 3033 assign_parm_setup_reg (&all, parm, &data); 3034 else 3035 assign_parm_setup_stack (&all, parm, &data); 3036 } 3037 3038 if (targetm.calls.split_complex_arg && fnargs != all.orig_fnargs) 3039 assign_parms_unsplit_complex (&all, fnargs); 3040 3041 /* Output all parameter conversion instructions (possibly including calls) 3042 now that all parameters have been copied out of hard registers. */ 3043 emit_insn (all.conversion_insns); 3044 3045 /* If we are receiving a struct value address as the first argument, set up 3046 the RTL for the function result. As this might require code to convert 3047 the transmitted address to Pmode, we do this here to ensure that possible 3048 preliminary conversions of the address have been emitted already. */ 3049 if (all.function_result_decl) 3050 { 3051 tree result = DECL_RESULT (current_function_decl); 3052 rtx addr = DECL_RTL (all.function_result_decl); 3053 rtx x; 3054 3055 if (DECL_BY_REFERENCE (result)) 3056 x = addr; 3057 else 3058 { 3059 addr = convert_memory_address (Pmode, addr); 3060 x = gen_rtx_MEM (DECL_MODE (result), addr); 3061 set_mem_attributes (x, result, 1); 3062 } 3063 SET_DECL_RTL (result, x); 3064 } 3065 3066 /* We have aligned all the args, so add space for the pretend args. */ 3067 current_function_pretend_args_size = all.pretend_args_size; 3068 all.stack_args_size.constant += all.extra_pretend_bytes; 3069 current_function_args_size = all.stack_args_size.constant; 3070 3071 /* Adjust function incoming argument size for alignment and 3072 minimum length. */ 3073 3074#ifdef REG_PARM_STACK_SPACE 3075 current_function_args_size = MAX (current_function_args_size, 3076 REG_PARM_STACK_SPACE (fndecl)); 3077#endif 3078 3079 current_function_args_size = CEIL_ROUND (current_function_args_size, 3080 PARM_BOUNDARY / BITS_PER_UNIT); 3081 3082#ifdef ARGS_GROW_DOWNWARD 3083 current_function_arg_offset_rtx 3084 = (all.stack_args_size.var == 0 ? GEN_INT (-all.stack_args_size.constant) 3085 : expand_expr (size_diffop (all.stack_args_size.var, 3086 size_int (-all.stack_args_size.constant)), 3087 NULL_RTX, VOIDmode, 0)); 3088#else 3089 current_function_arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size); 3090#endif 3091 3092 /* See how many bytes, if any, of its args a function should try to pop 3093 on return. */ 3094 3095 current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl), 3096 current_function_args_size); 3097 3098 /* For stdarg.h function, save info about 3099 regs and stack space used by the named args. */ 3100 3101 current_function_args_info = all.args_so_far; 3102 3103 /* Set the rtx used for the function return value. Put this in its 3104 own variable so any optimizers that need this information don't have 3105 to include tree.h. Do this here so it gets done when an inlined 3106 function gets output. */ 3107 3108 current_function_return_rtx 3109 = (DECL_RTL_SET_P (DECL_RESULT (fndecl)) 3110 ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX); 3111 3112 /* If scalar return value was computed in a pseudo-reg, or was a named 3113 return value that got dumped to the stack, copy that to the hard 3114 return register. */ 3115 if (DECL_RTL_SET_P (DECL_RESULT (fndecl))) 3116 { 3117 tree decl_result = DECL_RESULT (fndecl); 3118 rtx decl_rtl = DECL_RTL (decl_result); 3119 3120 if (REG_P (decl_rtl) 3121 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER 3122 : DECL_REGISTER (decl_result)) 3123 { 3124 rtx real_decl_rtl; 3125 3126 real_decl_rtl = targetm.calls.function_value (TREE_TYPE (decl_result), 3127 fndecl, true); 3128 REG_FUNCTION_VALUE_P (real_decl_rtl) = 1; 3129 /* The delay slot scheduler assumes that current_function_return_rtx 3130 holds the hard register containing the return value, not a 3131 temporary pseudo. */ 3132 current_function_return_rtx = real_decl_rtl; 3133 } 3134 } 3135} 3136 3137/* A subroutine of gimplify_parameters, invoked via walk_tree. 3138 For all seen types, gimplify their sizes. */ 3139 3140static tree 3141gimplify_parm_type (tree *tp, int *walk_subtrees, void *data) 3142{ 3143 tree t = *tp; 3144 3145 *walk_subtrees = 0; 3146 if (TYPE_P (t)) 3147 { 3148 if (POINTER_TYPE_P (t)) 3149 *walk_subtrees = 1; 3150 else if (TYPE_SIZE (t) && !TREE_CONSTANT (TYPE_SIZE (t)) 3151 && !TYPE_SIZES_GIMPLIFIED (t)) 3152 { 3153 gimplify_type_sizes (t, (tree *) data); 3154 *walk_subtrees = 1; 3155 } 3156 } 3157 3158 return NULL; 3159} 3160 3161/* Gimplify the parameter list for current_function_decl. This involves 3162 evaluating SAVE_EXPRs of variable sized parameters and generating code 3163 to implement callee-copies reference parameters. Returns a list of 3164 statements to add to the beginning of the function, or NULL if nothing 3165 to do. */ 3166 3167tree 3168gimplify_parameters (void) 3169{ 3170 struct assign_parm_data_all all; 3171 tree fnargs, parm, stmts = NULL; 3172 3173 assign_parms_initialize_all (&all); 3174 fnargs = assign_parms_augmented_arg_list (&all); 3175 3176 for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) 3177 { 3178 struct assign_parm_data_one data; 3179 3180 /* Extract the type of PARM; adjust it according to ABI. */ 3181 assign_parm_find_data_types (&all, parm, &data); 3182 3183 /* Early out for errors and void parameters. */ 3184 if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL) 3185 continue; 3186 3187 /* Update info on where next arg arrives in registers. */ 3188 FUNCTION_ARG_ADVANCE (all.args_so_far, data.promoted_mode, 3189 data.passed_type, data.named_arg); 3190 3191 /* ??? Once upon a time variable_size stuffed parameter list 3192 SAVE_EXPRs (amongst others) onto a pending sizes list. This 3193 turned out to be less than manageable in the gimple world. 3194 Now we have to hunt them down ourselves. */ 3195 walk_tree_without_duplicates (&data.passed_type, 3196 gimplify_parm_type, &stmts); 3197 3198 if (!TREE_CONSTANT (DECL_SIZE (parm))) 3199 { 3200 gimplify_one_sizepos (&DECL_SIZE (parm), &stmts); 3201 gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts); 3202 } 3203 3204 if (data.passed_pointer) 3205 { 3206 tree type = TREE_TYPE (data.passed_type); 3207 if (reference_callee_copied (&all.args_so_far, TYPE_MODE (type), 3208 type, data.named_arg)) 3209 { 3210 tree local, t; 3211 3212 /* For constant sized objects, this is trivial; for 3213 variable-sized objects, we have to play games. */ 3214 if (TREE_CONSTANT (DECL_SIZE (parm))) 3215 { 3216 local = create_tmp_var (type, get_name (parm)); 3217 DECL_IGNORED_P (local) = 0; 3218 } 3219 else 3220 { 3221 tree ptr_type, addr, args; 3222 3223 ptr_type = build_pointer_type (type); 3224 addr = create_tmp_var (ptr_type, get_name (parm)); 3225 DECL_IGNORED_P (addr) = 0; 3226 local = build_fold_indirect_ref (addr); 3227 3228 args = tree_cons (NULL, DECL_SIZE_UNIT (parm), NULL); 3229 t = built_in_decls[BUILT_IN_ALLOCA]; 3230 t = build_function_call_expr (t, args); 3231 t = fold_convert (ptr_type, t); 3232 t = build2 (MODIFY_EXPR, void_type_node, addr, t); 3233 gimplify_and_add (t, &stmts); 3234 } 3235 3236 t = build2 (MODIFY_EXPR, void_type_node, local, parm); 3237 gimplify_and_add (t, &stmts); 3238 3239 SET_DECL_VALUE_EXPR (parm, local); 3240 DECL_HAS_VALUE_EXPR_P (parm) = 1; 3241 } 3242 } 3243 } 3244 3245 return stmts; 3246} 3247 3248/* Indicate whether REGNO is an incoming argument to the current function 3249 that was promoted to a wider mode. If so, return the RTX for the 3250 register (to get its mode). PMODE and PUNSIGNEDP are set to the mode 3251 that REGNO is promoted from and whether the promotion was signed or 3252 unsigned. */ 3253 3254rtx 3255promoted_input_arg (unsigned int regno, enum machine_mode *pmode, int *punsignedp) 3256{ 3257 tree arg; 3258 3259 for (arg = DECL_ARGUMENTS (current_function_decl); arg; 3260 arg = TREE_CHAIN (arg)) 3261 if (REG_P (DECL_INCOMING_RTL (arg)) 3262 && REGNO (DECL_INCOMING_RTL (arg)) == regno 3263 && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg))) 3264 { 3265 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg)); 3266 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (arg)); 3267 3268 mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1); 3269 if (mode == GET_MODE (DECL_INCOMING_RTL (arg)) 3270 && mode != DECL_MODE (arg)) 3271 { 3272 *pmode = DECL_MODE (arg); 3273 *punsignedp = unsignedp; 3274 return DECL_INCOMING_RTL (arg); 3275 } 3276 } 3277 3278 return 0; 3279} 3280 3281 3282/* Compute the size and offset from the start of the stacked arguments for a 3283 parm passed in mode PASSED_MODE and with type TYPE. 3284 3285 INITIAL_OFFSET_PTR points to the current offset into the stacked 3286 arguments. 3287 3288 The starting offset and size for this parm are returned in 3289 LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is 3290 nonzero, the offset is that of stack slot, which is returned in 3291 LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of 3292 padding required from the initial offset ptr to the stack slot. 3293 3294 IN_REGS is nonzero if the argument will be passed in registers. It will 3295 never be set if REG_PARM_STACK_SPACE is not defined. 3296 3297 FNDECL is the function in which the argument was defined. 3298 3299 There are two types of rounding that are done. The first, controlled by 3300 FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument 3301 list to be aligned to the specific boundary (in bits). This rounding 3302 affects the initial and starting offsets, but not the argument size. 3303 3304 The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, 3305 optionally rounds the size of the parm to PARM_BOUNDARY. The 3306 initial offset is not affected by this rounding, while the size always 3307 is and the starting offset may be. */ 3308 3309/* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case; 3310 INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's 3311 callers pass in the total size of args so far as 3312 INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */ 3313 3314void 3315locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs, 3316 int partial, tree fndecl ATTRIBUTE_UNUSED, 3317 struct args_size *initial_offset_ptr, 3318 struct locate_and_pad_arg_data *locate) 3319{ 3320 tree sizetree; 3321 enum direction where_pad; 3322 unsigned int boundary; 3323 int reg_parm_stack_space = 0; 3324 int part_size_in_regs; 3325 3326#ifdef REG_PARM_STACK_SPACE 3327 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); 3328 3329 /* If we have found a stack parm before we reach the end of the 3330 area reserved for registers, skip that area. */ 3331 if (! in_regs) 3332 { 3333 if (reg_parm_stack_space > 0) 3334 { 3335 if (initial_offset_ptr->var) 3336 { 3337 initial_offset_ptr->var 3338 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), 3339 ssize_int (reg_parm_stack_space)); 3340 initial_offset_ptr->constant = 0; 3341 } 3342 else if (initial_offset_ptr->constant < reg_parm_stack_space) 3343 initial_offset_ptr->constant = reg_parm_stack_space; 3344 } 3345 } 3346#endif /* REG_PARM_STACK_SPACE */ 3347 3348 part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0); 3349 3350 sizetree 3351 = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); 3352 where_pad = FUNCTION_ARG_PADDING (passed_mode, type); 3353 boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type); 3354 locate->where_pad = where_pad; 3355 locate->boundary = boundary; 3356 3357 /* Remember if the outgoing parameter requires extra alignment on the 3358 calling function side. */ 3359 if (boundary > PREFERRED_STACK_BOUNDARY) 3360 boundary = PREFERRED_STACK_BOUNDARY; 3361 if (cfun->stack_alignment_needed < boundary) 3362 cfun->stack_alignment_needed = boundary; 3363 3364#ifdef ARGS_GROW_DOWNWARD 3365 locate->slot_offset.constant = -initial_offset_ptr->constant; 3366 if (initial_offset_ptr->var) 3367 locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0), 3368 initial_offset_ptr->var); 3369 3370 { 3371 tree s2 = sizetree; 3372 if (where_pad != none 3373 && (!host_integerp (sizetree, 1) 3374 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) 3375 s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT); 3376 SUB_PARM_SIZE (locate->slot_offset, s2); 3377 } 3378 3379 locate->slot_offset.constant += part_size_in_regs; 3380 3381 if (!in_regs 3382#ifdef REG_PARM_STACK_SPACE 3383 || REG_PARM_STACK_SPACE (fndecl) > 0 3384#endif 3385 ) 3386 pad_to_arg_alignment (&locate->slot_offset, boundary, 3387 &locate->alignment_pad); 3388 3389 locate->size.constant = (-initial_offset_ptr->constant 3390 - locate->slot_offset.constant); 3391 if (initial_offset_ptr->var) 3392 locate->size.var = size_binop (MINUS_EXPR, 3393 size_binop (MINUS_EXPR, 3394 ssize_int (0), 3395 initial_offset_ptr->var), 3396 locate->slot_offset.var); 3397 3398 /* Pad_below needs the pre-rounded size to know how much to pad 3399 below. */ 3400 locate->offset = locate->slot_offset; 3401 if (where_pad == downward) 3402 pad_below (&locate->offset, passed_mode, sizetree); 3403 3404#else /* !ARGS_GROW_DOWNWARD */ 3405 if (!in_regs 3406#ifdef REG_PARM_STACK_SPACE 3407 || REG_PARM_STACK_SPACE (fndecl) > 0 3408#endif 3409 ) 3410 pad_to_arg_alignment (initial_offset_ptr, boundary, 3411 &locate->alignment_pad); 3412 locate->slot_offset = *initial_offset_ptr; 3413 3414#ifdef PUSH_ROUNDING 3415 if (passed_mode != BLKmode) 3416 sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); 3417#endif 3418 3419 /* Pad_below needs the pre-rounded size to know how much to pad below 3420 so this must be done before rounding up. */ 3421 locate->offset = locate->slot_offset; 3422 if (where_pad == downward) 3423 pad_below (&locate->offset, passed_mode, sizetree); 3424 3425 if (where_pad != none 3426 && (!host_integerp (sizetree, 1) 3427 || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY)) 3428 sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); 3429 3430 ADD_PARM_SIZE (locate->size, sizetree); 3431 3432 locate->size.constant -= part_size_in_regs; 3433#endif /* ARGS_GROW_DOWNWARD */ 3434} 3435 3436/* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. 3437 BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ 3438 3439static void 3440pad_to_arg_alignment (struct args_size *offset_ptr, int boundary, 3441 struct args_size *alignment_pad) 3442{ 3443 tree save_var = NULL_TREE; 3444 HOST_WIDE_INT save_constant = 0; 3445 int boundary_in_bytes = boundary / BITS_PER_UNIT; 3446 HOST_WIDE_INT sp_offset = STACK_POINTER_OFFSET; 3447 3448#ifdef SPARC_STACK_BOUNDARY_HACK 3449 /* ??? The SPARC port may claim a STACK_BOUNDARY higher than 3450 the real alignment of %sp. However, when it does this, the 3451 alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */ 3452 if (SPARC_STACK_BOUNDARY_HACK) 3453 sp_offset = 0; 3454#endif 3455 3456 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 3457 { 3458 save_var = offset_ptr->var; 3459 save_constant = offset_ptr->constant; 3460 } 3461 3462 alignment_pad->var = NULL_TREE; 3463 alignment_pad->constant = 0; 3464 3465 if (boundary > BITS_PER_UNIT) 3466 { 3467 if (offset_ptr->var) 3468 { 3469 tree sp_offset_tree = ssize_int (sp_offset); 3470 tree offset = size_binop (PLUS_EXPR, 3471 ARGS_SIZE_TREE (*offset_ptr), 3472 sp_offset_tree); 3473#ifdef ARGS_GROW_DOWNWARD 3474 tree rounded = round_down (offset, boundary / BITS_PER_UNIT); 3475#else 3476 tree rounded = round_up (offset, boundary / BITS_PER_UNIT); 3477#endif 3478 3479 offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree); 3480 /* ARGS_SIZE_TREE includes constant term. */ 3481 offset_ptr->constant = 0; 3482 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 3483 alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var, 3484 save_var); 3485 } 3486 else 3487 { 3488 offset_ptr->constant = -sp_offset + 3489#ifdef ARGS_GROW_DOWNWARD 3490 FLOOR_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); 3491#else 3492 CEIL_ROUND (offset_ptr->constant + sp_offset, boundary_in_bytes); 3493#endif 3494 if (boundary > PARM_BOUNDARY && boundary > STACK_BOUNDARY) 3495 alignment_pad->constant = offset_ptr->constant - save_constant; 3496 } 3497 } 3498} 3499 3500static void 3501pad_below (struct args_size *offset_ptr, enum machine_mode passed_mode, tree sizetree) 3502{ 3503 if (passed_mode != BLKmode) 3504 { 3505 if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) 3506 offset_ptr->constant 3507 += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) 3508 / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) 3509 - GET_MODE_SIZE (passed_mode)); 3510 } 3511 else 3512 { 3513 if (TREE_CODE (sizetree) != INTEGER_CST 3514 || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) 3515 { 3516 /* Round the size up to multiple of PARM_BOUNDARY bits. */ 3517 tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); 3518 /* Add it in. */ 3519 ADD_PARM_SIZE (*offset_ptr, s2); 3520 SUB_PARM_SIZE (*offset_ptr, sizetree); 3521 } 3522 } 3523} 3524 3525/* Walk the tree of blocks describing the binding levels within a function 3526 and warn about variables the might be killed by setjmp or vfork. 3527 This is done after calling flow_analysis and before global_alloc 3528 clobbers the pseudo-regs to hard regs. */ 3529 3530void 3531setjmp_vars_warning (tree block) 3532{ 3533 tree decl, sub; 3534 3535 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 3536 { 3537 if (TREE_CODE (decl) == VAR_DECL 3538 && DECL_RTL_SET_P (decl) 3539 && REG_P (DECL_RTL (decl)) 3540 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) 3541 warning (0, "variable %q+D might be clobbered by %<longjmp%>" 3542 " or %<vfork%>", 3543 decl); 3544 } 3545 3546 for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) 3547 setjmp_vars_warning (sub); 3548} 3549 3550/* Do the appropriate part of setjmp_vars_warning 3551 but for arguments instead of local variables. */ 3552 3553void 3554setjmp_args_warning (void) 3555{ 3556 tree decl; 3557 for (decl = DECL_ARGUMENTS (current_function_decl); 3558 decl; decl = TREE_CHAIN (decl)) 3559 if (DECL_RTL (decl) != 0 3560 && REG_P (DECL_RTL (decl)) 3561 && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) 3562 warning (0, "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>", 3563 decl); 3564} 3565 3566 3567/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, 3568 and create duplicate blocks. */ 3569/* ??? Need an option to either create block fragments or to create 3570 abstract origin duplicates of a source block. It really depends 3571 on what optimization has been performed. */ 3572 3573void 3574reorder_blocks (void) 3575{ 3576 tree block = DECL_INITIAL (current_function_decl); 3577 VEC(tree,heap) *block_stack; 3578 3579 if (block == NULL_TREE) 3580 return; 3581 3582 block_stack = VEC_alloc (tree, heap, 10); 3583 3584 /* Reset the TREE_ASM_WRITTEN bit for all blocks. */ 3585 clear_block_marks (block); 3586 3587 /* Prune the old trees away, so that they don't get in the way. */ 3588 BLOCK_SUBBLOCKS (block) = NULL_TREE; 3589 BLOCK_CHAIN (block) = NULL_TREE; 3590 3591 /* Recreate the block tree from the note nesting. */ 3592 reorder_blocks_1 (get_insns (), block, &block_stack); 3593 BLOCK_SUBBLOCKS (block) = blocks_nreverse (BLOCK_SUBBLOCKS (block)); 3594 3595 VEC_free (tree, heap, block_stack); 3596} 3597 3598/* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */ 3599 3600void 3601clear_block_marks (tree block) 3602{ 3603 while (block) 3604 { 3605 TREE_ASM_WRITTEN (block) = 0; 3606 clear_block_marks (BLOCK_SUBBLOCKS (block)); 3607 block = BLOCK_CHAIN (block); 3608 } 3609} 3610 3611static void 3612reorder_blocks_1 (rtx insns, tree current_block, VEC(tree,heap) **p_block_stack) 3613{ 3614 rtx insn; 3615 3616 for (insn = insns; insn; insn = NEXT_INSN (insn)) 3617 { 3618 if (NOTE_P (insn)) 3619 { 3620 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) 3621 { 3622 tree block = NOTE_BLOCK (insn); 3623 tree origin; 3624 3625 origin = (BLOCK_FRAGMENT_ORIGIN (block) 3626 ? BLOCK_FRAGMENT_ORIGIN (block) 3627 : block); 3628 3629 /* If we have seen this block before, that means it now 3630 spans multiple address regions. Create a new fragment. */ 3631 if (TREE_ASM_WRITTEN (block)) 3632 { 3633 tree new_block = copy_node (block); 3634 3635 BLOCK_FRAGMENT_ORIGIN (new_block) = origin; 3636 BLOCK_FRAGMENT_CHAIN (new_block) 3637 = BLOCK_FRAGMENT_CHAIN (origin); 3638 BLOCK_FRAGMENT_CHAIN (origin) = new_block; 3639 3640 NOTE_BLOCK (insn) = new_block; 3641 block = new_block; 3642 } 3643 3644 BLOCK_SUBBLOCKS (block) = 0; 3645 TREE_ASM_WRITTEN (block) = 1; 3646 /* When there's only one block for the entire function, 3647 current_block == block and we mustn't do this, it 3648 will cause infinite recursion. */ 3649 if (block != current_block) 3650 { 3651 if (block != origin) 3652 gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block); 3653 3654 BLOCK_SUPERCONTEXT (block) = current_block; 3655 BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); 3656 BLOCK_SUBBLOCKS (current_block) = block; 3657 current_block = origin; 3658 } 3659 VEC_safe_push (tree, heap, *p_block_stack, block); 3660 } 3661 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) 3662 { 3663 NOTE_BLOCK (insn) = VEC_pop (tree, *p_block_stack); 3664 BLOCK_SUBBLOCKS (current_block) 3665 = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); 3666 current_block = BLOCK_SUPERCONTEXT (current_block); 3667 } 3668 } 3669 } 3670} 3671 3672/* Reverse the order of elements in the chain T of blocks, 3673 and return the new head of the chain (old last element). */ 3674 3675tree 3676blocks_nreverse (tree t) 3677{ 3678 tree prev = 0, decl, next; 3679 for (decl = t; decl; decl = next) 3680 { 3681 next = BLOCK_CHAIN (decl); 3682 BLOCK_CHAIN (decl) = prev; 3683 prev = decl; 3684 } 3685 return prev; 3686} 3687 3688/* Count the subblocks of the list starting with BLOCK. If VECTOR is 3689 non-NULL, list them all into VECTOR, in a depth-first preorder 3690 traversal of the block tree. Also clear TREE_ASM_WRITTEN in all 3691 blocks. */ 3692 3693static int 3694all_blocks (tree block, tree *vector) 3695{ 3696 int n_blocks = 0; 3697 3698 while (block) 3699 { 3700 TREE_ASM_WRITTEN (block) = 0; 3701 3702 /* Record this block. */ 3703 if (vector) 3704 vector[n_blocks] = block; 3705 3706 ++n_blocks; 3707 3708 /* Record the subblocks, and their subblocks... */ 3709 n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), 3710 vector ? vector + n_blocks : 0); 3711 block = BLOCK_CHAIN (block); 3712 } 3713 3714 return n_blocks; 3715} 3716 3717/* Return a vector containing all the blocks rooted at BLOCK. The 3718 number of elements in the vector is stored in N_BLOCKS_P. The 3719 vector is dynamically allocated; it is the caller's responsibility 3720 to call `free' on the pointer returned. */ 3721 3722static tree * 3723get_block_vector (tree block, int *n_blocks_p) 3724{ 3725 tree *block_vector; 3726 3727 *n_blocks_p = all_blocks (block, NULL); 3728 block_vector = XNEWVEC (tree, *n_blocks_p); 3729 all_blocks (block, block_vector); 3730 3731 return block_vector; 3732} 3733 3734static GTY(()) int next_block_index = 2; 3735 3736/* Set BLOCK_NUMBER for all the blocks in FN. */ 3737 3738void 3739number_blocks (tree fn) 3740{ 3741 int i; 3742 int n_blocks; 3743 tree *block_vector; 3744 3745 /* For SDB and XCOFF debugging output, we start numbering the blocks 3746 from 1 within each function, rather than keeping a running 3747 count. */ 3748#if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 3749 if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG) 3750 next_block_index = 1; 3751#endif 3752 3753 block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks); 3754 3755 /* The top-level BLOCK isn't numbered at all. */ 3756 for (i = 1; i < n_blocks; ++i) 3757 /* We number the blocks from two. */ 3758 BLOCK_NUMBER (block_vector[i]) = next_block_index++; 3759 3760 free (block_vector); 3761 3762 return; 3763} 3764 3765/* If VAR is present in a subblock of BLOCK, return the subblock. */ 3766 3767tree 3768debug_find_var_in_block_tree (tree var, tree block) 3769{ 3770 tree t; 3771 3772 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) 3773 if (t == var) 3774 return block; 3775 3776 for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t)) 3777 { 3778 tree ret = debug_find_var_in_block_tree (var, t); 3779 if (ret) 3780 return ret; 3781 } 3782 3783 return NULL_TREE; 3784} 3785 3786/* Allocate a function structure for FNDECL and set its contents 3787 to the defaults. */ 3788 3789void 3790allocate_struct_function (tree fndecl) 3791{ 3792 tree result; 3793 tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE; 3794 3795 cfun = ggc_alloc_cleared (sizeof (struct function)); 3796 3797 cfun->stack_alignment_needed = STACK_BOUNDARY; 3798 cfun->preferred_stack_boundary = STACK_BOUNDARY; 3799 3800 current_function_funcdef_no = funcdef_no++; 3801 3802 cfun->function_frequency = FUNCTION_FREQUENCY_NORMAL; 3803 3804 init_eh_for_function (); 3805 3806 lang_hooks.function.init (cfun); 3807 if (init_machine_status) 3808 cfun->machine = (*init_machine_status) (); 3809 3810 if (fndecl == NULL) 3811 return; 3812 3813 DECL_STRUCT_FUNCTION (fndecl) = cfun; 3814 cfun->decl = fndecl; 3815 3816 result = DECL_RESULT (fndecl); 3817 if (aggregate_value_p (result, fndecl)) 3818 { 3819#ifdef PCC_STATIC_STRUCT_RETURN 3820 current_function_returns_pcc_struct = 1; 3821#endif 3822 current_function_returns_struct = 1; 3823 } 3824 3825 current_function_returns_pointer = POINTER_TYPE_P (TREE_TYPE (result)); 3826 3827 current_function_stdarg 3828 = (fntype 3829 && TYPE_ARG_TYPES (fntype) != 0 3830 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) 3831 != void_type_node)); 3832 3833 /* Assume all registers in stdarg functions need to be saved. */ 3834 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; 3835 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; 3836} 3837 3838/* Reset cfun, and other non-struct-function variables to defaults as 3839 appropriate for emitting rtl at the start of a function. */ 3840 3841static void 3842prepare_function_start (tree fndecl) 3843{ 3844 if (fndecl && DECL_STRUCT_FUNCTION (fndecl)) 3845 cfun = DECL_STRUCT_FUNCTION (fndecl); 3846 else 3847 allocate_struct_function (fndecl); 3848 init_emit (); 3849 init_varasm_status (cfun); 3850 init_expr (); 3851 3852 cse_not_expected = ! optimize; 3853 3854 /* Caller save not needed yet. */ 3855 caller_save_needed = 0; 3856 3857 /* We haven't done register allocation yet. */ 3858 reg_renumber = 0; 3859 3860 /* Indicate that we have not instantiated virtual registers yet. */ 3861 virtuals_instantiated = 0; 3862 3863 /* Indicate that we want CONCATs now. */ 3864 generating_concat_p = 1; 3865 3866 /* Indicate we have no need of a frame pointer yet. */ 3867 frame_pointer_needed = 0; 3868} 3869 3870/* Initialize the rtl expansion mechanism so that we can do simple things 3871 like generate sequences. This is used to provide a context during global 3872 initialization of some passes. */ 3873void 3874init_dummy_function_start (void) 3875{ 3876 prepare_function_start (NULL); 3877} 3878 3879/* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) 3880 and initialize static variables for generating RTL for the statements 3881 of the function. */ 3882 3883void 3884init_function_start (tree subr) 3885{ 3886 prepare_function_start (subr); 3887 3888 /* Prevent ever trying to delete the first instruction of a 3889 function. Also tell final how to output a linenum before the 3890 function prologue. Note linenums could be missing, e.g. when 3891 compiling a Java .class file. */ 3892 if (! DECL_IS_BUILTIN (subr)) 3893 emit_line_note (DECL_SOURCE_LOCATION (subr)); 3894 3895 /* Make sure first insn is a note even if we don't want linenums. 3896 This makes sure the first insn will never be deleted. 3897 Also, final expects a note to appear there. */ 3898 emit_note (NOTE_INSN_DELETED); 3899 3900 /* Warn if this value is an aggregate type, 3901 regardless of which calling convention we are using for it. */ 3902 if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) 3903 warning (OPT_Waggregate_return, "function returns an aggregate"); 3904} 3905 3906/* Make sure all values used by the optimization passes have sane 3907 defaults. */ 3908unsigned int 3909init_function_for_compilation (void) 3910{ 3911 reg_renumber = 0; 3912 3913 /* No prologue/epilogue insns yet. Make sure that these vectors are 3914 empty. */ 3915 gcc_assert (VEC_length (int, prologue) == 0); 3916 gcc_assert (VEC_length (int, epilogue) == 0); 3917 gcc_assert (VEC_length (int, sibcall_epilogue) == 0); 3918 return 0; 3919} 3920 3921struct tree_opt_pass pass_init_function = 3922{ 3923 NULL, /* name */ 3924 NULL, /* gate */ 3925 init_function_for_compilation, /* execute */ 3926 NULL, /* sub */ 3927 NULL, /* next */ 3928 0, /* static_pass_number */ 3929 0, /* tv_id */ 3930 0, /* properties_required */ 3931 0, /* properties_provided */ 3932 0, /* properties_destroyed */ 3933 0, /* todo_flags_start */ 3934 0, /* todo_flags_finish */ 3935 0 /* letter */ 3936}; 3937 3938 3939void 3940expand_main_function (void) 3941{ 3942#if (defined(INVOKE__main) \ 3943 || (!defined(HAS_INIT_SECTION) \ 3944 && !defined(INIT_SECTION_ASM_OP) \ 3945 && !defined(INIT_ARRAY_SECTION_ASM_OP))) 3946 emit_library_call (init_one_libfunc (NAME__MAIN), LCT_NORMAL, VOIDmode, 0); 3947#endif 3948} 3949 3950/* Expand code to initialize the stack_protect_guard. This is invoked at 3951 the beginning of a function to be protected. */ 3952 3953#ifndef HAVE_stack_protect_set 3954# define HAVE_stack_protect_set 0 3955# define gen_stack_protect_set(x,y) (gcc_unreachable (), NULL_RTX) 3956#endif 3957 3958void 3959stack_protect_prologue (void) 3960{ 3961 tree guard_decl = targetm.stack_protect_guard (); 3962 rtx x, y; 3963 3964 /* Avoid expand_expr here, because we don't want guard_decl pulled 3965 into registers unless absolutely necessary. And we know that 3966 cfun->stack_protect_guard is a local stack slot, so this skips 3967 all the fluff. */ 3968 x = validize_mem (DECL_RTL (cfun->stack_protect_guard)); 3969 y = validize_mem (DECL_RTL (guard_decl)); 3970 3971 /* Allow the target to copy from Y to X without leaking Y into a 3972 register. */ 3973 if (HAVE_stack_protect_set) 3974 { 3975 rtx insn = gen_stack_protect_set (x, y); 3976 if (insn) 3977 { 3978 emit_insn (insn); 3979 return; 3980 } 3981 } 3982 3983 /* Otherwise do a straight move. */ 3984 emit_move_insn (x, y); 3985} 3986 3987/* Expand code to verify the stack_protect_guard. This is invoked at 3988 the end of a function to be protected. */ 3989 3990#ifndef HAVE_stack_protect_test 3991# define HAVE_stack_protect_test 0 3992# define gen_stack_protect_test(x, y, z) (gcc_unreachable (), NULL_RTX) 3993#endif 3994 3995void 3996stack_protect_epilogue (void) 3997{ 3998 tree guard_decl = targetm.stack_protect_guard (); 3999 rtx label = gen_label_rtx (); 4000 rtx x, y, tmp; 4001 4002 /* Avoid expand_expr here, because we don't want guard_decl pulled 4003 into registers unless absolutely necessary. And we know that 4004 cfun->stack_protect_guard is a local stack slot, so this skips 4005 all the fluff. */ 4006 x = validize_mem (DECL_RTL (cfun->stack_protect_guard)); 4007 y = validize_mem (DECL_RTL (guard_decl)); 4008 4009 /* Allow the target to compare Y with X without leaking either into 4010 a register. */ 4011 if (HAVE_stack_protect_test != 0) 4012 { 4013 tmp = gen_stack_protect_test (x, y, label); 4014 if (tmp) 4015 { 4016 emit_insn (tmp); 4017 goto done; 4018 } 4019 } 4020 4021 emit_cmp_and_jump_insns (x, y, EQ, NULL_RTX, ptr_mode, 1, label); 4022 done: 4023 4024 /* The noreturn predictor has been moved to the tree level. The rtl-level 4025 predictors estimate this branch about 20%, which isn't enough to get 4026 things moved out of line. Since this is the only extant case of adding 4027 a noreturn function at the rtl level, it doesn't seem worth doing ought 4028 except adding the prediction by hand. */ 4029 tmp = get_last_insn (); 4030 if (JUMP_P (tmp)) 4031 predict_insn_def (tmp, PRED_NORETURN, TAKEN); 4032 4033 expand_expr_stmt (targetm.stack_protect_fail ()); 4034 emit_label (label); 4035} 4036 4037/* Start the RTL for a new function, and set variables used for 4038 emitting RTL. 4039 SUBR is the FUNCTION_DECL node. 4040 PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with 4041 the function's parameters, which must be run at any return statement. */ 4042 4043void 4044expand_function_start (tree subr) 4045{ 4046 /* Make sure volatile mem refs aren't considered 4047 valid operands of arithmetic insns. */ 4048 init_recog_no_volatile (); 4049 4050 current_function_profile 4051 = (profile_flag 4052 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); 4053 4054 current_function_limit_stack 4055 = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr)); 4056 4057 /* Make the label for return statements to jump to. Do not special 4058 case machines with special return instructions -- they will be 4059 handled later during jump, ifcvt, or epilogue creation. */ 4060 return_label = gen_label_rtx (); 4061 4062 /* Initialize rtx used to return the value. */ 4063 /* Do this before assign_parms so that we copy the struct value address 4064 before any library calls that assign parms might generate. */ 4065 4066 /* Decide whether to return the value in memory or in a register. */ 4067 if (aggregate_value_p (DECL_RESULT (subr), subr)) 4068 { 4069 /* Returning something that won't go in a register. */ 4070 rtx value_address = 0; 4071 4072#ifdef PCC_STATIC_STRUCT_RETURN 4073 if (current_function_returns_pcc_struct) 4074 { 4075 int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); 4076 value_address = assemble_static_space (size); 4077 } 4078 else 4079#endif 4080 { 4081 rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 2); 4082 /* Expect to be passed the address of a place to store the value. 4083 If it is passed as an argument, assign_parms will take care of 4084 it. */ 4085 if (sv) 4086 { 4087 value_address = gen_reg_rtx (Pmode); 4088 emit_move_insn (value_address, sv); 4089 } 4090 } 4091 if (value_address) 4092 { 4093 rtx x = value_address; 4094 if (!DECL_BY_REFERENCE (DECL_RESULT (subr))) 4095 { 4096 x = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), x); 4097 set_mem_attributes (x, DECL_RESULT (subr), 1); 4098 } 4099 SET_DECL_RTL (DECL_RESULT (subr), x); 4100 } 4101 } 4102 else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) 4103 /* If return mode is void, this decl rtl should not be used. */ 4104 SET_DECL_RTL (DECL_RESULT (subr), NULL_RTX); 4105 else 4106 { 4107 /* Compute the return values into a pseudo reg, which we will copy 4108 into the true return register after the cleanups are done. */ 4109 tree return_type = TREE_TYPE (DECL_RESULT (subr)); 4110 if (TYPE_MODE (return_type) != BLKmode 4111 && targetm.calls.return_in_msb (return_type)) 4112 /* expand_function_end will insert the appropriate padding in 4113 this case. Use the return value's natural (unpadded) mode 4114 within the function proper. */ 4115 SET_DECL_RTL (DECL_RESULT (subr), 4116 gen_reg_rtx (TYPE_MODE (return_type))); 4117 else 4118 { 4119 /* In order to figure out what mode to use for the pseudo, we 4120 figure out what the mode of the eventual return register will 4121 actually be, and use that. */ 4122 rtx hard_reg = hard_function_value (return_type, subr, 0, 1); 4123 4124 /* Structures that are returned in registers are not 4125 aggregate_value_p, so we may see a PARALLEL or a REG. */ 4126 if (REG_P (hard_reg)) 4127 SET_DECL_RTL (DECL_RESULT (subr), 4128 gen_reg_rtx (GET_MODE (hard_reg))); 4129 else 4130 { 4131 gcc_assert (GET_CODE (hard_reg) == PARALLEL); 4132 SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg)); 4133 } 4134 } 4135 4136 /* Set DECL_REGISTER flag so that expand_function_end will copy the 4137 result to the real return register(s). */ 4138 DECL_REGISTER (DECL_RESULT (subr)) = 1; 4139 } 4140 4141 /* Initialize rtx for parameters and local variables. 4142 In some cases this requires emitting insns. */ 4143 assign_parms (subr); 4144 4145 /* If function gets a static chain arg, store it. */ 4146 if (cfun->static_chain_decl) 4147 { 4148 tree parm = cfun->static_chain_decl; 4149 rtx local = gen_reg_rtx (Pmode); 4150 4151 set_decl_incoming_rtl (parm, static_chain_incoming_rtx); 4152 SET_DECL_RTL (parm, local); 4153 mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))); 4154 4155 emit_move_insn (local, static_chain_incoming_rtx); 4156 } 4157 4158 /* If the function receives a non-local goto, then store the 4159 bits we need to restore the frame pointer. */ 4160 if (cfun->nonlocal_goto_save_area) 4161 { 4162 tree t_save; 4163 rtx r_save; 4164 4165 /* ??? We need to do this save early. Unfortunately here is 4166 before the frame variable gets declared. Help out... */ 4167 expand_var (TREE_OPERAND (cfun->nonlocal_goto_save_area, 0)); 4168 4169 t_save = build4 (ARRAY_REF, ptr_type_node, 4170 cfun->nonlocal_goto_save_area, 4171 integer_zero_node, NULL_TREE, NULL_TREE); 4172 r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE); 4173 r_save = convert_memory_address (Pmode, r_save); 4174 4175 emit_move_insn (r_save, virtual_stack_vars_rtx); 4176 update_nonlocal_goto_save_area (); 4177 } 4178 4179 /* The following was moved from init_function_start. 4180 The move is supposed to make sdb output more accurate. */ 4181 /* Indicate the beginning of the function body, 4182 as opposed to parm setup. */ 4183 emit_note (NOTE_INSN_FUNCTION_BEG); 4184 4185 gcc_assert (NOTE_P (get_last_insn ())); 4186 4187 parm_birth_insn = get_last_insn (); 4188 4189 if (current_function_profile) 4190 { 4191#ifdef PROFILE_HOOK 4192 PROFILE_HOOK (current_function_funcdef_no); 4193#endif 4194 } 4195 4196 /* After the display initializations is where the stack checking 4197 probe should go. */ 4198 if(flag_stack_check) 4199 stack_check_probe_note = emit_note (NOTE_INSN_DELETED); 4200 4201 /* Make sure there is a line number after the function entry setup code. */ 4202 force_next_line_note (); 4203} 4204 4205/* Undo the effects of init_dummy_function_start. */ 4206void 4207expand_dummy_function_end (void) 4208{ 4209 /* End any sequences that failed to be closed due to syntax errors. */ 4210 while (in_sequence_p ()) 4211 end_sequence (); 4212 4213 /* Outside function body, can't compute type's actual size 4214 until next function's body starts. */ 4215 4216 free_after_parsing (cfun); 4217 free_after_compilation (cfun); 4218 cfun = 0; 4219} 4220 4221/* Call DOIT for each hard register used as a return value from 4222 the current function. */ 4223 4224void 4225diddle_return_value (void (*doit) (rtx, void *), void *arg) 4226{ 4227 rtx outgoing = current_function_return_rtx; 4228 4229 if (! outgoing) 4230 return; 4231 4232 if (REG_P (outgoing)) 4233 (*doit) (outgoing, arg); 4234 else if (GET_CODE (outgoing) == PARALLEL) 4235 { 4236 int i; 4237 4238 for (i = 0; i < XVECLEN (outgoing, 0); i++) 4239 { 4240 rtx x = XEXP (XVECEXP (outgoing, 0, i), 0); 4241 4242 if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER) 4243 (*doit) (x, arg); 4244 } 4245 } 4246} 4247 4248static void 4249do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) 4250{ 4251 emit_insn (gen_rtx_CLOBBER (VOIDmode, reg)); 4252} 4253 4254void 4255clobber_return_register (void) 4256{ 4257 diddle_return_value (do_clobber_return_reg, NULL); 4258 4259 /* In case we do use pseudo to return value, clobber it too. */ 4260 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) 4261 { 4262 tree decl_result = DECL_RESULT (current_function_decl); 4263 rtx decl_rtl = DECL_RTL (decl_result); 4264 if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER) 4265 { 4266 do_clobber_return_reg (decl_rtl, NULL); 4267 } 4268 } 4269} 4270 4271static void 4272do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED) 4273{ 4274 emit_insn (gen_rtx_USE (VOIDmode, reg)); 4275} 4276 4277static void 4278use_return_register (void) 4279{ 4280 diddle_return_value (do_use_return_reg, NULL); 4281} 4282 4283/* Possibly warn about unused parameters. */ 4284void 4285do_warn_unused_parameter (tree fn) 4286{ 4287 tree decl; 4288 4289 for (decl = DECL_ARGUMENTS (fn); 4290 decl; decl = TREE_CHAIN (decl)) 4291 if (!TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL 4292 && DECL_NAME (decl) && !DECL_ARTIFICIAL (decl)) 4293 warning (OPT_Wunused_parameter, "unused parameter %q+D", decl); 4294} 4295 4296static GTY(()) rtx initial_trampoline; 4297 4298/* Generate RTL for the end of the current function. */ 4299 4300void 4301expand_function_end (void) 4302{ 4303 rtx clobber_after; 4304 4305 /* If arg_pointer_save_area was referenced only from a nested 4306 function, we will not have initialized it yet. Do that now. */ 4307 if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init) 4308 get_arg_pointer_save_area (cfun); 4309 4310 /* If we are doing stack checking and this function makes calls, 4311 do a stack probe at the start of the function to ensure we have enough 4312 space for another stack frame. */ 4313 if (flag_stack_check && ! STACK_CHECK_BUILTIN) 4314 { 4315 rtx insn, seq; 4316 4317 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 4318 if (CALL_P (insn)) 4319 { 4320 start_sequence (); 4321 probe_stack_range (STACK_CHECK_PROTECT, 4322 GEN_INT (STACK_CHECK_MAX_FRAME_SIZE)); 4323 seq = get_insns (); 4324 end_sequence (); 4325 emit_insn_before (seq, stack_check_probe_note); 4326 break; 4327 } 4328 } 4329 4330 /* Possibly warn about unused parameters. 4331 When frontend does unit-at-a-time, the warning is already 4332 issued at finalization time. */ 4333 if (warn_unused_parameter 4334 && !lang_hooks.callgraph.expand_function) 4335 do_warn_unused_parameter (current_function_decl); 4336 4337 /* End any sequences that failed to be closed due to syntax errors. */ 4338 while (in_sequence_p ()) 4339 end_sequence (); 4340 4341 clear_pending_stack_adjust (); 4342 do_pending_stack_adjust (); 4343 4344 /* Mark the end of the function body. 4345 If control reaches this insn, the function can drop through 4346 without returning a value. */ 4347 emit_note (NOTE_INSN_FUNCTION_END); 4348 4349 /* Must mark the last line number note in the function, so that the test 4350 coverage code can avoid counting the last line twice. This just tells 4351 the code to ignore the immediately following line note, since there 4352 already exists a copy of this note somewhere above. This line number 4353 note is still needed for debugging though, so we can't delete it. */ 4354 if (flag_test_coverage) 4355 emit_note (NOTE_INSN_REPEATED_LINE_NUMBER); 4356 4357 /* Output a linenumber for the end of the function. 4358 SDB depends on this. */ 4359 force_next_line_note (); 4360 emit_line_note (input_location); 4361 4362 /* Before the return label (if any), clobber the return 4363 registers so that they are not propagated live to the rest of 4364 the function. This can only happen with functions that drop 4365 through; if there had been a return statement, there would 4366 have either been a return rtx, or a jump to the return label. 4367 4368 We delay actual code generation after the current_function_value_rtx 4369 is computed. */ 4370 clobber_after = get_last_insn (); 4371 4372 /* Output the label for the actual return from the function. */ 4373 emit_label (return_label); 4374 4375#ifdef TARGET_PROFILER_EPILOGUE 4376 if (current_function_profile && TARGET_PROFILER_EPILOGUE) 4377 { 4378 static rtx mexitcount_libfunc; 4379 static int initialized; 4380 4381 if (!initialized) 4382 { 4383 mexitcount_libfunc = init_one_libfunc (".mexitcount"); 4384 initialized = 0; 4385 } 4386 emit_library_call (mexitcount_libfunc, LCT_NORMAL, VOIDmode, 0); 4387 } 4388#endif 4389 4390 if (USING_SJLJ_EXCEPTIONS) 4391 { 4392 /* Let except.c know where it should emit the call to unregister 4393 the function context for sjlj exceptions. */ 4394 if (flag_exceptions) 4395 sjlj_emit_function_exit_after (get_last_insn ()); 4396 } 4397 else 4398 { 4399 /* @@@ This is a kludge. We want to ensure that instructions that 4400 may trap are not moved into the epilogue by scheduling, because 4401 we don't always emit unwind information for the epilogue. 4402 However, not all machine descriptions define a blockage insn, so 4403 emit an ASM_INPUT to act as one. */ 4404 if (flag_non_call_exceptions) 4405 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, "")); 4406 } 4407 4408 /* If this is an implementation of throw, do what's necessary to 4409 communicate between __builtin_eh_return and the epilogue. */ 4410 expand_eh_return (); 4411 4412 /* If scalar return value was computed in a pseudo-reg, or was a named 4413 return value that got dumped to the stack, copy that to the hard 4414 return register. */ 4415 if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl))) 4416 { 4417 tree decl_result = DECL_RESULT (current_function_decl); 4418 rtx decl_rtl = DECL_RTL (decl_result); 4419 4420 if (REG_P (decl_rtl) 4421 ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER 4422 : DECL_REGISTER (decl_result)) 4423 { 4424 rtx real_decl_rtl = current_function_return_rtx; 4425 4426 /* This should be set in assign_parms. */ 4427 gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl)); 4428 4429 /* If this is a BLKmode structure being returned in registers, 4430 then use the mode computed in expand_return. Note that if 4431 decl_rtl is memory, then its mode may have been changed, 4432 but that current_function_return_rtx has not. */ 4433 if (GET_MODE (real_decl_rtl) == BLKmode) 4434 PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl)); 4435 4436 /* If a non-BLKmode return value should be padded at the least 4437 significant end of the register, shift it left by the appropriate 4438 amount. BLKmode results are handled using the group load/store 4439 machinery. */ 4440 if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode 4441 && targetm.calls.return_in_msb (TREE_TYPE (decl_result))) 4442 { 4443 emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl), 4444 REGNO (real_decl_rtl)), 4445 decl_rtl); 4446 shift_return_value (GET_MODE (decl_rtl), true, real_decl_rtl); 4447 } 4448 /* If a named return value dumped decl_return to memory, then 4449 we may need to re-do the PROMOTE_MODE signed/unsigned 4450 extension. */ 4451 else if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl)) 4452 { 4453 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result)); 4454 4455 if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl))) 4456 promote_mode (TREE_TYPE (decl_result), GET_MODE (decl_rtl), 4457 &unsignedp, 1); 4458 4459 convert_move (real_decl_rtl, decl_rtl, unsignedp); 4460 } 4461 else if (GET_CODE (real_decl_rtl) == PARALLEL) 4462 { 4463 /* If expand_function_start has created a PARALLEL for decl_rtl, 4464 move the result to the real return registers. Otherwise, do 4465 a group load from decl_rtl for a named return. */ 4466 if (GET_CODE (decl_rtl) == PARALLEL) 4467 emit_group_move (real_decl_rtl, decl_rtl); 4468 else 4469 emit_group_load (real_decl_rtl, decl_rtl, 4470 TREE_TYPE (decl_result), 4471 int_size_in_bytes (TREE_TYPE (decl_result))); 4472 } 4473 /* In the case of complex integer modes smaller than a word, we'll 4474 need to generate some non-trivial bitfield insertions. Do that 4475 on a pseudo and not the hard register. */ 4476 else if (GET_CODE (decl_rtl) == CONCAT 4477 && GET_MODE_CLASS (GET_MODE (decl_rtl)) == MODE_COMPLEX_INT 4478 && GET_MODE_BITSIZE (GET_MODE (decl_rtl)) <= BITS_PER_WORD) 4479 { 4480 int old_generating_concat_p; 4481 rtx tmp; 4482 4483 old_generating_concat_p = generating_concat_p; 4484 generating_concat_p = 0; 4485 tmp = gen_reg_rtx (GET_MODE (decl_rtl)); 4486 generating_concat_p = old_generating_concat_p; 4487 4488 emit_move_insn (tmp, decl_rtl); 4489 emit_move_insn (real_decl_rtl, tmp); 4490 } 4491 else 4492 emit_move_insn (real_decl_rtl, decl_rtl); 4493 } 4494 } 4495 4496 /* If returning a structure, arrange to return the address of the value 4497 in a place where debuggers expect to find it. 4498 4499 If returning a structure PCC style, 4500 the caller also depends on this value. 4501 And current_function_returns_pcc_struct is not necessarily set. */ 4502 if (current_function_returns_struct 4503 || current_function_returns_pcc_struct) 4504 { 4505 rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl)); 4506 tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); 4507 rtx outgoing; 4508 4509 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))) 4510 type = TREE_TYPE (type); 4511 else 4512 value_address = XEXP (value_address, 0); 4513 4514 outgoing = targetm.calls.function_value (build_pointer_type (type), 4515 current_function_decl, true); 4516 4517 /* Mark this as a function return value so integrate will delete the 4518 assignment and USE below when inlining this function. */ 4519 REG_FUNCTION_VALUE_P (outgoing) = 1; 4520 4521 /* The address may be ptr_mode and OUTGOING may be Pmode. */ 4522 value_address = convert_memory_address (GET_MODE (outgoing), 4523 value_address); 4524 4525 emit_move_insn (outgoing, value_address); 4526 4527 /* Show return register used to hold result (in this case the address 4528 of the result. */ 4529 current_function_return_rtx = outgoing; 4530 } 4531 4532 /* Emit the actual code to clobber return register. */ 4533 { 4534 rtx seq; 4535 4536 start_sequence (); 4537 clobber_return_register (); 4538 expand_naked_return (); 4539 seq = get_insns (); 4540 end_sequence (); 4541 4542 emit_insn_after (seq, clobber_after); 4543 } 4544 4545 /* Output the label for the naked return from the function. */ 4546 emit_label (naked_return_label); 4547 4548 /* If stack protection is enabled for this function, check the guard. */ 4549 if (cfun->stack_protect_guard) 4550 stack_protect_epilogue (); 4551 4552 /* If we had calls to alloca, and this machine needs 4553 an accurate stack pointer to exit the function, 4554 insert some code to save and restore the stack pointer. */ 4555 if (! EXIT_IGNORE_STACK 4556 && current_function_calls_alloca) 4557 { 4558 rtx tem = 0; 4559 4560 emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn); 4561 emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX); 4562 } 4563 4564 /* ??? This should no longer be necessary since stupid is no longer with 4565 us, but there are some parts of the compiler (eg reload_combine, and 4566 sh mach_dep_reorg) that still try and compute their own lifetime info 4567 instead of using the general framework. */ 4568 use_return_register (); 4569} 4570 4571rtx 4572get_arg_pointer_save_area (struct function *f) 4573{ 4574 rtx ret = f->x_arg_pointer_save_area; 4575 4576 if (! ret) 4577 { 4578 ret = assign_stack_local_1 (Pmode, GET_MODE_SIZE (Pmode), 0, f); 4579 f->x_arg_pointer_save_area = ret; 4580 } 4581 4582 if (f == cfun && ! f->arg_pointer_save_area_init) 4583 { 4584 rtx seq; 4585 4586 /* Save the arg pointer at the beginning of the function. The 4587 generated stack slot may not be a valid memory address, so we 4588 have to check it and fix it if necessary. */ 4589 start_sequence (); 4590 emit_move_insn (validize_mem (ret), virtual_incoming_args_rtx); 4591 seq = get_insns (); 4592 end_sequence (); 4593 4594 push_topmost_sequence (); 4595 emit_insn_after (seq, entry_of_function ()); 4596 pop_topmost_sequence (); 4597 } 4598 4599 return ret; 4600} 4601 4602/* Extend a vector that records the INSN_UIDs of INSNS 4603 (a list of one or more insns). */ 4604 4605static void 4606record_insns (rtx insns, VEC(int,heap) **vecp) 4607{ 4608 rtx tmp; 4609 4610 for (tmp = insns; tmp != NULL_RTX; tmp = NEXT_INSN (tmp)) 4611 VEC_safe_push (int, heap, *vecp, INSN_UID (tmp)); 4612} 4613 4614/* Set the locator of the insn chain starting at INSN to LOC. */ 4615static void 4616set_insn_locators (rtx insn, int loc) 4617{ 4618 while (insn != NULL_RTX) 4619 { 4620 if (INSN_P (insn)) 4621 INSN_LOCATOR (insn) = loc; 4622 insn = NEXT_INSN (insn); 4623 } 4624} 4625 4626/* Determine how many INSN_UIDs in VEC are part of INSN. Because we can 4627 be running after reorg, SEQUENCE rtl is possible. */ 4628 4629static int 4630contains (rtx insn, VEC(int,heap) **vec) 4631{ 4632 int i, j; 4633 4634 if (NONJUMP_INSN_P (insn) 4635 && GET_CODE (PATTERN (insn)) == SEQUENCE) 4636 { 4637 int count = 0; 4638 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 4639 for (j = VEC_length (int, *vec) - 1; j >= 0; --j) 4640 if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) 4641 == VEC_index (int, *vec, j)) 4642 count++; 4643 return count; 4644 } 4645 else 4646 { 4647 for (j = VEC_length (int, *vec) - 1; j >= 0; --j) 4648 if (INSN_UID (insn) == VEC_index (int, *vec, j)) 4649 return 1; 4650 } 4651 return 0; 4652} 4653 4654int 4655prologue_epilogue_contains (rtx insn) 4656{ 4657 if (contains (insn, &prologue)) 4658 return 1; 4659 if (contains (insn, &epilogue)) 4660 return 1; 4661 return 0; 4662} 4663 4664int 4665sibcall_epilogue_contains (rtx insn) 4666{ 4667 if (sibcall_epilogue) 4668 return contains (insn, &sibcall_epilogue); 4669 return 0; 4670} 4671 4672#ifdef HAVE_return 4673/* Insert gen_return at the end of block BB. This also means updating 4674 block_for_insn appropriately. */ 4675 4676static void 4677emit_return_into_block (basic_block bb, rtx line_note) 4678{ 4679 emit_jump_insn_after (gen_return (), BB_END (bb)); 4680 if (line_note) 4681 emit_note_copy_after (line_note, PREV_INSN (BB_END (bb))); 4682} 4683#endif /* HAVE_return */ 4684 4685#if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX) 4686 4687/* These functions convert the epilogue into a variant that does not 4688 modify the stack pointer. This is used in cases where a function 4689 returns an object whose size is not known until it is computed. 4690 The called function leaves the object on the stack, leaves the 4691 stack depressed, and returns a pointer to the object. 4692 4693 What we need to do is track all modifications and references to the 4694 stack pointer, deleting the modifications and changing the 4695 references to point to the location the stack pointer would have 4696 pointed to had the modifications taken place. 4697 4698 These functions need to be portable so we need to make as few 4699 assumptions about the epilogue as we can. However, the epilogue 4700 basically contains three things: instructions to reset the stack 4701 pointer, instructions to reload registers, possibly including the 4702 frame pointer, and an instruction to return to the caller. 4703 4704 We must be sure of what a relevant epilogue insn is doing. We also 4705 make no attempt to validate the insns we make since if they are 4706 invalid, we probably can't do anything valid. The intent is that 4707 these routines get "smarter" as more and more machines start to use 4708 them and they try operating on different epilogues. 4709 4710 We use the following structure to track what the part of the 4711 epilogue that we've already processed has done. We keep two copies 4712 of the SP equivalence, one for use during the insn we are 4713 processing and one for use in the next insn. The difference is 4714 because one part of a PARALLEL may adjust SP and the other may use 4715 it. */ 4716 4717struct epi_info 4718{ 4719 rtx sp_equiv_reg; /* REG that SP is set from, perhaps SP. */ 4720 HOST_WIDE_INT sp_offset; /* Offset from SP_EQUIV_REG of present SP. */ 4721 rtx new_sp_equiv_reg; /* REG to be used at end of insn. */ 4722 HOST_WIDE_INT new_sp_offset; /* Offset to be used at end of insn. */ 4723 rtx equiv_reg_src; /* If nonzero, the value that SP_EQUIV_REG 4724 should be set to once we no longer need 4725 its value. */ 4726 rtx const_equiv[FIRST_PSEUDO_REGISTER]; /* Any known constant equivalences 4727 for registers. */ 4728}; 4729 4730static void handle_epilogue_set (rtx, struct epi_info *); 4731static void update_epilogue_consts (rtx, rtx, void *); 4732static void emit_equiv_load (struct epi_info *); 4733 4734/* Modify INSN, a list of one or more insns that is part of the epilogue, to 4735 no modifications to the stack pointer. Return the new list of insns. */ 4736 4737static rtx 4738keep_stack_depressed (rtx insns) 4739{ 4740 int j; 4741 struct epi_info info; 4742 rtx insn, next; 4743 4744 /* If the epilogue is just a single instruction, it must be OK as is. */ 4745 if (NEXT_INSN (insns) == NULL_RTX) 4746 return insns; 4747 4748 /* Otherwise, start a sequence, initialize the information we have, and 4749 process all the insns we were given. */ 4750 start_sequence (); 4751 4752 info.sp_equiv_reg = stack_pointer_rtx; 4753 info.sp_offset = 0; 4754 info.equiv_reg_src = 0; 4755 4756 for (j = 0; j < FIRST_PSEUDO_REGISTER; j++) 4757 info.const_equiv[j] = 0; 4758 4759 insn = insns; 4760 next = NULL_RTX; 4761 while (insn != NULL_RTX) 4762 { 4763 next = NEXT_INSN (insn); 4764 4765 if (!INSN_P (insn)) 4766 { 4767 add_insn (insn); 4768 insn = next; 4769 continue; 4770 } 4771 4772 /* If this insn references the register that SP is equivalent to and 4773 we have a pending load to that register, we must force out the load 4774 first and then indicate we no longer know what SP's equivalent is. */ 4775 if (info.equiv_reg_src != 0 4776 && reg_referenced_p (info.sp_equiv_reg, PATTERN (insn))) 4777 { 4778 emit_equiv_load (&info); 4779 info.sp_equiv_reg = 0; 4780 } 4781 4782 info.new_sp_equiv_reg = info.sp_equiv_reg; 4783 info.new_sp_offset = info.sp_offset; 4784 4785 /* If this is a (RETURN) and the return address is on the stack, 4786 update the address and change to an indirect jump. */ 4787 if (GET_CODE (PATTERN (insn)) == RETURN 4788 || (GET_CODE (PATTERN (insn)) == PARALLEL 4789 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == RETURN)) 4790 { 4791 rtx retaddr = INCOMING_RETURN_ADDR_RTX; 4792 rtx base = 0; 4793 HOST_WIDE_INT offset = 0; 4794 rtx jump_insn, jump_set; 4795 4796 /* If the return address is in a register, we can emit the insn 4797 unchanged. Otherwise, it must be a MEM and we see what the 4798 base register and offset are. In any case, we have to emit any 4799 pending load to the equivalent reg of SP, if any. */ 4800 if (REG_P (retaddr)) 4801 { 4802 emit_equiv_load (&info); 4803 add_insn (insn); 4804 insn = next; 4805 continue; 4806 } 4807 else 4808 { 4809 rtx ret_ptr; 4810 gcc_assert (MEM_P (retaddr)); 4811 4812 ret_ptr = XEXP (retaddr, 0); 4813 4814 if (REG_P (ret_ptr)) 4815 { 4816 base = gen_rtx_REG (Pmode, REGNO (ret_ptr)); 4817 offset = 0; 4818 } 4819 else 4820 { 4821 gcc_assert (GET_CODE (ret_ptr) == PLUS 4822 && REG_P (XEXP (ret_ptr, 0)) 4823 && GET_CODE (XEXP (ret_ptr, 1)) == CONST_INT); 4824 base = gen_rtx_REG (Pmode, REGNO (XEXP (ret_ptr, 0))); 4825 offset = INTVAL (XEXP (ret_ptr, 1)); 4826 } 4827 } 4828 4829 /* If the base of the location containing the return pointer 4830 is SP, we must update it with the replacement address. Otherwise, 4831 just build the necessary MEM. */ 4832 retaddr = plus_constant (base, offset); 4833 if (base == stack_pointer_rtx) 4834 retaddr = simplify_replace_rtx (retaddr, stack_pointer_rtx, 4835 plus_constant (info.sp_equiv_reg, 4836 info.sp_offset)); 4837 4838 retaddr = gen_rtx_MEM (Pmode, retaddr); 4839 MEM_NOTRAP_P (retaddr) = 1; 4840 4841 /* If there is a pending load to the equivalent register for SP 4842 and we reference that register, we must load our address into 4843 a scratch register and then do that load. */ 4844 if (info.equiv_reg_src 4845 && reg_overlap_mentioned_p (info.equiv_reg_src, retaddr)) 4846 { 4847 unsigned int regno; 4848 rtx reg; 4849 4850 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 4851 if (HARD_REGNO_MODE_OK (regno, Pmode) 4852 && !fixed_regs[regno] 4853 && TEST_HARD_REG_BIT (regs_invalidated_by_call, regno) 4854 && !REGNO_REG_SET_P 4855 (EXIT_BLOCK_PTR->il.rtl->global_live_at_start, regno) 4856 && !refers_to_regno_p (regno, 4857 regno + hard_regno_nregs[regno] 4858 [Pmode], 4859 info.equiv_reg_src, NULL) 4860 && info.const_equiv[regno] == 0) 4861 break; 4862 4863 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 4864 4865 reg = gen_rtx_REG (Pmode, regno); 4866 emit_move_insn (reg, retaddr); 4867 retaddr = reg; 4868 } 4869 4870 emit_equiv_load (&info); 4871 jump_insn = emit_jump_insn (gen_indirect_jump (retaddr)); 4872 4873 /* Show the SET in the above insn is a RETURN. */ 4874 jump_set = single_set (jump_insn); 4875 gcc_assert (jump_set); 4876 SET_IS_RETURN_P (jump_set) = 1; 4877 } 4878 4879 /* If SP is not mentioned in the pattern and its equivalent register, if 4880 any, is not modified, just emit it. Otherwise, if neither is set, 4881 replace the reference to SP and emit the insn. If none of those are 4882 true, handle each SET individually. */ 4883 else if (!reg_mentioned_p (stack_pointer_rtx, PATTERN (insn)) 4884 && (info.sp_equiv_reg == stack_pointer_rtx 4885 || !reg_set_p (info.sp_equiv_reg, insn))) 4886 add_insn (insn); 4887 else if (! reg_set_p (stack_pointer_rtx, insn) 4888 && (info.sp_equiv_reg == stack_pointer_rtx 4889 || !reg_set_p (info.sp_equiv_reg, insn))) 4890 { 4891 int changed; 4892 4893 changed = validate_replace_rtx (stack_pointer_rtx, 4894 plus_constant (info.sp_equiv_reg, 4895 info.sp_offset), 4896 insn); 4897 gcc_assert (changed); 4898 4899 add_insn (insn); 4900 } 4901 else if (GET_CODE (PATTERN (insn)) == SET) 4902 handle_epilogue_set (PATTERN (insn), &info); 4903 else if (GET_CODE (PATTERN (insn)) == PARALLEL) 4904 { 4905 for (j = 0; j < XVECLEN (PATTERN (insn), 0); j++) 4906 if (GET_CODE (XVECEXP (PATTERN (insn), 0, j)) == SET) 4907 handle_epilogue_set (XVECEXP (PATTERN (insn), 0, j), &info); 4908 } 4909 else 4910 add_insn (insn); 4911 4912 info.sp_equiv_reg = info.new_sp_equiv_reg; 4913 info.sp_offset = info.new_sp_offset; 4914 4915 /* Now update any constants this insn sets. */ 4916 note_stores (PATTERN (insn), update_epilogue_consts, &info); 4917 insn = next; 4918 } 4919 4920 insns = get_insns (); 4921 end_sequence (); 4922 return insns; 4923} 4924 4925/* SET is a SET from an insn in the epilogue. P is a pointer to the epi_info 4926 structure that contains information about what we've seen so far. We 4927 process this SET by either updating that data or by emitting one or 4928 more insns. */ 4929 4930static void 4931handle_epilogue_set (rtx set, struct epi_info *p) 4932{ 4933 /* First handle the case where we are setting SP. Record what it is being 4934 set from, which we must be able to determine */ 4935 if (reg_set_p (stack_pointer_rtx, set)) 4936 { 4937 gcc_assert (SET_DEST (set) == stack_pointer_rtx); 4938 4939 if (GET_CODE (SET_SRC (set)) == PLUS) 4940 { 4941 p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0); 4942 if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT) 4943 p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1)); 4944 else 4945 { 4946 gcc_assert (REG_P (XEXP (SET_SRC (set), 1)) 4947 && (REGNO (XEXP (SET_SRC (set), 1)) 4948 < FIRST_PSEUDO_REGISTER) 4949 && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]); 4950 p->new_sp_offset 4951 = INTVAL (p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]); 4952 } 4953 } 4954 else 4955 p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0; 4956 4957 /* If we are adjusting SP, we adjust from the old data. */ 4958 if (p->new_sp_equiv_reg == stack_pointer_rtx) 4959 { 4960 p->new_sp_equiv_reg = p->sp_equiv_reg; 4961 p->new_sp_offset += p->sp_offset; 4962 } 4963 4964 gcc_assert (p->new_sp_equiv_reg && REG_P (p->new_sp_equiv_reg)); 4965 4966 return; 4967 } 4968 4969 /* Next handle the case where we are setting SP's equivalent 4970 register. We must not already have a value to set it to. We 4971 could update, but there seems little point in handling that case. 4972 Note that we have to allow for the case where we are setting the 4973 register set in the previous part of a PARALLEL inside a single 4974 insn. But use the old offset for any updates within this insn. 4975 We must allow for the case where the register is being set in a 4976 different (usually wider) mode than Pmode). */ 4977 else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set)) 4978 { 4979 gcc_assert (!p->equiv_reg_src 4980 && REG_P (p->new_sp_equiv_reg) 4981 && REG_P (SET_DEST (set)) 4982 && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) 4983 <= BITS_PER_WORD) 4984 && REGNO (p->new_sp_equiv_reg) == REGNO (SET_DEST (set))); 4985 p->equiv_reg_src 4986 = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, 4987 plus_constant (p->sp_equiv_reg, 4988 p->sp_offset)); 4989 } 4990 4991 /* Otherwise, replace any references to SP in the insn to its new value 4992 and emit the insn. */ 4993 else 4994 { 4995 SET_SRC (set) = simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx, 4996 plus_constant (p->sp_equiv_reg, 4997 p->sp_offset)); 4998 SET_DEST (set) = simplify_replace_rtx (SET_DEST (set), stack_pointer_rtx, 4999 plus_constant (p->sp_equiv_reg, 5000 p->sp_offset)); 5001 emit_insn (set); 5002 } 5003} 5004 5005/* Update the tracking information for registers set to constants. */ 5006 5007static void 5008update_epilogue_consts (rtx dest, rtx x, void *data) 5009{ 5010 struct epi_info *p = (struct epi_info *) data; 5011 rtx new; 5012 5013 if (!REG_P (dest) || REGNO (dest) >= FIRST_PSEUDO_REGISTER) 5014 return; 5015 5016 /* If we are either clobbering a register or doing a partial set, 5017 show we don't know the value. */ 5018 else if (GET_CODE (x) == CLOBBER || ! rtx_equal_p (dest, SET_DEST (x))) 5019 p->const_equiv[REGNO (dest)] = 0; 5020 5021 /* If we are setting it to a constant, record that constant. */ 5022 else if (GET_CODE (SET_SRC (x)) == CONST_INT) 5023 p->const_equiv[REGNO (dest)] = SET_SRC (x); 5024 5025 /* If this is a binary operation between a register we have been tracking 5026 and a constant, see if we can compute a new constant value. */ 5027 else if (ARITHMETIC_P (SET_SRC (x)) 5028 && REG_P (XEXP (SET_SRC (x), 0)) 5029 && REGNO (XEXP (SET_SRC (x), 0)) < FIRST_PSEUDO_REGISTER 5030 && p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))] != 0 5031 && GET_CODE (XEXP (SET_SRC (x), 1)) == CONST_INT 5032 && 0 != (new = simplify_binary_operation 5033 (GET_CODE (SET_SRC (x)), GET_MODE (dest), 5034 p->const_equiv[REGNO (XEXP (SET_SRC (x), 0))], 5035 XEXP (SET_SRC (x), 1))) 5036 && GET_CODE (new) == CONST_INT) 5037 p->const_equiv[REGNO (dest)] = new; 5038 5039 /* Otherwise, we can't do anything with this value. */ 5040 else 5041 p->const_equiv[REGNO (dest)] = 0; 5042} 5043 5044/* Emit an insn to do the load shown in p->equiv_reg_src, if needed. */ 5045 5046static void 5047emit_equiv_load (struct epi_info *p) 5048{ 5049 if (p->equiv_reg_src != 0) 5050 { 5051 rtx dest = p->sp_equiv_reg; 5052 5053 if (GET_MODE (p->equiv_reg_src) != GET_MODE (dest)) 5054 dest = gen_rtx_REG (GET_MODE (p->equiv_reg_src), 5055 REGNO (p->sp_equiv_reg)); 5056 5057 emit_move_insn (dest, p->equiv_reg_src); 5058 p->equiv_reg_src = 0; 5059 } 5060} 5061#endif 5062 5063/* Generate the prologue and epilogue RTL if the machine supports it. Thread 5064 this into place with notes indicating where the prologue ends and where 5065 the epilogue begins. Update the basic block information when possible. */ 5066 5067void 5068thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED) 5069{ 5070 int inserted = 0; 5071 edge e; 5072#if defined (HAVE_sibcall_epilogue) || defined (HAVE_epilogue) || defined (HAVE_return) || defined (HAVE_prologue) 5073 rtx seq; 5074#endif 5075#ifdef HAVE_prologue 5076 rtx prologue_end = NULL_RTX; 5077#endif 5078#if defined (HAVE_epilogue) || defined(HAVE_return) 5079 rtx epilogue_end = NULL_RTX; 5080#endif 5081 edge_iterator ei; 5082 5083#ifdef HAVE_prologue 5084 if (HAVE_prologue) 5085 { 5086 start_sequence (); 5087 seq = gen_prologue (); 5088 emit_insn (seq); 5089 5090 /* Retain a map of the prologue insns. */ 5091 record_insns (seq, &prologue); 5092 prologue_end = emit_note (NOTE_INSN_PROLOGUE_END); 5093 5094#ifndef PROFILE_BEFORE_PROLOGUE 5095 /* Ensure that instructions are not moved into the prologue when 5096 profiling is on. The call to the profiling routine can be 5097 emitted within the live range of a call-clobbered register. */ 5098 if (current_function_profile) 5099 emit_insn (gen_rtx_ASM_INPUT (VOIDmode, "")); 5100#endif 5101 5102 seq = get_insns (); 5103 end_sequence (); 5104 set_insn_locators (seq, prologue_locator); 5105 5106 /* Can't deal with multiple successors of the entry block 5107 at the moment. Function should always have at least one 5108 entry point. */ 5109 gcc_assert (single_succ_p (ENTRY_BLOCK_PTR)); 5110 5111 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR)); 5112 inserted = 1; 5113 } 5114#endif 5115 5116 /* If the exit block has no non-fake predecessors, we don't need 5117 an epilogue. */ 5118 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) 5119 if ((e->flags & EDGE_FAKE) == 0) 5120 break; 5121 if (e == NULL) 5122 goto epilogue_done; 5123 5124#ifdef HAVE_return 5125 if (optimize && HAVE_return) 5126 { 5127 /* If we're allowed to generate a simple return instruction, 5128 then by definition we don't need a full epilogue. Examine 5129 the block that falls through to EXIT. If it does not 5130 contain any code, examine its predecessors and try to 5131 emit (conditional) return instructions. */ 5132 5133 basic_block last; 5134 rtx label; 5135 5136 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) 5137 if (e->flags & EDGE_FALLTHRU) 5138 break; 5139 if (e == NULL) 5140 goto epilogue_done; 5141 last = e->src; 5142 5143 /* Verify that there are no active instructions in the last block. */ 5144 label = BB_END (last); 5145 while (label && !LABEL_P (label)) 5146 { 5147 if (active_insn_p (label)) 5148 break; 5149 label = PREV_INSN (label); 5150 } 5151 5152 if (BB_HEAD (last) == label && LABEL_P (label)) 5153 { 5154 edge_iterator ei2; 5155 rtx epilogue_line_note = NULL_RTX; 5156 5157 /* Locate the line number associated with the closing brace, 5158 if we can find one. */ 5159 for (seq = get_last_insn (); 5160 seq && ! active_insn_p (seq); 5161 seq = PREV_INSN (seq)) 5162 if (NOTE_P (seq) && NOTE_LINE_NUMBER (seq) > 0) 5163 { 5164 epilogue_line_note = seq; 5165 break; 5166 } 5167 5168 for (ei2 = ei_start (last->preds); (e = ei_safe_edge (ei2)); ) 5169 { 5170 basic_block bb = e->src; 5171 rtx jump; 5172 5173 if (bb == ENTRY_BLOCK_PTR) 5174 { 5175 ei_next (&ei2); 5176 continue; 5177 } 5178 5179 jump = BB_END (bb); 5180 if (!JUMP_P (jump) || JUMP_LABEL (jump) != label) 5181 { 5182 ei_next (&ei2); 5183 continue; 5184 } 5185 5186 /* If we have an unconditional jump, we can replace that 5187 with a simple return instruction. */ 5188 if (simplejump_p (jump)) 5189 { 5190 emit_return_into_block (bb, epilogue_line_note); 5191 delete_insn (jump); 5192 } 5193 5194 /* If we have a conditional jump, we can try to replace 5195 that with a conditional return instruction. */ 5196 else if (condjump_p (jump)) 5197 { 5198 if (! redirect_jump (jump, 0, 0)) 5199 { 5200 ei_next (&ei2); 5201 continue; 5202 } 5203 5204 /* If this block has only one successor, it both jumps 5205 and falls through to the fallthru block, so we can't 5206 delete the edge. */ 5207 if (single_succ_p (bb)) 5208 { 5209 ei_next (&ei2); 5210 continue; 5211 } 5212 } 5213 else 5214 { 5215 ei_next (&ei2); 5216 continue; 5217 } 5218 5219 /* Fix up the CFG for the successful change we just made. */ 5220 redirect_edge_succ (e, EXIT_BLOCK_PTR); 5221 } 5222 5223 /* Emit a return insn for the exit fallthru block. Whether 5224 this is still reachable will be determined later. */ 5225 5226 emit_barrier_after (BB_END (last)); 5227 emit_return_into_block (last, epilogue_line_note); 5228 epilogue_end = BB_END (last); 5229 single_succ_edge (last)->flags &= ~EDGE_FALLTHRU; 5230 goto epilogue_done; 5231 } 5232 } 5233#endif 5234 /* Find the edge that falls through to EXIT. Other edges may exist 5235 due to RETURN instructions, but those don't need epilogues. 5236 There really shouldn't be a mixture -- either all should have 5237 been converted or none, however... */ 5238 5239 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) 5240 if (e->flags & EDGE_FALLTHRU) 5241 break; 5242 if (e == NULL) 5243 goto epilogue_done; 5244 5245#ifdef HAVE_epilogue 5246 if (HAVE_epilogue) 5247 { 5248 start_sequence (); 5249 epilogue_end = emit_note (NOTE_INSN_EPILOGUE_BEG); 5250 5251 seq = gen_epilogue (); 5252 5253#ifdef INCOMING_RETURN_ADDR_RTX 5254 /* If this function returns with the stack depressed and we can support 5255 it, massage the epilogue to actually do that. */ 5256 if (TREE_CODE (TREE_TYPE (current_function_decl)) == FUNCTION_TYPE 5257 && TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl))) 5258 seq = keep_stack_depressed (seq); 5259#endif 5260 5261 emit_jump_insn (seq); 5262 5263 /* Retain a map of the epilogue insns. */ 5264 record_insns (seq, &epilogue); 5265 set_insn_locators (seq, epilogue_locator); 5266 5267 seq = get_insns (); 5268 end_sequence (); 5269 5270 insert_insn_on_edge (seq, e); 5271 inserted = 1; 5272 } 5273 else 5274#endif 5275 { 5276 basic_block cur_bb; 5277 5278 if (! next_active_insn (BB_END (e->src))) 5279 goto epilogue_done; 5280 /* We have a fall-through edge to the exit block, the source is not 5281 at the end of the function, and there will be an assembler epilogue 5282 at the end of the function. 5283 We can't use force_nonfallthru here, because that would try to 5284 use return. Inserting a jump 'by hand' is extremely messy, so 5285 we take advantage of cfg_layout_finalize using 5286 fixup_fallthru_exit_predecessor. */ 5287 cfg_layout_initialize (0); 5288 FOR_EACH_BB (cur_bb) 5289 if (cur_bb->index >= NUM_FIXED_BLOCKS 5290 && cur_bb->next_bb->index >= NUM_FIXED_BLOCKS) 5291 cur_bb->aux = cur_bb->next_bb; 5292 cfg_layout_finalize (); 5293 } 5294epilogue_done: 5295 5296 if (inserted) 5297 commit_edge_insertions (); 5298 5299#ifdef HAVE_sibcall_epilogue 5300 /* Emit sibling epilogues before any sibling call sites. */ 5301 for (ei = ei_start (EXIT_BLOCK_PTR->preds); (e = ei_safe_edge (ei)); ) 5302 { 5303 basic_block bb = e->src; 5304 rtx insn = BB_END (bb); 5305 5306 if (!CALL_P (insn) 5307 || ! SIBLING_CALL_P (insn)) 5308 { 5309 ei_next (&ei); 5310 continue; 5311 } 5312 5313 start_sequence (); 5314 emit_insn (gen_sibcall_epilogue ()); 5315 seq = get_insns (); 5316 end_sequence (); 5317 5318 /* Retain a map of the epilogue insns. Used in life analysis to 5319 avoid getting rid of sibcall epilogue insns. Do this before we 5320 actually emit the sequence. */ 5321 record_insns (seq, &sibcall_epilogue); 5322 set_insn_locators (seq, epilogue_locator); 5323 5324 emit_insn_before (seq, insn); 5325 ei_next (&ei); 5326 } 5327#endif 5328 5329#ifdef HAVE_prologue 5330 /* This is probably all useless now that we use locators. */ 5331 if (prologue_end) 5332 { 5333 rtx insn, prev; 5334 5335 /* GDB handles `break f' by setting a breakpoint on the first 5336 line note after the prologue. Which means (1) that if 5337 there are line number notes before where we inserted the 5338 prologue we should move them, and (2) we should generate a 5339 note before the end of the first basic block, if there isn't 5340 one already there. 5341 5342 ??? This behavior is completely broken when dealing with 5343 multiple entry functions. We simply place the note always 5344 into first basic block and let alternate entry points 5345 to be missed. 5346 */ 5347 5348 for (insn = prologue_end; insn; insn = prev) 5349 { 5350 prev = PREV_INSN (insn); 5351 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0) 5352 { 5353 /* Note that we cannot reorder the first insn in the 5354 chain, since rest_of_compilation relies on that 5355 remaining constant. */ 5356 if (prev == NULL) 5357 break; 5358 reorder_insns (insn, insn, prologue_end); 5359 } 5360 } 5361 5362 /* Find the last line number note in the first block. */ 5363 for (insn = BB_END (ENTRY_BLOCK_PTR->next_bb); 5364 insn != prologue_end && insn; 5365 insn = PREV_INSN (insn)) 5366 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0) 5367 break; 5368 5369 /* If we didn't find one, make a copy of the first line number 5370 we run across. */ 5371 if (! insn) 5372 { 5373 for (insn = next_active_insn (prologue_end); 5374 insn; 5375 insn = PREV_INSN (insn)) 5376 if (NOTE_P (insn) && NOTE_LINE_NUMBER (insn) > 0) 5377 { 5378 emit_note_copy_after (insn, prologue_end); 5379 break; 5380 } 5381 } 5382 } 5383#endif 5384#ifdef HAVE_epilogue 5385 if (epilogue_end) 5386 { 5387 rtx insn, next; 5388 5389 /* Similarly, move any line notes that appear after the epilogue. 5390 There is no need, however, to be quite so anal about the existence 5391 of such a note. Also move the NOTE_INSN_FUNCTION_END and (possibly) 5392 NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug 5393 info generation. */ 5394 for (insn = epilogue_end; insn; insn = next) 5395 { 5396 next = NEXT_INSN (insn); 5397 if (NOTE_P (insn) 5398 && (NOTE_LINE_NUMBER (insn) > 0 5399 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG 5400 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_END)) 5401 reorder_insns (insn, insn, PREV_INSN (epilogue_end)); 5402 } 5403 } 5404#endif 5405} 5406 5407/* Reposition the prologue-end and epilogue-begin notes after instruction 5408 scheduling and delayed branch scheduling. */ 5409 5410void 5411reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED) 5412{ 5413#if defined (HAVE_prologue) || defined (HAVE_epilogue) 5414 rtx insn, last, note; 5415 int len; 5416 5417 if ((len = VEC_length (int, prologue)) > 0) 5418 { 5419 last = 0, note = 0; 5420 5421 /* Scan from the beginning until we reach the last prologue insn. 5422 We apparently can't depend on basic_block_{head,end} after 5423 reorg has run. */ 5424 for (insn = f; insn; insn = NEXT_INSN (insn)) 5425 { 5426 if (NOTE_P (insn)) 5427 { 5428 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) 5429 note = insn; 5430 } 5431 else if (contains (insn, &prologue)) 5432 { 5433 last = insn; 5434 if (--len == 0) 5435 break; 5436 } 5437 } 5438 5439 if (last) 5440 { 5441 /* Find the prologue-end note if we haven't already, and 5442 move it to just after the last prologue insn. */ 5443 if (note == 0) 5444 { 5445 for (note = last; (note = NEXT_INSN (note));) 5446 if (NOTE_P (note) 5447 && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END) 5448 break; 5449 } 5450 5451 /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */ 5452 if (LABEL_P (last)) 5453 last = NEXT_INSN (last); 5454 reorder_insns (note, note, last); 5455 } 5456 } 5457 5458 if ((len = VEC_length (int, epilogue)) > 0) 5459 { 5460 last = 0, note = 0; 5461 5462 /* Scan from the end until we reach the first epilogue insn. 5463 We apparently can't depend on basic_block_{head,end} after 5464 reorg has run. */ 5465 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn)) 5466 { 5467 if (NOTE_P (insn)) 5468 { 5469 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG) 5470 note = insn; 5471 } 5472 else if (contains (insn, &epilogue)) 5473 { 5474 last = insn; 5475 if (--len == 0) 5476 break; 5477 } 5478 } 5479 5480 if (last) 5481 { 5482 /* Find the epilogue-begin note if we haven't already, and 5483 move it to just before the first epilogue insn. */ 5484 if (note == 0) 5485 { 5486 for (note = insn; (note = PREV_INSN (note));) 5487 if (NOTE_P (note) 5488 && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG) 5489 break; 5490 } 5491 5492 if (PREV_INSN (last) != note) 5493 reorder_insns (note, note, PREV_INSN (last)); 5494 } 5495 } 5496#endif /* HAVE_prologue or HAVE_epilogue */ 5497} 5498 5499/* Resets insn_block_boundaries array. */ 5500 5501void 5502reset_block_changes (void) 5503{ 5504 cfun->ib_boundaries_block = VEC_alloc (tree, gc, 100); 5505 VEC_quick_push (tree, cfun->ib_boundaries_block, NULL_TREE); 5506} 5507 5508/* Record the boundary for BLOCK. */ 5509void 5510record_block_change (tree block) 5511{ 5512 int i, n; 5513 tree last_block; 5514 5515 if (!block) 5516 return; 5517 5518 if(!cfun->ib_boundaries_block) 5519 return; 5520 5521 last_block = VEC_pop (tree, cfun->ib_boundaries_block); 5522 n = get_max_uid (); 5523 for (i = VEC_length (tree, cfun->ib_boundaries_block); i < n; i++) 5524 VEC_safe_push (tree, gc, cfun->ib_boundaries_block, last_block); 5525 5526 VEC_safe_push (tree, gc, cfun->ib_boundaries_block, block); 5527} 5528 5529/* Finishes record of boundaries. */ 5530void 5531finalize_block_changes (void) 5532{ 5533 record_block_change (DECL_INITIAL (current_function_decl)); 5534} 5535 5536/* For INSN return the BLOCK it belongs to. */ 5537void 5538check_block_change (rtx insn, tree *block) 5539{ 5540 unsigned uid = INSN_UID (insn); 5541 5542 if (uid >= VEC_length (tree, cfun->ib_boundaries_block)) 5543 return; 5544 5545 *block = VEC_index (tree, cfun->ib_boundaries_block, uid); 5546} 5547 5548/* Releases the ib_boundaries_block records. */ 5549void 5550free_block_changes (void) 5551{ 5552 VEC_free (tree, gc, cfun->ib_boundaries_block); 5553} 5554 5555/* Returns the name of the current function. */ 5556const char * 5557current_function_name (void) 5558{ 5559 return lang_hooks.decl_printable_name (cfun->decl, 2); 5560} 5561 5562 5563static unsigned int 5564rest_of_handle_check_leaf_regs (void) 5565{ 5566#ifdef LEAF_REGISTERS 5567 current_function_uses_only_leaf_regs 5568 = optimize > 0 && only_leaf_regs_used () && leaf_function_p (); 5569#endif 5570 return 0; 5571} 5572 5573/* Insert a TYPE into the used types hash table of CFUN. */ 5574static void 5575used_types_insert_helper (tree type, struct function *func) 5576{ 5577 if (type != NULL && func != NULL) 5578 { 5579 void **slot; 5580 5581 if (func->used_types_hash == NULL) 5582 func->used_types_hash = htab_create_ggc (37, htab_hash_pointer, 5583 htab_eq_pointer, NULL); 5584 slot = htab_find_slot (func->used_types_hash, type, INSERT); 5585 if (*slot == NULL) 5586 *slot = type; 5587 } 5588} 5589 5590/* Given a type, insert it into the used hash table in cfun. */ 5591void 5592used_types_insert (tree t) 5593{ 5594 while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE) 5595 t = TREE_TYPE (t); 5596 t = TYPE_MAIN_VARIANT (t); 5597 if (debug_info_level > DINFO_LEVEL_NONE) 5598 used_types_insert_helper (t, cfun); 5599} 5600 5601struct tree_opt_pass pass_leaf_regs = 5602{ 5603 NULL, /* name */ 5604 NULL, /* gate */ 5605 rest_of_handle_check_leaf_regs, /* execute */ 5606 NULL, /* sub */ 5607 NULL, /* next */ 5608 0, /* static_pass_number */ 5609 0, /* tv_id */ 5610 0, /* properties_required */ 5611 0, /* properties_provided */ 5612 0, /* properties_destroyed */ 5613 0, /* todo_flags_start */ 5614 0, /* todo_flags_finish */ 5615 0 /* letter */ 5616}; 5617 5618 5619#include "gt-function.h" 5620