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