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