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