![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to calls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to calls.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Convert function calls to rtl insns, for GNU C compiler. 1.1.1.6 ! root 2: Copyright (C) 1989, 1992, 1993 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: #include "config.h" 21: #include "rtl.h" 22: #include "tree.h" 23: #include "flags.h" 24: #include "expr.h" 1.1.1.5 root 25: #include "gvarargs.h" 1.1 root 26: #include "insn-flags.h" 27: 28: /* Decide whether a function's arguments should be processed 1.1.1.5 root 29: from first to last or from last to first. 30: 31: They should if the stack and args grow in opposite directions, but 32: only if we have push insns. */ 1.1 root 33: 34: #ifdef PUSH_ROUNDING 1.1.1.5 root 35: 1.1.1.6 ! root 36: #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) 1.1 root 37: #define PUSH_ARGS_REVERSED /* If it's last to first */ 38: #endif 1.1.1.5 root 39: 1.1 root 40: #endif 41: 42: /* Like STACK_BOUNDARY but in units of bytes, not bits. */ 43: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT) 44: 45: /* Data structure and subroutines used within expand_call. */ 46: 47: struct arg_data 48: { 49: /* Tree node for this argument. */ 50: tree tree_value; 1.1.1.5 root 51: /* Mode for value; TYPE_MODE unless promoted. */ 52: enum machine_mode mode; 1.1 root 53: /* Current RTL value for argument, or 0 if it isn't precomputed. */ 54: rtx value; 55: /* Initially-compute RTL value for argument; only for const functions. */ 56: rtx initial_value; 57: /* Register to pass this argument in, 0 if passed on stack, or an 58: EXPR_LIST if the arg is to be copied into multiple different 59: registers. */ 60: rtx reg; 1.1.1.4 root 61: /* If REG was promoted from the actual mode of the argument expression, 62: indicates whether the promotion is sign- or zero-extended. */ 63: int unsignedp; 1.1 root 64: /* Number of registers to use. 0 means put the whole arg in registers. 65: Also 0 if not passed in registers. */ 66: int partial; 1.1.1.3 root 67: /* Non-zero if argument must be passed on stack. 68: Note that some arguments may be passed on the stack 69: even though pass_on_stack is zero, just because FUNCTION_ARG says so. 70: pass_on_stack identifies arguments that *cannot* go in registers. */ 1.1 root 71: int pass_on_stack; 72: /* Offset of this argument from beginning of stack-args. */ 73: struct args_size offset; 74: /* Similar, but offset to the start of the stack slot. Different from 75: OFFSET if this arg pads downward. */ 76: struct args_size slot_offset; 77: /* Size of this argument on the stack, rounded up for any padding it gets, 78: parts of the argument passed in registers do not count. 79: If REG_PARM_STACK_SPACE is defined, then register parms 80: are counted here as well. */ 81: struct args_size size; 82: /* Location on the stack at which parameter should be stored. The store 83: has already been done if STACK == VALUE. */ 84: rtx stack; 85: /* Location on the stack of the start of this argument slot. This can 86: differ from STACK if this arg pads downward. This location is known 87: to be aligned to FUNCTION_ARG_BOUNDARY. */ 88: rtx stack_slot; 89: #ifdef ACCUMULATE_OUTGOING_ARGS 90: /* Place that this stack area has been saved, if needed. */ 91: rtx save_area; 92: #endif 1.1.1.5 root 93: #ifdef STRICT_ALIGNMENT 94: /* If an argument's alignment does not permit direct copying into registers, 95: copy in smaller-sized pieces into pseudos. These are stored in a 96: block pointed to by this field. The next field says how many 97: word-sized pseudos we made. */ 98: rtx *aligned_regs; 99: int n_aligned_regs; 100: #endif 1.1 root 101: }; 102: 103: #ifdef ACCUMULATE_OUTGOING_ARGS 1.1.1.4 root 104: /* A vector of one char per byte of stack space. A byte if non-zero if 1.1 root 105: the corresponding stack location has been used. 106: This vector is used to prevent a function call within an argument from 107: clobbering any stack already set up. */ 108: static char *stack_usage_map; 109: 110: /* Size of STACK_USAGE_MAP. */ 111: static int highest_outgoing_arg_in_use; 1.1.1.3 root 112: 113: /* stack_arg_under_construction is nonzero when an argument may be 114: initialized with a constructor call (including a C function that 115: returns a BLKmode struct) and expand_call must take special action 116: to make sure the object being constructed does not overlap the 117: argument list for the constructor call. */ 118: int stack_arg_under_construction; 1.1 root 119: #endif 120: 1.1.1.5 root 121: static int calls_function PROTO((tree, int)); 1.1.1.6 ! root 122: static int calls_function_1 PROTO((tree, int)); 1.1.1.5 root 123: static void emit_call_1 PROTO((rtx, tree, int, int, rtx, rtx, int, 124: rtx, int)); 125: static void store_one_arg PROTO ((struct arg_data *, rtx, int, int, 126: tree, int)); 1.1 root 127: 1.1.1.5 root 128: /* If WHICH is 1, return 1 if EXP contains a call to the built-in function 129: `alloca'. 130: 131: If WHICH is 0, return 1 if EXP contains a call to any function. 132: Actually, we only need return 1 if evaluating EXP would require pushing 133: arguments on the stack, but that is too difficult to compute, so we just 134: assume any function call might require the stack. */ 1.1 root 135: 1.1.1.6 ! root 136: static tree calls_function_save_exprs; ! 137: 1.1 root 138: static int 1.1.1.5 root 139: calls_function (exp, which) 1.1 root 140: tree exp; 1.1.1.5 root 141: int which; 1.1 root 142: { 1.1.1.6 ! root 143: int val; ! 144: calls_function_save_exprs = 0; ! 145: val = calls_function_1 (exp, which); ! 146: calls_function_save_exprs = 0; ! 147: return val; ! 148: } ! 149: ! 150: static int ! 151: calls_function_1 (exp, which) ! 152: tree exp; ! 153: int which; ! 154: { 1.1 root 155: register int i; 156: int type = TREE_CODE_CLASS (TREE_CODE (exp)); 157: int length = tree_code_length[(int) TREE_CODE (exp)]; 158: 159: /* Only expressions and references can contain calls. */ 160: 1.1.1.4 root 161: if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r' 162: && type != 'b') 1.1 root 163: return 0; 164: 165: switch (TREE_CODE (exp)) 166: { 167: case CALL_EXPR: 1.1.1.5 root 168: if (which == 0) 169: return 1; 170: else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR 171: && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) 172: == FUNCTION_DECL) 173: && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) 174: && (DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) 175: == BUILT_IN_ALLOCA)) 1.1 root 176: return 1; 177: 178: /* Third operand is RTL. */ 179: length = 2; 180: break; 181: 182: case SAVE_EXPR: 183: if (SAVE_EXPR_RTL (exp) != 0) 184: return 0; 1.1.1.6 ! root 185: if (value_member (exp, calls_function_save_exprs)) ! 186: return 0; ! 187: calls_function_save_exprs = tree_cons (NULL_TREE, exp, ! 188: calls_function_save_exprs); ! 189: return (TREE_OPERAND (exp, 0) != 0 ! 190: && calls_function_1 (TREE_OPERAND (exp, 0), which)); 1.1 root 191: 192: case BLOCK: 1.1.1.4 root 193: { 194: register tree local; 195: 196: for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local)) 1.1.1.5 root 197: if (DECL_INITIAL (local) != 0 1.1.1.6 ! root 198: && calls_function_1 (DECL_INITIAL (local), which)) 1.1.1.4 root 199: return 1; 200: } 201: { 202: register tree subblock; 203: 204: for (subblock = BLOCK_SUBBLOCKS (exp); 205: subblock; 206: subblock = TREE_CHAIN (subblock)) 1.1.1.6 ! root 207: if (calls_function_1 (subblock, which)) 1.1.1.4 root 208: return 1; 209: } 210: return 0; 1.1 root 211: 212: case METHOD_CALL_EXPR: 213: length = 3; 214: break; 215: 216: case WITH_CLEANUP_EXPR: 217: length = 1; 218: break; 219: 220: case RTL_EXPR: 221: return 0; 222: } 223: 224: for (i = 0; i < length; i++) 225: if (TREE_OPERAND (exp, i) != 0 1.1.1.6 ! root 226: && calls_function_1 (TREE_OPERAND (exp, i), which)) 1.1 root 227: return 1; 228: 229: return 0; 230: } 231: 232: /* Force FUNEXP into a form suitable for the address of a CALL, 233: and return that as an rtx. Also load the static chain register 234: if FNDECL is a nested function. 235: 236: USE_INSNS points to a variable holding a chain of USE insns 237: to which a USE of the static chain 238: register should be added, if required. */ 239: 240: rtx 241: prepare_call_address (funexp, fndecl, use_insns) 242: rtx funexp; 243: tree fndecl; 244: rtx *use_insns; 245: { 246: rtx static_chain_value = 0; 247: 248: funexp = protect_from_queue (funexp, 0); 249: 250: if (fndecl != 0) 251: /* Get possible static chain value for nested function in C. */ 252: static_chain_value = lookup_static_chain (fndecl); 253: 254: /* Make a valid memory address and copy constants thru pseudo-regs, 255: but not for a constant address if -fno-function-cse. */ 256: if (GET_CODE (funexp) != SYMBOL_REF) 257: funexp = memory_address (FUNCTION_MODE, funexp); 258: else 259: { 260: #ifndef NO_FUNCTION_CSE 261: if (optimize && ! flag_no_function_cse) 262: #ifdef NO_RECURSIVE_FUNCTION_CSE 263: if (fndecl != current_function_decl) 264: #endif 265: funexp = force_reg (Pmode, funexp); 266: #endif 267: } 268: 269: if (static_chain_value != 0) 270: { 271: emit_move_insn (static_chain_rtx, static_chain_value); 272: 273: /* Put the USE insn in the chain we were passed. It will later be 274: output immediately in front of the CALL insn. */ 275: push_to_sequence (*use_insns); 276: emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx)); 277: *use_insns = get_insns (); 278: end_sequence (); 279: } 280: 281: return funexp; 282: } 283: 284: /* Generate instructions to call function FUNEXP, 285: and optionally pop the results. 286: The CALL_INSN is the first insn generated. 287: 288: FUNTYPE is the data type of the function, or, for a library call, 289: the identifier for the name of the call. This is given to the 290: macro RETURN_POPS_ARGS to determine whether this function pops its own args. 291: 292: STACK_SIZE is the number of bytes of arguments on the stack, 293: rounded up to STACK_BOUNDARY; zero if the size is variable. 294: This is both to put into the call insn and 295: to generate explicit popping code if necessary. 296: 297: STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value. 298: It is zero if this call doesn't want a structure value. 299: 300: NEXT_ARG_REG is the rtx that results from executing 301: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1) 302: just after all the args have had their registers assigned. 303: This could be whatever you like, but normally it is the first 304: arg-register beyond those used for args in this call, 305: or 0 if all the arg-registers are used in this call. 306: It is passed on to `gen_call' so you can put this info in the call insn. 307: 308: VALREG is a hard register in which a value is returned, 309: or 0 if the call does not return a value. 310: 311: OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before 312: the args to this call were processed. 313: We restore `inhibit_defer_pop' to that value. 314: 315: USE_INSNS is a chain of USE insns to be emitted immediately before 316: the actual CALL insn. 317: 318: IS_CONST is true if this is a `const' call. */ 319: 1.1.1.5 root 320: static void 1.1 root 321: emit_call_1 (funexp, funtype, stack_size, struct_value_size, next_arg_reg, 322: valreg, old_inhibit_defer_pop, use_insns, is_const) 323: rtx funexp; 324: tree funtype; 325: int stack_size; 326: int struct_value_size; 327: rtx next_arg_reg; 328: rtx valreg; 329: int old_inhibit_defer_pop; 330: rtx use_insns; 331: int is_const; 332: { 1.1.1.4 root 333: rtx stack_size_rtx = GEN_INT (stack_size); 334: rtx struct_value_size_rtx = GEN_INT (struct_value_size); 1.1 root 335: rtx call_insn; 336: int already_popped = 0; 337: 338: /* Ensure address is valid. SYMBOL_REF is already valid, so no need, 339: and we don't want to load it into a register as an optimization, 340: because prepare_call_address already did it if it should be done. */ 341: if (GET_CODE (funexp) != SYMBOL_REF) 342: funexp = memory_address (FUNCTION_MODE, funexp); 343: 344: #ifndef ACCUMULATE_OUTGOING_ARGS 345: #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop) 346: if (HAVE_call_pop && HAVE_call_value_pop 347: && (RETURN_POPS_ARGS (funtype, stack_size) > 0 || stack_size == 0)) 348: { 1.1.1.4 root 349: rtx n_pop = GEN_INT (RETURN_POPS_ARGS (funtype, stack_size)); 1.1 root 350: rtx pat; 351: 352: /* If this subroutine pops its own args, record that in the call insn 353: if possible, for the sake of frame pointer elimination. */ 354: if (valreg) 355: pat = gen_call_value_pop (valreg, 356: gen_rtx (MEM, FUNCTION_MODE, funexp), 357: stack_size_rtx, next_arg_reg, n_pop); 358: else 359: pat = gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, funexp), 360: stack_size_rtx, next_arg_reg, n_pop); 361: 362: emit_call_insn (pat); 363: already_popped = 1; 364: } 365: else 366: #endif 367: #endif 368: 369: #if defined (HAVE_call) && defined (HAVE_call_value) 370: if (HAVE_call && HAVE_call_value) 371: { 372: if (valreg) 373: emit_call_insn (gen_call_value (valreg, 374: gen_rtx (MEM, FUNCTION_MODE, funexp), 1.1.1.5 root 375: stack_size_rtx, next_arg_reg, 376: NULL_RTX)); 1.1 root 377: else 378: emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, funexp), 379: stack_size_rtx, next_arg_reg, 380: struct_value_size_rtx)); 381: } 382: else 383: #endif 384: abort (); 385: 386: /* Find the CALL insn we just emitted and write the USE insns before it. */ 387: for (call_insn = get_last_insn (); 388: call_insn && GET_CODE (call_insn) != CALL_INSN; 389: call_insn = PREV_INSN (call_insn)) 390: ; 391: 392: if (! call_insn) 393: abort (); 394: 395: /* Put the USE insns before the CALL. */ 396: emit_insns_before (use_insns, call_insn); 397: 398: /* If this is a const call, then set the insn's unchanging bit. */ 399: if (is_const) 400: CONST_CALL_P (call_insn) = 1; 401: 1.1.1.5 root 402: /* Restore this now, so that we do defer pops for this call's args 403: if the context of the call as a whole permits. */ 404: inhibit_defer_pop = old_inhibit_defer_pop; 405: 1.1 root 406: #ifndef ACCUMULATE_OUTGOING_ARGS 407: /* If returning from the subroutine does not automatically pop the args, 408: we need an instruction to pop them sooner or later. 409: Perhaps do it now; perhaps just record how much space to pop later. 410: 411: If returning from the subroutine does pop the args, indicate that the 412: stack pointer will be changed. */ 413: 414: if (stack_size != 0 && RETURN_POPS_ARGS (funtype, stack_size) > 0) 415: { 416: if (!already_popped) 417: emit_insn (gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx)); 418: stack_size -= RETURN_POPS_ARGS (funtype, stack_size); 1.1.1.4 root 419: stack_size_rtx = GEN_INT (stack_size); 1.1 root 420: } 421: 422: if (stack_size != 0) 423: { 1.1.1.5 root 424: if (flag_defer_pop && inhibit_defer_pop == 0 && !is_const) 1.1 root 425: pending_stack_adjust += stack_size; 426: else 427: adjust_stack (stack_size_rtx); 428: } 429: #endif 430: } 431: 432: /* Generate all the code for a function call 433: and return an rtx for its value. 434: Store the value in TARGET (specified as an rtx) if convenient. 435: If the value is stored in TARGET then TARGET is returned. 436: If IGNORE is nonzero, then we ignore the value of the function call. */ 437: 438: rtx 1.1.1.3 root 439: expand_call (exp, target, ignore) 1.1 root 440: tree exp; 441: rtx target; 442: int ignore; 443: { 444: /* List of actual parameters. */ 445: tree actparms = TREE_OPERAND (exp, 1); 446: /* RTX for the function to be called. */ 447: rtx funexp; 448: /* Tree node for the function to be called (not the address!). */ 449: tree funtree; 450: /* Data type of the function. */ 451: tree funtype; 452: /* Declaration of the function being called, 453: or 0 if the function is computed (not known by name). */ 454: tree fndecl = 0; 455: char *name = 0; 456: 457: /* Register in which non-BLKmode value will be returned, 458: or 0 if no value or if value is BLKmode. */ 459: rtx valreg; 460: /* Address where we should return a BLKmode value; 461: 0 if value not BLKmode. */ 462: rtx structure_value_addr = 0; 463: /* Nonzero if that address is being passed by treating it as 464: an extra, implicit first parameter. Otherwise, 465: it is passed by being copied directly into struct_value_rtx. */ 466: int structure_value_addr_parm = 0; 467: /* Size of aggregate value wanted, or zero if none wanted 468: or if we are using the non-reentrant PCC calling convention 469: or expecting the value in registers. */ 470: int struct_value_size = 0; 471: /* Nonzero if called function returns an aggregate in memory PCC style, 472: by returning the address of where to find it. */ 473: int pcc_struct_value = 0; 474: 475: /* Number of actual parameters in this call, including struct value addr. */ 476: int num_actuals; 477: /* Number of named args. Args after this are anonymous ones 478: and they must all go on the stack. */ 479: int n_named_args; 480: /* Count arg position in order args appear. */ 481: int argpos; 482: 483: /* Vector of information about each argument. 484: Arguments are numbered in the order they will be pushed, 485: not the order they are written. */ 486: struct arg_data *args; 487: 488: /* Total size in bytes of all the stack-parms scanned so far. */ 489: struct args_size args_size; 490: /* Size of arguments before any adjustments (such as rounding). */ 491: struct args_size original_args_size; 492: /* Data on reg parms scanned so far. */ 493: CUMULATIVE_ARGS args_so_far; 494: /* Nonzero if a reg parm has been scanned. */ 495: int reg_parm_seen; 1.1.1.5 root 496: /* Nonzero if this is an indirect function call. */ 497: int current_call_is_indirect = 0; 1.1 root 498: 499: /* Nonzero if we must avoid push-insns in the args for this call. 500: If stack space is allocated for register parameters, but not by the 501: caller, then it is preallocated in the fixed part of the stack frame. 502: So the entire argument block must then be preallocated (i.e., we 503: ignore PUSH_ROUNDING in that case). */ 504: 505: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) 506: int must_preallocate = 1; 507: #else 508: #ifdef PUSH_ROUNDING 509: int must_preallocate = 0; 510: #else 511: int must_preallocate = 1; 512: #endif 513: #endif 514: 1.1.1.4 root 515: /* Size of the stack reserved for parameter registers. */ 1.1.1.3 root 516: int reg_parm_stack_space = 0; 517: 1.1 root 518: /* 1 if scanning parms front to back, -1 if scanning back to front. */ 519: int inc; 520: /* Address of space preallocated for stack parms 521: (on machines that lack push insns), or 0 if space not preallocated. */ 522: rtx argblock = 0; 523: 524: /* Nonzero if it is plausible that this is a call to alloca. */ 525: int may_be_alloca; 526: /* Nonzero if this is a call to setjmp or a related function. */ 527: int returns_twice; 528: /* Nonzero if this is a call to `longjmp'. */ 529: int is_longjmp; 530: /* Nonzero if this is a call to an inline function. */ 531: int is_integrable = 0; 532: /* Nonzero if this is a call to a `const' function. 533: Note that only explicitly named functions are handled as `const' here. */ 534: int is_const = 0; 535: /* Nonzero if this is a call to a `volatile' function. */ 536: int is_volatile = 0; 537: #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE) 538: /* Define the boundary of the register parm stack space that needs to be 539: save, if any. */ 540: int low_to_save = -1, high_to_save; 541: rtx save_area = 0; /* Place that it is saved */ 542: #endif 543: 544: #ifdef ACCUMULATE_OUTGOING_ARGS 545: int initial_highest_arg_in_use = highest_outgoing_arg_in_use; 546: char *initial_stack_usage_map = stack_usage_map; 547: #endif 548: 549: rtx old_stack_level = 0; 550: int old_pending_adj; 1.1.1.3 root 551: int old_stack_arg_under_construction; 1.1 root 552: int old_inhibit_defer_pop = inhibit_defer_pop; 553: tree old_cleanups = cleanups_this_call; 554: 555: rtx use_insns = 0; 556: 557: register tree p; 1.1.1.5 root 558: register int i, j; 1.1 root 559: 560: /* See if we can find a DECL-node for the actual function. 561: As a result, decide whether this is a call to an integrable function. */ 562: 563: p = TREE_OPERAND (exp, 0); 564: if (TREE_CODE (p) == ADDR_EXPR) 565: { 566: fndecl = TREE_OPERAND (p, 0); 567: if (TREE_CODE (fndecl) != FUNCTION_DECL) 568: { 569: /* May still be a `const' function if it is 570: a call through a pointer-to-const. 571: But we don't handle that. */ 572: fndecl = 0; 573: } 574: else 575: { 576: if (!flag_no_inline 577: && fndecl != current_function_decl 578: && DECL_SAVED_INSNS (fndecl)) 579: is_integrable = 1; 580: else if (! TREE_ADDRESSABLE (fndecl)) 581: { 1.1.1.5 root 582: /* In case this function later becomes inlinable, 1.1 root 583: record that there was already a non-inline call to it. 584: 585: Use abstraction instead of setting TREE_ADDRESSABLE 586: directly. */ 1.1.1.5 root 587: if (DECL_INLINE (fndecl) && extra_warnings && warn_inline 588: && !flag_no_inline) 1.1 root 589: warning_with_decl (fndecl, "can't inline call to `%s' which was declared inline"); 590: mark_addressable (fndecl); 591: } 592: 593: if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl) 594: && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode) 595: is_const = 1; 1.1.1.6 ! root 596: ! 597: if (TREE_THIS_VOLATILE (fndecl)) ! 598: is_volatile = 1; 1.1 root 599: } 600: } 601: 1.1.1.3 root 602: #ifdef REG_PARM_STACK_SPACE 603: #ifdef MAYBE_REG_PARM_STACK_SPACE 604: reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE; 605: #else 606: reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); 607: #endif 608: #endif 609: 1.1 root 610: /* Warn if this value is an aggregate type, 611: regardless of which calling convention we are using for it. */ 612: if (warn_aggregate_return 613: && (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE 614: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE 1.1.1.5 root 615: || TREE_CODE (TREE_TYPE (exp)) == QUAL_UNION_TYPE 1.1 root 616: || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)) 617: warning ("function call has aggregate value"); 618: 619: /* Set up a place to return a structure. */ 620: 621: /* Cater to broken compilers. */ 622: if (aggregate_value_p (exp)) 623: { 624: /* This call returns a big structure. */ 625: is_const = 0; 626: 627: #ifdef PCC_STATIC_STRUCT_RETURN 1.1.1.5 root 628: { 629: pcc_struct_value = 1; 630: is_integrable = 0; /* Easier than making that case work right. */ 631: } 632: #else /* not PCC_STATIC_STRUCT_RETURN */ 633: { 634: struct_value_size = int_size_in_bytes (TREE_TYPE (exp)); 1.1 root 635: 1.1.1.5 root 636: if (struct_value_size < 0) 637: abort (); 1.1 root 638: 1.1.1.5 root 639: if (target && GET_CODE (target) == MEM) 640: structure_value_addr = XEXP (target, 0); 641: else 642: { 643: /* Assign a temporary on the stack to hold the value. */ 1.1 root 644: 1.1.1.5 root 645: /* For variable-sized objects, we must be called with a target 646: specified. If we were to allocate space on the stack here, 647: we would have no way of knowing when to free it. */ 648: 649: structure_value_addr 650: = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0); 651: target = 0; 652: } 653: } 654: #endif /* not PCC_STATIC_STRUCT_RETURN */ 1.1 root 655: } 656: 657: /* If called function is inline, try to integrate it. */ 658: 659: if (is_integrable) 660: { 661: rtx temp; 1.1.1.3 root 662: rtx before_call = get_last_insn (); 1.1 root 663: 664: temp = expand_inline_function (fndecl, actparms, target, 665: ignore, TREE_TYPE (exp), 666: structure_value_addr); 667: 668: /* If inlining succeeded, return. */ 1.1.1.4 root 669: if ((HOST_WIDE_INT) temp != -1) 1.1 root 670: { 671: /* Perform all cleanups needed for the arguments of this call 672: (i.e. destructors in C++). It is ok if these destructors 673: clobber RETURN_VALUE_REG, because the only time we care about 674: this is when TARGET is that register. But in C++, we take 675: care to never return that register directly. */ 676: expand_cleanups_to (old_cleanups); 677: 1.1.1.3 root 678: #ifdef ACCUMULATE_OUTGOING_ARGS 679: /* If the outgoing argument list must be preserved, push 680: the stack before executing the inlined function if it 681: makes any calls. */ 682: 683: for (i = reg_parm_stack_space - 1; i >= 0; i--) 684: if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0) 685: break; 686: 687: if (stack_arg_under_construction || i >= 0) 688: { 689: rtx insn = NEXT_INSN (before_call), seq; 690: 691: /* Look for a call in the inline function code. 692: If OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) is 693: nonzero then there is a call and it is not necessary 694: to scan the insns. */ 695: 696: if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0) 697: for (; insn; insn = NEXT_INSN (insn)) 698: if (GET_CODE (insn) == CALL_INSN) 699: break; 700: 701: if (insn) 702: { 703: /* Reserve enough stack space so that the largest 704: argument list of any function call in the inline 705: function does not overlap the argument list being 706: evaluated. This is usually an overestimate because 707: allocate_dynamic_stack_space reserves space for an 708: outgoing argument list in addition to the requested 709: space, but there is no way to ask for stack space such 710: that an argument list of a certain length can be 711: safely constructed. */ 712: 713: int adjust = OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)); 714: #ifdef REG_PARM_STACK_SPACE 715: /* Add the stack space reserved for register arguments 716: in the inline function. What is really needed is the 717: largest value of reg_parm_stack_space in the inline 718: function, but that is not available. Using the current 719: value of reg_parm_stack_space is wrong, but gives 720: correct results on all supported machines. */ 721: adjust += reg_parm_stack_space; 722: #endif 723: start_sequence (); 1.1.1.5 root 724: emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX); 1.1.1.4 root 725: allocate_dynamic_stack_space (GEN_INT (adjust), 726: NULL_RTX, BITS_PER_UNIT); 1.1.1.3 root 727: seq = get_insns (); 728: end_sequence (); 729: emit_insns_before (seq, NEXT_INSN (before_call)); 1.1.1.4 root 730: emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX); 1.1.1.3 root 731: } 732: } 733: #endif 734: 1.1 root 735: /* If the result is equivalent to TARGET, return TARGET to simplify 736: checks in store_expr. They can be equivalent but not equal in the 737: case of a function that returns BLKmode. */ 738: if (temp != target && rtx_equal_p (temp, target)) 739: return target; 740: return temp; 741: } 742: 743: /* If inlining failed, mark FNDECL as needing to be compiled 744: separately after all. */ 745: mark_addressable (fndecl); 746: } 747: 748: /* When calling a const function, we must pop the stack args right away, 749: so that the pop is deleted or moved with the call. */ 750: if (is_const) 751: NO_DEFER_POP; 752: 753: function_call_count++; 754: 755: if (fndecl && DECL_NAME (fndecl)) 756: name = IDENTIFIER_POINTER (DECL_NAME (fndecl)); 757: 1.1.1.5 root 758: /* On some machines (such as the PA) indirect calls have a different 759: calling convention than normal calls. FUNCTION_ARG in the target 760: description can look at current_call_is_indirect to determine which 761: calling convention to use. */ 762: current_call_is_indirect = (fndecl == 0); 763: #if 0 764: = TREE_CODE (TREE_OPERAND (exp, 0)) == NON_LVALUE_EXPR ? 1 : 0; 765: #endif 766: 1.1 root 767: #if 0 768: /* Unless it's a call to a specific function that isn't alloca, 769: if it has one argument, we must assume it might be alloca. */ 770: 771: may_be_alloca = 772: (!(fndecl != 0 && strcmp (name, "alloca")) 773: && actparms != 0 774: && TREE_CHAIN (actparms) == 0); 775: #else 776: /* We assume that alloca will always be called by name. It 777: makes no sense to pass it as a pointer-to-function to 778: anything that does not understand its behavior. */ 779: may_be_alloca = 780: (name && ((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6 781: && name[0] == 'a' 782: && ! strcmp (name, "alloca")) 783: || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16 784: && name[0] == '_' 785: && ! strcmp (name, "__builtin_alloca")))); 786: #endif 787: 788: /* See if this is a call to a function that can return more than once 789: or a call to longjmp. */ 790: 791: returns_twice = 0; 792: is_longjmp = 0; 793: 794: if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15) 795: { 796: char *tname = name; 797: 1.1.1.6 ! root 798: /* Disregard prefix _, __ or __x. */ 1.1 root 799: if (name[0] == '_') 1.1.1.6 ! root 800: { ! 801: if (name[1] == '_' && name[2] == 'x') ! 802: tname += 3; ! 803: else if (name[1] == '_') ! 804: tname += 2; ! 805: else ! 806: tname += 1; ! 807: } 1.1 root 808: 809: if (tname[0] == 's') 810: { 811: returns_twice 812: = ((tname[1] == 'e' 813: && (! strcmp (tname, "setjmp") 814: || ! strcmp (tname, "setjmp_syscall"))) 815: || (tname[1] == 'i' 816: && ! strcmp (tname, "sigsetjmp")) 817: || (tname[1] == 'a' 818: && ! strcmp (tname, "savectx"))); 819: if (tname[1] == 'i' 820: && ! strcmp (tname, "siglongjmp")) 821: is_longjmp = 1; 822: } 823: else if ((tname[0] == 'q' && tname[1] == 's' 824: && ! strcmp (tname, "qsetjmp")) 825: || (tname[0] == 'v' && tname[1] == 'f' 826: && ! strcmp (tname, "vfork"))) 827: returns_twice = 1; 828: 829: else if (tname[0] == 'l' && tname[1] == 'o' 830: && ! strcmp (tname, "longjmp")) 831: is_longjmp = 1; 832: } 833: 834: if (may_be_alloca) 835: current_function_calls_alloca = 1; 836: 837: /* Don't let pending stack adjusts add up to too much. 838: Also, do all pending adjustments now 839: if there is any chance this might be a call to alloca. */ 840: 841: if (pending_stack_adjust >= 32 842: || (pending_stack_adjust > 0 && may_be_alloca)) 843: do_pending_stack_adjust (); 844: 845: /* Operand 0 is a pointer-to-function; get the type of the function. */ 846: funtype = TREE_TYPE (TREE_OPERAND (exp, 0)); 847: if (TREE_CODE (funtype) != POINTER_TYPE) 848: abort (); 849: funtype = TREE_TYPE (funtype); 850: 851: /* Push the temporary stack slot level so that we can free temporaries used 852: by each of the arguments separately. */ 853: push_temp_slots (); 854: 855: /* Start updating where the next arg would go. */ 1.1.1.5 root 856: INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX); 1.1 root 857: 858: /* If struct_value_rtx is 0, it means pass the address 859: as if it were an extra parameter. */ 860: if (structure_value_addr && struct_value_rtx == 0) 861: { 1.1.1.3 root 862: #ifdef ACCUMULATE_OUTGOING_ARGS 863: /* If the stack will be adjusted, make sure the structure address 864: does not refer to virtual_outgoing_args_rtx. */ 865: rtx temp = (stack_arg_under_construction 866: ? copy_addr_to_reg (structure_value_addr) 867: : force_reg (Pmode, structure_value_addr)); 868: #else 869: rtx temp = force_reg (Pmode, structure_value_addr); 870: #endif 871: 1.1 root 872: actparms 873: = tree_cons (error_mark_node, 874: make_tree (build_pointer_type (TREE_TYPE (funtype)), 1.1.1.3 root 875: temp), 1.1 root 876: actparms); 877: structure_value_addr_parm = 1; 878: } 879: 880: /* Count the arguments and set NUM_ACTUALS. */ 881: for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++; 882: num_actuals = i; 883: 884: /* Compute number of named args. 885: Normally, don't include the last named arg if anonymous args follow. 886: (If no anonymous args follow, the result of list_length 887: is actually one too large.) 888: 889: If SETUP_INCOMING_VARARGS is defined, this machine will be able to 890: place unnamed args that were passed in registers into the stack. So 891: treat all args as named. This allows the insns emitting for a specific 1.1.1.2 root 892: argument list to be independent of the function declaration. 1.1 root 893: 894: If SETUP_INCOMING_VARARGS is not defined, we do not have any reliable 895: way to pass unnamed args in registers, so we must force them into 896: memory. */ 897: #ifndef SETUP_INCOMING_VARARGS 898: if (TYPE_ARG_TYPES (funtype) != 0) 899: n_named_args 900: = list_length (TYPE_ARG_TYPES (funtype)) - 1 901: /* Count the struct value address, if it is passed as a parm. */ 902: + structure_value_addr_parm; 903: else 904: #endif 905: /* If we know nothing, treat all args as named. */ 906: n_named_args = num_actuals; 907: 908: /* Make a vector to hold all the information about each arg. */ 909: args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data)); 910: bzero (args, num_actuals * sizeof (struct arg_data)); 911: 912: args_size.constant = 0; 913: args_size.var = 0; 914: 915: /* In this loop, we consider args in the order they are written. 916: We fill up ARGS from the front of from the back if necessary 917: so that in any case the first arg to be pushed ends up at the front. */ 918: 919: #ifdef PUSH_ARGS_REVERSED 920: i = num_actuals - 1, inc = -1; 921: /* In this case, must reverse order of args 922: so that we compute and push the last arg first. */ 923: #else 924: i = 0, inc = 1; 925: #endif 926: 927: /* I counts args in order (to be) pushed; ARGPOS counts in order written. */ 928: for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++) 929: { 930: tree type = TREE_TYPE (TREE_VALUE (p)); 1.1.1.4 root 931: enum machine_mode mode; 1.1 root 932: 933: args[i].tree_value = TREE_VALUE (p); 934: 935: /* Replace erroneous argument with constant zero. */ 936: if (type == error_mark_node || TYPE_SIZE (type) == 0) 937: args[i].tree_value = integer_zero_node, type = integer_type_node; 938: 939: /* Decide where to pass this arg. 940: 941: args[i].reg is nonzero if all or part is passed in registers. 942: 943: args[i].partial is nonzero if part but not all is passed in registers, 944: and the exact value says how many words are passed in registers. 945: 946: args[i].pass_on_stack is nonzero if the argument must at least be 947: computed on the stack. It may then be loaded back into registers 948: if args[i].reg is nonzero. 949: 950: These decisions are driven by the FUNCTION_... macros and must agree 951: with those made by function.c. */ 952: 953: /* See if this argument should be passed by invisible reference. */ 1.1.1.6 ! root 954: if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST ! 955: && contains_placeholder_p (TYPE_SIZE (type))) ! 956: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE ! 957: || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, TYPE_MODE (type), ! 958: type, argpos < n_named_args) ! 959: #endif ! 960: ) 1.1 root 961: { 1.1.1.5 root 962: #ifdef FUNCTION_ARG_CALLEE_COPIES 963: if (FUNCTION_ARG_CALLEE_COPIES (args_so_far, TYPE_MODE (type), type, 964: argpos < n_named_args) 965: /* If it's in a register, we must make a copy of it too. */ 966: /* ??? Is this a sufficient test? Is there a better one? */ 967: && !(TREE_CODE (args[i].tree_value) == VAR_DECL 968: && REG_P (DECL_RTL (args[i].tree_value)))) 969: { 970: args[i].tree_value = build1 (ADDR_EXPR, 971: build_pointer_type (type), 972: args[i].tree_value); 973: type = build_pointer_type (type); 974: } 975: else 976: #endif 1.1 root 977: { 1.1.1.5 root 978: /* We make a copy of the object and pass the address to the 979: function being called. */ 980: rtx copy; 1.1 root 981: 1.1.1.5 root 982: if (TYPE_SIZE (type) == 0 983: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1.1 root 984: { 1.1.1.5 root 985: /* This is a variable-sized object. Make space on the stack 986: for it. */ 987: rtx size_rtx = expr_size (TREE_VALUE (p)); 988: 989: if (old_stack_level == 0) 990: { 991: emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX); 992: old_pending_adj = pending_stack_adjust; 993: pending_stack_adjust = 0; 994: } 995: 996: copy = gen_rtx (MEM, BLKmode, 997: allocate_dynamic_stack_space (size_rtx, 998: NULL_RTX, 999: TYPE_ALIGN (type))); 1000: } 1001: else 1002: { 1003: int size = int_size_in_bytes (type); 1004: copy = assign_stack_temp (TYPE_MODE (type), size, 1); 1.1 root 1005: } 1006: 1.1.1.6 ! root 1007: MEM_IN_STRUCT_P (copy) ! 1008: = (TREE_CODE (type) == RECORD_TYPE ! 1009: || TREE_CODE (type) == UNION_TYPE ! 1010: || TREE_CODE (type) == QUAL_UNION_TYPE ! 1011: || TREE_CODE (type) == ARRAY_TYPE); ! 1012: 1.1.1.5 root 1013: store_expr (args[i].tree_value, copy, 0); 1.1 root 1014: 1.1.1.5 root 1015: args[i].tree_value = build1 (ADDR_EXPR, 1016: build_pointer_type (type), 1017: make_tree (type, copy)); 1018: type = build_pointer_type (type); 1019: } 1.1 root 1020: } 1021: 1.1.1.4 root 1022: mode = TYPE_MODE (type); 1023: 1024: #ifdef PROMOTE_FUNCTION_ARGS 1025: /* Compute the mode in which the arg is actually to be extended to. */ 1026: if (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == ENUMERAL_TYPE 1027: || TREE_CODE (type) == BOOLEAN_TYPE || TREE_CODE (type) == CHAR_TYPE 1028: || TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == POINTER_TYPE 1029: || TREE_CODE (type) == OFFSET_TYPE) 1030: { 1031: int unsignedp = TREE_UNSIGNED (type); 1032: PROMOTE_MODE (mode, unsignedp, type); 1033: args[i].unsignedp = unsignedp; 1034: } 1035: #endif 1036: 1.1.1.5 root 1037: args[i].mode = mode; 1.1.1.4 root 1038: args[i].reg = FUNCTION_ARG (args_so_far, mode, type, 1.1 root 1039: argpos < n_named_args); 1040: #ifdef FUNCTION_ARG_PARTIAL_NREGS 1041: if (args[i].reg) 1042: args[i].partial 1.1.1.4 root 1043: = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, type, 1.1 root 1044: argpos < n_named_args); 1045: #endif 1046: 1.1.1.4 root 1047: args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type); 1.1 root 1048: 1049: /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that 1050: we are to pass this arg in the register(s) designated by FOO, but 1051: also to pass it in the stack. */ 1052: if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST 1053: && XEXP (args[i].reg, 0) == 0) 1054: args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1); 1055: 1056: /* If this is an addressable type, we must preallocate the stack 1057: since we must evaluate the object into its final location. 1058: 1059: If this is to be passed in both registers and the stack, it is simpler 1060: to preallocate. */ 1061: if (TREE_ADDRESSABLE (type) 1062: || (args[i].pass_on_stack && args[i].reg != 0)) 1063: must_preallocate = 1; 1064: 1065: /* If this is an addressable type, we cannot pre-evaluate it. Thus, 1066: we cannot consider this function call constant. */ 1067: if (TREE_ADDRESSABLE (type)) 1068: is_const = 0; 1069: 1070: /* Compute the stack-size of this argument. */ 1071: if (args[i].reg == 0 || args[i].partial != 0 1072: #ifdef REG_PARM_STACK_SPACE 1.1.1.3 root 1073: || reg_parm_stack_space > 0 1.1 root 1074: #endif 1075: || args[i].pass_on_stack) 1.1.1.5 root 1076: locate_and_pad_parm (mode, type, 1.1 root 1077: #ifdef STACK_PARMS_IN_REG_PARM_AREA 1078: 1, 1079: #else 1080: args[i].reg != 0, 1081: #endif 1082: fndecl, &args_size, &args[i].offset, 1083: &args[i].size); 1084: 1085: #ifndef ARGS_GROW_DOWNWARD 1086: args[i].slot_offset = args_size; 1087: #endif 1088: 1089: #ifndef REG_PARM_STACK_SPACE 1090: /* If a part of the arg was put into registers, 1091: don't include that part in the amount pushed. */ 1092: if (! args[i].pass_on_stack) 1093: args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD) 1094: / (PARM_BOUNDARY / BITS_PER_UNIT) 1095: * (PARM_BOUNDARY / BITS_PER_UNIT)); 1096: #endif 1097: 1098: /* Update ARGS_SIZE, the total stack space for args so far. */ 1099: 1100: args_size.constant += args[i].size.constant; 1101: if (args[i].size.var) 1102: { 1103: ADD_PARM_SIZE (args_size, args[i].size.var); 1104: } 1105: 1106: /* Since the slot offset points to the bottom of the slot, 1107: we must record it after incrementing if the args grow down. */ 1108: #ifdef ARGS_GROW_DOWNWARD 1109: args[i].slot_offset = args_size; 1110: 1111: args[i].slot_offset.constant = -args_size.constant; 1112: if (args_size.var) 1113: { 1114: SUB_PARM_SIZE (args[i].slot_offset, args_size.var); 1115: } 1116: #endif 1117: 1118: /* Increment ARGS_SO_FAR, which has info about which arg-registers 1119: have been used, etc. */ 1120: 1121: FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type, 1122: argpos < n_named_args); 1123: } 1124: 1.1.1.3 root 1125: #ifdef FINAL_REG_PARM_STACK_SPACE 1126: reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant, 1127: args_size.var); 1128: #endif 1129: 1.1 root 1130: /* Compute the actual size of the argument block required. The variable 1131: and constant sizes must be combined, the size may have to be rounded, 1132: and there may be a minimum required size. */ 1133: 1134: original_args_size = args_size; 1135: if (args_size.var) 1136: { 1137: /* If this function requires a variable-sized argument list, don't try to 1138: make a cse'able block for this call. We may be able to do this 1139: eventually, but it is too complicated to keep track of what insns go 1140: in the cse'able block and which don't. */ 1141: 1142: is_const = 0; 1143: must_preallocate = 1; 1144: 1145: args_size.var = ARGS_SIZE_TREE (args_size); 1146: args_size.constant = 0; 1147: 1148: #ifdef STACK_BOUNDARY 1149: if (STACK_BOUNDARY != BITS_PER_UNIT) 1150: args_size.var = round_up (args_size.var, STACK_BYTES); 1151: #endif 1152: 1153: #ifdef REG_PARM_STACK_SPACE 1.1.1.3 root 1154: if (reg_parm_stack_space > 0) 1.1 root 1155: { 1156: args_size.var 1157: = size_binop (MAX_EXPR, args_size.var, 1158: size_int (REG_PARM_STACK_SPACE (fndecl))); 1159: 1160: #ifndef OUTGOING_REG_PARM_STACK_SPACE 1161: /* The area corresponding to register parameters is not to count in 1162: the size of the block we need. So make the adjustment. */ 1163: args_size.var 1164: = size_binop (MINUS_EXPR, args_size.var, 1.1.1.3 root 1165: size_int (reg_parm_stack_space)); 1.1 root 1166: #endif 1167: } 1168: #endif 1169: } 1170: else 1171: { 1172: #ifdef STACK_BOUNDARY 1173: args_size.constant = (((args_size.constant + (STACK_BYTES - 1)) 1174: / STACK_BYTES) * STACK_BYTES); 1175: #endif 1176: 1177: #ifdef REG_PARM_STACK_SPACE 1178: args_size.constant = MAX (args_size.constant, 1.1.1.3 root 1179: reg_parm_stack_space); 1.1.1.5 root 1180: #ifdef MAYBE_REG_PARM_STACK_SPACE 1181: if (reg_parm_stack_space == 0) 1182: args_size.constant = 0; 1183: #endif 1.1 root 1184: #ifndef OUTGOING_REG_PARM_STACK_SPACE 1.1.1.3 root 1185: args_size.constant -= reg_parm_stack_space; 1.1 root 1186: #endif 1187: #endif 1188: } 1189: 1190: /* See if we have or want to preallocate stack space. 1191: 1192: If we would have to push a partially-in-regs parm 1193: before other stack parms, preallocate stack space instead. 1194: 1195: If the size of some parm is not a multiple of the required stack 1196: alignment, we must preallocate. 1197: 1198: If the total size of arguments that would otherwise create a copy in 1199: a temporary (such as a CALL) is more than half the total argument list 1200: size, preallocation is faster. 1201: 1202: Another reason to preallocate is if we have a machine (like the m88k) 1203: where stack alignment is required to be maintained between every 1204: pair of insns, not just when the call is made. However, we assume here 1205: that such machines either do not have push insns (and hence preallocation 1206: would occur anyway) or the problem is taken care of with 1207: PUSH_ROUNDING. */ 1208: 1209: if (! must_preallocate) 1210: { 1211: int partial_seen = 0; 1212: int copy_to_evaluate_size = 0; 1213: 1214: for (i = 0; i < num_actuals && ! must_preallocate; i++) 1215: { 1216: if (args[i].partial > 0 && ! args[i].pass_on_stack) 1217: partial_seen = 1; 1218: else if (partial_seen && args[i].reg == 0) 1219: must_preallocate = 1; 1220: 1221: if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode 1222: && (TREE_CODE (args[i].tree_value) == CALL_EXPR 1223: || TREE_CODE (args[i].tree_value) == TARGET_EXPR 1224: || TREE_CODE (args[i].tree_value) == COND_EXPR 1225: || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))) 1226: copy_to_evaluate_size 1227: += int_size_in_bytes (TREE_TYPE (args[i].tree_value)); 1228: } 1229: 1.1.1.3 root 1230: if (copy_to_evaluate_size * 2 >= args_size.constant 1231: && args_size.constant > 0) 1.1 root 1232: must_preallocate = 1; 1233: } 1234: 1235: /* If the structure value address will reference the stack pointer, we must 1236: stabilize it. We don't need to do this if we know that we are not going 1237: to adjust the stack pointer in processing this call. */ 1238: 1239: if (structure_value_addr 1240: && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr) 1241: || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr)) 1242: && (args_size.var 1243: #ifndef ACCUMULATE_OUTGOING_ARGS 1244: || args_size.constant 1245: #endif 1246: )) 1247: structure_value_addr = copy_to_reg (structure_value_addr); 1248: 1249: /* If this function call is cse'able, precompute all the parameters. 1250: Note that if the parameter is constructed into a temporary, this will 1251: cause an additional copy because the parameter will be constructed 1252: into a temporary location and then copied into the outgoing arguments. 1253: If a parameter contains a call to alloca and this function uses the 1254: stack, precompute the parameter. */ 1255: 1.1.1.5 root 1256: /* If we preallocated the stack space, and some arguments must be passed 1257: on the stack, then we must precompute any parameter which contains a 1258: function call which will store arguments on the stack. 1259: Otherwise, evaluating the parameter may clobber previous parameters 1260: which have already been stored into the stack. */ 1261: 1.1 root 1262: for (i = 0; i < num_actuals; i++) 1263: if (is_const 1264: || ((args_size.var != 0 || args_size.constant != 0) 1.1.1.5 root 1265: && calls_function (args[i].tree_value, 1)) 1266: || (must_preallocate && (args_size.var != 0 || args_size.constant != 0) 1267: && calls_function (args[i].tree_value, 0))) 1.1 root 1268: { 1269: args[i].initial_value = args[i].value 1.1.1.4 root 1270: = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0); 1.1.1.5 root 1271: 1272: if (GET_MODE (args[i].value ) != VOIDmode 1273: && GET_MODE (args[i].value) != args[i].mode) 1274: args[i].value = convert_to_mode (args[i].mode, args[i].value, 1275: args[i].unsignedp); 1.1 root 1276: preserve_temp_slots (args[i].value); 1.1.1.5 root 1277: 1.1 root 1278: free_temp_slots (); 1279: 1280: /* ANSI doesn't require a sequence point here, 1281: but PCC has one, so this will avoid some problems. */ 1282: emit_queue (); 1283: } 1284: 1285: /* Now we are about to start emitting insns that can be deleted 1286: if a libcall is deleted. */ 1287: if (is_const) 1288: start_sequence (); 1289: 1290: /* If we have no actual push instructions, or shouldn't use them, 1291: make space for all args right now. */ 1292: 1293: if (args_size.var != 0) 1294: { 1295: if (old_stack_level == 0) 1296: { 1.1.1.4 root 1297: emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX); 1.1 root 1298: old_pending_adj = pending_stack_adjust; 1299: pending_stack_adjust = 0; 1.1.1.3 root 1300: #ifdef ACCUMULATE_OUTGOING_ARGS 1301: /* stack_arg_under_construction says whether a stack arg is 1302: being constructed at the old stack level. Pushing the stack 1303: gets a clean outgoing argument block. */ 1304: old_stack_arg_under_construction = stack_arg_under_construction; 1305: stack_arg_under_construction = 0; 1306: #endif 1.1 root 1307: } 1308: argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0); 1309: } 1310: else if (must_preallocate) 1311: { 1312: /* Note that we must go through the motions of allocating an argument 1313: block even if the size is zero because we may be storing args 1314: in the area reserved for register arguments, which may be part of 1315: the stack frame. */ 1316: int needed = args_size.constant; 1317: 1318: #ifdef ACCUMULATE_OUTGOING_ARGS 1319: /* Store the maximum argument space used. It will be pushed by the 1320: prologue. 1321: 1322: Since the stack pointer will never be pushed, it is possible for 1323: the evaluation of a parm to clobber something we have already 1324: written to the stack. Since most function calls on RISC machines 1325: do not use the stack, this is uncommon, but must work correctly. 1326: 1327: Therefore, we save any area of the stack that was already written 1328: and that we are using. Here we set up to do this by making a new 1329: stack usage map from the old one. The actual save will be done 1330: by store_one_arg. 1331: 1332: Another approach might be to try to reorder the argument 1333: evaluations to avoid this conflicting stack usage. */ 1334: 1335: if (needed > current_function_outgoing_args_size) 1336: current_function_outgoing_args_size = needed; 1337: 1338: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) 1339: /* Since we will be writing into the entire argument area, the 1340: map must be allocated for its entire size, not just the part that 1341: is the responsibility of the caller. */ 1.1.1.3 root 1342: needed += reg_parm_stack_space; 1.1 root 1343: #endif 1344: 1345: #ifdef ARGS_GROW_DOWNWARD 1346: highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, 1347: needed + 1); 1348: #else 1349: highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed); 1350: #endif 1351: stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use); 1352: 1353: if (initial_highest_arg_in_use) 1354: bcopy (initial_stack_usage_map, stack_usage_map, 1355: initial_highest_arg_in_use); 1356: 1357: if (initial_highest_arg_in_use != highest_outgoing_arg_in_use) 1358: bzero (&stack_usage_map[initial_highest_arg_in_use], 1359: highest_outgoing_arg_in_use - initial_highest_arg_in_use); 1360: needed = 0; 1.1.1.3 root 1361: 1362: /* The address of the outgoing argument list must not be copied to a 1363: register here, because argblock would be left pointing to the 1364: wrong place after the call to allocate_dynamic_stack_space below. */ 1365: 1.1 root 1366: argblock = virtual_outgoing_args_rtx; 1.1.1.3 root 1367: 1.1 root 1368: #else /* not ACCUMULATE_OUTGOING_ARGS */ 1369: if (inhibit_defer_pop == 0) 1370: { 1371: /* Try to reuse some or all of the pending_stack_adjust 1372: to get this space. Maybe we can avoid any pushing. */ 1373: if (needed > pending_stack_adjust) 1374: { 1375: needed -= pending_stack_adjust; 1376: pending_stack_adjust = 0; 1377: } 1378: else 1379: { 1380: pending_stack_adjust -= needed; 1381: needed = 0; 1382: } 1383: } 1384: /* Special case this because overhead of `push_block' in this 1385: case is non-trivial. */ 1386: if (needed == 0) 1387: argblock = virtual_outgoing_args_rtx; 1388: else 1.1.1.4 root 1389: argblock = push_block (GEN_INT (needed), 0, 0); 1.1 root 1390: 1391: /* We only really need to call `copy_to_reg' in the case where push 1392: insns are going to be used to pass ARGBLOCK to a function 1393: call in ARGS. In that case, the stack pointer changes value 1394: from the allocation point to the call point, and hence 1395: the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well. 1396: But might as well always do it. */ 1397: argblock = copy_to_reg (argblock); 1398: #endif /* not ACCUMULATE_OUTGOING_ARGS */ 1399: } 1400: 1.1.1.3 root 1401: 1402: #ifdef ACCUMULATE_OUTGOING_ARGS 1403: /* The save/restore code in store_one_arg handles all cases except one: 1404: a constructor call (including a C function returning a BLKmode struct) 1405: to initialize an argument. */ 1406: if (stack_arg_under_construction) 1407: { 1408: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) 1.1.1.4 root 1409: rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant); 1.1.1.3 root 1410: #else 1.1.1.4 root 1411: rtx push_size = GEN_INT (args_size.constant); 1.1.1.3 root 1412: #endif 1413: if (old_stack_level == 0) 1414: { 1.1.1.4 root 1415: emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX); 1.1.1.3 root 1416: old_pending_adj = pending_stack_adjust; 1417: pending_stack_adjust = 0; 1418: /* stack_arg_under_construction says whether a stack arg is 1419: being constructed at the old stack level. Pushing the stack 1420: gets a clean outgoing argument block. */ 1421: old_stack_arg_under_construction = stack_arg_under_construction; 1422: stack_arg_under_construction = 0; 1423: /* Make a new map for the new argument list. */ 1424: stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use); 1425: bzero (stack_usage_map, highest_outgoing_arg_in_use); 1426: highest_outgoing_arg_in_use = 0; 1427: } 1.1.1.4 root 1428: allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT); 1.1.1.3 root 1429: } 1430: /* If argument evaluation might modify the stack pointer, copy the 1431: address of the argument list to a register. */ 1432: for (i = 0; i < num_actuals; i++) 1433: if (args[i].pass_on_stack) 1434: { 1435: argblock = copy_addr_to_reg (argblock); 1436: break; 1437: } 1438: #endif 1439: 1440: 1.1 root 1441: /* If we preallocated stack space, compute the address of each argument. 1442: We need not ensure it is a valid memory address here; it will be 1443: validized when it is used. */ 1444: if (argblock) 1445: { 1446: rtx arg_reg = argblock; 1447: int arg_offset = 0; 1448: 1449: if (GET_CODE (argblock) == PLUS) 1450: arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1)); 1451: 1452: for (i = 0; i < num_actuals; i++) 1453: { 1454: rtx offset = ARGS_SIZE_RTX (args[i].offset); 1455: rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset); 1456: rtx addr; 1457: 1458: /* Skip this parm if it will not be passed on the stack. */ 1459: if (! args[i].pass_on_stack && args[i].reg != 0) 1460: continue; 1461: 1462: if (GET_CODE (offset) == CONST_INT) 1463: addr = plus_constant (arg_reg, INTVAL (offset)); 1464: else 1465: addr = gen_rtx (PLUS, Pmode, arg_reg, offset); 1466: 1467: addr = plus_constant (addr, arg_offset); 1.1.1.5 root 1468: args[i].stack = gen_rtx (MEM, args[i].mode, addr); 1.1.1.6 ! root 1469: MEM_IN_STRUCT_P (args[i].stack) ! 1470: = (TREE_CODE (TREE_TYPE (args[i].tree_value)) == RECORD_TYPE ! 1471: || TREE_CODE (TREE_TYPE (args[i].tree_value)) == UNION_TYPE ! 1472: || TREE_CODE (TREE_TYPE (args[i].tree_value)) == QUAL_UNION_TYPE ! 1473: || TREE_CODE (TREE_TYPE (args[i].tree_value)) == ARRAY_TYPE); 1.1 root 1474: 1475: if (GET_CODE (slot_offset) == CONST_INT) 1476: addr = plus_constant (arg_reg, INTVAL (slot_offset)); 1477: else 1478: addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset); 1479: 1480: addr = plus_constant (addr, arg_offset); 1.1.1.5 root 1481: args[i].stack_slot = gen_rtx (MEM, args[i].mode, addr); 1.1 root 1482: } 1483: } 1484: 1485: #ifdef PUSH_ARGS_REVERSED 1486: #ifdef STACK_BOUNDARY 1487: /* If we push args individually in reverse order, perform stack alignment 1488: before the first push (the last arg). */ 1489: if (argblock == 0) 1.1.1.4 root 1490: anti_adjust_stack (GEN_INT (args_size.constant 1491: - original_args_size.constant)); 1.1 root 1492: #endif 1493: #endif 1494: 1495: /* Don't try to defer pops if preallocating, not even from the first arg, 1496: since ARGBLOCK probably refers to the SP. */ 1497: if (argblock) 1498: NO_DEFER_POP; 1499: 1500: /* Get the function to call, in the form of RTL. */ 1501: if (fndecl) 1.1.1.6 ! root 1502: { ! 1503: /* If this is the first use of the function, see if we need to ! 1504: make an external definition for it. */ ! 1505: if (! TREE_USED (fndecl)) ! 1506: { ! 1507: assemble_external (fndecl); ! 1508: TREE_USED (fndecl) = 1; ! 1509: } ! 1510: ! 1511: /* Get a SYMBOL_REF rtx for the function address. */ ! 1512: funexp = XEXP (DECL_RTL (fndecl), 0); ! 1513: } 1.1 root 1514: else 1515: /* Generate an rtx (probably a pseudo-register) for the address. */ 1516: { 1.1.1.4 root 1517: funexp = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0); 1.1 root 1518: free_temp_slots (); /* FUNEXP can't be BLKmode */ 1519: emit_queue (); 1520: } 1521: 1522: /* Figure out the register where the value, if any, will come back. */ 1523: valreg = 0; 1524: if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode 1525: && ! structure_value_addr) 1526: { 1527: if (pcc_struct_value) 1528: valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)), 1529: fndecl); 1530: else 1531: valreg = hard_function_value (TREE_TYPE (exp), fndecl); 1532: } 1533: 1534: /* Precompute all register parameters. It isn't safe to compute anything 1535: once we have started filling any specific hard regs. */ 1536: reg_parm_seen = 0; 1537: for (i = 0; i < num_actuals; i++) 1538: if (args[i].reg != 0 && ! args[i].pass_on_stack) 1539: { 1540: reg_parm_seen = 1; 1541: 1542: if (args[i].value == 0) 1543: { 1.1.1.4 root 1544: args[i].value = expand_expr (args[i].tree_value, NULL_RTX, 1545: VOIDmode, 0); 1.1 root 1546: preserve_temp_slots (args[i].value); 1547: free_temp_slots (); 1548: 1549: /* ANSI doesn't require a sequence point here, 1550: but PCC has one, so this will avoid some problems. */ 1551: emit_queue (); 1552: } 1.1.1.4 root 1553: 1554: /* If we are to promote the function arg to a wider mode, 1555: do it now. */ 1556: 1.1.1.6 ! root 1557: if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value))) ! 1558: args[i].value ! 1559: = convert_modes (args[i].mode, ! 1560: TYPE_MODE (TREE_TYPE (args[i].tree_value)), ! 1561: args[i].value, args[i].unsignedp); 1.1 root 1562: } 1563: 1564: #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE) 1565: /* The argument list is the property of the called routine and it 1566: may clobber it. If the fixed area has been used for previous 1567: parameters, we must save and restore it. 1568: 1569: Here we compute the boundary of the that needs to be saved, if any. */ 1570: 1.1.1.4 root 1571: #ifdef ARGS_GROW_DOWNWARD 1572: for (i = 0; i < reg_parm_stack_space + 1; i++) 1573: #else 1.1.1.3 root 1574: for (i = 0; i < reg_parm_stack_space; i++) 1.1.1.4 root 1575: #endif 1.1 root 1576: { 1577: if (i >= highest_outgoing_arg_in_use 1578: || stack_usage_map[i] == 0) 1579: continue; 1580: 1581: if (low_to_save == -1) 1582: low_to_save = i; 1583: 1584: high_to_save = i; 1585: } 1586: 1587: if (low_to_save >= 0) 1588: { 1589: int num_to_save = high_to_save - low_to_save + 1; 1590: enum machine_mode save_mode 1591: = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1); 1592: rtx stack_area; 1593: 1594: /* If we don't have the required alignment, must do this in BLKmode. */ 1595: if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode), 1596: BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1))) 1597: save_mode = BLKmode; 1598: 1599: stack_area = gen_rtx (MEM, save_mode, 1600: memory_address (save_mode, 1.1.1.4 root 1601: 1602: #ifdef ARGS_GROW_DOWNWARD 1603: plus_constant (argblock, 1604: - high_to_save) 1605: #else 1.1 root 1606: plus_constant (argblock, 1.1.1.4 root 1607: low_to_save) 1608: #endif 1609: )); 1.1 root 1610: if (save_mode == BLKmode) 1611: { 1612: save_area = assign_stack_temp (BLKmode, num_to_save, 1); 1613: emit_block_move (validize_mem (save_area), stack_area, 1.1.1.4 root 1614: GEN_INT (num_to_save), 1.1 root 1615: PARM_BOUNDARY / BITS_PER_UNIT); 1616: } 1617: else 1618: { 1619: save_area = gen_reg_rtx (save_mode); 1620: emit_move_insn (save_area, stack_area); 1621: } 1622: } 1623: #endif 1624: 1625: 1626: /* Now store (and compute if necessary) all non-register parms. 1627: These come before register parms, since they can require block-moves, 1628: which could clobber the registers used for register parms. 1629: Parms which have partial registers are not stored here, 1630: but we do preallocate space here if they want that. */ 1631: 1632: for (i = 0; i < num_actuals; i++) 1633: if (args[i].reg == 0 || args[i].pass_on_stack) 1634: store_one_arg (&args[i], argblock, may_be_alloca, 1.1.1.3 root 1635: args_size.var != 0, fndecl, reg_parm_stack_space); 1.1 root 1636: 1.1.1.5 root 1637: #ifdef STRICT_ALIGNMENT 1638: /* If we have a parm that is passed in registers but not in memory 1639: and whose alignment does not permit a direct copy into registers, 1640: make a group of pseudos that correspond to each register that we 1641: will later fill. */ 1642: 1643: for (i = 0; i < num_actuals; i++) 1644: if (args[i].reg != 0 && ! args[i].pass_on_stack 1645: && args[i].mode == BLKmode 1646: && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value)) 1647: < MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD))) 1648: { 1649: int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value)); 1.1.1.6 ! root 1650: int big_endian_correction = 0; 1.1.1.5 root 1651: 1652: args[i].n_aligned_regs 1653: = args[i].partial ? args[i].partial 1654: : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD; 1655: 1656: args[i].aligned_regs = (rtx *) alloca (sizeof (rtx) 1657: * args[i].n_aligned_regs); 1658: 1.1.1.6 ! root 1659: /* Structures smaller than a word are aligned to the least signifcant ! 1660: byte (to the right). On a BYTES_BIG_ENDIAN machine, this means we ! 1661: must skip the empty high order bytes when calculating the bit ! 1662: offset. */ ! 1663: if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD) ! 1664: big_endian_correction = (BITS_PER_WORD - (bytes * BITS_PER_UNIT)); ! 1665: 1.1.1.5 root 1666: for (j = 0; j < args[i].n_aligned_regs; j++) 1667: { 1668: rtx reg = gen_reg_rtx (word_mode); 1669: rtx word = operand_subword_force (args[i].value, j, BLKmode); 1670: int bitsize = TYPE_ALIGN (TREE_TYPE (args[i].tree_value)); 1671: int bitpos; 1672: 1673: args[i].aligned_regs[j] = reg; 1674: 1675: /* Clobber REG and move each partword into it. Ensure we don't 1676: go past the end of the structure. Note that the loop below 1677: works because we've already verified that padding 1678: and endianness are compatible. */ 1679: 1680: emit_insn (gen_rtx (CLOBBER, VOIDmode, reg)); 1681: 1682: for (bitpos = 0; 1683: bitpos < BITS_PER_WORD && bytes > 0; 1684: bitpos += bitsize, bytes -= bitsize / BITS_PER_UNIT) 1685: { 1.1.1.6 ! root 1686: int xbitpos = bitpos + big_endian_correction; 1.1.1.5 root 1687: 1688: store_bit_field (reg, bitsize, xbitpos, word_mode, 1.1.1.6 ! root 1689: extract_bit_field (word, bitsize, bitpos, 1, 1.1.1.5 root 1690: NULL_RTX, word_mode, 1691: word_mode, 1692: bitsize / BITS_PER_UNIT, 1693: BITS_PER_WORD), 1694: bitsize / BITS_PER_UNIT, BITS_PER_WORD); 1695: } 1696: } 1697: } 1698: #endif 1699: 1.1 root 1700: /* Now store any partially-in-registers parm. 1701: This is the last place a block-move can happen. */ 1702: if (reg_parm_seen) 1703: for (i = 0; i < num_actuals; i++) 1704: if (args[i].partial != 0 && ! args[i].pass_on_stack) 1705: store_one_arg (&args[i], argblock, may_be_alloca, 1.1.1.3 root 1706: args_size.var != 0, fndecl, reg_parm_stack_space); 1.1 root 1707: 1708: #ifndef PUSH_ARGS_REVERSED 1709: #ifdef STACK_BOUNDARY 1710: /* If we pushed args in forward order, perform stack alignment 1711: after pushing the last arg. */ 1712: if (argblock == 0) 1.1.1.4 root 1713: anti_adjust_stack (GEN_INT (args_size.constant 1714: - original_args_size.constant)); 1.1 root 1715: #endif 1716: #endif 1717: 1.1.1.3 root 1718: /* If register arguments require space on the stack and stack space 1719: was not preallocated, allocate stack space here for arguments 1720: passed in registers. */ 1.1.1.6 ! root 1721: #if ! defined(ACCUMULATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE) 1.1.1.3 root 1722: if (must_preallocate == 0 && reg_parm_stack_space > 0) 1.1.1.4 root 1723: anti_adjust_stack (GEN_INT (reg_parm_stack_space)); 1.1.1.3 root 1724: #endif 1725: 1.1 root 1726: /* Pass the function the address in which to return a structure value. */ 1727: if (structure_value_addr && ! structure_value_addr_parm) 1728: { 1729: emit_move_insn (struct_value_rtx, 1730: force_reg (Pmode, 1.1.1.4 root 1731: force_operand (structure_value_addr, 1732: NULL_RTX))); 1.1 root 1733: if (GET_CODE (struct_value_rtx) == REG) 1734: { 1735: push_to_sequence (use_insns); 1736: emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx)); 1737: use_insns = get_insns (); 1738: end_sequence (); 1739: } 1740: } 1741: 1742: /* Now do the register loads required for any wholly-register parms or any 1743: parms which are passed both on the stack and in a register. Their 1744: expressions were already evaluated. 1745: 1746: Mark all register-parms as living through the call, putting these USE 1747: insns in a list headed by USE_INSNS. */ 1748: 1749: for (i = 0; i < num_actuals; i++) 1750: { 1751: rtx list = args[i].reg; 1752: int partial = args[i].partial; 1753: 1754: while (list) 1755: { 1756: rtx reg; 1757: int nregs; 1758: 1759: /* Process each register that needs to get this arg. */ 1760: if (GET_CODE (list) == EXPR_LIST) 1761: reg = XEXP (list, 0), list = XEXP (list, 1); 1762: else 1763: reg = list, list = 0; 1764: 1765: /* Set to non-zero if must move a word at a time, even if just one 1766: word (e.g, partial == 1 && mode == DFmode). Set to zero if 1767: we just use a normal move insn. */ 1768: nregs = (partial ? partial 1769: : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode 1770: ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value)) 1771: + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD) 1772: : 0)); 1773: 1774: /* If simple case, just do move. If normal partial, store_one_arg 1775: has already loaded the register for us. In all other cases, 1776: load the register(s) from memory. */ 1777: 1778: if (nregs == 0) 1779: emit_move_insn (reg, args[i].value); 1.1.1.5 root 1780: 1781: #ifdef STRICT_ALIGNMENT 1782: /* If we have pre-computed the values to put in the registers in 1783: the case of non-aligned structures, copy them in now. */ 1784: 1785: else if (args[i].n_aligned_regs != 0) 1786: for (j = 0; j < args[i].n_aligned_regs; j++) 1787: emit_move_insn (gen_rtx (REG, word_mode, REGNO (reg) + j), 1788: args[i].aligned_regs[j]); 1789: #endif 1790: 1.1 root 1791: else if (args[i].partial == 0 || args[i].pass_on_stack) 1792: move_block_to_reg (REGNO (reg), 1793: validize_mem (args[i].value), nregs, 1.1.1.5 root 1794: args[i].mode); 1.1 root 1795: 1796: push_to_sequence (use_insns); 1797: if (nregs == 0) 1798: emit_insn (gen_rtx (USE, VOIDmode, reg)); 1799: else 1800: use_regs (REGNO (reg), nregs); 1801: use_insns = get_insns (); 1802: end_sequence (); 1803: 1804: /* PARTIAL referred only to the first register, so clear it for the 1805: next time. */ 1806: partial = 0; 1807: } 1808: } 1809: 1810: /* Perform postincrements before actually calling the function. */ 1811: emit_queue (); 1812: 1813: /* All arguments and registers used for the call must be set up by now! */ 1814: 1815: funexp = prepare_call_address (funexp, fndecl, &use_insns); 1816: 1817: /* Generate the actual call instruction. */ 1818: emit_call_1 (funexp, funtype, args_size.constant, struct_value_size, 1819: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), 1820: valreg, old_inhibit_defer_pop, use_insns, is_const); 1821: 1822: /* If call is cse'able, make appropriate pair of reg-notes around it. 1823: Test valreg so we don't crash; may safely ignore `const' 1824: if return type is void. */ 1825: if (is_const && valreg != 0) 1826: { 1827: rtx note = 0; 1828: rtx temp = gen_reg_rtx (GET_MODE (valreg)); 1829: rtx insns; 1830: 1831: /* Construct an "equal form" for the value which mentions all the 1832: arguments in order as well as the function name. */ 1833: #ifdef PUSH_ARGS_REVERSED 1834: for (i = 0; i < num_actuals; i++) 1835: note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note); 1836: #else 1837: for (i = num_actuals - 1; i >= 0; i--) 1838: note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note); 1839: #endif 1840: note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note); 1841: 1842: insns = get_insns (); 1843: end_sequence (); 1844: 1845: emit_libcall_block (insns, temp, valreg, note); 1846: 1847: valreg = temp; 1848: } 1849: 1850: /* For calls to `setjmp', etc., inform flow.c it should complain 1851: if nonvolatile values are live. */ 1852: 1853: if (returns_twice) 1854: { 1855: emit_note (name, NOTE_INSN_SETJMP); 1856: current_function_calls_setjmp = 1; 1857: } 1858: 1859: if (is_longjmp) 1860: current_function_calls_longjmp = 1; 1861: 1862: /* Notice functions that cannot return. 1863: If optimizing, insns emitted below will be dead. 1864: If not optimizing, they will exist, which is useful 1865: if the user uses the `return' command in the debugger. */ 1866: 1867: if (is_volatile || is_longjmp) 1868: emit_barrier (); 1869: 1870: /* If value type not void, return an rtx for the value. */ 1871: 1872: /* If there are cleanups to be called, don't use a hard reg as target. */ 1873: if (cleanups_this_call != old_cleanups 1874: && target && REG_P (target) 1875: && REGNO (target) < FIRST_PSEUDO_REGISTER) 1876: target = 0; 1877: 1878: if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode 1879: || ignore) 1880: { 1881: target = const0_rtx; 1882: } 1883: else if (structure_value_addr) 1884: { 1885: if (target == 0 || GET_CODE (target) != MEM) 1.1.1.3 root 1886: { 1887: target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), 1888: memory_address (TYPE_MODE (TREE_TYPE (exp)), 1889: structure_value_addr)); 1890: MEM_IN_STRUCT_P (target) 1891: = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE 1892: || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE 1.1.1.5 root 1893: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE 1894: || TREE_CODE (TREE_TYPE (exp)) == QUAL_UNION_TYPE); 1.1.1.3 root 1895: } 1.1 root 1896: } 1897: else if (pcc_struct_value) 1898: { 1899: if (target == 0) 1.1.1.3 root 1900: { 1.1.1.5 root 1901: /* We used leave the value in the location that it is 1902: returned in, but that causes problems if it is used more 1903: than once in one expression. Rather than trying to track 1904: when a copy is required, we always copy when TARGET is 1905: not specified. This calling sequence is only used on 1906: a few machines and TARGET is usually nonzero. */ 1907: if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode) 1908: { 1909: target = assign_stack_temp (BLKmode, 1910: int_size_in_bytes (TREE_TYPE (exp)), 1911: 0); 1912: 1913: /* Save this temp slot around the pop below. */ 1914: preserve_temp_slots (target); 1915: } 1916: else 1917: target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp))); 1.1.1.3 root 1918: } 1.1.1.5 root 1919: 1920: if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode) 1.1 root 1921: emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), 1922: copy_to_reg (valreg))); 1923: else 1924: emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)), 1925: expr_size (exp), 1926: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT); 1927: } 1.1.1.4 root 1928: else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp)) 1929: && GET_MODE (target) == GET_MODE (valreg)) 1.1 root 1930: /* TARGET and VALREG cannot be equal at this point because the latter 1931: would not have REG_FUNCTION_VALUE_P true, while the former would if 1932: it were referring to the same register. 1933: 1934: If they refer to the same register, this move will be a no-op, except 1935: when function inlining is being done. */ 1936: emit_move_insn (target, valreg); 1937: else 1938: target = copy_to_reg (valreg); 1939: 1.1.1.4 root 1940: #ifdef PROMOTE_FUNCTION_RETURN 1.1.1.5 root 1941: /* If we promoted this return value, make the proper SUBREG. TARGET 1942: might be const0_rtx here, so be careful. */ 1943: if (GET_CODE (target) == REG 1944: && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))) 1.1.1.4 root 1945: { 1.1.1.5 root 1946: enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); 1.1.1.4 root 1947: int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp)); 1948: 1949: if (TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE 1950: || TREE_CODE (TREE_TYPE (exp)) == ENUMERAL_TYPE 1951: || TREE_CODE (TREE_TYPE (exp)) == BOOLEAN_TYPE 1952: || TREE_CODE (TREE_TYPE (exp)) == CHAR_TYPE 1953: || TREE_CODE (TREE_TYPE (exp)) == REAL_TYPE 1954: || TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE 1955: || TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE) 1956: { 1957: PROMOTE_MODE (mode, unsignedp, TREE_TYPE (exp)); 1958: } 1959: 1.1.1.5 root 1960: /* If we didn't promote as expected, something is wrong. */ 1961: if (mode != GET_MODE (target)) 1962: abort (); 1963: 1.1.1.4 root 1964: target = gen_rtx (SUBREG, TYPE_MODE (TREE_TYPE (exp)), target, 0); 1965: SUBREG_PROMOTED_VAR_P (target) = 1; 1966: SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp; 1967: } 1968: #endif 1969: 1.1 root 1970: /* Perform all cleanups needed for the arguments of this call 1971: (i.e. destructors in C++). */ 1972: expand_cleanups_to (old_cleanups); 1973: 1.1.1.3 root 1974: /* If size of args is variable or this was a constructor call for a stack 1975: argument, restore saved stack-pointer value. */ 1.1 root 1976: 1977: if (old_stack_level) 1978: { 1.1.1.4 root 1979: emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX); 1.1 root 1980: pending_stack_adjust = old_pending_adj; 1.1.1.3 root 1981: #ifdef ACCUMULATE_OUTGOING_ARGS 1982: stack_arg_under_construction = old_stack_arg_under_construction; 1983: highest_outgoing_arg_in_use = initial_highest_arg_in_use; 1984: stack_usage_map = initial_stack_usage_map; 1985: #endif 1.1 root 1986: } 1987: #ifdef ACCUMULATE_OUTGOING_ARGS 1988: else 1989: { 1990: #ifdef REG_PARM_STACK_SPACE 1991: if (save_area) 1992: { 1993: enum machine_mode save_mode = GET_MODE (save_area); 1994: rtx stack_area 1995: = gen_rtx (MEM, save_mode, 1996: memory_address (save_mode, 1.1.1.4 root 1997: #ifdef ARGS_GROW_DOWNWARD 1998: plus_constant (argblock, - high_to_save) 1999: #else 2000: plus_constant (argblock, low_to_save) 2001: #endif 2002: )); 1.1 root 2003: 2004: if (save_mode != BLKmode) 2005: emit_move_insn (stack_area, save_area); 2006: else 2007: emit_block_move (stack_area, validize_mem (save_area), 1.1.1.4 root 2008: GEN_INT (high_to_save - low_to_save + 1), 2009: PARM_BOUNDARY / BITS_PER_UNIT); 1.1 root 2010: } 2011: #endif 2012: 2013: /* If we saved any argument areas, restore them. */ 2014: for (i = 0; i < num_actuals; i++) 2015: if (args[i].save_area) 2016: { 2017: enum machine_mode save_mode = GET_MODE (args[i].save_area); 2018: rtx stack_area 2019: = gen_rtx (MEM, save_mode, 2020: memory_address (save_mode, 2021: XEXP (args[i].stack_slot, 0))); 2022: 2023: if (save_mode != BLKmode) 2024: emit_move_insn (stack_area, args[i].save_area); 2025: else 2026: emit_block_move (stack_area, validize_mem (args[i].save_area), 1.1.1.4 root 2027: GEN_INT (args[i].size.constant), 1.1 root 2028: PARM_BOUNDARY / BITS_PER_UNIT); 2029: } 2030: 2031: highest_outgoing_arg_in_use = initial_highest_arg_in_use; 2032: stack_usage_map = initial_stack_usage_map; 2033: } 2034: #endif 2035: 1.1.1.3 root 2036: /* If this was alloca, record the new stack level for nonlocal gotos. 2037: Check for the handler slots since we might not have a save area 2038: for non-local gotos. */ 2039: 2040: if (may_be_alloca && nonlocal_goto_handler_slot != 0) 1.1.1.4 root 2041: emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX); 1.1 root 2042: 2043: pop_temp_slots (); 2044: 2045: return target; 2046: } 2047: 1.1.1.5 root 2048: /* Output a library call to function FUN (a SYMBOL_REF rtx) 2049: (emitting the queue unless NO_QUEUE is nonzero), 2050: for a value of mode OUTMODE, 2051: with NARGS different arguments, passed as alternating rtx values 2052: and machine_modes to convert them to. 2053: The rtx values should have been passed through protect_from_queue already. 2054: 2055: NO_QUEUE will be true if and only if the library call is a `const' call 2056: which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent 2057: to the variable is_const in expand_call. 2058: 2059: NO_QUEUE must be true for const calls, because if it isn't, then 2060: any pending increment will be emitted between REG_LIBCALL/REG_RETVAL notes, 2061: and will be lost if the libcall sequence is optimized away. 2062: 2063: NO_QUEUE must be false for non-const calls, because if it isn't, the 2064: call insn will have its CONST_CALL_P bit set, and it will be incorrectly 2065: optimized. For instance, the instruction scheduler may incorrectly 2066: move memory references across the non-const call. */ 2067: 2068: void 2069: emit_library_call (va_alist) 2070: va_dcl 2071: { 2072: va_list p; 2073: /* Total size in bytes of all the stack-parms scanned so far. */ 2074: struct args_size args_size; 2075: /* Size of arguments before any adjustments (such as rounding). */ 2076: struct args_size original_args_size; 2077: register int argnum; 2078: enum machine_mode outmode; 2079: int nargs; 2080: rtx fun; 2081: rtx orgfun; 2082: int inc; 2083: int count; 2084: rtx argblock = 0; 2085: CUMULATIVE_ARGS args_so_far; 2086: struct arg { rtx value; enum machine_mode mode; rtx reg; int partial; 2087: struct args_size offset; struct args_size size; }; 2088: struct arg *argvec; 2089: int old_inhibit_defer_pop = inhibit_defer_pop; 2090: int no_queue = 0; 2091: rtx use_insns; 2092: /* library calls are never indirect calls. */ 2093: int current_call_is_indirect = 0; 2094: 2095: va_start (p); 2096: orgfun = fun = va_arg (p, rtx); 2097: no_queue = va_arg (p, int); 2098: outmode = va_arg (p, enum machine_mode); 2099: nargs = va_arg (p, int); 2100: 2101: /* Copy all the libcall-arguments out of the varargs data 2102: and into a vector ARGVEC. 2103: 2104: Compute how to pass each argument. We only support a very small subset 2105: of the full argument passing conventions to limit complexity here since 2106: library functions shouldn't have many args. */ 2107: 2108: argvec = (struct arg *) alloca (nargs * sizeof (struct arg)); 2109: 2110: INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun); 2111: 2112: args_size.constant = 0; 2113: args_size.var = 0; 2114: 1.1.1.6 ! root 2115: push_temp_slots (); ! 2116: 1.1.1.5 root 2117: for (count = 0; count < nargs; count++) 2118: { 2119: rtx val = va_arg (p, rtx); 2120: enum machine_mode mode = va_arg (p, enum machine_mode); 2121: 2122: /* We cannot convert the arg value to the mode the library wants here; 2123: must do it earlier where we know the signedness of the arg. */ 2124: if (mode == BLKmode 2125: || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode)) 2126: abort (); 2127: 2128: /* On some machines, there's no way to pass a float to a library fcn. 2129: Pass it as a double instead. */ 2130: #ifdef LIBGCC_NEEDS_DOUBLE 2131: if (LIBGCC_NEEDS_DOUBLE && mode == SFmode) 2132: val = convert_to_mode (DFmode, val, 0), mode = DFmode; 2133: #endif 2134: 2135: /* There's no need to call protect_from_queue, because 2136: either emit_move_insn or emit_push_insn will do that. */ 2137: 2138: /* Make sure it is a reasonable operand for a move or push insn. */ 2139: if (GET_CODE (val) != REG && GET_CODE (val) != MEM 2140: && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val))) 2141: val = force_operand (val, NULL_RTX); 2142: 2143: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE 2144: if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1)) 1.1.1.6 ! root 2145: { ! 2146: /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can ! 2147: be viewed as just an efficiency improvement. */ ! 2148: rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0); ! 2149: emit_move_insn (slot, val); ! 2150: val = XEXP (slot, 0); ! 2151: mode = Pmode; ! 2152: } 1.1.1.5 root 2153: #endif 2154: 1.1.1.6 ! root 2155: argvec[count].value = val; ! 2156: argvec[count].mode = mode; ! 2157: 1.1.1.5 root 2158: argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1); 2159: if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST) 2160: abort (); 2161: #ifdef FUNCTION_ARG_PARTIAL_NREGS 2162: argvec[count].partial 2163: = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1); 2164: #else 2165: argvec[count].partial = 0; 2166: #endif 2167: 2168: locate_and_pad_parm (mode, NULL_TREE, 2169: argvec[count].reg && argvec[count].partial == 0, 2170: NULL_TREE, &args_size, &argvec[count].offset, 2171: &argvec[count].size); 2172: 2173: if (argvec[count].size.var) 2174: abort (); 2175: 2176: #ifndef REG_PARM_STACK_SPACE 2177: if (argvec[count].partial) 2178: argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD; 2179: #endif 2180: 2181: if (argvec[count].reg == 0 || argvec[count].partial != 0 2182: #ifdef REG_PARM_STACK_SPACE 2183: || 1 2184: #endif 2185: ) 2186: args_size.constant += argvec[count].size.constant; 2187: 2188: #ifdef ACCUMULATE_OUTGOING_ARGS 2189: /* If this arg is actually passed on the stack, it might be 2190: clobbering something we already put there (this library call might 2191: be inside the evaluation of an argument to a function whose call 2192: requires the stack). This will only occur when the library call 2193: has sufficient args to run out of argument registers. Abort in 2194: this case; if this ever occurs, code must be added to save and 2195: restore the arg slot. */ 2196: 2197: if (argvec[count].reg == 0 || argvec[count].partial != 0) 2198: abort (); 2199: #endif 2200: 2201: FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1); 2202: } 2203: va_end (p); 2204: 2205: /* If this machine requires an external definition for library 2206: functions, write one out. */ 2207: assemble_external_libcall (fun); 2208: 2209: original_args_size = args_size; 2210: #ifdef STACK_BOUNDARY 2211: args_size.constant = (((args_size.constant + (STACK_BYTES - 1)) 2212: / STACK_BYTES) * STACK_BYTES); 2213: #endif 2214: 2215: #ifdef REG_PARM_STACK_SPACE 2216: args_size.constant = MAX (args_size.constant, 2217: REG_PARM_STACK_SPACE (NULL_TREE)); 2218: #ifndef OUTGOING_REG_PARM_STACK_SPACE 2219: args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE); 2220: #endif 2221: #endif 2222: 2223: #ifdef ACCUMULATE_OUTGOING_ARGS 2224: if (args_size.constant > current_function_outgoing_args_size) 2225: current_function_outgoing_args_size = args_size.constant; 2226: args_size.constant = 0; 2227: #endif 2228: 2229: #ifndef PUSH_ROUNDING 2230: argblock = push_block (GEN_INT (args_size.constant), 0, 0); 2231: #endif 2232: 2233: #ifdef PUSH_ARGS_REVERSED 2234: #ifdef STACK_BOUNDARY 2235: /* If we push args individually in reverse order, perform stack alignment 2236: before the first push (the last arg). */ 2237: if (argblock == 0) 2238: anti_adjust_stack (GEN_INT (args_size.constant 2239: - original_args_size.constant)); 2240: #endif 2241: #endif 2242: 2243: #ifdef PUSH_ARGS_REVERSED 2244: inc = -1; 2245: argnum = nargs - 1; 2246: #else 2247: inc = 1; 2248: argnum = 0; 2249: #endif 2250: 2251: /* Push the args that need to be pushed. */ 2252: 2253: for (count = 0; count < nargs; count++, argnum += inc) 2254: { 2255: register enum machine_mode mode = argvec[argnum].mode; 2256: register rtx val = argvec[argnum].value; 2257: rtx reg = argvec[argnum].reg; 2258: int partial = argvec[argnum].partial; 2259: 2260: if (! (reg != 0 && partial == 0)) 2261: emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0, 2262: argblock, GEN_INT (argvec[count].offset.constant)); 2263: NO_DEFER_POP; 2264: } 2265: 2266: #ifndef PUSH_ARGS_REVERSED 2267: #ifdef STACK_BOUNDARY 2268: /* If we pushed args in forward order, perform stack alignment 2269: after pushing the last arg. */ 2270: if (argblock == 0) 2271: anti_adjust_stack (GEN_INT (args_size.constant 2272: - original_args_size.constant)); 2273: #endif 2274: #endif 2275: 2276: #ifdef PUSH_ARGS_REVERSED 2277: argnum = nargs - 1; 2278: #else 2279: argnum = 0; 2280: #endif 2281: 2282: /* Now load any reg parms into their regs. */ 2283: 2284: for (count = 0; count < nargs; count++, argnum += inc) 2285: { 2286: register enum machine_mode mode = argvec[argnum].mode; 2287: register rtx val = argvec[argnum].value; 2288: rtx reg = argvec[argnum].reg; 2289: int partial = argvec[argnum].partial; 2290: 2291: if (reg != 0 && partial == 0) 2292: emit_move_insn (reg, val); 2293: NO_DEFER_POP; 2294: } 2295: 2296: /* For version 1.37, try deleting this entirely. */ 2297: if (! no_queue) 2298: emit_queue (); 2299: 2300: /* Any regs containing parms remain in use through the call. */ 2301: start_sequence (); 2302: for (count = 0; count < nargs; count++) 2303: if (argvec[count].reg != 0) 2304: emit_insn (gen_rtx (USE, VOIDmode, argvec[count].reg)); 2305: 2306: use_insns = get_insns (); 2307: end_sequence (); 2308: 2309: fun = prepare_call_address (fun, NULL_TREE, &use_insns); 2310: 2311: /* Don't allow popping to be deferred, since then 2312: cse'ing of library calls could delete a call and leave the pop. */ 2313: NO_DEFER_POP; 2314: 2315: /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which 2316: will set inhibit_defer_pop to that value. */ 2317: 2318: emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), args_size.constant, 0, 2319: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), 2320: outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX, 2321: old_inhibit_defer_pop + 1, use_insns, no_queue); 2322: 1.1.1.6 ! root 2323: pop_temp_slots (); ! 2324: 1.1.1.5 root 2325: /* Now restore inhibit_defer_pop to its actual original value. */ 2326: OK_DEFER_POP; 2327: } 2328: 2329: /* Like emit_library_call except that an extra argument, VALUE, 2330: comes second and says where to store the result. 1.1.1.6 ! root 2331: (If VALUE is zero, this function chooses a convenient way ! 2332: to return the value. 1.1.1.5 root 2333: 1.1.1.6 ! root 2334: This function returns an rtx for where the value is to be found. ! 2335: If VALUE is nonzero, VALUE is returned. */ ! 2336: ! 2337: rtx 1.1.1.5 root 2338: emit_library_call_value (va_alist) 2339: va_dcl 2340: { 2341: va_list p; 2342: /* Total size in bytes of all the stack-parms scanned so far. */ 2343: struct args_size args_size; 2344: /* Size of arguments before any adjustments (such as rounding). */ 2345: struct args_size original_args_size; 2346: register int argnum; 2347: enum machine_mode outmode; 2348: int nargs; 2349: rtx fun; 2350: rtx orgfun; 2351: int inc; 2352: int count; 2353: rtx argblock = 0; 2354: CUMULATIVE_ARGS args_so_far; 2355: struct arg { rtx value; enum machine_mode mode; rtx reg; int partial; 2356: struct args_size offset; struct args_size size; }; 2357: struct arg *argvec; 2358: int old_inhibit_defer_pop = inhibit_defer_pop; 2359: int no_queue = 0; 2360: rtx use_insns; 2361: rtx value; 2362: rtx mem_value = 0; 1.1.1.6 ! root 2363: int pcc_struct_value = 0; ! 2364: int struct_value_size = 0; 1.1.1.5 root 2365: /* library calls are never indirect calls. */ 2366: int current_call_is_indirect = 0; 2367: 2368: va_start (p); 2369: orgfun = fun = va_arg (p, rtx); 2370: value = va_arg (p, rtx); 2371: no_queue = va_arg (p, int); 2372: outmode = va_arg (p, enum machine_mode); 2373: nargs = va_arg (p, int); 2374: 2375: /* If this kind of value comes back in memory, 2376: decide where in memory it should come back. */ 1.1.1.6 ! root 2377: if (aggregate_value_p (type_for_mode (outmode, 0))) 1.1.1.5 root 2378: { 1.1.1.6 ! root 2379: #ifdef PCC_STATIC_STRUCT_RETURN ! 2380: rtx pointer_reg ! 2381: = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)), ! 2382: 0); ! 2383: mem_value = gen_rtx (MEM, outmode, pointer_reg); ! 2384: pcc_struct_value = 1; ! 2385: if (value == 0) ! 2386: value = gen_reg_rtx (outmode); ! 2387: #else /* not PCC_STATIC_STRUCT_RETURN */ ! 2388: struct_value_size = GET_MODE_SIZE (outmode); ! 2389: if (value != 0 && GET_CODE (value) == MEM) 1.1.1.5 root 2390: mem_value = value; 2391: else 2392: mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0); 1.1.1.6 ! root 2393: #endif 1.1.1.5 root 2394: } 2395: 2396: /* ??? Unfinished: must pass the memory address as an argument. */ 2397: 2398: /* Copy all the libcall-arguments out of the varargs data 2399: and into a vector ARGVEC. 2400: 2401: Compute how to pass each argument. We only support a very small subset 2402: of the full argument passing conventions to limit complexity here since 2403: library functions shouldn't have many args. */ 2404: 2405: argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg)); 2406: 2407: INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun); 2408: 2409: args_size.constant = 0; 2410: args_size.var = 0; 2411: 2412: count = 0; 2413: 1.1.1.6 ! root 2414: push_temp_slots (); ! 2415: 1.1.1.5 root 2416: /* If there's a structure value address to be passed, 2417: either pass it in the special place, or pass it as an extra argument. */ 1.1.1.6 ! root 2418: if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value) 1.1.1.5 root 2419: { 2420: rtx addr = XEXP (mem_value, 0); 1.1.1.6 ! root 2421: nargs++; 1.1.1.5 root 2422: 1.1.1.6 ! root 2423: /* Make sure it is a reasonable operand for a move or push insn. */ ! 2424: if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM ! 2425: && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr))) ! 2426: addr = force_operand (addr, NULL_RTX); 1.1.1.5 root 2427: 1.1.1.6 ! root 2428: argvec[count].value = addr; ! 2429: argvec[count].mode = Pmode; ! 2430: argvec[count].partial = 0; 1.1.1.5 root 2431: 1.1.1.6 ! root 2432: argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1); 1.1.1.5 root 2433: #ifdef FUNCTION_ARG_PARTIAL_NREGS 1.1.1.6 ! root 2434: if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1)) ! 2435: abort (); 1.1.1.5 root 2436: #endif 2437: 1.1.1.6 ! root 2438: locate_and_pad_parm (Pmode, NULL_TREE, ! 2439: argvec[count].reg && argvec[count].partial == 0, ! 2440: NULL_TREE, &args_size, &argvec[count].offset, ! 2441: &argvec[count].size); 1.1.1.5 root 2442: 2443: 1.1.1.6 ! root 2444: if (argvec[count].reg == 0 || argvec[count].partial != 0 1.1.1.5 root 2445: #ifdef REG_PARM_STACK_SPACE 1.1.1.6 ! root 2446: || 1 1.1.1.5 root 2447: #endif 1.1.1.6 ! root 2448: ) ! 2449: args_size.constant += argvec[count].size.constant; 1.1.1.5 root 2450: 1.1.1.6 ! root 2451: FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree)0, 1); ! 2452: ! 2453: count++; 1.1.1.5 root 2454: } 2455: 2456: for (; count < nargs; count++) 2457: { 2458: rtx val = va_arg (p, rtx); 2459: enum machine_mode mode = va_arg (p, enum machine_mode); 2460: 2461: /* We cannot convert the arg value to the mode the library wants here; 2462: must do it earlier where we know the signedness of the arg. */ 2463: if (mode == BLKmode 2464: || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode)) 2465: abort (); 2466: 2467: /* On some machines, there's no way to pass a float to a library fcn. 2468: Pass it as a double instead. */ 2469: #ifdef LIBGCC_NEEDS_DOUBLE 2470: if (LIBGCC_NEEDS_DOUBLE && mode == SFmode) 2471: val = convert_to_mode (DFmode, val, 0), mode = DFmode; 2472: #endif 2473: 2474: /* There's no need to call protect_from_queue, because 2475: either emit_move_insn or emit_push_insn will do that. */ 2476: 2477: /* Make sure it is a reasonable operand for a move or push insn. */ 2478: if (GET_CODE (val) != REG && GET_CODE (val) != MEM 2479: && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val))) 2480: val = force_operand (val, NULL_RTX); 2481: 2482: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE 2483: if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1)) 1.1.1.6 ! root 2484: { ! 2485: /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can ! 2486: be viewed as just an efficiency improvement. */ ! 2487: rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0); ! 2488: emit_move_insn (slot, val); ! 2489: val = XEXP (slot, 0); ! 2490: mode = Pmode; ! 2491: } 1.1.1.5 root 2492: #endif 2493: 1.1.1.6 ! root 2494: argvec[count].value = val; ! 2495: argvec[count].mode = mode; ! 2496: 1.1.1.5 root 2497: argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1); 2498: if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST) 2499: abort (); 2500: #ifdef FUNCTION_ARG_PARTIAL_NREGS 2501: argvec[count].partial 2502: = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1); 2503: #else 2504: argvec[count].partial = 0; 2505: #endif 2506: 2507: locate_and_pad_parm (mode, NULL_TREE, 2508: argvec[count].reg && argvec[count].partial == 0, 2509: NULL_TREE, &args_size, &argvec[count].offset, 2510: &argvec[count].size); 2511: 2512: if (argvec[count].size.var) 2513: abort (); 2514: 2515: #ifndef REG_PARM_STACK_SPACE 2516: if (argvec[count].partial) 2517: argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD; 2518: #endif 2519: 2520: if (argvec[count].reg == 0 || argvec[count].partial != 0 2521: #ifdef REG_PARM_STACK_SPACE 2522: || 1 2523: #endif 2524: ) 2525: args_size.constant += argvec[count].size.constant; 2526: 2527: #ifdef ACCUMULATE_OUTGOING_ARGS 2528: /* If this arg is actually passed on the stack, it might be 2529: clobbering something we already put there (this library call might 2530: be inside the evaluation of an argument to a function whose call 2531: requires the stack). This will only occur when the library call 2532: has sufficient args to run out of argument registers. Abort in 2533: this case; if this ever occurs, code must be added to save and 2534: restore the arg slot. */ 2535: 2536: if (argvec[count].reg == 0 || argvec[count].partial != 0) 2537: abort (); 2538: #endif 2539: 2540: FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1); 2541: } 2542: va_end (p); 2543: 2544: /* If this machine requires an external definition for library 2545: functions, write one out. */ 2546: assemble_external_libcall (fun); 2547: 2548: original_args_size = args_size; 2549: #ifdef STACK_BOUNDARY 2550: args_size.constant = (((args_size.constant + (STACK_BYTES - 1)) 2551: / STACK_BYTES) * STACK_BYTES); 2552: #endif 2553: 2554: #ifdef REG_PARM_STACK_SPACE 2555: args_size.constant = MAX (args_size.constant, 2556: REG_PARM_STACK_SPACE (NULL_TREE)); 2557: #ifndef OUTGOING_REG_PARM_STACK_SPACE 2558: args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE); 2559: #endif 2560: #endif 2561: 2562: #ifdef ACCUMULATE_OUTGOING_ARGS 2563: if (args_size.constant > current_function_outgoing_args_size) 2564: current_function_outgoing_args_size = args_size.constant; 2565: args_size.constant = 0; 2566: #endif 2567: 2568: #ifndef PUSH_ROUNDING 2569: argblock = push_block (GEN_INT (args_size.constant), 0, 0); 2570: #endif 2571: 2572: #ifdef PUSH_ARGS_REVERSED 2573: #ifdef STACK_BOUNDARY 2574: /* If we push args individually in reverse order, perform stack alignment 2575: before the first push (the last arg). */ 2576: if (argblock == 0) 2577: anti_adjust_stack (GEN_INT (args_size.constant 2578: - original_args_size.constant)); 2579: #endif 2580: #endif 2581: 2582: #ifdef PUSH_ARGS_REVERSED 2583: inc = -1; 2584: argnum = nargs - 1; 2585: #else 2586: inc = 1; 2587: argnum = 0; 2588: #endif 2589: 2590: /* Push the args that need to be pushed. */ 2591: 2592: for (count = 0; count < nargs; count++, argnum += inc) 2593: { 2594: register enum machine_mode mode = argvec[argnum].mode; 2595: register rtx val = argvec[argnum].value; 2596: rtx reg = argvec[argnum].reg; 2597: int partial = argvec[argnum].partial; 2598: 2599: if (! (reg != 0 && partial == 0)) 2600: emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0, 2601: argblock, GEN_INT (argvec[count].offset.constant)); 2602: NO_DEFER_POP; 2603: } 2604: 2605: #ifndef PUSH_ARGS_REVERSED 2606: #ifdef STACK_BOUNDARY 2607: /* If we pushed args in forward order, perform stack alignment 2608: after pushing the last arg. */ 2609: if (argblock == 0) 2610: anti_adjust_stack (GEN_INT (args_size.constant 2611: - original_args_size.constant)); 2612: #endif 2613: #endif 2614: 2615: #ifdef PUSH_ARGS_REVERSED 2616: argnum = nargs - 1; 2617: #else 2618: argnum = 0; 2619: #endif 2620: 2621: /* Now load any reg parms into their regs. */ 2622: 2623: for (count = 0; count < nargs; count++, argnum += inc) 2624: { 2625: register enum machine_mode mode = argvec[argnum].mode; 2626: register rtx val = argvec[argnum].value; 2627: rtx reg = argvec[argnum].reg; 2628: int partial = argvec[argnum].partial; 2629: 2630: if (reg != 0 && partial == 0) 2631: emit_move_insn (reg, val); 2632: NO_DEFER_POP; 2633: } 2634: 2635: #if 0 2636: /* For version 1.37, try deleting this entirely. */ 2637: if (! no_queue) 2638: emit_queue (); 2639: #endif 2640: 2641: /* Any regs containing parms remain in use through the call. */ 2642: start_sequence (); 2643: for (count = 0; count < nargs; count++) 2644: if (argvec[count].reg != 0) 2645: emit_insn (gen_rtx (USE, VOIDmode, argvec[count].reg)); 2646: 2647: use_insns = get_insns (); 2648: end_sequence (); 2649: 1.1.1.6 ! root 2650: /* Pass the function the address in which to return a structure value. */ ! 2651: if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value) ! 2652: { ! 2653: emit_move_insn (struct_value_rtx, ! 2654: force_reg (Pmode, ! 2655: force_operand (XEXP (mem_value, 0), ! 2656: NULL_RTX))); ! 2657: if (GET_CODE (struct_value_rtx) == REG) ! 2658: { ! 2659: push_to_sequence (use_insns); ! 2660: emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx)); ! 2661: use_insns = get_insns (); ! 2662: end_sequence (); ! 2663: } ! 2664: } ! 2665: 1.1.1.5 root 2666: fun = prepare_call_address (fun, NULL_TREE, &use_insns); 2667: 2668: /* Don't allow popping to be deferred, since then 2669: cse'ing of library calls could delete a call and leave the pop. */ 2670: NO_DEFER_POP; 2671: 2672: /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which 2673: will set inhibit_defer_pop to that value. */ 2674: 1.1.1.6 ! root 2675: emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), args_size.constant, ! 2676: struct_value_size, 1.1.1.5 root 2677: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), 1.1.1.6 ! root 2678: (outmode != VOIDmode && mem_value == 0 ! 2679: ? hard_libcall_value (outmode) : NULL_RTX), 1.1.1.5 root 2680: old_inhibit_defer_pop + 1, use_insns, no_queue); 2681: 2682: /* Now restore inhibit_defer_pop to its actual original value. */ 2683: OK_DEFER_POP; 2684: 1.1.1.6 ! root 2685: pop_temp_slots (); ! 2686: 1.1.1.5 root 2687: /* Copy the value to the right place. */ 2688: if (outmode != VOIDmode) 2689: { 2690: if (mem_value) 2691: { 2692: if (value == 0) 1.1.1.6 ! root 2693: value = mem_value; 1.1.1.5 root 2694: if (value != mem_value) 2695: emit_move_insn (value, mem_value); 2696: } 2697: else if (value != 0) 2698: emit_move_insn (value, hard_libcall_value (outmode)); 1.1.1.6 ! root 2699: else ! 2700: value = hard_libcall_value (outmode); 1.1.1.5 root 2701: } 1.1.1.6 ! root 2702: ! 2703: return value; 1.1.1.5 root 2704: } 2705: 1.1 root 2706: #if 0 2707: /* Return an rtx which represents a suitable home on the stack 2708: given TYPE, the type of the argument looking for a home. 2709: This is called only for BLKmode arguments. 2710: 2711: SIZE is the size needed for this target. 2712: ARGS_ADDR is the address of the bottom of the argument block for this call. 2713: OFFSET describes this parameter's offset into ARGS_ADDR. It is meaningless 2714: if this machine uses push insns. */ 2715: 2716: static rtx 2717: target_for_arg (type, size, args_addr, offset) 2718: tree type; 2719: rtx size; 2720: rtx args_addr; 2721: struct args_size offset; 2722: { 2723: rtx target; 2724: rtx offset_rtx = ARGS_SIZE_RTX (offset); 2725: 2726: /* We do not call memory_address if possible, 2727: because we want to address as close to the stack 2728: as possible. For non-variable sized arguments, 2729: this will be stack-pointer relative addressing. */ 2730: if (GET_CODE (offset_rtx) == CONST_INT) 2731: target = plus_constant (args_addr, INTVAL (offset_rtx)); 2732: else 2733: { 2734: /* I have no idea how to guarantee that this 2735: will work in the presence of register parameters. */ 2736: target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx); 2737: target = memory_address (QImode, target); 2738: } 2739: 2740: return gen_rtx (MEM, BLKmode, target); 2741: } 2742: #endif 2743: 2744: /* Store a single argument for a function call 2745: into the register or memory area where it must be passed. 2746: *ARG describes the argument value and where to pass it. 2747: 2748: ARGBLOCK is the address of the stack-block for all the arguments, 1.1.1.2 root 2749: or 0 on a machine where arguments are pushed individually. 1.1 root 2750: 2751: MAY_BE_ALLOCA nonzero says this could be a call to `alloca' 2752: so must be careful about how the stack is used. 2753: 2754: VARIABLE_SIZE nonzero says that this was a variable-sized outgoing 2755: argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate 2756: that we need not worry about saving and restoring the stack. 2757: 2758: FNDECL is the declaration of the function we are calling. */ 2759: 2760: static void 1.1.1.3 root 2761: store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl, 2762: reg_parm_stack_space) 1.1 root 2763: struct arg_data *arg; 2764: rtx argblock; 2765: int may_be_alloca; 2766: int variable_size; 2767: tree fndecl; 1.1.1.3 root 2768: int reg_parm_stack_space; 1.1 root 2769: { 2770: register tree pval = arg->tree_value; 2771: rtx reg = 0; 2772: int partial = 0; 2773: int used = 0; 2774: int i, lower_bound, upper_bound; 2775: 2776: if (TREE_CODE (pval) == ERROR_MARK) 2777: return; 2778: 2779: #ifdef ACCUMULATE_OUTGOING_ARGS 2780: /* If this is being stored into a pre-allocated, fixed-size, stack area, 2781: save any previous data at that location. */ 2782: if (argblock && ! variable_size && arg->stack) 2783: { 2784: #ifdef ARGS_GROW_DOWNWARD 2785: /* stack_slot is negative, but we want to index stack_usage_map */ 2786: /* with positive values. */ 2787: if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS) 2788: upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1; 2789: else 2790: abort (); 2791: 2792: lower_bound = upper_bound - arg->size.constant; 2793: #else 2794: if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS) 2795: lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)); 2796: else 2797: lower_bound = 0; 2798: 2799: upper_bound = lower_bound + arg->size.constant; 2800: #endif 2801: 2802: for (i = lower_bound; i < upper_bound; i++) 2803: if (stack_usage_map[i] 2804: #ifdef REG_PARM_STACK_SPACE 2805: /* Don't store things in the fixed argument area at this point; 2806: it has already been saved. */ 1.1.1.3 root 2807: && i > reg_parm_stack_space 1.1 root 2808: #endif 2809: ) 2810: break; 2811: 2812: if (i != upper_bound) 2813: { 2814: /* We need to make a save area. See what mode we can make it. */ 2815: enum machine_mode save_mode 2816: = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1); 2817: rtx stack_area 2818: = gen_rtx (MEM, save_mode, 2819: memory_address (save_mode, XEXP (arg->stack_slot, 0))); 2820: 2821: if (save_mode == BLKmode) 2822: { 2823: arg->save_area = assign_stack_temp (BLKmode, 2824: arg->size.constant, 1); 2825: emit_block_move (validize_mem (arg->save_area), stack_area, 1.1.1.4 root 2826: GEN_INT (arg->size.constant), 1.1 root 2827: PARM_BOUNDARY / BITS_PER_UNIT); 2828: } 2829: else 2830: { 2831: arg->save_area = gen_reg_rtx (save_mode); 2832: emit_move_insn (arg->save_area, stack_area); 2833: } 2834: } 2835: } 2836: #endif 2837: 2838: /* If this isn't going to be placed on both the stack and in registers, 2839: set up the register and number of words. */ 2840: if (! arg->pass_on_stack) 2841: reg = arg->reg, partial = arg->partial; 2842: 2843: if (reg != 0 && partial == 0) 2844: /* Being passed entirely in a register. We shouldn't be called in 2845: this case. */ 2846: abort (); 2847: 1.1.1.5 root 2848: #ifdef STRICT_ALIGNMENT 2849: /* If this arg needs special alignment, don't load the registers 2850: here. */ 2851: if (arg->n_aligned_regs != 0) 2852: reg = 0; 2853: #endif 2854: 1.1 root 2855: /* If this is being partially passed in a register, but multiple locations 2856: are specified, we assume that the one partially used is the one that is 2857: listed first. */ 2858: if (reg && GET_CODE (reg) == EXPR_LIST) 2859: reg = XEXP (reg, 0); 2860: 1.1.1.5 root 2861: /* If this is being passed partially in a register, we can't evaluate 1.1 root 2862: it directly into its stack slot. Otherwise, we can. */ 2863: if (arg->value == 0) 1.1.1.3 root 2864: { 2865: #ifdef ACCUMULATE_OUTGOING_ARGS 2866: /* stack_arg_under_construction is nonzero if a function argument is 2867: being evaluated directly into the outgoing argument list and 2868: expand_call must take special action to preserve the argument list 2869: if it is called recursively. 2870: 2871: For scalar function arguments stack_usage_map is sufficient to 2872: determine which stack slots must be saved and restored. Scalar 2873: arguments in general have pass_on_stack == 0. 2874: 2875: If this argument is initialized by a function which takes the 2876: address of the argument (a C++ constructor or a C function 2877: returning a BLKmode structure), then stack_usage_map is 2878: insufficient and expand_call must push the stack around the 2879: function call. Such arguments have pass_on_stack == 1. 2880: 2881: Note that it is always safe to set stack_arg_under_construction, 2882: but this generates suboptimal code if set when not needed. */ 2883: 2884: if (arg->pass_on_stack) 2885: stack_arg_under_construction++; 2886: #endif 1.1.1.6 ! root 2887: arg->value = expand_expr (pval, ! 2888: (partial ! 2889: || TYPE_MODE (TREE_TYPE (pval)) != arg->mode) ! 2890: ? NULL_RTX : arg->stack, 1.1.1.4 root 2891: VOIDmode, 0); 1.1.1.5 root 2892: 2893: /* If we are promoting object (or for any other reason) the mode 2894: doesn't agree, convert the mode. */ 2895: 2896: if (GET_MODE (arg->value) != VOIDmode 2897: && GET_MODE (arg->value) != arg->mode) 2898: arg->value = convert_to_mode (arg->mode, arg->value, arg->unsignedp); 2899: 1.1.1.3 root 2900: #ifdef ACCUMULATE_OUTGOING_ARGS 2901: if (arg->pass_on_stack) 2902: stack_arg_under_construction--; 2903: #endif 2904: } 1.1 root 2905: 2906: /* Don't allow anything left on stack from computation 2907: of argument to alloca. */ 2908: if (may_be_alloca) 2909: do_pending_stack_adjust (); 2910: 2911: if (arg->value == arg->stack) 2912: /* If the value is already in the stack slot, we are done. */ 2913: ; 1.1.1.5 root 2914: else if (arg->mode != BLKmode) 1.1 root 2915: { 2916: register int size; 2917: 2918: /* Argument is a scalar, not entirely passed in registers. 2919: (If part is passed in registers, arg->partial says how much 2920: and emit_push_insn will take care of putting it there.) 2921: 2922: Push it, and if its size is less than the 2923: amount of space allocated to it, 2924: also bump stack pointer by the additional space. 2925: Note that in C the default argument promotions 2926: will prevent such mismatches. */ 2927: 1.1.1.5 root 2928: size = GET_MODE_SIZE (arg->mode); 1.1 root 2929: /* Compute how much space the push instruction will push. 2930: On many machines, pushing a byte will advance the stack 2931: pointer by a halfword. */ 2932: #ifdef PUSH_ROUNDING 2933: size = PUSH_ROUNDING (size); 2934: #endif 2935: used = size; 2936: 2937: /* Compute how much space the argument should get: 2938: round up to a multiple of the alignment for arguments. */ 1.1.1.5 root 2939: if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval))) 1.1 root 2940: used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1) 2941: / (PARM_BOUNDARY / BITS_PER_UNIT)) 2942: * (PARM_BOUNDARY / BITS_PER_UNIT)); 2943: 2944: /* This isn't already where we want it on the stack, so put it there. 2945: This can either be done with push or copy insns. */ 1.1.1.5 root 2946: emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 2947: 0, partial, reg, used - size, 2948: argblock, ARGS_SIZE_RTX (arg->offset)); 1.1 root 2949: } 2950: else 2951: { 2952: /* BLKmode, at least partly to be pushed. */ 2953: 2954: register int excess; 2955: rtx size_rtx; 2956: 2957: /* Pushing a nonscalar. 2958: If part is passed in registers, PARTIAL says how much 2959: and emit_push_insn will take care of putting it there. */ 2960: 2961: /* Round its size up to a multiple 2962: of the allocation unit for arguments. */ 2963: 2964: if (arg->size.var != 0) 2965: { 2966: excess = 0; 2967: size_rtx = ARGS_SIZE_RTX (arg->size); 2968: } 2969: else 2970: { 2971: /* PUSH_ROUNDING has no effect on us, because 2972: emit_push_insn for BLKmode is careful to avoid it. */ 1.1.1.5 root 2973: excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval)) 1.1 root 2974: + partial * UNITS_PER_WORD); 1.1.1.5 root 2975: size_rtx = expr_size (pval); 1.1 root 2976: } 2977: 1.1.1.5 root 2978: emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx, 1.1 root 2979: TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial, 2980: reg, excess, argblock, ARGS_SIZE_RTX (arg->offset)); 2981: } 2982: 2983: 2984: /* Unless this is a partially-in-register argument, the argument is now 2985: in the stack. 2986: 2987: ??? Note that this can change arg->value from arg->stack to 2988: arg->stack_slot and it matters when they are not the same. 2989: It isn't totally clear that this is correct in all cases. */ 2990: if (partial == 0) 2991: arg->value = arg->stack_slot; 2992: 2993: /* Once we have pushed something, pops can't safely 2994: be deferred during the rest of the arguments. */ 2995: NO_DEFER_POP; 2996: 2997: /* ANSI doesn't require a sequence point here, 2998: but PCC has one, so this will avoid some problems. */ 2999: emit_queue (); 3000: 3001: /* Free any temporary slots made in processing this argument. */ 3002: free_temp_slots (); 3003: 3004: #ifdef ACCUMULATE_OUTGOING_ARGS 3005: /* Now mark the segment we just used. */ 3006: if (argblock && ! variable_size && arg->stack) 3007: for (i = lower_bound; i < upper_bound; i++) 3008: stack_usage_map[i] = 1; 3009: #endif 3010: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.