1 /* Convert function calls to rtl insns, for GNU C compiler. 2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "gimple.h" 29 #include "flags.h" 30 #include "expr.h" 31 #include "optabs.h" 32 #include "libfuncs.h" 33 #include "function.h" 34 #include "regs.h" 35 #include "toplev.h" 36 #include "output.h" 37 #include "tm_p.h" 38 #include "timevar.h" 39 #include "sbitmap.h" 40 #include "langhooks.h" 41 #include "target.h" 42 #include "debug.h" 43 #include "cgraph.h" 44 #include "except.h" 45 #include "dbgcnt.h" 46 #include "tree-flow.h" 47 48 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */ 49 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT) 50 51 /* Data structure and subroutines used within expand_call. */ 52 53 struct arg_data 54 { 55 /* Tree node for this argument. */ 56 tree tree_value; 57 /* Mode for value; TYPE_MODE unless promoted. */ 58 enum machine_mode mode; 59 /* Current RTL value for argument, or 0 if it isn't precomputed. */ 60 rtx value; 61 /* Initially-compute RTL value for argument; only for const functions. */ 62 rtx initial_value; 63 /* Register to pass this argument in, 0 if passed on stack, or an 64 PARALLEL if the arg is to be copied into multiple non-contiguous 65 registers. */ 66 rtx reg; 67 /* Register to pass this argument in when generating tail call sequence. 68 This is not the same register as for normal calls on machines with 69 register windows. */ 70 rtx tail_call_reg; 71 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct 72 form for emit_group_move. */ 73 rtx parallel_value; 74 /* If REG was promoted from the actual mode of the argument expression, 75 indicates whether the promotion is sign- or zero-extended. */ 76 int unsignedp; 77 /* Number of bytes to put in registers. 0 means put the whole arg 78 in registers. Also 0 if not passed in registers. */ 79 int partial; 80 /* Nonzero if argument must be passed on stack. 81 Note that some arguments may be passed on the stack 82 even though pass_on_stack is zero, just because FUNCTION_ARG says so. 83 pass_on_stack identifies arguments that *cannot* go in registers. */ 84 int pass_on_stack; 85 /* Some fields packaged up for locate_and_pad_parm. */ 86 struct locate_and_pad_arg_data locate; 87 /* Location on the stack at which parameter should be stored. The store 88 has already been done if STACK == VALUE. */ 89 rtx stack; 90 /* Location on the stack of the start of this argument slot. This can 91 differ from STACK if this arg pads downward. This location is known 92 to be aligned to FUNCTION_ARG_BOUNDARY. */ 93 rtx stack_slot; 94 /* Place that this stack area has been saved, if needed. */ 95 rtx save_area; 96 /* If an argument's alignment does not permit direct copying into registers, 97 copy in smaller-sized pieces into pseudos. These are stored in a 98 block pointed to by this field. The next field says how many 99 word-sized pseudos we made. */ 100 rtx *aligned_regs; 101 int n_aligned_regs; 102 }; 103 104 /* A vector of one char per byte of stack space. A byte if nonzero if 105 the corresponding stack location has been used. 106 This vector is used to prevent a function call within an argument from 107 clobbering any stack already set up. */ 108 static char *stack_usage_map; 109 110 /* Size of STACK_USAGE_MAP. */ 111 static int highest_outgoing_arg_in_use; 112 113 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding 114 stack location's tail call argument has been already stored into the stack. 115 This bitmap is used to prevent sibling call optimization if function tries 116 to use parent's incoming argument slots when they have been already 117 overwritten with tail call arguments. */ 118 static sbitmap stored_args_map; 119 120 /* stack_arg_under_construction is nonzero when an argument may be 121 initialized with a constructor call (including a C function that 122 returns a BLKmode struct) and expand_call must take special action 123 to make sure the object being constructed does not overlap the 124 argument list for the constructor call. */ 125 static int stack_arg_under_construction; 126 127 static void emit_call_1 (rtx, tree, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT, 128 HOST_WIDE_INT, rtx, rtx, int, rtx, int, 129 CUMULATIVE_ARGS *); 130 static void precompute_register_parameters (int, struct arg_data *, int *); 131 static int store_one_arg (struct arg_data *, rtx, int, int, int); 132 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int); 133 static int finalize_must_preallocate (int, int, struct arg_data *, 134 struct args_size *); 135 static void precompute_arguments (int, struct arg_data *); 136 static int compute_argument_block_size (int, struct args_size *, tree, tree, int); 137 static void initialize_argument_information (int, struct arg_data *, 138 struct args_size *, int, 139 tree, tree, 140 tree, tree, CUMULATIVE_ARGS *, int, 141 rtx *, int *, int *, int *, 142 bool *, bool); 143 static void compute_argument_addresses (struct arg_data *, rtx, int); 144 static rtx rtx_for_function_call (tree, tree); 145 static void load_register_parameters (struct arg_data *, int, rtx *, int, 146 int, int *); 147 static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type, 148 enum machine_mode, int, va_list); 149 static int special_function_p (const_tree, int); 150 static int check_sibcall_argument_overlap_1 (rtx); 151 static int check_sibcall_argument_overlap (rtx, struct arg_data *, int); 152 153 static int combine_pending_stack_adjustment_and_call (int, struct args_size *, 154 unsigned int); 155 static tree split_complex_types (tree); 156 157 #ifdef REG_PARM_STACK_SPACE 158 static rtx save_fixed_argument_area (int, rtx, int *, int *); 159 static void restore_fixed_argument_area (rtx, rtx, int, int); 160 #endif 161 162 /* Force FUNEXP into a form suitable for the address of a CALL, 163 and return that as an rtx. Also load the static chain register 164 if FNDECL is a nested function. 165 166 CALL_FUSAGE points to a variable holding the prospective 167 CALL_INSN_FUNCTION_USAGE information. */ 168 169 rtx 170 prepare_call_address (tree fndecl, rtx funexp, rtx static_chain_value, 171 rtx *call_fusage, int reg_parm_seen, int sibcallp) 172 { 173 /* Make a valid memory address and copy constants through pseudo-regs, 174 but not for a constant address if -fno-function-cse. */ 175 if (GET_CODE (funexp) != SYMBOL_REF) 176 /* If we are using registers for parameters, force the 177 function address into a register now. */ 178 funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen) 179 ? force_not_mem (memory_address (FUNCTION_MODE, funexp)) 180 : memory_address (FUNCTION_MODE, funexp)); 181 else if (! sibcallp) 182 { 183 #ifndef NO_FUNCTION_CSE 184 if (optimize && ! flag_no_function_cse) 185 funexp = force_reg (Pmode, funexp); 186 #endif 187 } 188 189 if (static_chain_value != 0) 190 { 191 rtx chain; 192 193 gcc_assert (fndecl); 194 chain = targetm.calls.static_chain (fndecl, false); 195 static_chain_value = convert_memory_address (Pmode, static_chain_value); 196 197 emit_move_insn (chain, static_chain_value); 198 if (REG_P (chain)) 199 use_reg (call_fusage, chain); 200 } 201 202 return funexp; 203 } 204 205 /* Generate instructions to call function FUNEXP, 206 and optionally pop the results. 207 The CALL_INSN is the first insn generated. 208 209 FNDECL is the declaration node of the function. This is given to the 210 macro RETURN_POPS_ARGS to determine whether this function pops its own args. 211 212 FUNTYPE is the data type of the function. This is given to the macro 213 RETURN_POPS_ARGS to determine whether this function pops its own args. 214 We used to allow an identifier for library functions, but that doesn't 215 work when the return type is an aggregate type and the calling convention 216 says that the pointer to this aggregate is to be popped by the callee. 217 218 STACK_SIZE is the number of bytes of arguments on the stack, 219 ROUNDED_STACK_SIZE is that number rounded up to 220 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is 221 both to put into the call insn and to generate explicit popping 222 code if necessary. 223 224 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value. 225 It is zero if this call doesn't want a structure value. 226 227 NEXT_ARG_REG is the rtx that results from executing 228 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1) 229 just after all the args have had their registers assigned. 230 This could be whatever you like, but normally it is the first 231 arg-register beyond those used for args in this call, 232 or 0 if all the arg-registers are used in this call. 233 It is passed on to `gen_call' so you can put this info in the call insn. 234 235 VALREG is a hard register in which a value is returned, 236 or 0 if the call does not return a value. 237 238 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before 239 the args to this call were processed. 240 We restore `inhibit_defer_pop' to that value. 241 242 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that 243 denote registers used by the called function. */ 244 245 static void 246 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED, 247 tree funtype ATTRIBUTE_UNUSED, 248 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED, 249 HOST_WIDE_INT rounded_stack_size, 250 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED, 251 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg, 252 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags, 253 CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED) 254 { 255 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size); 256 rtx call_insn; 257 int already_popped = 0; 258 HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size); 259 260 #ifdef CALL_POPS_ARGS 261 n_popped += CALL_POPS_ARGS (* args_so_far); 262 #endif 263 264 /* Ensure address is valid. SYMBOL_REF is already valid, so no need, 265 and we don't want to load it into a register as an optimization, 266 because prepare_call_address already did it if it should be done. */ 267 if (GET_CODE (funexp) != SYMBOL_REF) 268 funexp = memory_address (FUNCTION_MODE, funexp); 269 270 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop) 271 if ((ecf_flags & ECF_SIBCALL) 272 && HAVE_sibcall_pop && HAVE_sibcall_value_pop 273 && (n_popped > 0 || stack_size == 0)) 274 { 275 rtx n_pop = GEN_INT (n_popped); 276 rtx pat; 277 278 /* If this subroutine pops its own args, record that in the call insn 279 if possible, for the sake of frame pointer elimination. */ 280 281 if (valreg) 282 pat = GEN_SIBCALL_VALUE_POP (valreg, 283 gen_rtx_MEM (FUNCTION_MODE, funexp), 284 rounded_stack_size_rtx, next_arg_reg, 285 n_pop); 286 else 287 pat = GEN_SIBCALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp), 288 rounded_stack_size_rtx, next_arg_reg, n_pop); 289 290 emit_call_insn (pat); 291 already_popped = 1; 292 } 293 else 294 #endif 295 296 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop) 297 /* If the target has "call" or "call_value" insns, then prefer them 298 if no arguments are actually popped. If the target does not have 299 "call" or "call_value" insns, then we must use the popping versions 300 even if the call has no arguments to pop. */ 301 #if defined (HAVE_call) && defined (HAVE_call_value) 302 if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop 303 && n_popped > 0) 304 #else 305 if (HAVE_call_pop && HAVE_call_value_pop) 306 #endif 307 { 308 rtx n_pop = GEN_INT (n_popped); 309 rtx pat; 310 311 /* If this subroutine pops its own args, record that in the call insn 312 if possible, for the sake of frame pointer elimination. */ 313 314 if (valreg) 315 pat = GEN_CALL_VALUE_POP (valreg, 316 gen_rtx_MEM (FUNCTION_MODE, funexp), 317 rounded_stack_size_rtx, next_arg_reg, n_pop); 318 else 319 pat = GEN_CALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp), 320 rounded_stack_size_rtx, next_arg_reg, n_pop); 321 322 emit_call_insn (pat); 323 already_popped = 1; 324 } 325 else 326 #endif 327 328 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value) 329 if ((ecf_flags & ECF_SIBCALL) 330 && HAVE_sibcall && HAVE_sibcall_value) 331 { 332 if (valreg) 333 emit_call_insn (GEN_SIBCALL_VALUE (valreg, 334 gen_rtx_MEM (FUNCTION_MODE, funexp), 335 rounded_stack_size_rtx, 336 next_arg_reg, NULL_RTX)); 337 else 338 emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE, funexp), 339 rounded_stack_size_rtx, next_arg_reg, 340 GEN_INT (struct_value_size))); 341 } 342 else 343 #endif 344 345 #if defined (HAVE_call) && defined (HAVE_call_value) 346 if (HAVE_call && HAVE_call_value) 347 { 348 if (valreg) 349 emit_call_insn (GEN_CALL_VALUE (valreg, 350 gen_rtx_MEM (FUNCTION_MODE, funexp), 351 rounded_stack_size_rtx, next_arg_reg, 352 NULL_RTX)); 353 else 354 emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE, funexp), 355 rounded_stack_size_rtx, next_arg_reg, 356 GEN_INT (struct_value_size))); 357 } 358 else 359 #endif 360 gcc_unreachable (); 361 362 /* Find the call we just emitted. */ 363 call_insn = last_call_insn (); 364 365 /* Put the register usage information there. */ 366 add_function_usage_to (call_insn, call_fusage); 367 368 /* If this is a const call, then set the insn's unchanging bit. */ 369 if (ecf_flags & ECF_CONST) 370 RTL_CONST_CALL_P (call_insn) = 1; 371 372 /* If this is a pure call, then set the insn's unchanging bit. */ 373 if (ecf_flags & ECF_PURE) 374 RTL_PURE_CALL_P (call_insn) = 1; 375 376 /* If this is a const call, then set the insn's unchanging bit. */ 377 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE) 378 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1; 379 380 /* Create a nothrow REG_EH_REGION note, if needed. */ 381 make_reg_eh_region_note (call_insn, ecf_flags, 0); 382 383 if (ecf_flags & ECF_NORETURN) 384 add_reg_note (call_insn, REG_NORETURN, const0_rtx); 385 386 if (ecf_flags & ECF_RETURNS_TWICE) 387 { 388 add_reg_note (call_insn, REG_SETJMP, const0_rtx); 389 cfun->calls_setjmp = 1; 390 } 391 392 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0); 393 394 /* Record debug information for virtual calls. */ 395 if (flag_enable_icf_debug && fndecl == NULL) 396 (*debug_hooks->virtual_call_token) (CALL_EXPR_FN (fntree), 397 INSN_UID (call_insn)); 398 399 /* Restore this now, so that we do defer pops for this call's args 400 if the context of the call as a whole permits. */ 401 inhibit_defer_pop = old_inhibit_defer_pop; 402 403 if (n_popped > 0) 404 { 405 if (!already_popped) 406 CALL_INSN_FUNCTION_USAGE (call_insn) 407 = gen_rtx_EXPR_LIST (VOIDmode, 408 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx), 409 CALL_INSN_FUNCTION_USAGE (call_insn)); 410 rounded_stack_size -= n_popped; 411 rounded_stack_size_rtx = GEN_INT (rounded_stack_size); 412 stack_pointer_delta -= n_popped; 413 414 /* If popup is needed, stack realign must use DRAP */ 415 if (SUPPORTS_STACK_ALIGNMENT) 416 crtl->need_drap = true; 417 } 418 419 if (!ACCUMULATE_OUTGOING_ARGS) 420 { 421 /* If returning from the subroutine does not automatically pop the args, 422 we need an instruction to pop them sooner or later. 423 Perhaps do it now; perhaps just record how much space to pop later. 424 425 If returning from the subroutine does pop the args, indicate that the 426 stack pointer will be changed. */ 427 428 if (rounded_stack_size != 0) 429 { 430 if (ecf_flags & ECF_NORETURN) 431 /* Just pretend we did the pop. */ 432 stack_pointer_delta -= rounded_stack_size; 433 else if (flag_defer_pop && inhibit_defer_pop == 0 434 && ! (ecf_flags & (ECF_CONST | ECF_PURE))) 435 pending_stack_adjust += rounded_stack_size; 436 else 437 adjust_stack (rounded_stack_size_rtx); 438 } 439 } 440 /* When we accumulate outgoing args, we must avoid any stack manipulations. 441 Restore the stack pointer to its original value now. Usually 442 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions. 443 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and 444 popping variants of functions exist as well. 445 446 ??? We may optimize similar to defer_pop above, but it is 447 probably not worthwhile. 448 449 ??? It will be worthwhile to enable combine_stack_adjustments even for 450 such machines. */ 451 else if (n_popped) 452 anti_adjust_stack (GEN_INT (n_popped)); 453 } 454 455 /* Determine if the function identified by NAME and FNDECL is one with 456 special properties we wish to know about. 457 458 For example, if the function might return more than one time (setjmp), then 459 set RETURNS_TWICE to a nonzero value. 460 461 Similarly set NORETURN if the function is in the longjmp family. 462 463 Set MAY_BE_ALLOCA for any memory allocation function that might allocate 464 space from the stack such as alloca. */ 465 466 static int 467 special_function_p (const_tree fndecl, int flags) 468 { 469 if (fndecl && DECL_NAME (fndecl) 470 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17 471 /* Exclude functions not at the file scope, or not `extern', 472 since they are not the magic functions we would otherwise 473 think they are. 474 FIXME: this should be handled with attributes, not with this 475 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong 476 because you can declare fork() inside a function if you 477 wish. */ 478 && (DECL_CONTEXT (fndecl) == NULL_TREE 479 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL) 480 && TREE_PUBLIC (fndecl)) 481 { 482 const char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl)); 483 const char *tname = name; 484 485 /* We assume that alloca will always be called by name. It 486 makes no sense to pass it as a pointer-to-function to 487 anything that does not understand its behavior. */ 488 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6 489 && name[0] == 'a' 490 && ! strcmp (name, "alloca")) 491 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16 492 && name[0] == '_' 493 && ! strcmp (name, "__builtin_alloca")))) 494 flags |= ECF_MAY_BE_ALLOCA; 495 496 /* Disregard prefix _, __, __x or __builtin_. */ 497 if (name[0] == '_') 498 { 499 if (name[1] == '_' 500 && name[2] == 'b' 501 && !strncmp (name + 3, "uiltin_", 7)) 502 tname += 10; 503 else if (name[1] == '_' && name[2] == 'x') 504 tname += 3; 505 else if (name[1] == '_') 506 tname += 2; 507 else 508 tname += 1; 509 } 510 511 if (tname[0] == 's') 512 { 513 if ((tname[1] == 'e' 514 && (! strcmp (tname, "setjmp") 515 || ! strcmp (tname, "setjmp_syscall"))) 516 || (tname[1] == 'i' 517 && ! strcmp (tname, "sigsetjmp")) 518 || (tname[1] == 'a' 519 && ! strcmp (tname, "savectx"))) 520 flags |= ECF_RETURNS_TWICE; 521 522 if (tname[1] == 'i' 523 && ! strcmp (tname, "siglongjmp")) 524 flags |= ECF_NORETURN; 525 } 526 else if ((tname[0] == 'q' && tname[1] == 's' 527 && ! strcmp (tname, "qsetjmp")) 528 || (tname[0] == 'v' && tname[1] == 'f' 529 && ! strcmp (tname, "vfork")) 530 || (tname[0] == 'g' && tname[1] == 'e' 531 && !strcmp (tname, "getcontext"))) 532 flags |= ECF_RETURNS_TWICE; 533 534 else if (tname[0] == 'l' && tname[1] == 'o' 535 && ! strcmp (tname, "longjmp")) 536 flags |= ECF_NORETURN; 537 } 538 539 return flags; 540 } 541 542 /* Return nonzero when FNDECL represents a call to setjmp. */ 543 544 int 545 setjmp_call_p (const_tree fndecl) 546 { 547 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE; 548 } 549 550 551 /* Return true if STMT is an alloca call. */ 552 553 bool 554 gimple_alloca_call_p (const_gimple stmt) 555 { 556 tree fndecl; 557 558 if (!is_gimple_call (stmt)) 559 return false; 560 561 fndecl = gimple_call_fndecl (stmt); 562 if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA)) 563 return true; 564 565 return false; 566 } 567 568 /* Return true when exp contains alloca call. */ 569 570 bool 571 alloca_call_p (const_tree exp) 572 { 573 if (TREE_CODE (exp) == CALL_EXPR 574 && TREE_CODE (CALL_EXPR_FN (exp)) == ADDR_EXPR 575 && (TREE_CODE (TREE_OPERAND (CALL_EXPR_FN (exp), 0)) == FUNCTION_DECL) 576 && (special_function_p (TREE_OPERAND (CALL_EXPR_FN (exp), 0), 0) 577 & ECF_MAY_BE_ALLOCA)) 578 return true; 579 return false; 580 } 581 582 /* Detect flags (function attributes) from the function decl or type node. */ 583 584 int 585 flags_from_decl_or_type (const_tree exp) 586 { 587 int flags = 0; 588 589 if (DECL_P (exp)) 590 { 591 /* The function exp may have the `malloc' attribute. */ 592 if (DECL_IS_MALLOC (exp)) 593 flags |= ECF_MALLOC; 594 595 /* The function exp may have the `returns_twice' attribute. */ 596 if (DECL_IS_RETURNS_TWICE (exp)) 597 flags |= ECF_RETURNS_TWICE; 598 599 /* Process the pure and const attributes. */ 600 if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp)) 601 flags |= ECF_CONST; 602 if (DECL_PURE_P (exp)) 603 flags |= ECF_PURE; 604 if (DECL_LOOPING_CONST_OR_PURE_P (exp)) 605 flags |= ECF_LOOPING_CONST_OR_PURE; 606 607 if (DECL_IS_NOVOPS (exp)) 608 flags |= ECF_NOVOPS; 609 610 if (TREE_NOTHROW (exp)) 611 flags |= ECF_NOTHROW; 612 613 flags = special_function_p (exp, flags); 614 } 615 else if (TYPE_P (exp) && TYPE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp)) 616 flags |= ECF_CONST; 617 618 if (TREE_THIS_VOLATILE (exp)) 619 flags |= ECF_NORETURN; 620 621 return flags; 622 } 623 624 /* Detect flags from a CALL_EXPR. */ 625 626 int 627 call_expr_flags (const_tree t) 628 { 629 int flags; 630 tree decl = get_callee_fndecl (t); 631 632 if (decl) 633 flags = flags_from_decl_or_type (decl); 634 else 635 { 636 t = TREE_TYPE (CALL_EXPR_FN (t)); 637 if (t && TREE_CODE (t) == POINTER_TYPE) 638 flags = flags_from_decl_or_type (TREE_TYPE (t)); 639 else 640 flags = 0; 641 } 642 643 return flags; 644 } 645 646 /* Precompute all register parameters as described by ARGS, storing values 647 into fields within the ARGS array. 648 649 NUM_ACTUALS indicates the total number elements in the ARGS array. 650 651 Set REG_PARM_SEEN if we encounter a register parameter. */ 652 653 static void 654 precompute_register_parameters (int num_actuals, struct arg_data *args, 655 int *reg_parm_seen) 656 { 657 int i; 658 659 *reg_parm_seen = 0; 660 661 for (i = 0; i < num_actuals; i++) 662 if (args[i].reg != 0 && ! args[i].pass_on_stack) 663 { 664 *reg_parm_seen = 1; 665 666 if (args[i].value == 0) 667 { 668 push_temp_slots (); 669 args[i].value = expand_normal (args[i].tree_value); 670 preserve_temp_slots (args[i].value); 671 pop_temp_slots (); 672 } 673 674 /* If the value is a non-legitimate constant, force it into a 675 pseudo now. TLS symbols sometimes need a call to resolve. */ 676 if (CONSTANT_P (args[i].value) 677 && !LEGITIMATE_CONSTANT_P (args[i].value)) 678 args[i].value = force_reg (args[i].mode, args[i].value); 679 680 /* If we are to promote the function arg to a wider mode, 681 do it now. */ 682 683 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value))) 684 args[i].value 685 = convert_modes (args[i].mode, 686 TYPE_MODE (TREE_TYPE (args[i].tree_value)), 687 args[i].value, args[i].unsignedp); 688 689 /* If we're going to have to load the value by parts, pull the 690 parts into pseudos. The part extraction process can involve 691 non-trivial computation. */ 692 if (GET_CODE (args[i].reg) == PARALLEL) 693 { 694 tree type = TREE_TYPE (args[i].tree_value); 695 args[i].parallel_value 696 = emit_group_load_into_temps (args[i].reg, args[i].value, 697 type, int_size_in_bytes (type)); 698 } 699 700 /* If the value is expensive, and we are inside an appropriately 701 short loop, put the value into a pseudo and then put the pseudo 702 into the hard reg. 703 704 For small register classes, also do this if this call uses 705 register parameters. This is to avoid reload conflicts while 706 loading the parameters registers. */ 707 708 else if ((! (REG_P (args[i].value) 709 || (GET_CODE (args[i].value) == SUBREG 710 && REG_P (SUBREG_REG (args[i].value))))) 711 && args[i].mode != BLKmode 712 && rtx_cost (args[i].value, SET, optimize_insn_for_speed_p ()) 713 > COSTS_N_INSNS (1) 714 && ((SMALL_REGISTER_CLASSES && *reg_parm_seen) 715 || optimize)) 716 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value); 717 } 718 } 719 720 #ifdef REG_PARM_STACK_SPACE 721 722 /* The argument list is the property of the called routine and it 723 may clobber it. If the fixed area has been used for previous 724 parameters, we must save and restore it. */ 725 726 static rtx 727 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save) 728 { 729 int low; 730 int high; 731 732 /* Compute the boundary of the area that needs to be saved, if any. */ 733 high = reg_parm_stack_space; 734 #ifdef ARGS_GROW_DOWNWARD 735 high += 1; 736 #endif 737 if (high > highest_outgoing_arg_in_use) 738 high = highest_outgoing_arg_in_use; 739 740 for (low = 0; low < high; low++) 741 if (stack_usage_map[low] != 0) 742 { 743 int num_to_save; 744 enum machine_mode save_mode; 745 int delta; 746 rtx stack_area; 747 rtx save_area; 748 749 while (stack_usage_map[--high] == 0) 750 ; 751 752 *low_to_save = low; 753 *high_to_save = high; 754 755 num_to_save = high - low + 1; 756 save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1); 757 758 /* If we don't have the required alignment, must do this 759 in BLKmode. */ 760 if ((low & (MIN (GET_MODE_SIZE (save_mode), 761 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1))) 762 save_mode = BLKmode; 763 764 #ifdef ARGS_GROW_DOWNWARD 765 delta = -high; 766 #else 767 delta = low; 768 #endif 769 stack_area = gen_rtx_MEM (save_mode, 770 memory_address (save_mode, 771 plus_constant (argblock, 772 delta))); 773 774 set_mem_align (stack_area, PARM_BOUNDARY); 775 if (save_mode == BLKmode) 776 { 777 save_area = assign_stack_temp (BLKmode, num_to_save, 0); 778 emit_block_move (validize_mem (save_area), stack_area, 779 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM); 780 } 781 else 782 { 783 save_area = gen_reg_rtx (save_mode); 784 emit_move_insn (save_area, stack_area); 785 } 786 787 return save_area; 788 } 789 790 return NULL_RTX; 791 } 792 793 static void 794 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save) 795 { 796 enum machine_mode save_mode = GET_MODE (save_area); 797 int delta; 798 rtx stack_area; 799 800 #ifdef ARGS_GROW_DOWNWARD 801 delta = -high_to_save; 802 #else 803 delta = low_to_save; 804 #endif 805 stack_area = gen_rtx_MEM (save_mode, 806 memory_address (save_mode, 807 plus_constant (argblock, delta))); 808 set_mem_align (stack_area, PARM_BOUNDARY); 809 810 if (save_mode != BLKmode) 811 emit_move_insn (stack_area, save_area); 812 else 813 emit_block_move (stack_area, validize_mem (save_area), 814 GEN_INT (high_to_save - low_to_save + 1), 815 BLOCK_OP_CALL_PARM); 816 } 817 #endif /* REG_PARM_STACK_SPACE */ 818 819 /* If any elements in ARGS refer to parameters that are to be passed in 820 registers, but not in memory, and whose alignment does not permit a 821 direct copy into registers. Copy the values into a group of pseudos 822 which we will later copy into the appropriate hard registers. 823 824 Pseudos for each unaligned argument will be stored into the array 825 args[argnum].aligned_regs. The caller is responsible for deallocating 826 the aligned_regs array if it is nonzero. */ 827 828 static void 829 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals) 830 { 831 int i, j; 832 833 for (i = 0; i < num_actuals; i++) 834 if (args[i].reg != 0 && ! args[i].pass_on_stack 835 && args[i].mode == BLKmode 836 && MEM_P (args[i].value) 837 && (MEM_ALIGN (args[i].value) 838 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD))) 839 { 840 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value)); 841 int endian_correction = 0; 842 843 if (args[i].partial) 844 { 845 gcc_assert (args[i].partial % UNITS_PER_WORD == 0); 846 args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD; 847 } 848 else 849 { 850 args[i].n_aligned_regs 851 = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD; 852 } 853 854 args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs); 855 856 /* Structures smaller than a word are normally aligned to the 857 least significant byte. On a BYTES_BIG_ENDIAN machine, 858 this means we must skip the empty high order bytes when 859 calculating the bit offset. */ 860 if (bytes < UNITS_PER_WORD 861 #ifdef BLOCK_REG_PADDING 862 && (BLOCK_REG_PADDING (args[i].mode, 863 TREE_TYPE (args[i].tree_value), 1) 864 == downward) 865 #else 866 && BYTES_BIG_ENDIAN 867 #endif 868 ) 869 endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT; 870 871 for (j = 0; j < args[i].n_aligned_regs; j++) 872 { 873 rtx reg = gen_reg_rtx (word_mode); 874 rtx word = operand_subword_force (args[i].value, j, BLKmode); 875 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD); 876 877 args[i].aligned_regs[j] = reg; 878 word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX, 879 word_mode, word_mode); 880 881 /* There is no need to restrict this code to loading items 882 in TYPE_ALIGN sized hunks. The bitfield instructions can 883 load up entire word sized registers efficiently. 884 885 ??? This may not be needed anymore. 886 We use to emit a clobber here but that doesn't let later 887 passes optimize the instructions we emit. By storing 0 into 888 the register later passes know the first AND to zero out the 889 bitfield being set in the register is unnecessary. The store 890 of 0 will be deleted as will at least the first AND. */ 891 892 emit_move_insn (reg, const0_rtx); 893 894 bytes -= bitsize / BITS_PER_UNIT; 895 store_bit_field (reg, bitsize, endian_correction, word_mode, 896 word); 897 } 898 } 899 } 900 901 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in 902 CALL_EXPR EXP. 903 904 NUM_ACTUALS is the total number of parameters. 905 906 N_NAMED_ARGS is the total number of named arguments. 907 908 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return 909 value, or null. 910 911 FNDECL is the tree code for the target of this call (if known) 912 913 ARGS_SO_FAR holds state needed by the target to know where to place 914 the next argument. 915 916 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved 917 for arguments which are passed in registers. 918 919 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level 920 and may be modified by this routine. 921 922 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer 923 flags which may may be modified by this routine. 924 925 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference 926 that requires allocation of stack space. 927 928 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to 929 the thunked-to function. */ 930 931 static void 932 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED, 933 struct arg_data *args, 934 struct args_size *args_size, 935 int n_named_args ATTRIBUTE_UNUSED, 936 tree exp, tree struct_value_addr_value, 937 tree fndecl, tree fntype, 938 CUMULATIVE_ARGS *args_so_far, 939 int reg_parm_stack_space, 940 rtx *old_stack_level, int *old_pending_adj, 941 int *must_preallocate, int *ecf_flags, 942 bool *may_tailcall, bool call_from_thunk_p) 943 { 944 location_t loc = EXPR_LOCATION (exp); 945 /* 1 if scanning parms front to back, -1 if scanning back to front. */ 946 int inc; 947 948 /* Count arg position in order args appear. */ 949 int argpos; 950 951 int i; 952 953 args_size->constant = 0; 954 args_size->var = 0; 955 956 /* In this loop, we consider args in the order they are written. 957 We fill up ARGS from the front or from the back if necessary 958 so that in any case the first arg to be pushed ends up at the front. */ 959 960 if (PUSH_ARGS_REVERSED) 961 { 962 i = num_actuals - 1, inc = -1; 963 /* In this case, must reverse order of args 964 so that we compute and push the last arg first. */ 965 } 966 else 967 { 968 i = 0, inc = 1; 969 } 970 971 /* First fill in the actual arguments in the ARGS array, splitting 972 complex arguments if necessary. */ 973 { 974 int j = i; 975 call_expr_arg_iterator iter; 976 tree arg; 977 978 if (struct_value_addr_value) 979 { 980 args[j].tree_value = struct_value_addr_value; 981 j += inc; 982 } 983 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 984 { 985 tree argtype = TREE_TYPE (arg); 986 if (targetm.calls.split_complex_arg 987 && argtype 988 && TREE_CODE (argtype) == COMPLEX_TYPE 989 && targetm.calls.split_complex_arg (argtype)) 990 { 991 tree subtype = TREE_TYPE (argtype); 992 args[j].tree_value = build1 (REALPART_EXPR, subtype, arg); 993 j += inc; 994 args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg); 995 } 996 else 997 args[j].tree_value = arg; 998 j += inc; 999 } 1000 } 1001 1002 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */ 1003 for (argpos = 0; argpos < num_actuals; i += inc, argpos++) 1004 { 1005 tree type = TREE_TYPE (args[i].tree_value); 1006 int unsignedp; 1007 enum machine_mode mode; 1008 1009 /* Replace erroneous argument with constant zero. */ 1010 if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 1011 args[i].tree_value = integer_zero_node, type = integer_type_node; 1012 1013 /* If TYPE is a transparent union or record, pass things the way 1014 we would pass the first field of the union or record. We have 1015 already verified that the modes are the same. */ 1016 if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE) 1017 && TYPE_TRANSPARENT_AGGR (type)) 1018 type = TREE_TYPE (first_field (type)); 1019 1020 /* Decide where to pass this arg. 1021 1022 args[i].reg is nonzero if all or part is passed in registers. 1023 1024 args[i].partial is nonzero if part but not all is passed in registers, 1025 and the exact value says how many bytes are passed in registers. 1026 1027 args[i].pass_on_stack is nonzero if the argument must at least be 1028 computed on the stack. It may then be loaded back into registers 1029 if args[i].reg is nonzero. 1030 1031 These decisions are driven by the FUNCTION_... macros and must agree 1032 with those made by function.c. */ 1033 1034 /* See if this argument should be passed by invisible reference. */ 1035 if (pass_by_reference (args_so_far, TYPE_MODE (type), 1036 type, argpos < n_named_args)) 1037 { 1038 bool callee_copies; 1039 tree base; 1040 1041 callee_copies 1042 = reference_callee_copied (args_so_far, TYPE_MODE (type), 1043 type, argpos < n_named_args); 1044 1045 /* If we're compiling a thunk, pass through invisible references 1046 instead of making a copy. */ 1047 if (call_from_thunk_p 1048 || (callee_copies 1049 && !TREE_ADDRESSABLE (type) 1050 && (base = get_base_address (args[i].tree_value)) 1051 && TREE_CODE (base) != SSA_NAME 1052 && (!DECL_P (base) || MEM_P (DECL_RTL (base))))) 1053 { 1054 /* We can't use sibcalls if a callee-copied argument is 1055 stored in the current function's frame. */ 1056 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base)) 1057 *may_tailcall = false; 1058 1059 args[i].tree_value = build_fold_addr_expr_loc (loc, 1060 args[i].tree_value); 1061 type = TREE_TYPE (args[i].tree_value); 1062 1063 if (*ecf_flags & ECF_CONST) 1064 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE); 1065 } 1066 else 1067 { 1068 /* We make a copy of the object and pass the address to the 1069 function being called. */ 1070 rtx copy; 1071 1072 if (!COMPLETE_TYPE_P (type) 1073 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST 1074 || (flag_stack_check == GENERIC_STACK_CHECK 1075 && compare_tree_int (TYPE_SIZE_UNIT (type), 1076 STACK_CHECK_MAX_VAR_SIZE) > 0)) 1077 { 1078 /* This is a variable-sized object. Make space on the stack 1079 for it. */ 1080 rtx size_rtx = expr_size (args[i].tree_value); 1081 1082 if (*old_stack_level == 0) 1083 { 1084 emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX); 1085 *old_pending_adj = pending_stack_adjust; 1086 pending_stack_adjust = 0; 1087 } 1088 1089 copy = gen_rtx_MEM (BLKmode, 1090 allocate_dynamic_stack_space 1091 (size_rtx, NULL_RTX, TYPE_ALIGN (type))); 1092 set_mem_attributes (copy, type, 1); 1093 } 1094 else 1095 copy = assign_temp (type, 0, 1, 0); 1096 1097 store_expr (args[i].tree_value, copy, 0, false); 1098 1099 /* Just change the const function to pure and then let 1100 the next test clear the pure based on 1101 callee_copies. */ 1102 if (*ecf_flags & ECF_CONST) 1103 { 1104 *ecf_flags &= ~ECF_CONST; 1105 *ecf_flags |= ECF_PURE; 1106 } 1107 1108 if (!callee_copies && *ecf_flags & ECF_PURE) 1109 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE); 1110 1111 args[i].tree_value 1112 = build_fold_addr_expr_loc (loc, make_tree (type, copy)); 1113 type = TREE_TYPE (args[i].tree_value); 1114 *may_tailcall = false; 1115 } 1116 } 1117 1118 unsignedp = TYPE_UNSIGNED (type); 1119 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp, 1120 fndecl ? TREE_TYPE (fndecl) : fntype, 0); 1121 1122 args[i].unsignedp = unsignedp; 1123 args[i].mode = mode; 1124 1125 args[i].reg = FUNCTION_ARG (*args_so_far, mode, type, 1126 argpos < n_named_args); 1127 #ifdef FUNCTION_INCOMING_ARG 1128 /* If this is a sibling call and the machine has register windows, the 1129 register window has to be unwinded before calling the routine, so 1130 arguments have to go into the incoming registers. */ 1131 args[i].tail_call_reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type, 1132 argpos < n_named_args); 1133 #else 1134 args[i].tail_call_reg = args[i].reg; 1135 #endif 1136 1137 if (args[i].reg) 1138 args[i].partial 1139 = targetm.calls.arg_partial_bytes (args_so_far, mode, type, 1140 argpos < n_named_args); 1141 1142 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type); 1143 1144 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]), 1145 it means that we are to pass this arg in the register(s) designated 1146 by the PARALLEL, but also to pass it in the stack. */ 1147 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL 1148 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0) 1149 args[i].pass_on_stack = 1; 1150 1151 /* If this is an addressable type, we must preallocate the stack 1152 since we must evaluate the object into its final location. 1153 1154 If this is to be passed in both registers and the stack, it is simpler 1155 to preallocate. */ 1156 if (TREE_ADDRESSABLE (type) 1157 || (args[i].pass_on_stack && args[i].reg != 0)) 1158 *must_preallocate = 1; 1159 1160 /* Compute the stack-size of this argument. */ 1161 if (args[i].reg == 0 || args[i].partial != 0 1162 || reg_parm_stack_space > 0 1163 || args[i].pass_on_stack) 1164 locate_and_pad_parm (mode, type, 1165 #ifdef STACK_PARMS_IN_REG_PARM_AREA 1166 1, 1167 #else 1168 args[i].reg != 0, 1169 #endif 1170 args[i].pass_on_stack ? 0 : args[i].partial, 1171 fndecl, args_size, &args[i].locate); 1172 #ifdef BLOCK_REG_PADDING 1173 else 1174 /* The argument is passed entirely in registers. See at which 1175 end it should be padded. */ 1176 args[i].locate.where_pad = 1177 BLOCK_REG_PADDING (mode, type, 1178 int_size_in_bytes (type) <= UNITS_PER_WORD); 1179 #endif 1180 1181 /* Update ARGS_SIZE, the total stack space for args so far. */ 1182 1183 args_size->constant += args[i].locate.size.constant; 1184 if (args[i].locate.size.var) 1185 ADD_PARM_SIZE (*args_size, args[i].locate.size.var); 1186 1187 /* Increment ARGS_SO_FAR, which has info about which arg-registers 1188 have been used, etc. */ 1189 1190 FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type, 1191 argpos < n_named_args); 1192 } 1193 } 1194 1195 /* Update ARGS_SIZE to contain the total size for the argument block. 1196 Return the original constant component of the argument block's size. 1197 1198 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved 1199 for arguments passed in registers. */ 1200 1201 static int 1202 compute_argument_block_size (int reg_parm_stack_space, 1203 struct args_size *args_size, 1204 tree fndecl ATTRIBUTE_UNUSED, 1205 tree fntype ATTRIBUTE_UNUSED, 1206 int preferred_stack_boundary ATTRIBUTE_UNUSED) 1207 { 1208 int unadjusted_args_size = args_size->constant; 1209 1210 /* For accumulate outgoing args mode we don't need to align, since the frame 1211 will be already aligned. Align to STACK_BOUNDARY in order to prevent 1212 backends from generating misaligned frame sizes. */ 1213 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY) 1214 preferred_stack_boundary = STACK_BOUNDARY; 1215 1216 /* Compute the actual size of the argument block required. The variable 1217 and constant sizes must be combined, the size may have to be rounded, 1218 and there may be a minimum required size. */ 1219 1220 if (args_size->var) 1221 { 1222 args_size->var = ARGS_SIZE_TREE (*args_size); 1223 args_size->constant = 0; 1224 1225 preferred_stack_boundary /= BITS_PER_UNIT; 1226 if (preferred_stack_boundary > 1) 1227 { 1228 /* We don't handle this case yet. To handle it correctly we have 1229 to add the delta, round and subtract the delta. 1230 Currently no machine description requires this support. */ 1231 gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1))); 1232 args_size->var = round_up (args_size->var, preferred_stack_boundary); 1233 } 1234 1235 if (reg_parm_stack_space > 0) 1236 { 1237 args_size->var 1238 = size_binop (MAX_EXPR, args_size->var, 1239 ssize_int (reg_parm_stack_space)); 1240 1241 /* The area corresponding to register parameters is not to count in 1242 the size of the block we need. So make the adjustment. */ 1243 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))) 1244 args_size->var 1245 = size_binop (MINUS_EXPR, args_size->var, 1246 ssize_int (reg_parm_stack_space)); 1247 } 1248 } 1249 else 1250 { 1251 preferred_stack_boundary /= BITS_PER_UNIT; 1252 if (preferred_stack_boundary < 1) 1253 preferred_stack_boundary = 1; 1254 args_size->constant = (((args_size->constant 1255 + stack_pointer_delta 1256 + preferred_stack_boundary - 1) 1257 / preferred_stack_boundary 1258 * preferred_stack_boundary) 1259 - stack_pointer_delta); 1260 1261 args_size->constant = MAX (args_size->constant, 1262 reg_parm_stack_space); 1263 1264 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))) 1265 args_size->constant -= reg_parm_stack_space; 1266 } 1267 return unadjusted_args_size; 1268 } 1269 1270 /* Precompute parameters as needed for a function call. 1271 1272 FLAGS is mask of ECF_* constants. 1273 1274 NUM_ACTUALS is the number of arguments. 1275 1276 ARGS is an array containing information for each argument; this 1277 routine fills in the INITIAL_VALUE and VALUE fields for each 1278 precomputed argument. */ 1279 1280 static void 1281 precompute_arguments (int num_actuals, struct arg_data *args) 1282 { 1283 int i; 1284 1285 /* If this is a libcall, then precompute all arguments so that we do not 1286 get extraneous instructions emitted as part of the libcall sequence. */ 1287 1288 /* If we preallocated the stack space, and some arguments must be passed 1289 on the stack, then we must precompute any parameter which contains a 1290 function call which will store arguments on the stack. 1291 Otherwise, evaluating the parameter may clobber previous parameters 1292 which have already been stored into the stack. (we have code to avoid 1293 such case by saving the outgoing stack arguments, but it results in 1294 worse code) */ 1295 if (!ACCUMULATE_OUTGOING_ARGS) 1296 return; 1297 1298 for (i = 0; i < num_actuals; i++) 1299 { 1300 tree type; 1301 enum machine_mode mode; 1302 1303 if (TREE_CODE (args[i].tree_value) != CALL_EXPR) 1304 continue; 1305 1306 /* If this is an addressable type, we cannot pre-evaluate it. */ 1307 type = TREE_TYPE (args[i].tree_value); 1308 gcc_assert (!TREE_ADDRESSABLE (type)); 1309 1310 args[i].initial_value = args[i].value 1311 = expand_normal (args[i].tree_value); 1312 1313 mode = TYPE_MODE (type); 1314 if (mode != args[i].mode) 1315 { 1316 int unsignedp = args[i].unsignedp; 1317 args[i].value 1318 = convert_modes (args[i].mode, mode, 1319 args[i].value, args[i].unsignedp); 1320 1321 /* CSE will replace this only if it contains args[i].value 1322 pseudo, so convert it down to the declared mode using 1323 a SUBREG. */ 1324 if (REG_P (args[i].value) 1325 && GET_MODE_CLASS (args[i].mode) == MODE_INT 1326 && promote_mode (type, mode, &unsignedp) != args[i].mode) 1327 { 1328 args[i].initial_value 1329 = gen_lowpart_SUBREG (mode, args[i].value); 1330 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1; 1331 SUBREG_PROMOTED_UNSIGNED_SET (args[i].initial_value, 1332 args[i].unsignedp); 1333 } 1334 } 1335 } 1336 } 1337 1338 /* Given the current state of MUST_PREALLOCATE and information about 1339 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE, 1340 compute and return the final value for MUST_PREALLOCATE. */ 1341 1342 static int 1343 finalize_must_preallocate (int must_preallocate, int num_actuals, 1344 struct arg_data *args, struct args_size *args_size) 1345 { 1346 /* See if we have or want to preallocate stack space. 1347 1348 If we would have to push a partially-in-regs parm 1349 before other stack parms, preallocate stack space instead. 1350 1351 If the size of some parm is not a multiple of the required stack 1352 alignment, we must preallocate. 1353 1354 If the total size of arguments that would otherwise create a copy in 1355 a temporary (such as a CALL) is more than half the total argument list 1356 size, preallocation is faster. 1357 1358 Another reason to preallocate is if we have a machine (like the m88k) 1359 where stack alignment is required to be maintained between every 1360 pair of insns, not just when the call is made. However, we assume here 1361 that such machines either do not have push insns (and hence preallocation 1362 would occur anyway) or the problem is taken care of with 1363 PUSH_ROUNDING. */ 1364 1365 if (! must_preallocate) 1366 { 1367 int partial_seen = 0; 1368 int copy_to_evaluate_size = 0; 1369 int i; 1370 1371 for (i = 0; i < num_actuals && ! must_preallocate; i++) 1372 { 1373 if (args[i].partial > 0 && ! args[i].pass_on_stack) 1374 partial_seen = 1; 1375 else if (partial_seen && args[i].reg == 0) 1376 must_preallocate = 1; 1377 1378 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode 1379 && (TREE_CODE (args[i].tree_value) == CALL_EXPR 1380 || TREE_CODE (args[i].tree_value) == TARGET_EXPR 1381 || TREE_CODE (args[i].tree_value) == COND_EXPR 1382 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))) 1383 copy_to_evaluate_size 1384 += int_size_in_bytes (TREE_TYPE (args[i].tree_value)); 1385 } 1386 1387 if (copy_to_evaluate_size * 2 >= args_size->constant 1388 && args_size->constant > 0) 1389 must_preallocate = 1; 1390 } 1391 return must_preallocate; 1392 } 1393 1394 /* If we preallocated stack space, compute the address of each argument 1395 and store it into the ARGS array. 1396 1397 We need not ensure it is a valid memory address here; it will be 1398 validized when it is used. 1399 1400 ARGBLOCK is an rtx for the address of the outgoing arguments. */ 1401 1402 static void 1403 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals) 1404 { 1405 if (argblock) 1406 { 1407 rtx arg_reg = argblock; 1408 int i, arg_offset = 0; 1409 1410 if (GET_CODE (argblock) == PLUS) 1411 arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1)); 1412 1413 for (i = 0; i < num_actuals; i++) 1414 { 1415 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset); 1416 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset); 1417 rtx addr; 1418 unsigned int align, boundary; 1419 unsigned int units_on_stack = 0; 1420 enum machine_mode partial_mode = VOIDmode; 1421 1422 /* Skip this parm if it will not be passed on the stack. */ 1423 if (! args[i].pass_on_stack 1424 && args[i].reg != 0 1425 && args[i].partial == 0) 1426 continue; 1427 1428 if (CONST_INT_P (offset)) 1429 addr = plus_constant (arg_reg, INTVAL (offset)); 1430 else 1431 addr = gen_rtx_PLUS (Pmode, arg_reg, offset); 1432 1433 addr = plus_constant (addr, arg_offset); 1434 1435 if (args[i].partial != 0) 1436 { 1437 /* Only part of the parameter is being passed on the stack. 1438 Generate a simple memory reference of the correct size. */ 1439 units_on_stack = args[i].locate.size.constant; 1440 partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT, 1441 MODE_INT, 1); 1442 args[i].stack = gen_rtx_MEM (partial_mode, addr); 1443 set_mem_size (args[i].stack, GEN_INT (units_on_stack)); 1444 } 1445 else 1446 { 1447 args[i].stack = gen_rtx_MEM (args[i].mode, addr); 1448 set_mem_attributes (args[i].stack, 1449 TREE_TYPE (args[i].tree_value), 1); 1450 } 1451 align = BITS_PER_UNIT; 1452 boundary = args[i].locate.boundary; 1453 if (args[i].locate.where_pad != downward) 1454 align = boundary; 1455 else if (CONST_INT_P (offset)) 1456 { 1457 align = INTVAL (offset) * BITS_PER_UNIT | boundary; 1458 align = align & -align; 1459 } 1460 set_mem_align (args[i].stack, align); 1461 1462 if (CONST_INT_P (slot_offset)) 1463 addr = plus_constant (arg_reg, INTVAL (slot_offset)); 1464 else 1465 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset); 1466 1467 addr = plus_constant (addr, arg_offset); 1468 1469 if (args[i].partial != 0) 1470 { 1471 /* Only part of the parameter is being passed on the stack. 1472 Generate a simple memory reference of the correct size. 1473 */ 1474 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr); 1475 set_mem_size (args[i].stack_slot, GEN_INT (units_on_stack)); 1476 } 1477 else 1478 { 1479 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr); 1480 set_mem_attributes (args[i].stack_slot, 1481 TREE_TYPE (args[i].tree_value), 1); 1482 } 1483 set_mem_align (args[i].stack_slot, args[i].locate.boundary); 1484 1485 /* Function incoming arguments may overlap with sibling call 1486 outgoing arguments and we cannot allow reordering of reads 1487 from function arguments with stores to outgoing arguments 1488 of sibling calls. */ 1489 set_mem_alias_set (args[i].stack, 0); 1490 set_mem_alias_set (args[i].stack_slot, 0); 1491 } 1492 } 1493 } 1494 1495 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address 1496 in a call instruction. 1497 1498 FNDECL is the tree node for the target function. For an indirect call 1499 FNDECL will be NULL_TREE. 1500 1501 ADDR is the operand 0 of CALL_EXPR for this call. */ 1502 1503 static rtx 1504 rtx_for_function_call (tree fndecl, tree addr) 1505 { 1506 rtx funexp; 1507 1508 /* Get the function to call, in the form of RTL. */ 1509 if (fndecl) 1510 { 1511 /* If this is the first use of the function, see if we need to 1512 make an external definition for it. */ 1513 if (!TREE_USED (fndecl) && fndecl != current_function_decl) 1514 { 1515 assemble_external (fndecl); 1516 TREE_USED (fndecl) = 1; 1517 } 1518 1519 /* Get a SYMBOL_REF rtx for the function address. */ 1520 funexp = XEXP (DECL_RTL (fndecl), 0); 1521 } 1522 else 1523 /* Generate an rtx (probably a pseudo-register) for the address. */ 1524 { 1525 push_temp_slots (); 1526 funexp = expand_normal (addr); 1527 pop_temp_slots (); /* FUNEXP can't be BLKmode. */ 1528 } 1529 return funexp; 1530 } 1531 1532 /* Return true if and only if SIZE storage units (usually bytes) 1533 starting from address ADDR overlap with already clobbered argument 1534 area. This function is used to determine if we should give up a 1535 sibcall. */ 1536 1537 static bool 1538 mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size) 1539 { 1540 HOST_WIDE_INT i; 1541 1542 if (addr == crtl->args.internal_arg_pointer) 1543 i = 0; 1544 else if (GET_CODE (addr) == PLUS 1545 && XEXP (addr, 0) == crtl->args.internal_arg_pointer 1546 && CONST_INT_P (XEXP (addr, 1))) 1547 i = INTVAL (XEXP (addr, 1)); 1548 /* Return true for arg pointer based indexed addressing. */ 1549 else if (GET_CODE (addr) == PLUS 1550 && (XEXP (addr, 0) == crtl->args.internal_arg_pointer 1551 || XEXP (addr, 1) == crtl->args.internal_arg_pointer)) 1552 return true; 1553 else 1554 return false; 1555 1556 #ifdef ARGS_GROW_DOWNWARD 1557 i = -i - size; 1558 #endif 1559 if (size > 0) 1560 { 1561 unsigned HOST_WIDE_INT k; 1562 1563 for (k = 0; k < size; k++) 1564 if (i + k < stored_args_map->n_bits 1565 && TEST_BIT (stored_args_map, i + k)) 1566 return true; 1567 } 1568 1569 return false; 1570 } 1571 1572 /* Do the register loads required for any wholly-register parms or any 1573 parms which are passed both on the stack and in a register. Their 1574 expressions were already evaluated. 1575 1576 Mark all register-parms as living through the call, putting these USE 1577 insns in the CALL_INSN_FUNCTION_USAGE field. 1578 1579 When IS_SIBCALL, perform the check_sibcall_argument_overlap 1580 checking, setting *SIBCALL_FAILURE if appropriate. */ 1581 1582 static void 1583 load_register_parameters (struct arg_data *args, int num_actuals, 1584 rtx *call_fusage, int flags, int is_sibcall, 1585 int *sibcall_failure) 1586 { 1587 int i, j; 1588 1589 for (i = 0; i < num_actuals; i++) 1590 { 1591 rtx reg = ((flags & ECF_SIBCALL) 1592 ? args[i].tail_call_reg : args[i].reg); 1593 if (reg) 1594 { 1595 int partial = args[i].partial; 1596 int nregs; 1597 int size = 0; 1598 rtx before_arg = get_last_insn (); 1599 /* Set non-negative if we must move a word at a time, even if 1600 just one word (e.g, partial == 4 && mode == DFmode). Set 1601 to -1 if we just use a normal move insn. This value can be 1602 zero if the argument is a zero size structure. */ 1603 nregs = -1; 1604 if (GET_CODE (reg) == PARALLEL) 1605 ; 1606 else if (partial) 1607 { 1608 gcc_assert (partial % UNITS_PER_WORD == 0); 1609 nregs = partial / UNITS_PER_WORD; 1610 } 1611 else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode) 1612 { 1613 size = int_size_in_bytes (TREE_TYPE (args[i].tree_value)); 1614 nregs = (size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD; 1615 } 1616 else 1617 size = GET_MODE_SIZE (args[i].mode); 1618 1619 /* Handle calls that pass values in multiple non-contiguous 1620 locations. The Irix 6 ABI has examples of this. */ 1621 1622 if (GET_CODE (reg) == PARALLEL) 1623 emit_group_move (reg, args[i].parallel_value); 1624 1625 /* If simple case, just do move. If normal partial, store_one_arg 1626 has already loaded the register for us. In all other cases, 1627 load the register(s) from memory. */ 1628 1629 else if (nregs == -1) 1630 { 1631 emit_move_insn (reg, args[i].value); 1632 #ifdef BLOCK_REG_PADDING 1633 /* Handle case where we have a value that needs shifting 1634 up to the msb. eg. a QImode value and we're padding 1635 upward on a BYTES_BIG_ENDIAN machine. */ 1636 if (size < UNITS_PER_WORD 1637 && (args[i].locate.where_pad 1638 == (BYTES_BIG_ENDIAN ? upward : downward))) 1639 { 1640 rtx x; 1641 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT; 1642 1643 /* Assigning REG here rather than a temp makes CALL_FUSAGE 1644 report the whole reg as used. Strictly speaking, the 1645 call only uses SIZE bytes at the msb end, but it doesn't 1646 seem worth generating rtl to say that. */ 1647 reg = gen_rtx_REG (word_mode, REGNO (reg)); 1648 x = expand_shift (LSHIFT_EXPR, word_mode, reg, 1649 build_int_cst (NULL_TREE, shift), 1650 reg, 1); 1651 if (x != reg) 1652 emit_move_insn (reg, x); 1653 } 1654 #endif 1655 } 1656 1657 /* If we have pre-computed the values to put in the registers in 1658 the case of non-aligned structures, copy them in now. */ 1659 1660 else if (args[i].n_aligned_regs != 0) 1661 for (j = 0; j < args[i].n_aligned_regs; j++) 1662 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j), 1663 args[i].aligned_regs[j]); 1664 1665 else if (partial == 0 || args[i].pass_on_stack) 1666 { 1667 rtx mem = validize_mem (args[i].value); 1668 1669 /* Check for overlap with already clobbered argument area. */ 1670 if (is_sibcall 1671 && mem_overlaps_already_clobbered_arg_p (XEXP (args[i].value, 0), 1672 size)) 1673 *sibcall_failure = 1; 1674 1675 /* Handle a BLKmode that needs shifting. */ 1676 if (nregs == 1 && size < UNITS_PER_WORD 1677 #ifdef BLOCK_REG_PADDING 1678 && args[i].locate.where_pad == downward 1679 #else 1680 && BYTES_BIG_ENDIAN 1681 #endif 1682 ) 1683 { 1684 rtx tem = operand_subword_force (mem, 0, args[i].mode); 1685 rtx ri = gen_rtx_REG (word_mode, REGNO (reg)); 1686 rtx x = gen_reg_rtx (word_mode); 1687 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT; 1688 enum tree_code dir = BYTES_BIG_ENDIAN ? RSHIFT_EXPR 1689 : LSHIFT_EXPR; 1690 1691 emit_move_insn (x, tem); 1692 x = expand_shift (dir, word_mode, x, 1693 build_int_cst (NULL_TREE, shift), 1694 ri, 1); 1695 if (x != ri) 1696 emit_move_insn (ri, x); 1697 } 1698 else 1699 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode); 1700 } 1701 1702 /* When a parameter is a block, and perhaps in other cases, it is 1703 possible that it did a load from an argument slot that was 1704 already clobbered. */ 1705 if (is_sibcall 1706 && check_sibcall_argument_overlap (before_arg, &args[i], 0)) 1707 *sibcall_failure = 1; 1708 1709 /* Handle calls that pass values in multiple non-contiguous 1710 locations. The Irix 6 ABI has examples of this. */ 1711 if (GET_CODE (reg) == PARALLEL) 1712 use_group_regs (call_fusage, reg); 1713 else if (nregs == -1) 1714 use_reg (call_fusage, reg); 1715 else if (nregs > 0) 1716 use_regs (call_fusage, REGNO (reg), nregs); 1717 } 1718 } 1719 } 1720 1721 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments 1722 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY 1723 bytes, then we would need to push some additional bytes to pad the 1724 arguments. So, we compute an adjust to the stack pointer for an 1725 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE 1726 bytes. Then, when the arguments are pushed the stack will be perfectly 1727 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should 1728 be popped after the call. Returns the adjustment. */ 1729 1730 static int 1731 combine_pending_stack_adjustment_and_call (int unadjusted_args_size, 1732 struct args_size *args_size, 1733 unsigned int preferred_unit_stack_boundary) 1734 { 1735 /* The number of bytes to pop so that the stack will be 1736 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */ 1737 HOST_WIDE_INT adjustment; 1738 /* The alignment of the stack after the arguments are pushed, if we 1739 just pushed the arguments without adjust the stack here. */ 1740 unsigned HOST_WIDE_INT unadjusted_alignment; 1741 1742 unadjusted_alignment 1743 = ((stack_pointer_delta + unadjusted_args_size) 1744 % preferred_unit_stack_boundary); 1745 1746 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes 1747 as possible -- leaving just enough left to cancel out the 1748 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the 1749 PENDING_STACK_ADJUST is non-negative, and congruent to 1750 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */ 1751 1752 /* Begin by trying to pop all the bytes. */ 1753 unadjusted_alignment 1754 = (unadjusted_alignment 1755 - (pending_stack_adjust % preferred_unit_stack_boundary)); 1756 adjustment = pending_stack_adjust; 1757 /* Push enough additional bytes that the stack will be aligned 1758 after the arguments are pushed. */ 1759 if (preferred_unit_stack_boundary > 1) 1760 { 1761 if (unadjusted_alignment > 0) 1762 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment; 1763 else 1764 adjustment += unadjusted_alignment; 1765 } 1766 1767 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of 1768 bytes after the call. The right number is the entire 1769 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required 1770 by the arguments in the first place. */ 1771 args_size->constant 1772 = pending_stack_adjust - adjustment + unadjusted_args_size; 1773 1774 return adjustment; 1775 } 1776 1777 /* Scan X expression if it does not dereference any argument slots 1778 we already clobbered by tail call arguments (as noted in stored_args_map 1779 bitmap). 1780 Return nonzero if X expression dereferences such argument slots, 1781 zero otherwise. */ 1782 1783 static int 1784 check_sibcall_argument_overlap_1 (rtx x) 1785 { 1786 RTX_CODE code; 1787 int i, j; 1788 const char *fmt; 1789 1790 if (x == NULL_RTX) 1791 return 0; 1792 1793 code = GET_CODE (x); 1794 1795 if (code == MEM) 1796 return mem_overlaps_already_clobbered_arg_p (XEXP (x, 0), 1797 GET_MODE_SIZE (GET_MODE (x))); 1798 1799 /* Scan all subexpressions. */ 1800 fmt = GET_RTX_FORMAT (code); 1801 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) 1802 { 1803 if (*fmt == 'e') 1804 { 1805 if (check_sibcall_argument_overlap_1 (XEXP (x, i))) 1806 return 1; 1807 } 1808 else if (*fmt == 'E') 1809 { 1810 for (j = 0; j < XVECLEN (x, i); j++) 1811 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j))) 1812 return 1; 1813 } 1814 } 1815 return 0; 1816 } 1817 1818 /* Scan sequence after INSN if it does not dereference any argument slots 1819 we already clobbered by tail call arguments (as noted in stored_args_map 1820 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to 1821 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP 1822 should be 0). Return nonzero if sequence after INSN dereferences such argument 1823 slots, zero otherwise. */ 1824 1825 static int 1826 check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map) 1827 { 1828 int low, high; 1829 1830 if (insn == NULL_RTX) 1831 insn = get_insns (); 1832 else 1833 insn = NEXT_INSN (insn); 1834 1835 for (; insn; insn = NEXT_INSN (insn)) 1836 if (INSN_P (insn) 1837 && check_sibcall_argument_overlap_1 (PATTERN (insn))) 1838 break; 1839 1840 if (mark_stored_args_map) 1841 { 1842 #ifdef ARGS_GROW_DOWNWARD 1843 low = -arg->locate.slot_offset.constant - arg->locate.size.constant; 1844 #else 1845 low = arg->locate.slot_offset.constant; 1846 #endif 1847 1848 for (high = low + arg->locate.size.constant; low < high; low++) 1849 SET_BIT (stored_args_map, low); 1850 } 1851 return insn != NULL_RTX; 1852 } 1853 1854 /* Given that a function returns a value of mode MODE at the most 1855 significant end of hard register VALUE, shift VALUE left or right 1856 as specified by LEFT_P. Return true if some action was needed. */ 1857 1858 bool 1859 shift_return_value (enum machine_mode mode, bool left_p, rtx value) 1860 { 1861 HOST_WIDE_INT shift; 1862 1863 gcc_assert (REG_P (value) && HARD_REGISTER_P (value)); 1864 shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode); 1865 if (shift == 0) 1866 return false; 1867 1868 /* Use ashr rather than lshr for right shifts. This is for the benefit 1869 of the MIPS port, which requires SImode values to be sign-extended 1870 when stored in 64-bit registers. */ 1871 if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab, 1872 value, GEN_INT (shift), value, 1, OPTAB_WIDEN)) 1873 gcc_unreachable (); 1874 return true; 1875 } 1876 1877 /* If X is a likely-spilled register value, copy it to a pseudo 1878 register and return that register. Return X otherwise. */ 1879 1880 static rtx 1881 avoid_likely_spilled_reg (rtx x) 1882 { 1883 rtx new_rtx; 1884 1885 if (REG_P (x) 1886 && HARD_REGISTER_P (x) 1887 && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (x)))) 1888 { 1889 /* Make sure that we generate a REG rather than a CONCAT. 1890 Moves into CONCATs can need nontrivial instructions, 1891 and the whole point of this function is to avoid 1892 using the hard register directly in such a situation. */ 1893 generating_concat_p = 0; 1894 new_rtx = gen_reg_rtx (GET_MODE (x)); 1895 generating_concat_p = 1; 1896 emit_move_insn (new_rtx, x); 1897 return new_rtx; 1898 } 1899 return x; 1900 } 1901 1902 /* Generate all the code for a CALL_EXPR exp 1903 and return an rtx for its value. 1904 Store the value in TARGET (specified as an rtx) if convenient. 1905 If the value is stored in TARGET then TARGET is returned. 1906 If IGNORE is nonzero, then we ignore the value of the function call. */ 1907 1908 rtx 1909 expand_call (tree exp, rtx target, int ignore) 1910 { 1911 /* Nonzero if we are currently expanding a call. */ 1912 static int currently_expanding_call = 0; 1913 1914 /* RTX for the function to be called. */ 1915 rtx funexp; 1916 /* Sequence of insns to perform a normal "call". */ 1917 rtx normal_call_insns = NULL_RTX; 1918 /* Sequence of insns to perform a tail "call". */ 1919 rtx tail_call_insns = NULL_RTX; 1920 /* Data type of the function. */ 1921 tree funtype; 1922 tree type_arg_types; 1923 tree rettype; 1924 /* Declaration of the function being called, 1925 or 0 if the function is computed (not known by name). */ 1926 tree fndecl = 0; 1927 /* The type of the function being called. */ 1928 tree fntype; 1929 bool try_tail_call = CALL_EXPR_TAILCALL (exp); 1930 int pass; 1931 1932 /* Register in which non-BLKmode value will be returned, 1933 or 0 if no value or if value is BLKmode. */ 1934 rtx valreg; 1935 /* Address where we should return a BLKmode value; 1936 0 if value not BLKmode. */ 1937 rtx structure_value_addr = 0; 1938 /* Nonzero if that address is being passed by treating it as 1939 an extra, implicit first parameter. Otherwise, 1940 it is passed by being copied directly into struct_value_rtx. */ 1941 int structure_value_addr_parm = 0; 1942 /* Holds the value of implicit argument for the struct value. */ 1943 tree structure_value_addr_value = NULL_TREE; 1944 /* Size of aggregate value wanted, or zero if none wanted 1945 or if we are using the non-reentrant PCC calling convention 1946 or expecting the value in registers. */ 1947 HOST_WIDE_INT struct_value_size = 0; 1948 /* Nonzero if called function returns an aggregate in memory PCC style, 1949 by returning the address of where to find it. */ 1950 int pcc_struct_value = 0; 1951 rtx struct_value = 0; 1952 1953 /* Number of actual parameters in this call, including struct value addr. */ 1954 int num_actuals; 1955 /* Number of named args. Args after this are anonymous ones 1956 and they must all go on the stack. */ 1957 int n_named_args; 1958 /* Number of complex actual arguments that need to be split. */ 1959 int num_complex_actuals = 0; 1960 1961 /* Vector of information about each argument. 1962 Arguments are numbered in the order they will be pushed, 1963 not the order they are written. */ 1964 struct arg_data *args; 1965 1966 /* Total size in bytes of all the stack-parms scanned so far. */ 1967 struct args_size args_size; 1968 struct args_size adjusted_args_size; 1969 /* Size of arguments before any adjustments (such as rounding). */ 1970 int unadjusted_args_size; 1971 /* Data on reg parms scanned so far. */ 1972 CUMULATIVE_ARGS args_so_far; 1973 /* Nonzero if a reg parm has been scanned. */ 1974 int reg_parm_seen; 1975 /* Nonzero if this is an indirect function call. */ 1976 1977 /* Nonzero if we must avoid push-insns in the args for this call. 1978 If stack space is allocated for register parameters, but not by the 1979 caller, then it is preallocated in the fixed part of the stack frame. 1980 So the entire argument block must then be preallocated (i.e., we 1981 ignore PUSH_ROUNDING in that case). */ 1982 1983 int must_preallocate = !PUSH_ARGS; 1984 1985 /* Size of the stack reserved for parameter registers. */ 1986 int reg_parm_stack_space = 0; 1987 1988 /* Address of space preallocated for stack parms 1989 (on machines that lack push insns), or 0 if space not preallocated. */ 1990 rtx argblock = 0; 1991 1992 /* Mask of ECF_ flags. */ 1993 int flags = 0; 1994 #ifdef REG_PARM_STACK_SPACE 1995 /* Define the boundary of the register parm stack space that needs to be 1996 saved, if any. */ 1997 int low_to_save, high_to_save; 1998 rtx save_area = 0; /* Place that it is saved */ 1999 #endif 2000 2001 int initial_highest_arg_in_use = highest_outgoing_arg_in_use; 2002 char *initial_stack_usage_map = stack_usage_map; 2003 char *stack_usage_map_buf = NULL; 2004 2005 int old_stack_allocated; 2006 2007 /* State variables to track stack modifications. */ 2008 rtx old_stack_level = 0; 2009 int old_stack_arg_under_construction = 0; 2010 int old_pending_adj = 0; 2011 int old_inhibit_defer_pop = inhibit_defer_pop; 2012 2013 /* Some stack pointer alterations we make are performed via 2014 allocate_dynamic_stack_space. This modifies the stack_pointer_delta, 2015 which we then also need to save/restore along the way. */ 2016 int old_stack_pointer_delta = 0; 2017 2018 rtx call_fusage; 2019 tree addr = CALL_EXPR_FN (exp); 2020 int i; 2021 /* The alignment of the stack, in bits. */ 2022 unsigned HOST_WIDE_INT preferred_stack_boundary; 2023 /* The alignment of the stack, in bytes. */ 2024 unsigned HOST_WIDE_INT preferred_unit_stack_boundary; 2025 /* The static chain value to use for this call. */ 2026 rtx static_chain_value; 2027 /* See if this is "nothrow" function call. */ 2028 if (TREE_NOTHROW (exp)) 2029 flags |= ECF_NOTHROW; 2030 2031 /* See if we can find a DECL-node for the actual function, and get the 2032 function attributes (flags) from the function decl or type node. */ 2033 fndecl = get_callee_fndecl (exp); 2034 if (fndecl) 2035 { 2036 fntype = TREE_TYPE (fndecl); 2037 flags |= flags_from_decl_or_type (fndecl); 2038 } 2039 else 2040 { 2041 fntype = TREE_TYPE (TREE_TYPE (addr)); 2042 flags |= flags_from_decl_or_type (fntype); 2043 } 2044 rettype = TREE_TYPE (exp); 2045 2046 struct_value = targetm.calls.struct_value_rtx (fntype, 0); 2047 2048 /* Warn if this value is an aggregate type, 2049 regardless of which calling convention we are using for it. */ 2050 if (AGGREGATE_TYPE_P (rettype)) 2051 warning (OPT_Waggregate_return, "function call has aggregate value"); 2052 2053 /* If the result of a non looping pure or const function call is 2054 ignored (or void), and none of its arguments are volatile, we can 2055 avoid expanding the call and just evaluate the arguments for 2056 side-effects. */ 2057 if ((flags & (ECF_CONST | ECF_PURE)) 2058 && (!(flags & ECF_LOOPING_CONST_OR_PURE)) 2059 && (ignore || target == const0_rtx 2060 || TYPE_MODE (rettype) == VOIDmode)) 2061 { 2062 bool volatilep = false; 2063 tree arg; 2064 call_expr_arg_iterator iter; 2065 2066 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 2067 if (TREE_THIS_VOLATILE (arg)) 2068 { 2069 volatilep = true; 2070 break; 2071 } 2072 2073 if (! volatilep) 2074 { 2075 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 2076 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL); 2077 return const0_rtx; 2078 } 2079 } 2080 2081 #ifdef REG_PARM_STACK_SPACE 2082 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl); 2083 #endif 2084 2085 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))) 2086 && reg_parm_stack_space > 0 && PUSH_ARGS) 2087 must_preallocate = 1; 2088 2089 /* Set up a place to return a structure. */ 2090 2091 /* Cater to broken compilers. */ 2092 if (aggregate_value_p (exp, (!fndecl ? fntype : fndecl))) 2093 { 2094 /* This call returns a big structure. */ 2095 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE); 2096 2097 #ifdef PCC_STATIC_STRUCT_RETURN 2098 { 2099 pcc_struct_value = 1; 2100 } 2101 #else /* not PCC_STATIC_STRUCT_RETURN */ 2102 { 2103 struct_value_size = int_size_in_bytes (rettype); 2104 2105 if (target && MEM_P (target) && CALL_EXPR_RETURN_SLOT_OPT (exp)) 2106 structure_value_addr = XEXP (target, 0); 2107 else 2108 { 2109 /* For variable-sized objects, we must be called with a target 2110 specified. If we were to allocate space on the stack here, 2111 we would have no way of knowing when to free it. */ 2112 rtx d = assign_temp (rettype, 0, 1, 1); 2113 2114 mark_temp_addr_taken (d); 2115 structure_value_addr = XEXP (d, 0); 2116 target = 0; 2117 } 2118 } 2119 #endif /* not PCC_STATIC_STRUCT_RETURN */ 2120 } 2121 2122 /* Figure out the amount to which the stack should be aligned. */ 2123 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 2124 if (fndecl) 2125 { 2126 struct cgraph_rtl_info *i = cgraph_rtl_info (fndecl); 2127 /* Without automatic stack alignment, we can't increase preferred 2128 stack boundary. With automatic stack alignment, it is 2129 unnecessary since unless we can guarantee that all callers will 2130 align the outgoing stack properly, callee has to align its 2131 stack anyway. */ 2132 if (i 2133 && i->preferred_incoming_stack_boundary 2134 && i->preferred_incoming_stack_boundary < preferred_stack_boundary) 2135 preferred_stack_boundary = i->preferred_incoming_stack_boundary; 2136 } 2137 2138 /* Operand 0 is a pointer-to-function; get the type of the function. */ 2139 funtype = TREE_TYPE (addr); 2140 gcc_assert (POINTER_TYPE_P (funtype)); 2141 funtype = TREE_TYPE (funtype); 2142 2143 /* Count whether there are actual complex arguments that need to be split 2144 into their real and imaginary parts. Munge the type_arg_types 2145 appropriately here as well. */ 2146 if (targetm.calls.split_complex_arg) 2147 { 2148 call_expr_arg_iterator iter; 2149 tree arg; 2150 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 2151 { 2152 tree type = TREE_TYPE (arg); 2153 if (type && TREE_CODE (type) == COMPLEX_TYPE 2154 && targetm.calls.split_complex_arg (type)) 2155 num_complex_actuals++; 2156 } 2157 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype)); 2158 } 2159 else 2160 type_arg_types = TYPE_ARG_TYPES (funtype); 2161 2162 if (flags & ECF_MAY_BE_ALLOCA) 2163 cfun->calls_alloca = 1; 2164 2165 /* If struct_value_rtx is 0, it means pass the address 2166 as if it were an extra parameter. Put the argument expression 2167 in structure_value_addr_value. */ 2168 if (structure_value_addr && struct_value == 0) 2169 { 2170 /* If structure_value_addr is a REG other than 2171 virtual_outgoing_args_rtx, we can use always use it. If it 2172 is not a REG, we must always copy it into a register. 2173 If it is virtual_outgoing_args_rtx, we must copy it to another 2174 register in some cases. */ 2175 rtx temp = (!REG_P (structure_value_addr) 2176 || (ACCUMULATE_OUTGOING_ARGS 2177 && stack_arg_under_construction 2178 && structure_value_addr == virtual_outgoing_args_rtx) 2179 ? copy_addr_to_reg (convert_memory_address 2180 (Pmode, structure_value_addr)) 2181 : structure_value_addr); 2182 2183 structure_value_addr_value = 2184 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp); 2185 structure_value_addr_parm = 1; 2186 } 2187 2188 /* Count the arguments and set NUM_ACTUALS. */ 2189 num_actuals = 2190 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm; 2191 2192 /* Compute number of named args. 2193 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */ 2194 2195 if (type_arg_types != 0) 2196 n_named_args 2197 = (list_length (type_arg_types) 2198 /* Count the struct value address, if it is passed as a parm. */ 2199 + structure_value_addr_parm); 2200 else 2201 /* If we know nothing, treat all args as named. */ 2202 n_named_args = num_actuals; 2203 2204 /* Start updating where the next arg would go. 2205 2206 On some machines (such as the PA) indirect calls have a different 2207 calling convention than normal calls. The fourth argument in 2208 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call 2209 or not. */ 2210 INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args); 2211 2212 /* Now possibly adjust the number of named args. 2213 Normally, don't include the last named arg if anonymous args follow. 2214 We do include the last named arg if 2215 targetm.calls.strict_argument_naming() returns nonzero. 2216 (If no anonymous args follow, the result of list_length is actually 2217 one too large. This is harmless.) 2218 2219 If targetm.calls.pretend_outgoing_varargs_named() returns 2220 nonzero, and targetm.calls.strict_argument_naming() returns zero, 2221 this machine will be able to place unnamed args that were passed 2222 in registers into the stack. So treat all args as named. This 2223 allows the insns emitting for a specific argument list to be 2224 independent of the function declaration. 2225 2226 If targetm.calls.pretend_outgoing_varargs_named() returns zero, 2227 we do not have any reliable way to pass unnamed args in 2228 registers, so we must force them into memory. */ 2229 2230 if (type_arg_types != 0 2231 && targetm.calls.strict_argument_naming (&args_so_far)) 2232 ; 2233 else if (type_arg_types != 0 2234 && ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far)) 2235 /* Don't include the last named arg. */ 2236 --n_named_args; 2237 else 2238 /* Treat all args as named. */ 2239 n_named_args = num_actuals; 2240 2241 /* Make a vector to hold all the information about each arg. */ 2242 args = XALLOCAVEC (struct arg_data, num_actuals); 2243 memset (args, 0, num_actuals * sizeof (struct arg_data)); 2244 2245 /* Build up entries in the ARGS array, compute the size of the 2246 arguments into ARGS_SIZE, etc. */ 2247 initialize_argument_information (num_actuals, args, &args_size, 2248 n_named_args, exp, 2249 structure_value_addr_value, fndecl, fntype, 2250 &args_so_far, reg_parm_stack_space, 2251 &old_stack_level, &old_pending_adj, 2252 &must_preallocate, &flags, 2253 &try_tail_call, CALL_FROM_THUNK_P (exp)); 2254 2255 if (args_size.var) 2256 must_preallocate = 1; 2257 2258 /* Now make final decision about preallocating stack space. */ 2259 must_preallocate = finalize_must_preallocate (must_preallocate, 2260 num_actuals, args, 2261 &args_size); 2262 2263 /* If the structure value address will reference the stack pointer, we 2264 must stabilize it. We don't need to do this if we know that we are 2265 not going to adjust the stack pointer in processing this call. */ 2266 2267 if (structure_value_addr 2268 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr) 2269 || reg_mentioned_p (virtual_outgoing_args_rtx, 2270 structure_value_addr)) 2271 && (args_size.var 2272 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant))) 2273 structure_value_addr = copy_to_reg (structure_value_addr); 2274 2275 /* Tail calls can make things harder to debug, and we've traditionally 2276 pushed these optimizations into -O2. Don't try if we're already 2277 expanding a call, as that means we're an argument. Don't try if 2278 there's cleanups, as we know there's code to follow the call. */ 2279 2280 if (currently_expanding_call++ != 0 2281 || !flag_optimize_sibling_calls 2282 || args_size.var 2283 || dbg_cnt (tail_call) == false) 2284 try_tail_call = 0; 2285 2286 /* Rest of purposes for tail call optimizations to fail. */ 2287 if ( 2288 #ifdef HAVE_sibcall_epilogue 2289 !HAVE_sibcall_epilogue 2290 #else 2291 1 2292 #endif 2293 || !try_tail_call 2294 /* Doing sibling call optimization needs some work, since 2295 structure_value_addr can be allocated on the stack. 2296 It does not seem worth the effort since few optimizable 2297 sibling calls will return a structure. */ 2298 || structure_value_addr != NULL_RTX 2299 #ifdef REG_PARM_STACK_SPACE 2300 /* If outgoing reg parm stack space changes, we can not do sibcall. */ 2301 || (OUTGOING_REG_PARM_STACK_SPACE (funtype) 2302 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))) 2303 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (fndecl)) 2304 #endif 2305 /* Check whether the target is able to optimize the call 2306 into a sibcall. */ 2307 || !targetm.function_ok_for_sibcall (fndecl, exp) 2308 /* Functions that do not return exactly once may not be sibcall 2309 optimized. */ 2310 || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN)) 2311 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr))) 2312 /* If the called function is nested in the current one, it might access 2313 some of the caller's arguments, but could clobber them beforehand if 2314 the argument areas are shared. */ 2315 || (fndecl && decl_function_context (fndecl) == current_function_decl) 2316 /* If this function requires more stack slots than the current 2317 function, we cannot change it into a sibling call. 2318 crtl->args.pretend_args_size is not part of the 2319 stack allocated by our caller. */ 2320 || args_size.constant > (crtl->args.size 2321 - crtl->args.pretend_args_size) 2322 /* If the callee pops its own arguments, then it must pop exactly 2323 the same number of arguments as the current function. */ 2324 || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant) 2325 != RETURN_POPS_ARGS (current_function_decl, 2326 TREE_TYPE (current_function_decl), 2327 crtl->args.size)) 2328 || !lang_hooks.decls.ok_for_sibcall (fndecl)) 2329 try_tail_call = 0; 2330 2331 /* Check if caller and callee disagree in promotion of function 2332 return value. */ 2333 if (try_tail_call) 2334 { 2335 enum machine_mode caller_mode, caller_promoted_mode; 2336 enum machine_mode callee_mode, callee_promoted_mode; 2337 int caller_unsignedp, callee_unsignedp; 2338 tree caller_res = DECL_RESULT (current_function_decl); 2339 2340 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res)); 2341 caller_mode = DECL_MODE (caller_res); 2342 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype)); 2343 callee_mode = TYPE_MODE (TREE_TYPE (funtype)); 2344 caller_promoted_mode 2345 = promote_function_mode (TREE_TYPE (caller_res), caller_mode, 2346 &caller_unsignedp, 2347 TREE_TYPE (current_function_decl), 1); 2348 callee_promoted_mode 2349 = promote_function_mode (TREE_TYPE (funtype), callee_mode, 2350 &callee_unsignedp, 2351 funtype, 1); 2352 if (caller_mode != VOIDmode 2353 && (caller_promoted_mode != callee_promoted_mode 2354 || ((caller_mode != caller_promoted_mode 2355 || callee_mode != callee_promoted_mode) 2356 && (caller_unsignedp != callee_unsignedp 2357 || GET_MODE_BITSIZE (caller_mode) 2358 < GET_MODE_BITSIZE (callee_mode))))) 2359 try_tail_call = 0; 2360 } 2361 2362 /* Ensure current function's preferred stack boundary is at least 2363 what we need. Stack alignment may also increase preferred stack 2364 boundary. */ 2365 if (crtl->preferred_stack_boundary < preferred_stack_boundary) 2366 crtl->preferred_stack_boundary = preferred_stack_boundary; 2367 else 2368 preferred_stack_boundary = crtl->preferred_stack_boundary; 2369 2370 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT; 2371 2372 /* We want to make two insn chains; one for a sibling call, the other 2373 for a normal call. We will select one of the two chains after 2374 initial RTL generation is complete. */ 2375 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++) 2376 { 2377 int sibcall_failure = 0; 2378 /* We want to emit any pending stack adjustments before the tail 2379 recursion "call". That way we know any adjustment after the tail 2380 recursion call can be ignored if we indeed use the tail 2381 call expansion. */ 2382 int save_pending_stack_adjust = 0; 2383 int save_stack_pointer_delta = 0; 2384 rtx insns; 2385 rtx before_call, next_arg_reg, after_args; 2386 2387 if (pass == 0) 2388 { 2389 /* State variables we need to save and restore between 2390 iterations. */ 2391 save_pending_stack_adjust = pending_stack_adjust; 2392 save_stack_pointer_delta = stack_pointer_delta; 2393 } 2394 if (pass) 2395 flags &= ~ECF_SIBCALL; 2396 else 2397 flags |= ECF_SIBCALL; 2398 2399 /* Other state variables that we must reinitialize each time 2400 through the loop (that are not initialized by the loop itself). */ 2401 argblock = 0; 2402 call_fusage = 0; 2403 2404 /* Start a new sequence for the normal call case. 2405 2406 From this point on, if the sibling call fails, we want to set 2407 sibcall_failure instead of continuing the loop. */ 2408 start_sequence (); 2409 2410 /* Don't let pending stack adjusts add up to too much. 2411 Also, do all pending adjustments now if there is any chance 2412 this might be a call to alloca or if we are expanding a sibling 2413 call sequence. 2414 Also do the adjustments before a throwing call, otherwise 2415 exception handling can fail; PR 19225. */ 2416 if (pending_stack_adjust >= 32 2417 || (pending_stack_adjust > 0 2418 && (flags & ECF_MAY_BE_ALLOCA)) 2419 || (pending_stack_adjust > 0 2420 && flag_exceptions && !(flags & ECF_NOTHROW)) 2421 || pass == 0) 2422 do_pending_stack_adjust (); 2423 2424 /* Precompute any arguments as needed. */ 2425 if (pass) 2426 precompute_arguments (num_actuals, args); 2427 2428 /* Now we are about to start emitting insns that can be deleted 2429 if a libcall is deleted. */ 2430 if (pass && (flags & ECF_MALLOC)) 2431 start_sequence (); 2432 2433 if (pass == 0 && crtl->stack_protect_guard) 2434 stack_protect_epilogue (); 2435 2436 adjusted_args_size = args_size; 2437 /* Compute the actual size of the argument block required. The variable 2438 and constant sizes must be combined, the size may have to be rounded, 2439 and there may be a minimum required size. When generating a sibcall 2440 pattern, do not round up, since we'll be re-using whatever space our 2441 caller provided. */ 2442 unadjusted_args_size 2443 = compute_argument_block_size (reg_parm_stack_space, 2444 &adjusted_args_size, 2445 fndecl, fntype, 2446 (pass == 0 ? 0 2447 : preferred_stack_boundary)); 2448 2449 old_stack_allocated = stack_pointer_delta - pending_stack_adjust; 2450 2451 /* The argument block when performing a sibling call is the 2452 incoming argument block. */ 2453 if (pass == 0) 2454 { 2455 argblock = crtl->args.internal_arg_pointer; 2456 argblock 2457 #ifdef STACK_GROWS_DOWNWARD 2458 = plus_constant (argblock, crtl->args.pretend_args_size); 2459 #else 2460 = plus_constant (argblock, -crtl->args.pretend_args_size); 2461 #endif 2462 stored_args_map = sbitmap_alloc (args_size.constant); 2463 sbitmap_zero (stored_args_map); 2464 } 2465 2466 /* If we have no actual push instructions, or shouldn't use them, 2467 make space for all args right now. */ 2468 else if (adjusted_args_size.var != 0) 2469 { 2470 if (old_stack_level == 0) 2471 { 2472 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX); 2473 old_stack_pointer_delta = stack_pointer_delta; 2474 old_pending_adj = pending_stack_adjust; 2475 pending_stack_adjust = 0; 2476 /* stack_arg_under_construction says whether a stack arg is 2477 being constructed at the old stack level. Pushing the stack 2478 gets a clean outgoing argument block. */ 2479 old_stack_arg_under_construction = stack_arg_under_construction; 2480 stack_arg_under_construction = 0; 2481 } 2482 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0); 2483 } 2484 else 2485 { 2486 /* Note that we must go through the motions of allocating an argument 2487 block even if the size is zero because we may be storing args 2488 in the area reserved for register arguments, which may be part of 2489 the stack frame. */ 2490 2491 int needed = adjusted_args_size.constant; 2492 2493 /* Store the maximum argument space used. It will be pushed by 2494 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow 2495 checking). */ 2496 2497 if (needed > crtl->outgoing_args_size) 2498 crtl->outgoing_args_size = needed; 2499 2500 if (must_preallocate) 2501 { 2502 if (ACCUMULATE_OUTGOING_ARGS) 2503 { 2504 /* Since the stack pointer will never be pushed, it is 2505 possible for the evaluation of a parm to clobber 2506 something we have already written to the stack. 2507 Since most function calls on RISC machines do not use 2508 the stack, this is uncommon, but must work correctly. 2509 2510 Therefore, we save any area of the stack that was already 2511 written and that we are using. Here we set up to do this 2512 by making a new stack usage map from the old one. The 2513 actual save will be done by store_one_arg. 2514 2515 Another approach might be to try to reorder the argument 2516 evaluations to avoid this conflicting stack usage. */ 2517 2518 /* Since we will be writing into the entire argument area, 2519 the map must be allocated for its entire size, not just 2520 the part that is the responsibility of the caller. */ 2521 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))) 2522 needed += reg_parm_stack_space; 2523 2524 #ifdef ARGS_GROW_DOWNWARD 2525 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, 2526 needed + 1); 2527 #else 2528 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, 2529 needed); 2530 #endif 2531 if (stack_usage_map_buf) 2532 free (stack_usage_map_buf); 2533 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use); 2534 stack_usage_map = stack_usage_map_buf; 2535 2536 if (initial_highest_arg_in_use) 2537 memcpy (stack_usage_map, initial_stack_usage_map, 2538 initial_highest_arg_in_use); 2539 2540 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use) 2541 memset (&stack_usage_map[initial_highest_arg_in_use], 0, 2542 (highest_outgoing_arg_in_use 2543 - initial_highest_arg_in_use)); 2544 needed = 0; 2545 2546 /* The address of the outgoing argument list must not be 2547 copied to a register here, because argblock would be left 2548 pointing to the wrong place after the call to 2549 allocate_dynamic_stack_space below. */ 2550 2551 argblock = virtual_outgoing_args_rtx; 2552 } 2553 else 2554 { 2555 if (inhibit_defer_pop == 0) 2556 { 2557 /* Try to reuse some or all of the pending_stack_adjust 2558 to get this space. */ 2559 needed 2560 = (combine_pending_stack_adjustment_and_call 2561 (unadjusted_args_size, 2562 &adjusted_args_size, 2563 preferred_unit_stack_boundary)); 2564 2565 /* combine_pending_stack_adjustment_and_call computes 2566 an adjustment before the arguments are allocated. 2567 Account for them and see whether or not the stack 2568 needs to go up or down. */ 2569 needed = unadjusted_args_size - needed; 2570 2571 if (needed < 0) 2572 { 2573 /* We're releasing stack space. */ 2574 /* ??? We can avoid any adjustment at all if we're 2575 already aligned. FIXME. */ 2576 pending_stack_adjust = -needed; 2577 do_pending_stack_adjust (); 2578 needed = 0; 2579 } 2580 else 2581 /* We need to allocate space. We'll do that in 2582 push_block below. */ 2583 pending_stack_adjust = 0; 2584 } 2585 2586 /* Special case this because overhead of `push_block' in 2587 this case is non-trivial. */ 2588 if (needed == 0) 2589 argblock = virtual_outgoing_args_rtx; 2590 else 2591 { 2592 argblock = push_block (GEN_INT (needed), 0, 0); 2593 #ifdef ARGS_GROW_DOWNWARD 2594 argblock = plus_constant (argblock, needed); 2595 #endif 2596 } 2597 2598 /* We only really need to call `copy_to_reg' in the case 2599 where push insns are going to be used to pass ARGBLOCK 2600 to a function call in ARGS. In that case, the stack 2601 pointer changes value from the allocation point to the 2602 call point, and hence the value of 2603 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might 2604 as well always do it. */ 2605 argblock = copy_to_reg (argblock); 2606 } 2607 } 2608 } 2609 2610 if (ACCUMULATE_OUTGOING_ARGS) 2611 { 2612 /* The save/restore code in store_one_arg handles all 2613 cases except one: a constructor call (including a C 2614 function returning a BLKmode struct) to initialize 2615 an argument. */ 2616 if (stack_arg_under_construction) 2617 { 2618 rtx push_size 2619 = GEN_INT (adjusted_args_size.constant 2620 + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype 2621 : TREE_TYPE (fndecl))) ? 0 2622 : reg_parm_stack_space)); 2623 if (old_stack_level == 0) 2624 { 2625 emit_stack_save (SAVE_BLOCK, &old_stack_level, 2626 NULL_RTX); 2627 old_stack_pointer_delta = stack_pointer_delta; 2628 old_pending_adj = pending_stack_adjust; 2629 pending_stack_adjust = 0; 2630 /* stack_arg_under_construction says whether a stack 2631 arg is being constructed at the old stack level. 2632 Pushing the stack gets a clean outgoing argument 2633 block. */ 2634 old_stack_arg_under_construction 2635 = stack_arg_under_construction; 2636 stack_arg_under_construction = 0; 2637 /* Make a new map for the new argument list. */ 2638 if (stack_usage_map_buf) 2639 free (stack_usage_map_buf); 2640 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use); 2641 stack_usage_map = stack_usage_map_buf; 2642 highest_outgoing_arg_in_use = 0; 2643 } 2644 allocate_dynamic_stack_space (push_size, NULL_RTX, 2645 BITS_PER_UNIT); 2646 } 2647 2648 /* If argument evaluation might modify the stack pointer, 2649 copy the address of the argument list to a register. */ 2650 for (i = 0; i < num_actuals; i++) 2651 if (args[i].pass_on_stack) 2652 { 2653 argblock = copy_addr_to_reg (argblock); 2654 break; 2655 } 2656 } 2657 2658 compute_argument_addresses (args, argblock, num_actuals); 2659 2660 /* If we push args individually in reverse order, perform stack alignment 2661 before the first push (the last arg). */ 2662 if (PUSH_ARGS_REVERSED && argblock == 0 2663 && adjusted_args_size.constant != unadjusted_args_size) 2664 { 2665 /* When the stack adjustment is pending, we get better code 2666 by combining the adjustments. */ 2667 if (pending_stack_adjust 2668 && ! inhibit_defer_pop) 2669 { 2670 pending_stack_adjust 2671 = (combine_pending_stack_adjustment_and_call 2672 (unadjusted_args_size, 2673 &adjusted_args_size, 2674 preferred_unit_stack_boundary)); 2675 do_pending_stack_adjust (); 2676 } 2677 else if (argblock == 0) 2678 anti_adjust_stack (GEN_INT (adjusted_args_size.constant 2679 - unadjusted_args_size)); 2680 } 2681 /* Now that the stack is properly aligned, pops can't safely 2682 be deferred during the evaluation of the arguments. */ 2683 NO_DEFER_POP; 2684 2685 funexp = rtx_for_function_call (fndecl, addr); 2686 2687 /* Figure out the register where the value, if any, will come back. */ 2688 valreg = 0; 2689 if (TYPE_MODE (rettype) != VOIDmode 2690 && ! structure_value_addr) 2691 { 2692 if (pcc_struct_value) 2693 valreg = hard_function_value (build_pointer_type (rettype), 2694 fndecl, NULL, (pass == 0)); 2695 else 2696 valreg = hard_function_value (rettype, fndecl, fntype, 2697 (pass == 0)); 2698 2699 /* If VALREG is a PARALLEL whose first member has a zero 2700 offset, use that. This is for targets such as m68k that 2701 return the same value in multiple places. */ 2702 if (GET_CODE (valreg) == PARALLEL) 2703 { 2704 rtx elem = XVECEXP (valreg, 0, 0); 2705 rtx where = XEXP (elem, 0); 2706 rtx offset = XEXP (elem, 1); 2707 if (offset == const0_rtx 2708 && GET_MODE (where) == GET_MODE (valreg)) 2709 valreg = where; 2710 } 2711 } 2712 2713 /* Precompute all register parameters. It isn't safe to compute anything 2714 once we have started filling any specific hard regs. */ 2715 precompute_register_parameters (num_actuals, args, ®_parm_seen); 2716 2717 if (CALL_EXPR_STATIC_CHAIN (exp)) 2718 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp)); 2719 else 2720 static_chain_value = 0; 2721 2722 #ifdef REG_PARM_STACK_SPACE 2723 /* Save the fixed argument area if it's part of the caller's frame and 2724 is clobbered by argument setup for this call. */ 2725 if (ACCUMULATE_OUTGOING_ARGS && pass) 2726 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock, 2727 &low_to_save, &high_to_save); 2728 #endif 2729 2730 /* Now store (and compute if necessary) all non-register parms. 2731 These come before register parms, since they can require block-moves, 2732 which could clobber the registers used for register parms. 2733 Parms which have partial registers are not stored here, 2734 but we do preallocate space here if they want that. */ 2735 2736 for (i = 0; i < num_actuals; i++) 2737 { 2738 if (args[i].reg == 0 || args[i].pass_on_stack) 2739 { 2740 rtx before_arg = get_last_insn (); 2741 2742 if (store_one_arg (&args[i], argblock, flags, 2743 adjusted_args_size.var != 0, 2744 reg_parm_stack_space) 2745 || (pass == 0 2746 && check_sibcall_argument_overlap (before_arg, 2747 &args[i], 1))) 2748 sibcall_failure = 1; 2749 } 2750 2751 if (((flags & ECF_CONST) 2752 || ((flags & ECF_PURE) && ACCUMULATE_OUTGOING_ARGS)) 2753 && args[i].stack) 2754 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, 2755 gen_rtx_USE (VOIDmode, 2756 args[i].stack), 2757 call_fusage); 2758 } 2759 2760 /* If we have a parm that is passed in registers but not in memory 2761 and whose alignment does not permit a direct copy into registers, 2762 make a group of pseudos that correspond to each register that we 2763 will later fill. */ 2764 if (STRICT_ALIGNMENT) 2765 store_unaligned_arguments_into_pseudos (args, num_actuals); 2766 2767 /* Now store any partially-in-registers parm. 2768 This is the last place a block-move can happen. */ 2769 if (reg_parm_seen) 2770 for (i = 0; i < num_actuals; i++) 2771 if (args[i].partial != 0 && ! args[i].pass_on_stack) 2772 { 2773 rtx before_arg = get_last_insn (); 2774 2775 if (store_one_arg (&args[i], argblock, flags, 2776 adjusted_args_size.var != 0, 2777 reg_parm_stack_space) 2778 || (pass == 0 2779 && check_sibcall_argument_overlap (before_arg, 2780 &args[i], 1))) 2781 sibcall_failure = 1; 2782 } 2783 2784 /* If we pushed args in forward order, perform stack alignment 2785 after pushing the last arg. */ 2786 if (!PUSH_ARGS_REVERSED && argblock == 0) 2787 anti_adjust_stack (GEN_INT (adjusted_args_size.constant 2788 - unadjusted_args_size)); 2789 2790 /* If register arguments require space on the stack and stack space 2791 was not preallocated, allocate stack space here for arguments 2792 passed in registers. */ 2793 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))) 2794 && !ACCUMULATE_OUTGOING_ARGS 2795 && must_preallocate == 0 && reg_parm_stack_space > 0) 2796 anti_adjust_stack (GEN_INT (reg_parm_stack_space)); 2797 2798 /* Pass the function the address in which to return a 2799 structure value. */ 2800 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm) 2801 { 2802 structure_value_addr 2803 = convert_memory_address (Pmode, structure_value_addr); 2804 emit_move_insn (struct_value, 2805 force_reg (Pmode, 2806 force_operand (structure_value_addr, 2807 NULL_RTX))); 2808 2809 if (REG_P (struct_value)) 2810 use_reg (&call_fusage, struct_value); 2811 } 2812 2813 after_args = get_last_insn (); 2814 funexp = prepare_call_address (fndecl, funexp, static_chain_value, 2815 &call_fusage, reg_parm_seen, pass == 0); 2816 2817 load_register_parameters (args, num_actuals, &call_fusage, flags, 2818 pass == 0, &sibcall_failure); 2819 2820 /* Save a pointer to the last insn before the call, so that we can 2821 later safely search backwards to find the CALL_INSN. */ 2822 before_call = get_last_insn (); 2823 2824 /* Set up next argument register. For sibling calls on machines 2825 with register windows this should be the incoming register. */ 2826 #ifdef FUNCTION_INCOMING_ARG 2827 if (pass == 0) 2828 next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode, 2829 void_type_node, 1); 2830 else 2831 #endif 2832 next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode, 2833 void_type_node, 1); 2834 2835 /* All arguments and registers used for the call must be set up by 2836 now! */ 2837 2838 /* Stack must be properly aligned now. */ 2839 gcc_assert (!pass 2840 || !(stack_pointer_delta % preferred_unit_stack_boundary)); 2841 2842 /* Generate the actual call instruction. */ 2843 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size, 2844 adjusted_args_size.constant, struct_value_size, 2845 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage, 2846 flags, & args_so_far); 2847 2848 /* If the call setup or the call itself overlaps with anything 2849 of the argument setup we probably clobbered our call address. 2850 In that case we can't do sibcalls. */ 2851 if (pass == 0 2852 && check_sibcall_argument_overlap (after_args, 0, 0)) 2853 sibcall_failure = 1; 2854 2855 /* If a non-BLKmode value is returned at the most significant end 2856 of a register, shift the register right by the appropriate amount 2857 and update VALREG accordingly. BLKmode values are handled by the 2858 group load/store machinery below. */ 2859 if (!structure_value_addr 2860 && !pcc_struct_value 2861 && TYPE_MODE (rettype) != BLKmode 2862 && targetm.calls.return_in_msb (rettype)) 2863 { 2864 if (shift_return_value (TYPE_MODE (rettype), false, valreg)) 2865 sibcall_failure = 1; 2866 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg)); 2867 } 2868 2869 if (pass && (flags & ECF_MALLOC)) 2870 { 2871 rtx temp = gen_reg_rtx (GET_MODE (valreg)); 2872 rtx last, insns; 2873 2874 /* The return value from a malloc-like function is a pointer. */ 2875 if (TREE_CODE (rettype) == POINTER_TYPE) 2876 mark_reg_pointer (temp, BIGGEST_ALIGNMENT); 2877 2878 emit_move_insn (temp, valreg); 2879 2880 /* The return value from a malloc-like function can not alias 2881 anything else. */ 2882 last = get_last_insn (); 2883 add_reg_note (last, REG_NOALIAS, temp); 2884 2885 /* Write out the sequence. */ 2886 insns = get_insns (); 2887 end_sequence (); 2888 emit_insn (insns); 2889 valreg = temp; 2890 } 2891 2892 /* For calls to `setjmp', etc., inform 2893 function.c:setjmp_warnings that it should complain if 2894 nonvolatile values are live. For functions that cannot 2895 return, inform flow that control does not fall through. */ 2896 2897 if ((flags & ECF_NORETURN) || pass == 0) 2898 { 2899 /* The barrier must be emitted 2900 immediately after the CALL_INSN. Some ports emit more 2901 than just a CALL_INSN above, so we must search for it here. */ 2902 2903 rtx last = get_last_insn (); 2904 while (!CALL_P (last)) 2905 { 2906 last = PREV_INSN (last); 2907 /* There was no CALL_INSN? */ 2908 gcc_assert (last != before_call); 2909 } 2910 2911 emit_barrier_after (last); 2912 2913 /* Stack adjustments after a noreturn call are dead code. 2914 However when NO_DEFER_POP is in effect, we must preserve 2915 stack_pointer_delta. */ 2916 if (inhibit_defer_pop == 0) 2917 { 2918 stack_pointer_delta = old_stack_allocated; 2919 pending_stack_adjust = 0; 2920 } 2921 } 2922 2923 /* If value type not void, return an rtx for the value. */ 2924 2925 if (TYPE_MODE (rettype) == VOIDmode 2926 || ignore) 2927 target = const0_rtx; 2928 else if (structure_value_addr) 2929 { 2930 if (target == 0 || !MEM_P (target)) 2931 { 2932 target 2933 = gen_rtx_MEM (TYPE_MODE (rettype), 2934 memory_address (TYPE_MODE (rettype), 2935 structure_value_addr)); 2936 set_mem_attributes (target, rettype, 1); 2937 } 2938 } 2939 else if (pcc_struct_value) 2940 { 2941 /* This is the special C++ case where we need to 2942 know what the true target was. We take care to 2943 never use this value more than once in one expression. */ 2944 target = gen_rtx_MEM (TYPE_MODE (rettype), 2945 copy_to_reg (valreg)); 2946 set_mem_attributes (target, rettype, 1); 2947 } 2948 /* Handle calls that return values in multiple non-contiguous locations. 2949 The Irix 6 ABI has examples of this. */ 2950 else if (GET_CODE (valreg) == PARALLEL) 2951 { 2952 if (target == 0) 2953 { 2954 /* This will only be assigned once, so it can be readonly. */ 2955 tree nt = build_qualified_type (rettype, 2956 (TYPE_QUALS (rettype) 2957 | TYPE_QUAL_CONST)); 2958 2959 target = assign_temp (nt, 0, 1, 1); 2960 } 2961 2962 if (! rtx_equal_p (target, valreg)) 2963 emit_group_store (target, valreg, rettype, 2964 int_size_in_bytes (rettype)); 2965 2966 /* We can not support sibling calls for this case. */ 2967 sibcall_failure = 1; 2968 } 2969 else if (target 2970 && GET_MODE (target) == TYPE_MODE (rettype) 2971 && GET_MODE (target) == GET_MODE (valreg)) 2972 { 2973 bool may_overlap = false; 2974 2975 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard 2976 reg to a plain register. */ 2977 if (!REG_P (target) || HARD_REGISTER_P (target)) 2978 valreg = avoid_likely_spilled_reg (valreg); 2979 2980 /* If TARGET is a MEM in the argument area, and we have 2981 saved part of the argument area, then we can't store 2982 directly into TARGET as it may get overwritten when we 2983 restore the argument save area below. Don't work too 2984 hard though and simply force TARGET to a register if it 2985 is a MEM; the optimizer is quite likely to sort it out. */ 2986 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target)) 2987 for (i = 0; i < num_actuals; i++) 2988 if (args[i].save_area) 2989 { 2990 may_overlap = true; 2991 break; 2992 } 2993 2994 if (may_overlap) 2995 target = copy_to_reg (valreg); 2996 else 2997 { 2998 /* TARGET and VALREG cannot be equal at this point 2999 because the latter would not have 3000 REG_FUNCTION_VALUE_P true, while the former would if 3001 it were referring to the same register. 3002 3003 If they refer to the same register, this move will be 3004 a no-op, except when function inlining is being 3005 done. */ 3006 emit_move_insn (target, valreg); 3007 3008 /* If we are setting a MEM, this code must be executed. 3009 Since it is emitted after the call insn, sibcall 3010 optimization cannot be performed in that case. */ 3011 if (MEM_P (target)) 3012 sibcall_failure = 1; 3013 } 3014 } 3015 else if (TYPE_MODE (rettype) == BLKmode) 3016 { 3017 rtx val = valreg; 3018 if (GET_MODE (val) != BLKmode) 3019 val = avoid_likely_spilled_reg (val); 3020 target = copy_blkmode_from_reg (target, val, rettype); 3021 3022 /* We can not support sibling calls for this case. */ 3023 sibcall_failure = 1; 3024 } 3025 else 3026 target = copy_to_reg (avoid_likely_spilled_reg (valreg)); 3027 3028 /* If we promoted this return value, make the proper SUBREG. 3029 TARGET might be const0_rtx here, so be careful. */ 3030 if (REG_P (target) 3031 && TYPE_MODE (rettype) != BLKmode 3032 && GET_MODE (target) != TYPE_MODE (rettype)) 3033 { 3034 tree type = rettype; 3035 int unsignedp = TYPE_UNSIGNED (type); 3036 int offset = 0; 3037 enum machine_mode pmode; 3038 3039 /* Ensure we promote as expected, and get the new unsignedness. */ 3040 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp, 3041 funtype, 1); 3042 gcc_assert (GET_MODE (target) == pmode); 3043 3044 if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN) 3045 && (GET_MODE_SIZE (GET_MODE (target)) 3046 > GET_MODE_SIZE (TYPE_MODE (type)))) 3047 { 3048 offset = GET_MODE_SIZE (GET_MODE (target)) 3049 - GET_MODE_SIZE (TYPE_MODE (type)); 3050 if (! BYTES_BIG_ENDIAN) 3051 offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD; 3052 else if (! WORDS_BIG_ENDIAN) 3053 offset %= UNITS_PER_WORD; 3054 } 3055 3056 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset); 3057 SUBREG_PROMOTED_VAR_P (target) = 1; 3058 SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp); 3059 } 3060 3061 /* If size of args is variable or this was a constructor call for a stack 3062 argument, restore saved stack-pointer value. */ 3063 3064 if (old_stack_level) 3065 { 3066 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX); 3067 stack_pointer_delta = old_stack_pointer_delta; 3068 pending_stack_adjust = old_pending_adj; 3069 old_stack_allocated = stack_pointer_delta - pending_stack_adjust; 3070 stack_arg_under_construction = old_stack_arg_under_construction; 3071 highest_outgoing_arg_in_use = initial_highest_arg_in_use; 3072 stack_usage_map = initial_stack_usage_map; 3073 sibcall_failure = 1; 3074 } 3075 else if (ACCUMULATE_OUTGOING_ARGS && pass) 3076 { 3077 #ifdef REG_PARM_STACK_SPACE 3078 if (save_area) 3079 restore_fixed_argument_area (save_area, argblock, 3080 high_to_save, low_to_save); 3081 #endif 3082 3083 /* If we saved any argument areas, restore them. */ 3084 for (i = 0; i < num_actuals; i++) 3085 if (args[i].save_area) 3086 { 3087 enum machine_mode save_mode = GET_MODE (args[i].save_area); 3088 rtx stack_area 3089 = gen_rtx_MEM (save_mode, 3090 memory_address (save_mode, 3091 XEXP (args[i].stack_slot, 0))); 3092 3093 if (save_mode != BLKmode) 3094 emit_move_insn (stack_area, args[i].save_area); 3095 else 3096 emit_block_move (stack_area, args[i].save_area, 3097 GEN_INT (args[i].locate.size.constant), 3098 BLOCK_OP_CALL_PARM); 3099 } 3100 3101 highest_outgoing_arg_in_use = initial_highest_arg_in_use; 3102 stack_usage_map = initial_stack_usage_map; 3103 } 3104 3105 /* If this was alloca, record the new stack level for nonlocal gotos. 3106 Check for the handler slots since we might not have a save area 3107 for non-local gotos. */ 3108 3109 if ((flags & ECF_MAY_BE_ALLOCA) && cfun->nonlocal_goto_save_area != 0) 3110 update_nonlocal_goto_save_area (); 3111 3112 /* Free up storage we no longer need. */ 3113 for (i = 0; i < num_actuals; ++i) 3114 if (args[i].aligned_regs) 3115 free (args[i].aligned_regs); 3116 3117 insns = get_insns (); 3118 end_sequence (); 3119 3120 if (pass == 0) 3121 { 3122 tail_call_insns = insns; 3123 3124 /* Restore the pending stack adjustment now that we have 3125 finished generating the sibling call sequence. */ 3126 3127 pending_stack_adjust = save_pending_stack_adjust; 3128 stack_pointer_delta = save_stack_pointer_delta; 3129 3130 /* Prepare arg structure for next iteration. */ 3131 for (i = 0; i < num_actuals; i++) 3132 { 3133 args[i].value = 0; 3134 args[i].aligned_regs = 0; 3135 args[i].stack = 0; 3136 } 3137 3138 sbitmap_free (stored_args_map); 3139 } 3140 else 3141 { 3142 normal_call_insns = insns; 3143 3144 /* Verify that we've deallocated all the stack we used. */ 3145 gcc_assert ((flags & ECF_NORETURN) 3146 || (old_stack_allocated 3147 == stack_pointer_delta - pending_stack_adjust)); 3148 } 3149 3150 /* If something prevents making this a sibling call, 3151 zero out the sequence. */ 3152 if (sibcall_failure) 3153 tail_call_insns = NULL_RTX; 3154 else 3155 break; 3156 } 3157 3158 /* If tail call production succeeded, we need to remove REG_EQUIV notes on 3159 arguments too, as argument area is now clobbered by the call. */ 3160 if (tail_call_insns) 3161 { 3162 emit_insn (tail_call_insns); 3163 crtl->tail_call_emit = true; 3164 } 3165 else 3166 emit_insn (normal_call_insns); 3167 3168 currently_expanding_call--; 3169 3170 if (stack_usage_map_buf) 3171 free (stack_usage_map_buf); 3172 3173 return target; 3174 } 3175 3176 /* A sibling call sequence invalidates any REG_EQUIV notes made for 3177 this function's incoming arguments. 3178 3179 At the start of RTL generation we know the only REG_EQUIV notes 3180 in the rtl chain are those for incoming arguments, so we can look 3181 for REG_EQUIV notes between the start of the function and the 3182 NOTE_INSN_FUNCTION_BEG. 3183 3184 This is (slight) overkill. We could keep track of the highest 3185 argument we clobber and be more selective in removing notes, but it 3186 does not seem to be worth the effort. */ 3187 3188 void 3189 fixup_tail_calls (void) 3190 { 3191 rtx insn; 3192 3193 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 3194 { 3195 rtx note; 3196 3197 /* There are never REG_EQUIV notes for the incoming arguments 3198 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */ 3199 if (NOTE_P (insn) 3200 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG) 3201 break; 3202 3203 note = find_reg_note (insn, REG_EQUIV, 0); 3204 if (note) 3205 remove_note (insn, note); 3206 note = find_reg_note (insn, REG_EQUIV, 0); 3207 gcc_assert (!note); 3208 } 3209 } 3210 3211 /* Traverse a list of TYPES and expand all complex types into their 3212 components. */ 3213 static tree 3214 split_complex_types (tree types) 3215 { 3216 tree p; 3217 3218 /* Before allocating memory, check for the common case of no complex. */ 3219 for (p = types; p; p = TREE_CHAIN (p)) 3220 { 3221 tree type = TREE_VALUE (p); 3222 if (TREE_CODE (type) == COMPLEX_TYPE 3223 && targetm.calls.split_complex_arg (type)) 3224 goto found; 3225 } 3226 return types; 3227 3228 found: 3229 types = copy_list (types); 3230 3231 for (p = types; p; p = TREE_CHAIN (p)) 3232 { 3233 tree complex_type = TREE_VALUE (p); 3234 3235 if (TREE_CODE (complex_type) == COMPLEX_TYPE 3236 && targetm.calls.split_complex_arg (complex_type)) 3237 { 3238 tree next, imag; 3239 3240 /* Rewrite complex type with component type. */ 3241 TREE_VALUE (p) = TREE_TYPE (complex_type); 3242 next = TREE_CHAIN (p); 3243 3244 /* Add another component type for the imaginary part. */ 3245 imag = build_tree_list (NULL_TREE, TREE_VALUE (p)); 3246 TREE_CHAIN (p) = imag; 3247 TREE_CHAIN (imag) = next; 3248 3249 /* Skip the newly created node. */ 3250 p = TREE_CHAIN (p); 3251 } 3252 } 3253 3254 return types; 3255 } 3256 3257 /* Output a library call to function FUN (a SYMBOL_REF rtx). 3258 The RETVAL parameter specifies whether return value needs to be saved, other 3259 parameters are documented in the emit_library_call function below. */ 3260 3261 static rtx 3262 emit_library_call_value_1 (int retval, rtx orgfun, rtx value, 3263 enum libcall_type fn_type, 3264 enum machine_mode outmode, int nargs, va_list p) 3265 { 3266 /* Total size in bytes of all the stack-parms scanned so far. */ 3267 struct args_size args_size; 3268 /* Size of arguments before any adjustments (such as rounding). */ 3269 struct args_size original_args_size; 3270 int argnum; 3271 rtx fun; 3272 /* Todo, choose the correct decl type of orgfun. Sadly this information 3273 isn't present here, so we default to native calling abi here. */ 3274 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */ 3275 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */ 3276 int inc; 3277 int count; 3278 rtx argblock = 0; 3279 CUMULATIVE_ARGS args_so_far; 3280 struct arg 3281 { 3282 rtx value; 3283 enum machine_mode mode; 3284 rtx reg; 3285 int partial; 3286 struct locate_and_pad_arg_data locate; 3287 rtx save_area; 3288 }; 3289 struct arg *argvec; 3290 int old_inhibit_defer_pop = inhibit_defer_pop; 3291 rtx call_fusage = 0; 3292 rtx mem_value = 0; 3293 rtx valreg; 3294 int pcc_struct_value = 0; 3295 int struct_value_size = 0; 3296 int flags; 3297 int reg_parm_stack_space = 0; 3298 int needed; 3299 rtx before_call; 3300 tree tfom; /* type_for_mode (outmode, 0) */ 3301 3302 #ifdef REG_PARM_STACK_SPACE 3303 /* Define the boundary of the register parm stack space that needs to be 3304 save, if any. */ 3305 int low_to_save = 0, high_to_save = 0; 3306 rtx save_area = 0; /* Place that it is saved. */ 3307 #endif 3308 3309 /* Size of the stack reserved for parameter registers. */ 3310 int initial_highest_arg_in_use = highest_outgoing_arg_in_use; 3311 char *initial_stack_usage_map = stack_usage_map; 3312 char *stack_usage_map_buf = NULL; 3313 3314 rtx struct_value = targetm.calls.struct_value_rtx (0, 0); 3315 3316 #ifdef REG_PARM_STACK_SPACE 3317 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0); 3318 #endif 3319 3320 /* By default, library functions can not throw. */ 3321 flags = ECF_NOTHROW; 3322 3323 switch (fn_type) 3324 { 3325 case LCT_NORMAL: 3326 break; 3327 case LCT_CONST: 3328 flags |= ECF_CONST; 3329 break; 3330 case LCT_PURE: 3331 flags |= ECF_PURE; 3332 break; 3333 case LCT_NORETURN: 3334 flags |= ECF_NORETURN; 3335 break; 3336 case LCT_THROW: 3337 flags = ECF_NORETURN; 3338 break; 3339 case LCT_RETURNS_TWICE: 3340 flags = ECF_RETURNS_TWICE; 3341 break; 3342 } 3343 fun = orgfun; 3344 3345 /* Ensure current function's preferred stack boundary is at least 3346 what we need. */ 3347 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY) 3348 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; 3349 3350 /* If this kind of value comes back in memory, 3351 decide where in memory it should come back. */ 3352 if (outmode != VOIDmode) 3353 { 3354 tfom = lang_hooks.types.type_for_mode (outmode, 0); 3355 if (aggregate_value_p (tfom, 0)) 3356 { 3357 #ifdef PCC_STATIC_STRUCT_RETURN 3358 rtx pointer_reg 3359 = hard_function_value (build_pointer_type (tfom), 0, 0, 0); 3360 mem_value = gen_rtx_MEM (outmode, pointer_reg); 3361 pcc_struct_value = 1; 3362 if (value == 0) 3363 value = gen_reg_rtx (outmode); 3364 #else /* not PCC_STATIC_STRUCT_RETURN */ 3365 struct_value_size = GET_MODE_SIZE (outmode); 3366 if (value != 0 && MEM_P (value)) 3367 mem_value = value; 3368 else 3369 mem_value = assign_temp (tfom, 0, 1, 1); 3370 #endif 3371 /* This call returns a big structure. */ 3372 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE); 3373 } 3374 } 3375 else 3376 tfom = void_type_node; 3377 3378 /* ??? Unfinished: must pass the memory address as an argument. */ 3379 3380 /* Copy all the libcall-arguments out of the varargs data 3381 and into a vector ARGVEC. 3382 3383 Compute how to pass each argument. We only support a very small subset 3384 of the full argument passing conventions to limit complexity here since 3385 library functions shouldn't have many args. */ 3386 3387 argvec = XALLOCAVEC (struct arg, nargs + 1); 3388 memset (argvec, 0, (nargs + 1) * sizeof (struct arg)); 3389 3390 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS 3391 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun); 3392 #else 3393 INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0, nargs); 3394 #endif 3395 3396 args_size.constant = 0; 3397 args_size.var = 0; 3398 3399 count = 0; 3400 3401 push_temp_slots (); 3402 3403 /* If there's a structure value address to be passed, 3404 either pass it in the special place, or pass it as an extra argument. */ 3405 if (mem_value && struct_value == 0 && ! pcc_struct_value) 3406 { 3407 rtx addr = XEXP (mem_value, 0); 3408 3409 nargs++; 3410 3411 /* Make sure it is a reasonable operand for a move or push insn. */ 3412 if (!REG_P (addr) && !MEM_P (addr) 3413 && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr))) 3414 addr = force_operand (addr, NULL_RTX); 3415 3416 argvec[count].value = addr; 3417 argvec[count].mode = Pmode; 3418 argvec[count].partial = 0; 3419 3420 argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1); 3421 gcc_assert (targetm.calls.arg_partial_bytes (&args_so_far, Pmode, 3422 NULL_TREE, 1) == 0); 3423 3424 locate_and_pad_parm (Pmode, NULL_TREE, 3425 #ifdef STACK_PARMS_IN_REG_PARM_AREA 3426 1, 3427 #else 3428 argvec[count].reg != 0, 3429 #endif 3430 0, NULL_TREE, &args_size, &argvec[count].locate); 3431 3432 if (argvec[count].reg == 0 || argvec[count].partial != 0 3433 || reg_parm_stack_space > 0) 3434 args_size.constant += argvec[count].locate.size.constant; 3435 3436 FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1); 3437 3438 count++; 3439 } 3440 3441 for (; count < nargs; count++) 3442 { 3443 rtx val = va_arg (p, rtx); 3444 enum machine_mode mode = (enum machine_mode) va_arg (p, int); 3445 3446 /* We cannot convert the arg value to the mode the library wants here; 3447 must do it earlier where we know the signedness of the arg. */ 3448 gcc_assert (mode != BLKmode 3449 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode)); 3450 3451 /* Make sure it is a reasonable operand for a move or push insn. */ 3452 if (!REG_P (val) && !MEM_P (val) 3453 && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val))) 3454 val = force_operand (val, NULL_RTX); 3455 3456 if (pass_by_reference (&args_so_far, mode, NULL_TREE, 1)) 3457 { 3458 rtx slot; 3459 int must_copy 3460 = !reference_callee_copied (&args_so_far, mode, NULL_TREE, 1); 3461 3462 /* If this was a CONST function, it is now PURE since it now 3463 reads memory. */ 3464 if (flags & ECF_CONST) 3465 { 3466 flags &= ~ECF_CONST; 3467 flags |= ECF_PURE; 3468 } 3469 3470 if (MEM_P (val) && !must_copy) 3471 slot = val; 3472 else 3473 { 3474 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0), 3475 0, 1, 1); 3476 emit_move_insn (slot, val); 3477 } 3478 3479 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, 3480 gen_rtx_USE (VOIDmode, slot), 3481 call_fusage); 3482 if (must_copy) 3483 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, 3484 gen_rtx_CLOBBER (VOIDmode, 3485 slot), 3486 call_fusage); 3487 3488 mode = Pmode; 3489 val = force_operand (XEXP (slot, 0), NULL_RTX); 3490 } 3491 3492 argvec[count].value = val; 3493 argvec[count].mode = mode; 3494 3495 argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1); 3496 3497 argvec[count].partial 3498 = targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL_TREE, 1); 3499 3500 locate_and_pad_parm (mode, NULL_TREE, 3501 #ifdef STACK_PARMS_IN_REG_PARM_AREA 3502 1, 3503 #else 3504 argvec[count].reg != 0, 3505 #endif 3506 argvec[count].partial, 3507 NULL_TREE, &args_size, &argvec[count].locate); 3508 3509 gcc_assert (!argvec[count].locate.size.var); 3510 3511 if (argvec[count].reg == 0 || argvec[count].partial != 0 3512 || reg_parm_stack_space > 0) 3513 args_size.constant += argvec[count].locate.size.constant; 3514 3515 FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1); 3516 } 3517 3518 /* If this machine requires an external definition for library 3519 functions, write one out. */ 3520 assemble_external_libcall (fun); 3521 3522 original_args_size = args_size; 3523 args_size.constant = (((args_size.constant 3524 + stack_pointer_delta 3525 + STACK_BYTES - 1) 3526 / STACK_BYTES 3527 * STACK_BYTES) 3528 - stack_pointer_delta); 3529 3530 args_size.constant = MAX (args_size.constant, 3531 reg_parm_stack_space); 3532 3533 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))) 3534 args_size.constant -= reg_parm_stack_space; 3535 3536 if (args_size.constant > crtl->outgoing_args_size) 3537 crtl->outgoing_args_size = args_size.constant; 3538 3539 if (ACCUMULATE_OUTGOING_ARGS) 3540 { 3541 /* Since the stack pointer will never be pushed, it is possible for 3542 the evaluation of a parm to clobber something we have already 3543 written to the stack. Since most function calls on RISC machines 3544 do not use the stack, this is uncommon, but must work correctly. 3545 3546 Therefore, we save any area of the stack that was already written 3547 and that we are using. Here we set up to do this by making a new 3548 stack usage map from the old one. 3549 3550 Another approach might be to try to reorder the argument 3551 evaluations to avoid this conflicting stack usage. */ 3552 3553 needed = args_size.constant; 3554 3555 /* Since we will be writing into the entire argument area, the 3556 map must be allocated for its entire size, not just the part that 3557 is the responsibility of the caller. */ 3558 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))) 3559 needed += reg_parm_stack_space; 3560 3561 #ifdef ARGS_GROW_DOWNWARD 3562 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, 3563 needed + 1); 3564 #else 3565 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, 3566 needed); 3567 #endif 3568 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use); 3569 stack_usage_map = stack_usage_map_buf; 3570 3571 if (initial_highest_arg_in_use) 3572 memcpy (stack_usage_map, initial_stack_usage_map, 3573 initial_highest_arg_in_use); 3574 3575 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use) 3576 memset (&stack_usage_map[initial_highest_arg_in_use], 0, 3577 highest_outgoing_arg_in_use - initial_highest_arg_in_use); 3578 needed = 0; 3579 3580 /* We must be careful to use virtual regs before they're instantiated, 3581 and real regs afterwards. Loop optimization, for example, can create 3582 new libcalls after we've instantiated the virtual regs, and if we 3583 use virtuals anyway, they won't match the rtl patterns. */ 3584 3585 if (virtuals_instantiated) 3586 argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET); 3587 else 3588 argblock = virtual_outgoing_args_rtx; 3589 } 3590 else 3591 { 3592 if (!PUSH_ARGS) 3593 argblock = push_block (GEN_INT (args_size.constant), 0, 0); 3594 } 3595 3596 /* If we push args individually in reverse order, perform stack alignment 3597 before the first push (the last arg). */ 3598 if (argblock == 0 && PUSH_ARGS_REVERSED) 3599 anti_adjust_stack (GEN_INT (args_size.constant 3600 - original_args_size.constant)); 3601 3602 if (PUSH_ARGS_REVERSED) 3603 { 3604 inc = -1; 3605 argnum = nargs - 1; 3606 } 3607 else 3608 { 3609 inc = 1; 3610 argnum = 0; 3611 } 3612 3613 #ifdef REG_PARM_STACK_SPACE 3614 if (ACCUMULATE_OUTGOING_ARGS) 3615 { 3616 /* The argument list is the property of the called routine and it 3617 may clobber it. If the fixed area has been used for previous 3618 parameters, we must save and restore it. */ 3619 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock, 3620 &low_to_save, &high_to_save); 3621 } 3622 #endif 3623 3624 /* Push the args that need to be pushed. */ 3625 3626 /* ARGNUM indexes the ARGVEC array in the order in which the arguments 3627 are to be pushed. */ 3628 for (count = 0; count < nargs; count++, argnum += inc) 3629 { 3630 enum machine_mode mode = argvec[argnum].mode; 3631 rtx val = argvec[argnum].value; 3632 rtx reg = argvec[argnum].reg; 3633 int partial = argvec[argnum].partial; 3634 unsigned int parm_align = argvec[argnum].locate.boundary; 3635 int lower_bound = 0, upper_bound = 0, i; 3636 3637 if (! (reg != 0 && partial == 0)) 3638 { 3639 if (ACCUMULATE_OUTGOING_ARGS) 3640 { 3641 /* If this is being stored into a pre-allocated, fixed-size, 3642 stack area, save any previous data at that location. */ 3643 3644 #ifdef ARGS_GROW_DOWNWARD 3645 /* stack_slot is negative, but we want to index stack_usage_map 3646 with positive values. */ 3647 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1; 3648 lower_bound = upper_bound - argvec[argnum].locate.size.constant; 3649 #else 3650 lower_bound = argvec[argnum].locate.slot_offset.constant; 3651 upper_bound = lower_bound + argvec[argnum].locate.size.constant; 3652 #endif 3653 3654 i = lower_bound; 3655 /* Don't worry about things in the fixed argument area; 3656 it has already been saved. */ 3657 if (i < reg_parm_stack_space) 3658 i = reg_parm_stack_space; 3659 while (i < upper_bound && stack_usage_map[i] == 0) 3660 i++; 3661 3662 if (i < upper_bound) 3663 { 3664 /* We need to make a save area. */ 3665 unsigned int size 3666 = argvec[argnum].locate.size.constant * BITS_PER_UNIT; 3667 enum machine_mode save_mode 3668 = mode_for_size (size, MODE_INT, 1); 3669 rtx adr 3670 = plus_constant (argblock, 3671 argvec[argnum].locate.offset.constant); 3672 rtx stack_area 3673 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr)); 3674 3675 if (save_mode == BLKmode) 3676 { 3677 argvec[argnum].save_area 3678 = assign_stack_temp (BLKmode, 3679 argvec[argnum].locate.size.constant, 3680 0); 3681 3682 emit_block_move (validize_mem (argvec[argnum].save_area), 3683 stack_area, 3684 GEN_INT (argvec[argnum].locate.size.constant), 3685 BLOCK_OP_CALL_PARM); 3686 } 3687 else 3688 { 3689 argvec[argnum].save_area = gen_reg_rtx (save_mode); 3690 3691 emit_move_insn (argvec[argnum].save_area, stack_area); 3692 } 3693 } 3694 } 3695 3696 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align, 3697 partial, reg, 0, argblock, 3698 GEN_INT (argvec[argnum].locate.offset.constant), 3699 reg_parm_stack_space, 3700 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad)); 3701 3702 /* Now mark the segment we just used. */ 3703 if (ACCUMULATE_OUTGOING_ARGS) 3704 for (i = lower_bound; i < upper_bound; i++) 3705 stack_usage_map[i] = 1; 3706 3707 NO_DEFER_POP; 3708 3709 if ((flags & ECF_CONST) 3710 || ((flags & ECF_PURE) && ACCUMULATE_OUTGOING_ARGS)) 3711 { 3712 rtx use; 3713 3714 /* Indicate argument access so that alias.c knows that these 3715 values are live. */ 3716 if (argblock) 3717 use = plus_constant (argblock, 3718 argvec[argnum].locate.offset.constant); 3719 else 3720 /* When arguments are pushed, trying to tell alias.c where 3721 exactly this argument is won't work, because the 3722 auto-increment causes confusion. So we merely indicate 3723 that we access something with a known mode somewhere on 3724 the stack. */ 3725 use = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx, 3726 gen_rtx_SCRATCH (Pmode)); 3727 use = gen_rtx_MEM (argvec[argnum].mode, use); 3728 use = gen_rtx_USE (VOIDmode, use); 3729 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage); 3730 } 3731 } 3732 } 3733 3734 /* If we pushed args in forward order, perform stack alignment 3735 after pushing the last arg. */ 3736 if (argblock == 0 && !PUSH_ARGS_REVERSED) 3737 anti_adjust_stack (GEN_INT (args_size.constant 3738 - original_args_size.constant)); 3739 3740 if (PUSH_ARGS_REVERSED) 3741 argnum = nargs - 1; 3742 else 3743 argnum = 0; 3744 3745 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0); 3746 3747 /* Now load any reg parms into their regs. */ 3748 3749 /* ARGNUM indexes the ARGVEC array in the order in which the arguments 3750 are to be pushed. */ 3751 for (count = 0; count < nargs; count++, argnum += inc) 3752 { 3753 enum machine_mode mode = argvec[argnum].mode; 3754 rtx val = argvec[argnum].value; 3755 rtx reg = argvec[argnum].reg; 3756 int partial = argvec[argnum].partial; 3757 3758 /* Handle calls that pass values in multiple non-contiguous 3759 locations. The PA64 has examples of this for library calls. */ 3760 if (reg != 0 && GET_CODE (reg) == PARALLEL) 3761 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode)); 3762 else if (reg != 0 && partial == 0) 3763 emit_move_insn (reg, val); 3764 3765 NO_DEFER_POP; 3766 } 3767 3768 /* Any regs containing parms remain in use through the call. */ 3769 for (count = 0; count < nargs; count++) 3770 { 3771 rtx reg = argvec[count].reg; 3772 if (reg != 0 && GET_CODE (reg) == PARALLEL) 3773 use_group_regs (&call_fusage, reg); 3774 else if (reg != 0) 3775 { 3776 int partial = argvec[count].partial; 3777 if (partial) 3778 { 3779 int nregs; 3780 gcc_assert (partial % UNITS_PER_WORD == 0); 3781 nregs = partial / UNITS_PER_WORD; 3782 use_regs (&call_fusage, REGNO (reg), nregs); 3783 } 3784 else 3785 use_reg (&call_fusage, reg); 3786 } 3787 } 3788 3789 /* Pass the function the address in which to return a structure value. */ 3790 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value) 3791 { 3792 emit_move_insn (struct_value, 3793 force_reg (Pmode, 3794 force_operand (XEXP (mem_value, 0), 3795 NULL_RTX))); 3796 if (REG_P (struct_value)) 3797 use_reg (&call_fusage, struct_value); 3798 } 3799 3800 /* Don't allow popping to be deferred, since then 3801 cse'ing of library calls could delete a call and leave the pop. */ 3802 NO_DEFER_POP; 3803 valreg = (mem_value == 0 && outmode != VOIDmode 3804 ? hard_libcall_value (outmode, orgfun) : NULL_RTX); 3805 3806 /* Stack must be properly aligned now. */ 3807 gcc_assert (!(stack_pointer_delta 3808 & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))); 3809 3810 before_call = get_last_insn (); 3811 3812 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which 3813 will set inhibit_defer_pop to that value. */ 3814 /* The return type is needed to decide how many bytes the function pops. 3815 Signedness plays no role in that, so for simplicity, we pretend it's 3816 always signed. We also assume that the list of arguments passed has 3817 no impact, so we pretend it is unknown. */ 3818 3819 emit_call_1 (fun, NULL, 3820 get_identifier (XSTR (orgfun, 0)), 3821 build_function_type (tfom, NULL_TREE), 3822 original_args_size.constant, args_size.constant, 3823 struct_value_size, 3824 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), 3825 valreg, 3826 old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far); 3827 3828 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings 3829 that it should complain if nonvolatile values are live. For 3830 functions that cannot return, inform flow that control does not 3831 fall through. */ 3832 3833 if (flags & ECF_NORETURN) 3834 { 3835 /* The barrier note must be emitted 3836 immediately after the CALL_INSN. Some ports emit more than 3837 just a CALL_INSN above, so we must search for it here. */ 3838 3839 rtx last = get_last_insn (); 3840 while (!CALL_P (last)) 3841 { 3842 last = PREV_INSN (last); 3843 /* There was no CALL_INSN? */ 3844 gcc_assert (last != before_call); 3845 } 3846 3847 emit_barrier_after (last); 3848 } 3849 3850 /* Now restore inhibit_defer_pop to its actual original value. */ 3851 OK_DEFER_POP; 3852 3853 pop_temp_slots (); 3854 3855 /* Copy the value to the right place. */ 3856 if (outmode != VOIDmode && retval) 3857 { 3858 if (mem_value) 3859 { 3860 if (value == 0) 3861 value = mem_value; 3862 if (value != mem_value) 3863 emit_move_insn (value, mem_value); 3864 } 3865 else if (GET_CODE (valreg) == PARALLEL) 3866 { 3867 if (value == 0) 3868 value = gen_reg_rtx (outmode); 3869 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode)); 3870 } 3871 else 3872 { 3873 /* Convert to the proper mode if a promotion has been active. */ 3874 if (GET_MODE (valreg) != outmode) 3875 { 3876 int unsignedp = TYPE_UNSIGNED (tfom); 3877 3878 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp, 3879 fndecl ? TREE_TYPE (fndecl) : fntype, 1) 3880 == GET_MODE (valreg)); 3881 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0); 3882 } 3883 3884 if (value != 0) 3885 emit_move_insn (value, valreg); 3886 else 3887 value = valreg; 3888 } 3889 } 3890 3891 if (ACCUMULATE_OUTGOING_ARGS) 3892 { 3893 #ifdef REG_PARM_STACK_SPACE 3894 if (save_area) 3895 restore_fixed_argument_area (save_area, argblock, 3896 high_to_save, low_to_save); 3897 #endif 3898 3899 /* If we saved any argument areas, restore them. */ 3900 for (count = 0; count < nargs; count++) 3901 if (argvec[count].save_area) 3902 { 3903 enum machine_mode save_mode = GET_MODE (argvec[count].save_area); 3904 rtx adr = plus_constant (argblock, 3905 argvec[count].locate.offset.constant); 3906 rtx stack_area = gen_rtx_MEM (save_mode, 3907 memory_address (save_mode, adr)); 3908 3909 if (save_mode == BLKmode) 3910 emit_block_move (stack_area, 3911 validize_mem (argvec[count].save_area), 3912 GEN_INT (argvec[count].locate.size.constant), 3913 BLOCK_OP_CALL_PARM); 3914 else 3915 emit_move_insn (stack_area, argvec[count].save_area); 3916 } 3917 3918 highest_outgoing_arg_in_use = initial_highest_arg_in_use; 3919 stack_usage_map = initial_stack_usage_map; 3920 } 3921 3922 if (stack_usage_map_buf) 3923 free (stack_usage_map_buf); 3924 3925 return value; 3926 3927 } 3928 3929 /* Output a library call to function FUN (a SYMBOL_REF rtx) 3930 (emitting the queue unless NO_QUEUE is nonzero), 3931 for a value of mode OUTMODE, 3932 with NARGS different arguments, passed as alternating rtx values 3933 and machine_modes to convert them to. 3934 3935 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for 3936 `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for 3937 other types of library calls. */ 3938 3939 void 3940 emit_library_call (rtx orgfun, enum libcall_type fn_type, 3941 enum machine_mode outmode, int nargs, ...) 3942 { 3943 va_list p; 3944 3945 va_start (p, nargs); 3946 emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p); 3947 va_end (p); 3948 } 3949 3950 /* Like emit_library_call except that an extra argument, VALUE, 3951 comes second and says where to store the result. 3952 (If VALUE is zero, this function chooses a convenient way 3953 to return the value. 3954 3955 This function returns an rtx for where the value is to be found. 3956 If VALUE is nonzero, VALUE is returned. */ 3957 3958 rtx 3959 emit_library_call_value (rtx orgfun, rtx value, 3960 enum libcall_type fn_type, 3961 enum machine_mode outmode, int nargs, ...) 3962 { 3963 rtx result; 3964 va_list p; 3965 3966 va_start (p, nargs); 3967 result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode, 3968 nargs, p); 3969 va_end (p); 3970 3971 return result; 3972 } 3973 3974 /* Store a single argument for a function call 3975 into the register or memory area where it must be passed. 3976 *ARG describes the argument value and where to pass it. 3977 3978 ARGBLOCK is the address of the stack-block for all the arguments, 3979 or 0 on a machine where arguments are pushed individually. 3980 3981 MAY_BE_ALLOCA nonzero says this could be a call to `alloca' 3982 so must be careful about how the stack is used. 3983 3984 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing 3985 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate 3986 that we need not worry about saving and restoring the stack. 3987 3988 FNDECL is the declaration of the function we are calling. 3989 3990 Return nonzero if this arg should cause sibcall failure, 3991 zero otherwise. */ 3992 3993 static int 3994 store_one_arg (struct arg_data *arg, rtx argblock, int flags, 3995 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space) 3996 { 3997 tree pval = arg->tree_value; 3998 rtx reg = 0; 3999 int partial = 0; 4000 int used = 0; 4001 int i, lower_bound = 0, upper_bound = 0; 4002 int sibcall_failure = 0; 4003 4004 if (TREE_CODE (pval) == ERROR_MARK) 4005 return 1; 4006 4007 /* Push a new temporary level for any temporaries we make for 4008 this argument. */ 4009 push_temp_slots (); 4010 4011 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)) 4012 { 4013 /* If this is being stored into a pre-allocated, fixed-size, stack area, 4014 save any previous data at that location. */ 4015 if (argblock && ! variable_size && arg->stack) 4016 { 4017 #ifdef ARGS_GROW_DOWNWARD 4018 /* stack_slot is negative, but we want to index stack_usage_map 4019 with positive values. */ 4020 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS) 4021 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1; 4022 else 4023 upper_bound = 0; 4024 4025 lower_bound = upper_bound - arg->locate.size.constant; 4026 #else 4027 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS) 4028 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)); 4029 else 4030 lower_bound = 0; 4031 4032 upper_bound = lower_bound + arg->locate.size.constant; 4033 #endif 4034 4035 i = lower_bound; 4036 /* Don't worry about things in the fixed argument area; 4037 it has already been saved. */ 4038 if (i < reg_parm_stack_space) 4039 i = reg_parm_stack_space; 4040 while (i < upper_bound && stack_usage_map[i] == 0) 4041 i++; 4042 4043 if (i < upper_bound) 4044 { 4045 /* We need to make a save area. */ 4046 unsigned int size = arg->locate.size.constant * BITS_PER_UNIT; 4047 enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1); 4048 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0)); 4049 rtx stack_area = gen_rtx_MEM (save_mode, adr); 4050 4051 if (save_mode == BLKmode) 4052 { 4053 tree ot = TREE_TYPE (arg->tree_value); 4054 tree nt = build_qualified_type (ot, (TYPE_QUALS (ot) 4055 | TYPE_QUAL_CONST)); 4056 4057 arg->save_area = assign_temp (nt, 0, 1, 1); 4058 preserve_temp_slots (arg->save_area); 4059 emit_block_move (validize_mem (arg->save_area), stack_area, 4060 GEN_INT (arg->locate.size.constant), 4061 BLOCK_OP_CALL_PARM); 4062 } 4063 else 4064 { 4065 arg->save_area = gen_reg_rtx (save_mode); 4066 emit_move_insn (arg->save_area, stack_area); 4067 } 4068 } 4069 } 4070 } 4071 4072 /* If this isn't going to be placed on both the stack and in registers, 4073 set up the register and number of words. */ 4074 if (! arg->pass_on_stack) 4075 { 4076 if (flags & ECF_SIBCALL) 4077 reg = arg->tail_call_reg; 4078 else 4079 reg = arg->reg; 4080 partial = arg->partial; 4081 } 4082 4083 /* Being passed entirely in a register. We shouldn't be called in 4084 this case. */ 4085 gcc_assert (reg == 0 || partial != 0); 4086 4087 /* If this arg needs special alignment, don't load the registers 4088 here. */ 4089 if (arg->n_aligned_regs != 0) 4090 reg = 0; 4091 4092 /* If this is being passed partially in a register, we can't evaluate 4093 it directly into its stack slot. Otherwise, we can. */ 4094 if (arg->value == 0) 4095 { 4096 /* stack_arg_under_construction is nonzero if a function argument is 4097 being evaluated directly into the outgoing argument list and 4098 expand_call must take special action to preserve the argument list 4099 if it is called recursively. 4100 4101 For scalar function arguments stack_usage_map is sufficient to 4102 determine which stack slots must be saved and restored. Scalar 4103 arguments in general have pass_on_stack == 0. 4104 4105 If this argument is initialized by a function which takes the 4106 address of the argument (a C++ constructor or a C function 4107 returning a BLKmode structure), then stack_usage_map is 4108 insufficient and expand_call must push the stack around the 4109 function call. Such arguments have pass_on_stack == 1. 4110 4111 Note that it is always safe to set stack_arg_under_construction, 4112 but this generates suboptimal code if set when not needed. */ 4113 4114 if (arg->pass_on_stack) 4115 stack_arg_under_construction++; 4116 4117 arg->value = expand_expr (pval, 4118 (partial 4119 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode) 4120 ? NULL_RTX : arg->stack, 4121 VOIDmode, EXPAND_STACK_PARM); 4122 4123 /* If we are promoting object (or for any other reason) the mode 4124 doesn't agree, convert the mode. */ 4125 4126 if (arg->mode != TYPE_MODE (TREE_TYPE (pval))) 4127 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)), 4128 arg->value, arg->unsignedp); 4129 4130 if (arg->pass_on_stack) 4131 stack_arg_under_construction--; 4132 } 4133 4134 /* Check for overlap with already clobbered argument area. */ 4135 if ((flags & ECF_SIBCALL) 4136 && MEM_P (arg->value) 4137 && mem_overlaps_already_clobbered_arg_p (XEXP (arg->value, 0), 4138 arg->locate.size.constant)) 4139 sibcall_failure = 1; 4140 4141 /* Don't allow anything left on stack from computation 4142 of argument to alloca. */ 4143 if (flags & ECF_MAY_BE_ALLOCA) 4144 do_pending_stack_adjust (); 4145 4146 if (arg->value == arg->stack) 4147 /* If the value is already in the stack slot, we are done. */ 4148 ; 4149 else if (arg->mode != BLKmode) 4150 { 4151 int size; 4152 unsigned int parm_align; 4153 4154 /* Argument is a scalar, not entirely passed in registers. 4155 (If part is passed in registers, arg->partial says how much 4156 and emit_push_insn will take care of putting it there.) 4157 4158 Push it, and if its size is less than the 4159 amount of space allocated to it, 4160 also bump stack pointer by the additional space. 4161 Note that in C the default argument promotions 4162 will prevent such mismatches. */ 4163 4164 size = GET_MODE_SIZE (arg->mode); 4165 /* Compute how much space the push instruction will push. 4166 On many machines, pushing a byte will advance the stack 4167 pointer by a halfword. */ 4168 #ifdef PUSH_ROUNDING 4169 size = PUSH_ROUNDING (size); 4170 #endif 4171 used = size; 4172 4173 /* Compute how much space the argument should get: 4174 round up to a multiple of the alignment for arguments. */ 4175 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval))) 4176 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1) 4177 / (PARM_BOUNDARY / BITS_PER_UNIT)) 4178 * (PARM_BOUNDARY / BITS_PER_UNIT)); 4179 4180 /* Compute the alignment of the pushed argument. */ 4181 parm_align = arg->locate.boundary; 4182 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward) 4183 { 4184 int pad = used - size; 4185 if (pad) 4186 { 4187 unsigned int pad_align = (pad & -pad) * BITS_PER_UNIT; 4188 parm_align = MIN (parm_align, pad_align); 4189 } 4190 } 4191 4192 /* This isn't already where we want it on the stack, so put it there. 4193 This can either be done with push or copy insns. */ 4194 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 4195 parm_align, partial, reg, used - size, argblock, 4196 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space, 4197 ARGS_SIZE_RTX (arg->locate.alignment_pad)); 4198 4199 /* Unless this is a partially-in-register argument, the argument is now 4200 in the stack. */ 4201 if (partial == 0) 4202 arg->value = arg->stack; 4203 } 4204 else 4205 { 4206 /* BLKmode, at least partly to be pushed. */ 4207 4208 unsigned int parm_align; 4209 int excess; 4210 rtx size_rtx; 4211 4212 /* Pushing a nonscalar. 4213 If part is passed in registers, PARTIAL says how much 4214 and emit_push_insn will take care of putting it there. */ 4215 4216 /* Round its size up to a multiple 4217 of the allocation unit for arguments. */ 4218 4219 if (arg->locate.size.var != 0) 4220 { 4221 excess = 0; 4222 size_rtx = ARGS_SIZE_RTX (arg->locate.size); 4223 } 4224 else 4225 { 4226 /* PUSH_ROUNDING has no effect on us, because emit_push_insn 4227 for BLKmode is careful to avoid it. */ 4228 excess = (arg->locate.size.constant 4229 - int_size_in_bytes (TREE_TYPE (pval)) 4230 + partial); 4231 size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)), 4232 NULL_RTX, TYPE_MODE (sizetype), 4233 EXPAND_NORMAL); 4234 } 4235 4236 parm_align = arg->locate.boundary; 4237 4238 /* When an argument is padded down, the block is aligned to 4239 PARM_BOUNDARY, but the actual argument isn't. */ 4240 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward) 4241 { 4242 if (arg->locate.size.var) 4243 parm_align = BITS_PER_UNIT; 4244 else if (excess) 4245 { 4246 unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT; 4247 parm_align = MIN (parm_align, excess_align); 4248 } 4249 } 4250 4251 if ((flags & ECF_SIBCALL) && MEM_P (arg->value)) 4252 { 4253 /* emit_push_insn might not work properly if arg->value and 4254 argblock + arg->locate.offset areas overlap. */ 4255 rtx x = arg->value; 4256 int i = 0; 4257 4258 if (XEXP (x, 0) == crtl->args.internal_arg_pointer 4259 || (GET_CODE (XEXP (x, 0)) == PLUS 4260 && XEXP (XEXP (x, 0), 0) == 4261 crtl->args.internal_arg_pointer 4262 && CONST_INT_P (XEXP (XEXP (x, 0), 1)))) 4263 { 4264 if (XEXP (x, 0) != crtl->args.internal_arg_pointer) 4265 i = INTVAL (XEXP (XEXP (x, 0), 1)); 4266 4267 /* expand_call should ensure this. */ 4268 gcc_assert (!arg->locate.offset.var 4269 && arg->locate.size.var == 0 4270 && CONST_INT_P (size_rtx)); 4271 4272 if (arg->locate.offset.constant > i) 4273 { 4274 if (arg->locate.offset.constant < i + INTVAL (size_rtx)) 4275 sibcall_failure = 1; 4276 } 4277 else if (arg->locate.offset.constant < i) 4278 { 4279 /* Use arg->locate.size.constant instead of size_rtx 4280 because we only care about the part of the argument 4281 on the stack. */ 4282 if (i < (arg->locate.offset.constant 4283 + arg->locate.size.constant)) 4284 sibcall_failure = 1; 4285 } 4286 else 4287 { 4288 /* Even though they appear to be at the same location, 4289 if part of the outgoing argument is in registers, 4290 they aren't really at the same location. Check for 4291 this by making sure that the incoming size is the 4292 same as the outgoing size. */ 4293 if (arg->locate.size.constant != INTVAL (size_rtx)) 4294 sibcall_failure = 1; 4295 } 4296 } 4297 } 4298 4299 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx, 4300 parm_align, partial, reg, excess, argblock, 4301 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space, 4302 ARGS_SIZE_RTX (arg->locate.alignment_pad)); 4303 4304 /* Unless this is a partially-in-register argument, the argument is now 4305 in the stack. 4306 4307 ??? Unlike the case above, in which we want the actual 4308 address of the data, so that we can load it directly into a 4309 register, here we want the address of the stack slot, so that 4310 it's properly aligned for word-by-word copying or something 4311 like that. It's not clear that this is always correct. */ 4312 if (partial == 0) 4313 arg->value = arg->stack_slot; 4314 } 4315 4316 if (arg->reg && GET_CODE (arg->reg) == PARALLEL) 4317 { 4318 tree type = TREE_TYPE (arg->tree_value); 4319 arg->parallel_value 4320 = emit_group_load_into_temps (arg->reg, arg->value, type, 4321 int_size_in_bytes (type)); 4322 } 4323 4324 /* Mark all slots this store used. */ 4325 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL) 4326 && argblock && ! variable_size && arg->stack) 4327 for (i = lower_bound; i < upper_bound; i++) 4328 stack_usage_map[i] = 1; 4329 4330 /* Once we have pushed something, pops can't safely 4331 be deferred during the rest of the arguments. */ 4332 NO_DEFER_POP; 4333 4334 /* Free any temporary slots made in processing this argument. Show 4335 that we might have taken the address of something and pushed that 4336 as an operand. */ 4337 preserve_temp_slots (NULL_RTX); 4338 free_temp_slots (); 4339 pop_temp_slots (); 4340 4341 return sibcall_failure; 4342 } 4343 4344 /* Nonzero if we do not know how to pass TYPE solely in registers. */ 4345 4346 bool 4347 must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED, 4348 const_tree type) 4349 { 4350 if (!type) 4351 return false; 4352 4353 /* If the type has variable size... */ 4354 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 4355 return true; 4356 4357 /* If the type is marked as addressable (it is required 4358 to be constructed into the stack)... */ 4359 if (TREE_ADDRESSABLE (type)) 4360 return true; 4361 4362 return false; 4363 } 4364 4365 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one 4366 takes trailing padding of a structure into account. */ 4367 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */ 4368 4369 bool 4370 must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type) 4371 { 4372 if (!type) 4373 return false; 4374 4375 /* If the type has variable size... */ 4376 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 4377 return true; 4378 4379 /* If the type is marked as addressable (it is required 4380 to be constructed into the stack)... */ 4381 if (TREE_ADDRESSABLE (type)) 4382 return true; 4383 4384 /* If the padding and mode of the type is such that a copy into 4385 a register would put it into the wrong part of the register. */ 4386 if (mode == BLKmode 4387 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT) 4388 && (FUNCTION_ARG_PADDING (mode, type) 4389 == (BYTES_BIG_ENDIAN ? upward : downward))) 4390 return true; 4391 4392 return false; 4393 } 4394