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