function.h revision 96263
1/* Structure for saving state for a nested function. 2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22struct var_refs_queue 23{ 24 rtx modified; 25 enum machine_mode promoted_mode; 26 int unsignedp; 27 struct var_refs_queue *next; 28}; 29 30/* Stack of pending (incomplete) sequences saved by `start_sequence'. 31 Each element describes one pending sequence. 32 The main insn-chain is saved in the last element of the chain, 33 unless the chain is empty. */ 34 35struct sequence_stack 36{ 37 /* First and last insns in the chain of the saved sequence. */ 38 rtx first, last; 39 tree sequence_rtl_expr; 40 struct sequence_stack *next; 41}; 42 43extern struct sequence_stack *sequence_stack; 44 45/* Stack of single obstacks. */ 46 47struct simple_obstack_stack 48{ 49 struct obstack *obstack; 50 struct simple_obstack_stack *next; 51}; 52 53struct emit_status 54{ 55 /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. 56 After rtl generation, it is 1 plus the largest register number used. */ 57 int x_reg_rtx_no; 58 59 /* Lowest label number in current function. */ 60 int x_first_label_num; 61 62 /* The ends of the doubly-linked chain of rtl for the current function. 63 Both are reset to null at the start of rtl generation for the function. 64 65 start_sequence saves both of these on `sequence_stack' along with 66 `sequence_rtl_expr' and then starts a new, nested sequence of insns. */ 67 rtx x_first_insn; 68 rtx x_last_insn; 69 70 /* RTL_EXPR within which the current sequence will be placed. Use to 71 prevent reuse of any temporaries within the sequence until after the 72 RTL_EXPR is emitted. */ 73 tree sequence_rtl_expr; 74 75 /* Stack of pending (incomplete) sequences saved by `start_sequence'. 76 Each element describes one pending sequence. 77 The main insn-chain is saved in the last element of the chain, 78 unless the chain is empty. */ 79 struct sequence_stack *sequence_stack; 80 81 /* INSN_UID for next insn emitted. 82 Reset to 1 for each function compiled. */ 83 int x_cur_insn_uid; 84 85 /* Line number and source file of the last line-number NOTE emitted. 86 This is used to avoid generating duplicates. */ 87 int x_last_linenum; 88 const char *x_last_filename; 89 90 /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx 91 vectors. Since these vectors are needed during the expansion phase when 92 the total number of registers in the function is not yet known, the 93 vectors are copied and made bigger when necessary. */ 94 int regno_pointer_align_length; 95 96 /* Indexed by pseudo register number, if nonzero gives the known alignment 97 for that pseudo (if REG_POINTER is set in x_regno_reg_rtx). 98 Allocated in parallel with x_regno_reg_rtx. */ 99 unsigned char *regno_pointer_align; 100 101 /* Indexed by pseudo register number, if nonzero gives the decl 102 corresponding to that register. */ 103 tree *regno_decl; 104 105 /* Indexed by pseudo register number, gives the rtx for that pseudo. 106 Allocated in parallel with regno_pointer_align. */ 107 rtx *x_regno_reg_rtx; 108}; 109 110/* For backward compatibility... eventually these should all go away. */ 111#define reg_rtx_no (cfun->emit->x_reg_rtx_no) 112#define seq_rtl_expr (cfun->emit->sequence_rtl_expr) 113#define regno_reg_rtx (cfun->emit->x_regno_reg_rtx) 114#define seq_stack (cfun->emit->sequence_stack) 115 116#define REGNO_POINTER_ALIGN(REGNO) (cfun->emit->regno_pointer_align[REGNO]) 117#define REGNO_DECL(REGNO) (cfun->emit->regno_decl[REGNO]) 118 119struct expr_status 120{ 121 /* Number of units that we should eventually pop off the stack. 122 These are the arguments to function calls that have already returned. */ 123 int x_pending_stack_adjust; 124 125 /* Under some ABIs, it is the caller's responsibility to pop arguments 126 pushed for function calls. A naive implementation would simply pop 127 the arguments immediately after each call. However, if several 128 function calls are made in a row, it is typically cheaper to pop 129 all the arguments after all of the calls are complete since a 130 single pop instruction can be used. Therefore, GCC attempts to 131 defer popping the arguments until absolutely necessary. (For 132 example, at the end of a conditional, the arguments must be popped, 133 since code outside the conditional won't know whether or not the 134 arguments need to be popped.) 135 136 When INHIBIT_DEFER_POP is non-zero, however, the compiler does not 137 attempt to defer pops. Instead, the stack is popped immediately 138 after each call. Rather then setting this variable directly, use 139 NO_DEFER_POP and OK_DEFER_POP. */ 140 int x_inhibit_defer_pop; 141 142 /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack 143 boundary can be momentairly unaligned while pushing the arguments. 144 Record the delta since last aligned boundary here in order to get 145 stack alignment in the nested function calls working right. */ 146 int x_stack_pointer_delta; 147 148 /* Nonzero means __builtin_saveregs has already been done in this function. 149 The value is the pseudoreg containing the value __builtin_saveregs 150 returned. */ 151 rtx x_saveregs_value; 152 153 /* Similarly for __builtin_apply_args. */ 154 rtx x_apply_args_value; 155 156 /* List of labels that must never be deleted. */ 157 rtx x_forced_labels; 158 159 /* Postincrements that still need to be expanded. */ 160 rtx x_pending_chain; 161}; 162 163#define pending_stack_adjust (cfun->expr->x_pending_stack_adjust) 164#define inhibit_defer_pop (cfun->expr->x_inhibit_defer_pop) 165#define saveregs_value (cfun->expr->x_saveregs_value) 166#define apply_args_value (cfun->expr->x_apply_args_value) 167#define forced_labels (cfun->expr->x_forced_labels) 168#define pending_chain (cfun->expr->x_pending_chain) 169#define stack_pointer_delta (cfun->expr->x_stack_pointer_delta) 170 171/* This structure can save all the important global and static variables 172 describing the status of the current function. */ 173 174struct function 175{ 176 struct eh_status *eh; 177 struct stmt_status *stmt; 178 struct expr_status *expr; 179 struct emit_status *emit; 180 struct varasm_status *varasm; 181 182 /* For function.c. */ 183 184 /* Name of this function. */ 185 const char *name; 186 187 /* Points to the FUNCTION_DECL of this function. */ 188 tree decl; 189 190 /* Function containing this function, if any. */ 191 struct function *outer; 192 193 /* Number of bytes of args popped by function being compiled on its return. 194 Zero if no bytes are to be popped. 195 May affect compilation of return insn or of function epilogue. */ 196 int pops_args; 197 198 /* If function's args have a fixed size, this is that size, in bytes. 199 Otherwise, it is -1. 200 May affect compilation of return insn or of function epilogue. */ 201 int args_size; 202 203 /* # bytes the prologue should push and pretend that the caller pushed them. 204 The prologue must do this, but only if parms can be passed in 205 registers. */ 206 int pretend_args_size; 207 208 /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is 209 defined, the needed space is pushed by the prologue. */ 210 int outgoing_args_size; 211 212 /* This is the offset from the arg pointer to the place where the first 213 anonymous arg can be found, if there is one. */ 214 rtx arg_offset_rtx; 215 216 /* Quantities of various kinds of registers 217 used for the current function's args. */ 218 CUMULATIVE_ARGS args_info; 219 220 /* If non-zero, an RTL expression for the location at which the current 221 function returns its result. If the current function returns its 222 result in a register, current_function_return_rtx will always be 223 the hard register containing the result. */ 224 rtx return_rtx; 225 226 /* The arg pointer hard register, or the pseudo into which it was copied. */ 227 rtx internal_arg_pointer; 228 229 /* Language-specific reason why the current function cannot be made 230 inline. */ 231 const char *cannot_inline; 232 233 /* Opaque pointer used by get_hard_reg_initial_val and 234 has_hard_reg_initial_val (see integrate.[hc]). */ 235 struct initial_value_struct *hard_reg_initial_vals; 236 237 /* Number of function calls seen so far in current function. */ 238 int x_function_call_count; 239 240 /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels 241 (labels to which there can be nonlocal gotos from nested functions) 242 in this function. */ 243 tree x_nonlocal_labels; 244 245 /* List (chain of EXPR_LIST) of stack slots that hold the current handlers 246 for nonlocal gotos. There is one for every nonlocal label in the 247 function; this list matches the one in nonlocal_labels. 248 Zero when function does not have nonlocal labels. */ 249 rtx x_nonlocal_goto_handler_slots; 250 251 /* List (chain of EXPR_LIST) of labels heading the current handlers for 252 nonlocal gotos. */ 253 rtx x_nonlocal_goto_handler_labels; 254 255 /* RTX for stack slot that holds the stack pointer value to restore 256 for a nonlocal goto. 257 Zero when function does not have nonlocal labels. */ 258 rtx x_nonlocal_goto_stack_level; 259 260 /* Label that will go on parm cleanup code, if any. 261 Jumping to this label runs cleanup code for parameters, if 262 such code must be run. Following this code is the logical return 263 label. */ 264 rtx x_cleanup_label; 265 266 /* Label that will go on function epilogue. 267 Jumping to this label serves as a "return" instruction 268 on machines which require execution of the epilogue on all returns. */ 269 rtx x_return_label; 270 271 /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. 272 So we can mark them all live at the end of the function, if nonopt. */ 273 rtx x_save_expr_regs; 274 275 /* List (chain of EXPR_LISTs) of all stack slots in this function. 276 Made for the sake of unshare_all_rtl. */ 277 rtx x_stack_slot_list; 278 279 /* Chain of all RTL_EXPRs that have insns in them. */ 280 tree x_rtl_expr_chain; 281 282 /* Label to jump back to for tail recursion, or 0 if we have 283 not yet needed one for this function. */ 284 rtx x_tail_recursion_label; 285 286 /* Place after which to insert the tail_recursion_label if we need one. */ 287 rtx x_tail_recursion_reentry; 288 289 /* Location at which to save the argument pointer if it will need to be 290 referenced. There are two cases where this is done: if nonlocal gotos 291 exist, or if vars stored at an offset from the argument pointer will be 292 needed by inner routines. */ 293 rtx x_arg_pointer_save_area; 294 295 /* If the function returns non-void, we will emit a clobber of the 296 return registers just in case the user fell off the end without 297 returning a proper value. This is that insn. */ 298 rtx x_clobber_return_insn; 299 300 /* Offset to end of allocated area of stack frame. 301 If stack grows down, this is the address of the last stack slot allocated. 302 If stack grows up, this is the address for the next slot. */ 303 HOST_WIDE_INT x_frame_offset; 304 305 /* List (chain of TREE_LISTs) of static chains for containing functions. 306 Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx 307 in an RTL_EXPR in the TREE_VALUE. */ 308 tree x_context_display; 309 310 /* List (chain of TREE_LISTs) of trampolines for nested functions. 311 The trampoline sets up the static chain and jumps to the function. 312 We supply the trampoline's address when the function's address is 313 requested. 314 315 Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx 316 in an RTL_EXPR in the TREE_VALUE. */ 317 tree x_trampoline_list; 318 319 /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ 320 rtx x_parm_birth_insn; 321 322 /* Last insn of those whose job was to put parms into their nominal 323 homes. */ 324 rtx x_last_parm_insn; 325 326 /* 1 + last pseudo register number possibly used for loading a copy 327 of a parameter of this function. */ 328 unsigned int x_max_parm_reg; 329 330 /* Vector indexed by REGNO, containing location on stack in which 331 to put the parm which is nominally in pseudo register REGNO, 332 if we discover that that parm must go in the stack. The highest 333 element in this vector is one less than MAX_PARM_REG, above. */ 334 rtx *x_parm_reg_stack_loc; 335 336 /* List of all temporaries allocated, both available and in use. */ 337 struct temp_slot *x_temp_slots; 338 339 /* Current nesting level for temporaries. */ 340 int x_temp_slot_level; 341 342 /* Current nesting level for variables in a block. */ 343 int x_var_temp_slot_level; 344 345 /* When temporaries are created by TARGET_EXPRs, they are created at 346 this level of temp_slot_level, so that they can remain allocated 347 until no longer needed. CLEANUP_POINT_EXPRs define the lifetime 348 of TARGET_EXPRs. */ 349 int x_target_temp_slot_level; 350 351 /* This slot is initialized as 0 and is added to 352 during the nested function. */ 353 struct var_refs_queue *fixup_var_refs_queue; 354 355 /* For integrate.c. */ 356 int inlinable; 357 int no_debugging_symbols; 358 /* This is in fact an rtvec. */ 359 void *original_arg_vector; 360 tree original_decl_initial; 361 /* Last insn of those whose job was to put parms into their nominal 362 homes. */ 363 rtx inl_last_parm_insn; 364 /* Highest label number in current function. */ 365 int inl_max_label_num; 366 367 /* Profile label number. */ 368 int profile_label_no; 369 370 /* For md files. */ 371 372 /* tm.h can use this to store whatever it likes. */ 373 struct machine_function *machine; 374 /* The largest alignment of slot allocated on the stack. */ 375 int stack_alignment_needed; 376 /* Preferred alignment of the end of stack frame. */ 377 int preferred_stack_boundary; 378 379 /* Language-specific code can use this to store whatever it likes. */ 380 struct language_function *language; 381 382 /* For reorg. */ 383 384 /* If some insns can be deferred to the delay slots of the epilogue, the 385 delay list for them is recorded here. */ 386 rtx epilogue_delay_list; 387 388 /* Collected bit flags. */ 389 390 /* Nonzero if function being compiled needs to be given an address 391 where the value should be stored. */ 392 unsigned int returns_struct : 1; 393 394 /* Nonzero if function being compiled needs to 395 return the address of where it has put a structure value. */ 396 unsigned int returns_pcc_struct : 1; 397 398 /* Nonzero if the current function returns a pointer type. */ 399 unsigned int returns_pointer : 1; 400 401 /* Nonzero if function being compiled needs to be passed a static chain. */ 402 unsigned int needs_context : 1; 403 404 /* Nonzero if function being compiled can call setjmp. */ 405 unsigned int calls_setjmp : 1; 406 407 /* Nonzero if function being compiled can call longjmp. */ 408 unsigned int calls_longjmp : 1; 409 410 /* Nonzero if function being compiled can call alloca, 411 either as a subroutine or builtin. */ 412 unsigned int calls_alloca : 1; 413 414 /* Nonzero if the function calls __builtin_eh_return. */ 415 unsigned int calls_eh_return : 1; 416 417 /* Nonzero if function being compiled receives nonlocal gotos 418 from nested functions. */ 419 unsigned int has_nonlocal_label : 1; 420 421 /* Nonzero if function being compiled has nonlocal gotos to parent 422 function. */ 423 unsigned int has_nonlocal_goto : 1; 424 425 /* Nonzero if function being compiled contains nested functions. */ 426 unsigned int contains_functions : 1; 427 428 /* Nonzero if the function being compiled issues a computed jump. */ 429 unsigned int has_computed_jump : 1; 430 431 /* Nonzero if the current function is a thunk (a lightweight function that 432 just adjusts one of its arguments and forwards to another function), so 433 we should try to cut corners where we can. */ 434 unsigned int is_thunk : 1; 435 436 /* Nonzero if instrumentation calls for function entry and exit should be 437 generated. */ 438 unsigned int instrument_entry_exit : 1; 439 440 /* Nonzero if profiling code should be generated. */ 441 unsigned int profile : 1; 442 443 /* Nonzero if stack limit checking should be enabled in the current 444 function. */ 445 unsigned int limit_stack : 1; 446 447 /* Nonzero if current function uses varargs.h or equivalent. 448 Zero for functions that use stdarg.h. */ 449 unsigned int varargs : 1; 450 451 /* Nonzero if current function uses stdarg.h or equivalent. 452 Zero for functions that use varargs.h. */ 453 unsigned int stdarg : 1; 454 455 /* Nonzero if this function is being processed in function-at-a-time 456 mode. In other words, if all tree structure for this function, 457 including the BLOCK tree, is created before RTL generation 458 commences. */ 459 unsigned int x_whole_function_mode_p : 1; 460 461 /* Nonzero if the back-end should not keep track of expressions that 462 determine the size of variable-sized objects. Normally, such 463 expressions are saved away, and then expanded when the next 464 function is started. For example, if a parameter has a 465 variable-sized type, then the size of the parameter is computed 466 when the function body is entered. However, some front-ends do 467 not desire this behavior. */ 468 unsigned int x_dont_save_pending_sizes_p : 1; 469 470 /* Nonzero if the current function uses the constant pool. */ 471 unsigned int uses_const_pool : 1; 472 473 /* Nonzero if the current function uses pic_offset_table_rtx. */ 474 unsigned int uses_pic_offset_table : 1; 475 476 /* Nonzero if the current function needs an lsda for exception handling. */ 477 unsigned int uses_eh_lsda : 1; 478 479 /* Nonzero if code to initialize arg_pointer_save_area has been emited. */ 480 unsigned int arg_pointer_save_area_init : 1; 481}; 482 483/* The function currently being compiled. */ 484extern struct function *cfun; 485 486/* Nonzero if we've already converted virtual regs to hard regs. */ 487extern int virtuals_instantiated; 488 489/* For backward compatibility... eventually these should all go away. */ 490#define current_function_name (cfun->name) 491#define current_function_pops_args (cfun->pops_args) 492#define current_function_returns_struct (cfun->returns_struct) 493#define current_function_returns_pcc_struct (cfun->returns_pcc_struct) 494#define current_function_returns_pointer (cfun->returns_pointer) 495#define current_function_needs_context (cfun->needs_context) 496#define current_function_calls_setjmp (cfun->calls_setjmp) 497#define current_function_calls_alloca (cfun->calls_alloca) 498#define current_function_calls_longjmp (cfun->calls_longjmp) 499#define current_function_calls_eh_return (cfun->calls_eh_return) 500#define current_function_has_computed_jump (cfun->has_computed_jump) 501#define current_function_contains_functions (cfun->contains_functions) 502#define current_function_is_thunk (cfun->is_thunk) 503#define current_function_args_info (cfun->args_info) 504#define current_function_args_size (cfun->args_size) 505#define current_function_pretend_args_size (cfun->pretend_args_size) 506#define current_function_outgoing_args_size (cfun->outgoing_args_size) 507#define current_function_arg_offset_rtx (cfun->arg_offset_rtx) 508#define current_function_varargs (cfun->varargs) 509#define current_function_stdarg (cfun->stdarg) 510#define current_function_internal_arg_pointer (cfun->internal_arg_pointer) 511#define current_function_return_rtx (cfun->return_rtx) 512#define current_function_instrument_entry_exit (cfun->instrument_entry_exit) 513#define current_function_profile (cfun->profile) 514#define current_function_profile_label_no (cfun->profile_label_no) 515#define current_function_limit_stack (cfun->limit_stack) 516#define current_function_uses_pic_offset_table (cfun->uses_pic_offset_table) 517#define current_function_uses_const_pool (cfun->uses_const_pool) 518#define current_function_cannot_inline (cfun->cannot_inline) 519#define current_function_epilogue_delay_list (cfun->epilogue_delay_list) 520#define current_function_has_nonlocal_label (cfun->has_nonlocal_label) 521#define current_function_has_nonlocal_goto (cfun->has_nonlocal_goto) 522 523#define max_parm_reg (cfun->x_max_parm_reg) 524#define parm_reg_stack_loc (cfun->x_parm_reg_stack_loc) 525#define cleanup_label (cfun->x_cleanup_label) 526#define return_label (cfun->x_return_label) 527#define save_expr_regs (cfun->x_save_expr_regs) 528#define stack_slot_list (cfun->x_stack_slot_list) 529#define parm_birth_insn (cfun->x_parm_birth_insn) 530#define frame_offset (cfun->x_frame_offset) 531#define tail_recursion_label (cfun->x_tail_recursion_label) 532#define tail_recursion_reentry (cfun->x_tail_recursion_reentry) 533#define arg_pointer_save_area (cfun->x_arg_pointer_save_area) 534#define rtl_expr_chain (cfun->x_rtl_expr_chain) 535#define last_parm_insn (cfun->x_last_parm_insn) 536#define context_display (cfun->x_context_display) 537#define trampoline_list (cfun->x_trampoline_list) 538#define function_call_count (cfun->x_function_call_count) 539#define temp_slots (cfun->x_temp_slots) 540#define temp_slot_level (cfun->x_temp_slot_level) 541#define target_temp_slot_level (cfun->x_target_temp_slot_level) 542#define var_temp_slot_level (cfun->x_var_temp_slot_level) 543#define nonlocal_labels (cfun->x_nonlocal_labels) 544#define nonlocal_goto_handler_slots (cfun->x_nonlocal_goto_handler_slots) 545#define nonlocal_goto_handler_labels (cfun->x_nonlocal_goto_handler_labels) 546#define nonlocal_goto_stack_level (cfun->x_nonlocal_goto_stack_level) 547 548/* The FUNCTION_DECL for an inline function currently being expanded. */ 549extern tree inline_function_decl; 550 551/* Given a function decl for a containing function, 552 return the `struct function' for it. */ 553struct function *find_function_data PARAMS ((tree)); 554 555/* Set NOTE_BLOCK for each block note in the current function. */ 556extern void identify_blocks PARAMS ((void)); 557 558/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, 559 and create duplicate blocks. */ 560extern void reorder_blocks PARAMS ((void)); 561 562/* Set BLOCK_NUMBER for all the blocks in FN. */ 563extern void number_blocks PARAMS ((tree)); 564 565/* Return size needed for stack frame based on slots so far allocated. 566 This size counts from zero. It is not rounded to STACK_BOUNDARY; 567 the caller may have to do that. */ 568extern HOST_WIDE_INT get_frame_size PARAMS ((void)); 569/* Likewise, but for a different than the current function. */ 570extern HOST_WIDE_INT get_func_frame_size PARAMS ((struct function *)); 571 572/* These variables hold pointers to functions to create and destroy 573 target specific, per-function data structures. */ 574extern void (*init_machine_status) PARAMS ((struct function *)); 575extern void (*free_machine_status) PARAMS ((struct function *)); 576/* This variable holds a pointer to a function to register any 577 data items in the target specific, per-function data structure 578 that will need garbage collection. */ 579extern void (*mark_machine_status) PARAMS ((struct function *)); 580 581/* Likewise, but for language-specific data. */ 582extern void (*init_lang_status) PARAMS ((struct function *)); 583extern void (*mark_lang_status) PARAMS ((struct function *)); 584extern void (*save_lang_status) PARAMS ((struct function *)); 585extern void (*restore_lang_status) PARAMS ((struct function *)); 586extern void (*free_lang_status) PARAMS ((struct function *)); 587 588/* Save and restore status information for a nested function. */ 589extern void restore_emit_status PARAMS ((struct function *)); 590extern void free_after_parsing PARAMS ((struct function *)); 591extern void free_after_compilation PARAMS ((struct function *)); 592 593extern void init_varasm_status PARAMS ((struct function *)); 594extern void free_varasm_status PARAMS ((struct function *)); 595extern void free_emit_status PARAMS ((struct function *)); 596extern void free_stmt_status PARAMS ((struct function *)); 597extern void free_eh_status PARAMS ((struct function *)); 598extern void free_expr_status PARAMS ((struct function *)); 599 600extern rtx get_first_block_beg PARAMS ((void)); 601 602#ifdef RTX_CODE 603extern void diddle_return_value PARAMS ((void (*)(rtx, void*), void*)); 604extern void clobber_return_register PARAMS ((void)); 605extern void use_return_register PARAMS ((void)); 606#endif 607 608extern rtx get_arg_pointer_save_area PARAMS ((struct function *)); 609 610extern void init_virtual_regs PARAMS ((struct emit_status *)); 611 612/* Called once, at initialization, to initialize function.c. */ 613extern void init_function_once PARAMS ((void)); 614