1/* Structure for saving state for a nested function. 2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22#ifndef GCC_FUNCTION_H 23#define GCC_FUNCTION_H 24 25#include "tree.h" 26#include "hashtab.h" 27 28struct var_refs_queue GTY(()) 29{ 30 rtx modified; 31 enum machine_mode promoted_mode; 32 int unsignedp; 33 struct var_refs_queue *next; 34}; 35 36/* Stack of pending (incomplete) sequences saved by `start_sequence'. 37 Each element describes one pending sequence. 38 The main insn-chain is saved in the last element of the chain, 39 unless the chain is empty. */ 40 41struct sequence_stack GTY(()) 42{ 43 /* First and last insns in the chain of the saved sequence. */ 44 rtx first; 45 rtx last; 46 struct sequence_stack *next; 47}; 48 49extern struct sequence_stack *sequence_stack; 50 51/* Stack of single obstacks. */ 52 53struct simple_obstack_stack 54{ 55 struct obstack *obstack; 56 struct simple_obstack_stack *next; 57}; 58 59struct emit_status GTY(()) 60{ 61 /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. 62 After rtl generation, it is 1 plus the largest register number used. */ 63 int x_reg_rtx_no; 64 65 /* Lowest label number in current function. */ 66 int x_first_label_num; 67 68 /* The ends of the doubly-linked chain of rtl for the current function. 69 Both are reset to null at the start of rtl generation for the function. 70 71 start_sequence saves both of these on `sequence_stack' and then starts 72 a new, nested sequence of insns. */ 73 rtx x_first_insn; 74 rtx x_last_insn; 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 /* Location the last line-number NOTE emitted. 87 This is used to avoid generating duplicates. */ 88 location_t x_last_location; 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 * GTY ((length ("%h.x_reg_rtx_no"))) 100 regno_pointer_align; 101 102 /* Indexed by pseudo register number, gives the rtx for that pseudo. 103 Allocated in parallel with regno_pointer_align. */ 104 rtx * GTY ((length ("%h.x_reg_rtx_no"))) x_regno_reg_rtx; 105}; 106 107/* For backward compatibility... eventually these should all go away. */ 108#define reg_rtx_no (cfun->emit->x_reg_rtx_no) 109#define regno_reg_rtx (cfun->emit->x_regno_reg_rtx) 110#define seq_stack (cfun->emit->sequence_stack) 111 112#define REGNO_POINTER_ALIGN(REGNO) (cfun->emit->regno_pointer_align[REGNO]) 113 114struct expr_status GTY(()) 115{ 116 /* Number of units that we should eventually pop off the stack. 117 These are the arguments to function calls that have already returned. */ 118 int x_pending_stack_adjust; 119 120 /* Under some ABIs, it is the caller's responsibility to pop arguments 121 pushed for function calls. A naive implementation would simply pop 122 the arguments immediately after each call. However, if several 123 function calls are made in a row, it is typically cheaper to pop 124 all the arguments after all of the calls are complete since a 125 single pop instruction can be used. Therefore, GCC attempts to 126 defer popping the arguments until absolutely necessary. (For 127 example, at the end of a conditional, the arguments must be popped, 128 since code outside the conditional won't know whether or not the 129 arguments need to be popped.) 130 131 When INHIBIT_DEFER_POP is nonzero, however, the compiler does not 132 attempt to defer pops. Instead, the stack is popped immediately 133 after each call. Rather then setting this variable directly, use 134 NO_DEFER_POP and OK_DEFER_POP. */ 135 int x_inhibit_defer_pop; 136 137 /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack 138 boundary can be momentarily unaligned while pushing the arguments. 139 Record the delta since last aligned boundary here in order to get 140 stack alignment in the nested function calls working right. */ 141 int x_stack_pointer_delta; 142 143 /* Nonzero means __builtin_saveregs has already been done in this function. 144 The value is the pseudoreg containing the value __builtin_saveregs 145 returned. */ 146 rtx x_saveregs_value; 147 148 /* Similarly for __builtin_apply_args. */ 149 rtx x_apply_args_value; 150 151 /* List of labels that must never be deleted. */ 152 rtx x_forced_labels; 153}; 154 155#define pending_stack_adjust (cfun->expr->x_pending_stack_adjust) 156#define inhibit_defer_pop (cfun->expr->x_inhibit_defer_pop) 157#define saveregs_value (cfun->expr->x_saveregs_value) 158#define apply_args_value (cfun->expr->x_apply_args_value) 159#define forced_labels (cfun->expr->x_forced_labels) 160#define stack_pointer_delta (cfun->expr->x_stack_pointer_delta) 161 162struct temp_slot; 163typedef struct temp_slot *temp_slot_p; 164 165DEF_VEC_P(temp_slot_p); 166DEF_VEC_ALLOC_P(temp_slot_p,gc); 167 168enum function_frequency { 169 /* This function most likely won't be executed at all. 170 (set only when profile feedback is available). */ 171 FUNCTION_FREQUENCY_UNLIKELY_EXECUTED, 172 /* The default value. */ 173 FUNCTION_FREQUENCY_NORMAL, 174 /* Optimize this function hard 175 (set only when profile feedback is available). */ 176 FUNCTION_FREQUENCY_HOT 177}; 178 179/* This structure can save all the important global and static variables 180 describing the status of the current function. */ 181 182struct function GTY(()) 183{ 184 struct eh_status *eh; 185 struct expr_status *expr; 186 struct emit_status *emit; 187 struct varasm_status *varasm; 188 189 /* The control flow graph for this function. */ 190 struct control_flow_graph *cfg; 191 192 /* For function.c. */ 193 194 /* Points to the FUNCTION_DECL of this function. */ 195 tree decl; 196 197 /* Function containing this function, if any. */ 198 struct function *outer; 199 200 /* Number of bytes of args popped by function being compiled on its return. 201 Zero if no bytes are to be popped. 202 May affect compilation of return insn or of function epilogue. */ 203 int pops_args; 204 205 /* If function's args have a fixed size, this is that size, in bytes. 206 Otherwise, it is -1. 207 May affect compilation of return insn or of function epilogue. */ 208 int args_size; 209 210 /* # bytes the prologue should push and pretend that the caller pushed them. 211 The prologue must do this, but only if parms can be passed in 212 registers. */ 213 int pretend_args_size; 214 215 /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is 216 defined, the needed space is pushed by the prologue. */ 217 int outgoing_args_size; 218 219 /* This is the offset from the arg pointer to the place where the first 220 anonymous arg can be found, if there is one. */ 221 rtx arg_offset_rtx; 222 223 /* Quantities of various kinds of registers 224 used for the current function's args. */ 225 CUMULATIVE_ARGS args_info; 226 227 /* If nonzero, an RTL expression for the location at which the current 228 function returns its result. If the current function returns its 229 result in a register, current_function_return_rtx will always be 230 the hard register containing the result. */ 231 rtx return_rtx; 232 233 /* The arg pointer hard register, or the pseudo into which it was copied. */ 234 rtx internal_arg_pointer; 235 236 /* Opaque pointer used by get_hard_reg_initial_val and 237 has_hard_reg_initial_val (see integrate.[hc]). */ 238 struct initial_value_struct *hard_reg_initial_vals; 239 240 /* List (chain of EXPR_LIST) of labels heading the current handlers for 241 nonlocal gotos. */ 242 rtx x_nonlocal_goto_handler_labels; 243 244 /* Label that will go on function epilogue. 245 Jumping to this label serves as a "return" instruction 246 on machines which require execution of the epilogue on all returns. */ 247 rtx x_return_label; 248 249 /* Label that will go on the end of function epilogue. 250 Jumping to this label serves as a "naked return" instruction 251 on machines which require execution of the epilogue on all returns. */ 252 rtx x_naked_return_label; 253 254 /* List (chain of EXPR_LISTs) of all stack slots in this function. 255 Made for the sake of unshare_all_rtl. */ 256 rtx x_stack_slot_list; 257 258 /* Place after which to insert the tail_recursion_label if we need one. */ 259 rtx x_stack_check_probe_note; 260 261 /* Location at which to save the argument pointer if it will need to be 262 referenced. There are two cases where this is done: if nonlocal gotos 263 exist, or if vars stored at an offset from the argument pointer will be 264 needed by inner routines. */ 265 rtx x_arg_pointer_save_area; 266 267 /* APPLE LOCAL begin radar 6411649 */ 268 /* Holds a unique number for this function. It is used to 269 generate block number for block names. */ 270 int unqiue_block_number; 271 /* APPLE LOCAL end radar 6411649 */ 272 273 /* Offset to end of allocated area of stack frame. 274 If stack grows down, this is the address of the last stack slot allocated. 275 If stack grows up, this is the address for the next slot. */ 276 HOST_WIDE_INT x_frame_offset; 277 278 /* A PARM_DECL that should contain the static chain for this function. 279 It will be initialized at the beginning of the function. */ 280 tree static_chain_decl; 281 282 /* An expression that contains the non-local goto save area. The first 283 word is the saved frame pointer and the second is the saved stack 284 pointer. */ 285 tree nonlocal_goto_save_area; 286 287 /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ 288 rtx x_parm_birth_insn; 289 290 /* List of all used temporaries allocated, by level. */ 291 VEC(temp_slot_p,gc) *x_used_temp_slots; 292 293 /* List of available temp slots. */ 294 struct temp_slot *x_avail_temp_slots; 295 296 /* This slot is initialized as 0 and is added to 297 during the nested function. */ 298 struct var_refs_queue *fixup_var_refs_queue; 299 300 /* Current nesting level for temporaries. */ 301 int x_temp_slot_level; 302 303 /* Highest label number in current function. */ 304 int inl_max_label_num; 305 306 /* Function sequence number for profiling, debugging, etc. */ 307 int funcdef_no; 308 309 /* For flow.c. */ 310 311 /* Highest loop depth seen so far in loop analysis. Used in flow.c 312 for the "failure strategy" when doing liveness analysis starting 313 with non-empty initial sets. */ 314 int max_loop_depth; 315 316 /* For md files. */ 317 318 /* tm.h can use this to store whatever it likes. */ 319 struct machine_function * GTY ((maybe_undef)) machine; 320 321 /* The largest alignment of slot allocated on the stack. */ 322 unsigned int stack_alignment_needed; 323 324 /* Preferred alignment of the end of stack frame. */ 325 unsigned int preferred_stack_boundary; 326 327 /* Language-specific code can use this to store whatever it likes. */ 328 struct language_function * language; 329 330 /* Used types hash table. */ 331 htab_t GTY ((param_is (union tree_node))) used_types_hash; 332 333 /* For reorg. */ 334 335 /* If some insns can be deferred to the delay slots of the epilogue, the 336 delay list for them is recorded here. */ 337 rtx epilogue_delay_list; 338 339 /* Maximal number of entities in the single jumptable. Used to estimate 340 final flowgraph size. */ 341 int max_jumptable_ents; 342 343 /* UIDs for LABEL_DECLs. */ 344 int last_label_uid; 345 346 /* Line number of the end of the function. */ 347 location_t function_end_locus; 348 349 /* Array mapping insn uids to blocks. */ 350 VEC(tree,gc) *ib_boundaries_block; 351 352 /* The variables unexpanded so far. */ 353 tree unexpanded_var_list; 354 355 /* Assembly labels for the hot and cold text sections, to 356 be used by debugger functions for determining the size of text 357 sections. */ 358 359 const char *hot_section_label; 360 const char *cold_section_label; 361 const char *hot_section_end_label; 362 const char *cold_section_end_label; 363 364 /* String to be used for name of cold text sections, via 365 targetm.asm_out.named_section. */ 366 367 const char *unlikely_text_section_name; 368 369 /* A variable living at the top of the frame that holds a known value. 370 Used for detecting stack clobbers. */ 371 tree stack_protect_guard; 372 373 /* Collected bit flags. */ 374 375 /* Nonzero if function being compiled needs to be given an address 376 where the value should be stored. */ 377 unsigned int returns_struct : 1; 378 379 /* Nonzero if function being compiled needs to 380 return the address of where it has put a structure value. */ 381 unsigned int returns_pcc_struct : 1; 382 383 /* Nonzero if the current function returns a pointer type. */ 384 unsigned int returns_pointer : 1; 385 386 /* Nonzero if function being compiled can call setjmp. */ 387 unsigned int calls_setjmp : 1; 388 389 /* Nonzero if function being compiled can call alloca, 390 either as a subroutine or builtin. */ 391 unsigned int calls_alloca : 1; 392 393 /* Nonzero if function being compiled called builtin_return_addr or 394 builtin_frame_address with nonzero count. */ 395 unsigned int accesses_prior_frames : 1; 396 397 /* Nonzero if the function calls __builtin_eh_return. */ 398 unsigned int calls_eh_return : 1; 399 400 /* Nonzero if function being compiled receives nonlocal gotos 401 from nested functions. */ 402 unsigned int has_nonlocal_label : 1; 403 404 /* Nonzero if function being compiled has nonlocal gotos to parent 405 function. */ 406 unsigned int has_nonlocal_goto : 1; 407 408 /* Nonzero if the current function is a thunk, i.e., a lightweight 409 function implemented by the output_mi_thunk hook) that just 410 adjusts one of its arguments and forwards to another 411 function. */ 412 unsigned int is_thunk : 1; 413 414 /* This bit is used by the exception handling logic. It is set if all 415 calls (if any) are sibling calls. Such functions do not have to 416 have EH tables generated, as they cannot throw. A call to such a 417 function, however, should be treated as throwing if any of its callees 418 can throw. */ 419 unsigned int all_throwers_are_sibcalls : 1; 420 421 /* Nonzero if profiling code should be generated. */ 422 unsigned int profile : 1; 423 424 /* Nonzero if stack limit checking should be enabled in the current 425 function. */ 426 unsigned int limit_stack : 1; 427 428 /* Nonzero if current function uses stdarg.h or equivalent. */ 429 unsigned int stdarg : 1; 430 431 /* Nonzero if the back-end should not keep track of expressions that 432 determine the size of variable-sized objects. Normally, such 433 expressions are saved away, and then expanded when the next 434 function is started. For example, if a parameter has a 435 variable-sized type, then the size of the parameter is computed 436 when the function body is entered. However, some front-ends do 437 not desire this behavior. */ 438 unsigned int x_dont_save_pending_sizes_p : 1; 439 440 /* Nonzero if the current function uses the constant pool. */ 441 unsigned int uses_const_pool : 1; 442 443 /* Nonzero if the current function uses pic_offset_table_rtx. */ 444 unsigned int uses_pic_offset_table : 1; 445 446 /* Nonzero if the current function needs an lsda for exception handling. */ 447 unsigned int uses_eh_lsda : 1; 448 449 /* Nonzero if code to initialize arg_pointer_save_area has been emitted. */ 450 unsigned int arg_pointer_save_area_init : 1; 451 452 unsigned int after_inlining : 1; 453 454 /* Set when the call to function itself has been emit. */ 455 unsigned int recursive_call_emit : 1; 456 457 /* Set when the tail call has been produced. */ 458 unsigned int tail_call_emit : 1; 459 460 /* How commonly executed the function is. Initialized during branch 461 probabilities pass. */ 462 ENUM_BITFIELD (function_frequency) function_frequency : 2; 463 464 /* Number of units of general registers that need saving in stdarg 465 function. What unit is depends on the backend, either it is number 466 of bytes, or it can be number of registers. */ 467 unsigned int va_list_gpr_size : 8; 468 469 /* Number of units of floating point registers that need saving in stdarg 470 function. */ 471 unsigned int va_list_fpr_size : 8; 472}; 473 474/* If va_list_[gf]pr_size is set to this, it means we don't know how 475 many units need to be saved. */ 476#define VA_LIST_MAX_GPR_SIZE 255 477#define VA_LIST_MAX_FPR_SIZE 255 478 479/* The function currently being compiled. */ 480extern GTY(()) struct function *cfun; 481 482/* Pointer to chain of `struct function' for containing functions. */ 483extern GTY(()) struct function *outer_function_chain; 484 485/* Nonzero if we've already converted virtual regs to hard regs. */ 486extern int virtuals_instantiated; 487 488/* Nonzero if at least one trampoline has been created. */ 489extern int trampolines_created; 490 491/* For backward compatibility... eventually these should all go away. */ 492#define current_function_pops_args (cfun->pops_args) 493#define current_function_returns_struct (cfun->returns_struct) 494#define current_function_returns_pcc_struct (cfun->returns_pcc_struct) 495#define current_function_returns_pointer (cfun->returns_pointer) 496#define current_function_calls_setjmp (cfun->calls_setjmp) 497#define current_function_calls_alloca (cfun->calls_alloca) 498#define current_function_accesses_prior_frames (cfun->accesses_prior_frames) 499#define current_function_calls_eh_return (cfun->calls_eh_return) 500#define current_function_is_thunk (cfun->is_thunk) 501#define current_function_args_info (cfun->args_info) 502#define current_function_args_size (cfun->args_size) 503#define current_function_pretend_args_size (cfun->pretend_args_size) 504#define current_function_outgoing_args_size (cfun->outgoing_args_size) 505#define current_function_arg_offset_rtx (cfun->arg_offset_rtx) 506#define current_function_stdarg (cfun->stdarg) 507#define current_function_internal_arg_pointer (cfun->internal_arg_pointer) 508#define current_function_return_rtx (cfun->return_rtx) 509#define current_function_profile (cfun->profile) 510#define current_function_funcdef_no (cfun->funcdef_no) 511#define current_function_limit_stack (cfun->limit_stack) 512#define current_function_uses_pic_offset_table (cfun->uses_pic_offset_table) 513#define current_function_uses_const_pool (cfun->uses_const_pool) 514#define current_function_epilogue_delay_list (cfun->epilogue_delay_list) 515#define current_function_has_nonlocal_label (cfun->has_nonlocal_label) 516#define current_function_has_nonlocal_goto (cfun->has_nonlocal_goto) 517 518#define return_label (cfun->x_return_label) 519#define naked_return_label (cfun->x_naked_return_label) 520#define stack_slot_list (cfun->x_stack_slot_list) 521#define parm_birth_insn (cfun->x_parm_birth_insn) 522#define frame_offset (cfun->x_frame_offset) 523#define stack_check_probe_note (cfun->x_stack_check_probe_note) 524#define arg_pointer_save_area (cfun->x_arg_pointer_save_area) 525#define used_temp_slots (cfun->x_used_temp_slots) 526#define avail_temp_slots (cfun->x_avail_temp_slots) 527#define temp_slot_level (cfun->x_temp_slot_level) 528#define nonlocal_goto_handler_labels (cfun->x_nonlocal_goto_handler_labels) 529 530/* Given a function decl for a containing function, 531 return the `struct function' for it. */ 532struct function *find_function_data (tree); 533 534/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, 535 and create duplicate blocks. */ 536extern void reorder_blocks (void); 537 538/* Set BLOCK_NUMBER for all the blocks in FN. */ 539extern void number_blocks (tree); 540 541extern void clear_block_marks (tree); 542extern tree blocks_nreverse (tree); 543extern void reset_block_changes (void); 544extern void record_block_change (tree); 545extern void finalize_block_changes (void); 546extern void check_block_change (rtx, tree *); 547extern void free_block_changes (void); 548 549/* Return size needed for stack frame based on slots so far allocated. 550 This size counts from zero. It is not rounded to STACK_BOUNDARY; 551 the caller may have to do that. */ 552extern HOST_WIDE_INT get_frame_size (void); 553 554/* Issue an error message and return TRUE if frame OFFSET overflows in 555 the signed target pointer arithmetics for function FUNC. Otherwise 556 return FALSE. */ 557extern bool frame_offset_overflow (HOST_WIDE_INT, tree); 558 559/* A pointer to a function to create target specific, per-function 560 data structures. */ 561extern struct machine_function * (*init_machine_status) (void); 562 563/* Save and restore status information for a nested function. */ 564extern void free_after_parsing (struct function *); 565extern void free_after_compilation (struct function *); 566 567extern void init_varasm_status (struct function *); 568 569#ifdef RTX_CODE 570extern void diddle_return_value (void (*)(rtx, void*), void*); 571extern void clobber_return_register (void); 572#endif 573 574extern rtx get_arg_pointer_save_area (struct function *); 575 576/* Returns the name of the current function. */ 577extern const char *current_function_name (void); 578 579extern void do_warn_unused_parameter (tree); 580 581extern bool pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode, 582 tree, bool); 583extern bool reference_callee_copied (CUMULATIVE_ARGS *, enum machine_mode, 584 tree, bool); 585 586extern void used_types_insert (tree); 587 588/* APPLE LOCAL radar 5732232 - blocks */ 589extern struct block_sema_info *cur_block; 590#endif /* GCC_FUNCTION_H */ 591