From c9ab9ae440a8066b2c2b85b157b1fdadcf09916a Mon Sep 17 00:00:00 2001 From: obrien Date: Fri, 1 Feb 2002 18:16:02 +0000 Subject: Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0. These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST. --- contrib/gcc/function.h | 734 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 519 insertions(+), 215 deletions(-) (limited to 'contrib/gcc/function.h') diff --git a/contrib/gcc/function.h b/contrib/gcc/function.h index c25933c..5cc0948 100644 --- a/contrib/gcc/function.h +++ b/contrib/gcc/function.h @@ -1,32 +1,23 @@ /* Structure for saving state for a nested function. - Copyright (C) 1989, 92-97, 1998 Free Software Foundation, Inc. + Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ - - -#if !defined(NULL_TREE) && !defined(tree) -typedef union union_node *_function_tree; -#define tree _function_tree -#endif -#if !defined(NULL_RTX) && !defined(rtx) -typedef struct rtx_def *_function_rtx; -#define rtx _function_rtx -#endif +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ struct var_refs_queue { @@ -59,247 +50,560 @@ struct simple_obstack_stack struct simple_obstack_stack *next; }; +struct emit_status +{ + /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. + After rtl generation, it is 1 plus the largest register number used. */ + int x_reg_rtx_no; + + /* Lowest label number in current function. */ + int x_first_label_num; + + /* The ends of the doubly-linked chain of rtl for the current function. + Both are reset to null at the start of rtl generation for the function. + + start_sequence saves both of these on `sequence_stack' along with + `sequence_rtl_expr' and then starts a new, nested sequence of insns. */ + rtx x_first_insn; + rtx x_last_insn; + + /* RTL_EXPR within which the current sequence will be placed. Use to + prevent reuse of any temporaries within the sequence until after the + RTL_EXPR is emitted. */ + tree sequence_rtl_expr; + + /* Stack of pending (incomplete) sequences saved by `start_sequence'. + Each element describes one pending sequence. + The main insn-chain is saved in the last element of the chain, + unless the chain is empty. */ + struct sequence_stack *sequence_stack; + + /* INSN_UID for next insn emitted. + Reset to 1 for each function compiled. */ + int x_cur_insn_uid; + + /* Line number and source file of the last line-number NOTE emitted. + This is used to avoid generating duplicates. */ + int x_last_linenum; + const char *x_last_filename; + + /* The length of the regno_pointer_align, regno_decl, and x_regno_reg_rtx + vectors. Since these vectors are needed during the expansion phase when + the total number of registers in the function is not yet known, the + vectors are copied and made bigger when necessary. */ + int regno_pointer_align_length; + + /* Indexed by pseudo register number, if nonzero gives the known alignment + for that pseudo (if REG_POINTER is set in x_regno_reg_rtx). + Allocated in parallel with x_regno_reg_rtx. */ + unsigned char *regno_pointer_align; + + /* Indexed by pseudo register number, if nonzero gives the decl + corresponding to that register. */ + tree *regno_decl; + + /* Indexed by pseudo register number, gives the rtx for that pseudo. + Allocated in parallel with regno_pointer_align. */ + rtx *x_regno_reg_rtx; +}; + +/* For backward compatibility... eventually these should all go away. */ +#define reg_rtx_no (cfun->emit->x_reg_rtx_no) +#define seq_rtl_expr (cfun->emit->sequence_rtl_expr) +#define regno_reg_rtx (cfun->emit->x_regno_reg_rtx) +#define seq_stack (cfun->emit->sequence_stack) + +#define REGNO_POINTER_ALIGN(REGNO) (cfun->emit->regno_pointer_align[REGNO]) +#define REGNO_DECL(REGNO) (cfun->emit->regno_decl[REGNO]) + +struct expr_status +{ + /* Number of units that we should eventually pop off the stack. + These are the arguments to function calls that have already returned. */ + int x_pending_stack_adjust; + + /* Under some ABIs, it is the caller's responsibility to pop arguments + pushed for function calls. A naive implementation would simply pop + the arguments immediately after each call. However, if several + function calls are made in a row, it is typically cheaper to pop + all the arguments after all of the calls are complete since a + single pop instruction can be used. Therefore, GCC attempts to + defer popping the arguments until absolutely necessary. (For + example, at the end of a conditional, the arguments must be popped, + since code outside the conditional won't know whether or not the + arguments need to be popped.) + + When INHIBIT_DEFER_POP is non-zero, however, the compiler does not + attempt to defer pops. Instead, the stack is popped immediately + after each call. Rather then setting this variable directly, use + NO_DEFER_POP and OK_DEFER_POP. */ + int x_inhibit_defer_pop; + + /* If PREFERRED_STACK_BOUNDARY and PUSH_ROUNDING are defined, the stack + boundary can be momentairly unaligned while pushing the arguments. + Record the delta since last aligned boundary here in order to get + stack alignment in the nested function calls working right. */ + int x_stack_pointer_delta; + + /* Nonzero means __builtin_saveregs has already been done in this function. + The value is the pseudoreg containing the value __builtin_saveregs + returned. */ + rtx x_saveregs_value; + + /* Similarly for __builtin_apply_args. */ + rtx x_apply_args_value; + + /* List of labels that must never be deleted. */ + rtx x_forced_labels; + + /* Postincrements that still need to be expanded. */ + rtx x_pending_chain; +}; + +#define pending_stack_adjust (cfun->expr->x_pending_stack_adjust) +#define inhibit_defer_pop (cfun->expr->x_inhibit_defer_pop) +#define saveregs_value (cfun->expr->x_saveregs_value) +#define apply_args_value (cfun->expr->x_apply_args_value) +#define forced_labels (cfun->expr->x_forced_labels) +#define pending_chain (cfun->expr->x_pending_chain) +#define stack_pointer_delta (cfun->expr->x_stack_pointer_delta) + /* This structure can save all the important global and static variables describing the status of the current function. */ struct function { - struct function *next; + struct eh_status *eh; + struct stmt_status *stmt; + struct expr_status *expr; + struct emit_status *emit; + struct varasm_status *varasm; /* For function.c. */ - char *name; + + /* Name of this function. */ + const char *name; + + /* Points to the FUNCTION_DECL of this function. */ tree decl; + + /* Function containing this function, if any. */ + struct function *outer; + + /* Number of bytes of args popped by function being compiled on its return. + Zero if no bytes are to be popped. + May affect compilation of return insn or of function epilogue. */ int pops_args; - int returns_struct; - int returns_pcc_struct; - int returns_pointer; - int needs_context; - int calls_setjmp; - int calls_longjmp; - int calls_alloca; - int has_nonlocal_label; - int has_nonlocal_goto; - int contains_functions; - int has_computed_jump; - int is_thunk; - rtx nonlocal_goto_handler_slots; - rtx nonlocal_goto_handler_labels; - rtx nonlocal_goto_stack_level; - tree nonlocal_labels; + + /* If function's args have a fixed size, this is that size, in bytes. + Otherwise, it is -1. + May affect compilation of return insn or of function epilogue. */ int args_size; + + /* # bytes the prologue should push and pretend that the caller pushed them. + The prologue must do this, but only if parms can be passed in + registers. */ int pretend_args_size; - rtx arg_offset_rtx; - int varargs; - int stdarg; - int max_parm_reg; - rtx *parm_reg_stack_loc; + + /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is + defined, the needed space is pushed by the prologue. */ int outgoing_args_size; + + /* This is the offset from the arg pointer to the place where the first + anonymous arg can be found, if there is one. */ + rtx arg_offset_rtx; + + /* Quantities of various kinds of registers + used for the current function's args. */ + CUMULATIVE_ARGS args_info; + + /* If non-zero, an RTL expression for the location at which the current + function returns its result. If the current function returns its + result in a register, current_function_return_rtx will always be + the hard register containing the result. */ rtx return_rtx; - rtx cleanup_label; - rtx return_label; - rtx save_expr_regs; - rtx stack_slot_list; - rtx parm_birth_insn; - HOST_WIDE_INT frame_offset; - rtx tail_recursion_label; - rtx tail_recursion_reentry; + + /* The arg pointer hard register, or the pseudo into which it was copied. */ rtx internal_arg_pointer; - char *cannot_inline; - rtx arg_pointer_save_area; - tree rtl_expr_chain; - rtx last_parm_insn; - tree context_display; - tree trampoline_list; - int function_call_count; - struct temp_slot *temp_slots; - int temp_slot_level; - int target_temp_slot_level; - int var_temp_slot_level; - int instrument_entry_exit; + + /* Language-specific reason why the current function cannot be made + inline. */ + const char *cannot_inline; + + /* Opaque pointer used by get_hard_reg_initial_val and + has_hard_reg_initial_val (see integrate.[hc]). */ + struct initial_value_struct *hard_reg_initial_vals; + + /* Number of function calls seen so far in current function. */ + int x_function_call_count; + + /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels + (labels to which there can be nonlocal gotos from nested functions) + in this function. */ + tree x_nonlocal_labels; + + /* List (chain of EXPR_LIST) of stack slots that hold the current handlers + for nonlocal gotos. There is one for every nonlocal label in the + function; this list matches the one in nonlocal_labels. + Zero when function does not have nonlocal labels. */ + rtx x_nonlocal_goto_handler_slots; + + /* List (chain of EXPR_LIST) of labels heading the current handlers for + nonlocal gotos. */ + rtx x_nonlocal_goto_handler_labels; + + /* RTX for stack slot that holds the stack pointer value to restore + for a nonlocal goto. + Zero when function does not have nonlocal labels. */ + rtx x_nonlocal_goto_stack_level; + + /* Label that will go on parm cleanup code, if any. + Jumping to this label runs cleanup code for parameters, if + such code must be run. Following this code is the logical return + label. */ + rtx x_cleanup_label; + + /* Label that will go on function epilogue. + Jumping to this label serves as a "return" instruction + on machines which require execution of the epilogue on all returns. */ + rtx x_return_label; + + /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. + So we can mark them all live at the end of the function, if nonopt. */ + rtx x_save_expr_regs; + + /* List (chain of EXPR_LISTs) of all stack slots in this function. + Made for the sake of unshare_all_rtl. */ + rtx x_stack_slot_list; + + /* Chain of all RTL_EXPRs that have insns in them. */ + tree x_rtl_expr_chain; + + /* Label to jump back to for tail recursion, or 0 if we have + not yet needed one for this function. */ + rtx x_tail_recursion_label; + + /* Place after which to insert the tail_recursion_label if we need one. */ + rtx x_tail_recursion_reentry; + + /* Location at which to save the argument pointer if it will need to be + referenced. There are two cases where this is done: if nonlocal gotos + exist, or if vars stored at an offset from the argument pointer will be + needed by inner routines. */ + rtx x_arg_pointer_save_area; + + /* If the function returns non-void, we will emit a clobber of the + return registers just in case the user fell off the end without + returning a proper value. This is that insn. */ + rtx x_clobber_return_insn; + + /* Offset to end of allocated area of stack frame. + If stack grows down, this is the address of the last stack slot allocated. + If stack grows up, this is the address for the next slot. */ + HOST_WIDE_INT x_frame_offset; + + /* List (chain of TREE_LISTs) of static chains for containing functions. + Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx + in an RTL_EXPR in the TREE_VALUE. */ + tree x_context_display; + + /* List (chain of TREE_LISTs) of trampolines for nested functions. + The trampoline sets up the static chain and jumps to the function. + We supply the trampoline's address when the function's address is + requested. + + Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx + in an RTL_EXPR in the TREE_VALUE. */ + tree x_trampoline_list; + + /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ + rtx x_parm_birth_insn; + + /* Last insn of those whose job was to put parms into their nominal + homes. */ + rtx x_last_parm_insn; + + /* 1 + last pseudo register number possibly used for loading a copy + of a parameter of this function. */ + unsigned int x_max_parm_reg; + + /* Vector indexed by REGNO, containing location on stack in which + to put the parm which is nominally in pseudo register REGNO, + if we discover that that parm must go in the stack. The highest + element in this vector is one less than MAX_PARM_REG, above. */ + rtx *x_parm_reg_stack_loc; + + /* List of all temporaries allocated, both available and in use. */ + struct temp_slot *x_temp_slots; + + /* Current nesting level for temporaries. */ + int x_temp_slot_level; + + /* Current nesting level for variables in a block. */ + int x_var_temp_slot_level; + + /* When temporaries are created by TARGET_EXPRs, they are created at + this level of temp_slot_level, so that they can remain allocated + until no longer needed. CLEANUP_POINT_EXPRs define the lifetime + of TARGET_EXPRs. */ + int x_target_temp_slot_level; + /* This slot is initialized as 0 and is added to during the nested function. */ struct var_refs_queue *fixup_var_refs_queue; - CUMULATIVE_ARGS args_info; - - /* For stmt.c */ - struct nesting *block_stack; - struct nesting *stack_block_stack; - struct nesting *cond_stack; - struct nesting *loop_stack; - struct nesting *case_stack; - struct nesting *nesting_stack; - int nesting_depth; - int block_start_count; - tree last_expr_type; - rtx last_expr_value; - int expr_stmts_for_value; - char *emit_filename; - int emit_lineno; - struct goto_fixup *goto_fixup_chain; - - /* For exception handling information. */ - struct eh_stack ehstack; - struct eh_stack catchstack; - struct eh_queue ehqueue; - rtx catch_clauses; - struct label_node *false_label_stack; - struct label_node *caught_return_label_stack; - tree protect_list; - rtx ehc; - rtx eh_return_stub_label; - - /* For expr.c. */ - rtx pending_chain; - int pending_stack_adjust; - int inhibit_defer_pop; - rtx saveregs_value; - rtx apply_args_value; - rtx forced_labels; - int check_memory_usage; - - /* For emit-rtl.c. */ - int reg_rtx_no; - int first_label_num; - rtx first_insn; - rtx last_insn; - tree sequence_rtl_expr; - struct sequence_stack *sequence_stack; - int cur_insn_uid; - int last_linenum; - char *last_filename; - char *regno_pointer_flag; - char *regno_pointer_align; - int regno_pointer_flag_length; - rtx *regno_reg_rtx; - - /* For stor-layout.c. */ - tree permanent_type_chain; - tree temporary_type_chain; - tree permanent_type_end; - tree temporary_type_end; - tree pending_sizes; - int immediate_size_expand; - - /* For tree.c. */ - int all_types_permanent; - struct momentary_level *momentary_stack; - char *maybepermanent_firstobj; - char *temporary_firstobj; - char *momentary_firstobj; - char *momentary_function_firstobj; - struct obstack *current_obstack; - struct obstack *function_obstack; - struct obstack *function_maybepermanent_obstack; - struct obstack *expression_obstack; - struct obstack *saveable_obstack; - struct obstack *rtl_obstack; - struct simple_obstack_stack *inline_obstacks; /* For integrate.c. */ - int uses_const_pool; + int inlinable; + int no_debugging_symbols; + /* This is in fact an rtvec. */ + void *original_arg_vector; + tree original_decl_initial; + /* Last insn of those whose job was to put parms into their nominal + homes. */ + rtx inl_last_parm_insn; + /* Highest label number in current function. */ + int inl_max_label_num; /* For md files. */ - int uses_pic_offset_table; + /* tm.h can use this to store whatever it likes. */ struct machine_function *machine; + /* The largest alignment of slot allocated on the stack. */ + int stack_alignment_needed; + /* Preferred alignment of the end of stack frame. */ + int preferred_stack_boundary; + + /* Language-specific code can use this to store whatever it likes. */ + struct language_function *language; /* For reorg. */ + + /* If some insns can be deferred to the delay slots of the epilogue, the + delay list for them is recorded here. */ rtx epilogue_delay_list; - /* For varasm. */ - struct constant_descriptor **const_rtx_hash_table; - struct pool_sym **const_rtx_sym_hash_table; - struct pool_constant *first_pool, *last_pool; - int pool_offset; - rtx const_double_chain; -}; + /* Collected bit flags. */ -/* The FUNCTION_DECL for an inline function currently being expanded. */ -extern tree inline_function_decl; + /* Nonzero if function being compiled needs to be given an address + where the value should be stored. */ + unsigned int returns_struct : 1; + + /* Nonzero if function being compiled needs to + return the address of where it has put a structure value. */ + unsigned int returns_pcc_struct : 1; + + /* Nonzero if the current function returns a pointer type. */ + unsigned int returns_pointer : 1; + + /* Nonzero if function being compiled needs to be passed a static chain. */ + unsigned int needs_context : 1; + + /* Nonzero if function being compiled can call setjmp. */ + unsigned int calls_setjmp : 1; + + /* Nonzero if function being compiled can call longjmp. */ + unsigned int calls_longjmp : 1; + + /* Nonzero if function being compiled can call alloca, + either as a subroutine or builtin. */ + unsigned int calls_alloca : 1; + + /* Nonzero if the function calls __builtin_eh_return. */ + unsigned int calls_eh_return : 1; -/* Label that will go on parm cleanup code, if any. - Jumping to this label runs cleanup code for parameters, if - such code must be run. Following this code is the logical return label. */ + /* Nonzero if function being compiled receives nonlocal gotos + from nested functions. */ + unsigned int has_nonlocal_label : 1; -extern rtx cleanup_label; + /* Nonzero if function being compiled has nonlocal gotos to parent + function. */ + unsigned int has_nonlocal_goto : 1; -/* Label that will go on function epilogue. - Jumping to this label serves as a "return" instruction - on machines which require execution of the epilogue on all returns. */ + /* Nonzero if function being compiled contains nested functions. */ + unsigned int contains_functions : 1; -extern rtx return_label; + /* Nonzero if the function being compiled issues a computed jump. */ + unsigned int has_computed_jump : 1; -/* Offset to end of allocated area of stack frame. - If stack grows down, this is the address of the last stack slot allocated. - If stack grows up, this is the address for the next slot. */ -extern HOST_WIDE_INT frame_offset; + /* Nonzero if the current function is a thunk (a lightweight function that + just adjusts one of its arguments and forwards to another function), so + we should try to cut corners where we can. */ + unsigned int is_thunk : 1; -/* Label to jump back to for tail recursion, or 0 if we have - not yet needed one for this function. */ -extern rtx tail_recursion_label; + /* Nonzero if instrumentation calls for function entry and exit should be + generated. */ + unsigned int instrument_entry_exit : 1; -/* Place after which to insert the tail_recursion_label if we need one. */ -extern rtx tail_recursion_reentry; + /* Nonzero if profiling code should be generated. */ + unsigned int profile : 1; -/* Location at which to save the argument pointer if it will need to be - referenced. There are two cases where this is done: if nonlocal gotos - exist, or if vars whose is an offset from the argument pointer will be - needed by inner routines. */ + /* Nonzero if stack limit checking should be enabled in the current + function. */ + unsigned int limit_stack : 1; -extern rtx arg_pointer_save_area; + /* Nonzero if current function uses varargs.h or equivalent. + Zero for functions that use stdarg.h. */ + unsigned int varargs : 1; -/* Chain of all RTL_EXPRs that have insns in them. */ -extern tree rtl_expr_chain; + /* Nonzero if current function uses stdarg.h or equivalent. + Zero for functions that use varargs.h. */ + unsigned int stdarg : 1; -/* List (chain of EXPR_LISTs) of all stack slots in this function. - Made for the sake of unshare_all_rtl. */ -extern rtx stack_slot_list; + /* Nonzero if this function is being processed in function-at-a-time + mode. In other words, if all tree structure for this function, + including the BLOCK tree, is created before RTL generation + commences. */ + unsigned int x_whole_function_mode_p : 1; + + /* Nonzero if the back-end should not keep track of expressions that + determine the size of variable-sized objects. Normally, such + expressions are saved away, and then expanded when the next + function is started. For example, if a parameter has a + variable-sized type, then the size of the parameter is computed + when the function body is entered. However, some front-ends do + not desire this behavior. */ + unsigned int x_dont_save_pending_sizes_p : 1; + + /* Nonzero if the current function uses the constant pool. */ + unsigned int uses_const_pool : 1; + + /* Nonzero if the current function uses pic_offset_table_rtx. */ + unsigned int uses_pic_offset_table : 1; + + /* Nonzero if the current function needs an lsda for exception handling. */ + unsigned int uses_eh_lsda : 1; + + /* Nonzero if code to initialize arg_pointer_save_area has been emited. */ + unsigned int arg_pointer_save_area_init : 1; +}; + +/* The function currently being compiled. */ +extern struct function *cfun; + +/* Nonzero if we've already converted virtual regs to hard regs. */ +extern int virtuals_instantiated; + +/* For backward compatibility... eventually these should all go away. */ +#define current_function_name (cfun->name) +#define current_function_pops_args (cfun->pops_args) +#define current_function_returns_struct (cfun->returns_struct) +#define current_function_returns_pcc_struct (cfun->returns_pcc_struct) +#define current_function_returns_pointer (cfun->returns_pointer) +#define current_function_needs_context (cfun->needs_context) +#define current_function_calls_setjmp (cfun->calls_setjmp) +#define current_function_calls_alloca (cfun->calls_alloca) +#define current_function_calls_longjmp (cfun->calls_longjmp) +#define current_function_calls_eh_return (cfun->calls_eh_return) +#define current_function_has_computed_jump (cfun->has_computed_jump) +#define current_function_contains_functions (cfun->contains_functions) +#define current_function_is_thunk (cfun->is_thunk) +#define current_function_args_info (cfun->args_info) +#define current_function_args_size (cfun->args_size) +#define current_function_pretend_args_size (cfun->pretend_args_size) +#define current_function_outgoing_args_size (cfun->outgoing_args_size) +#define current_function_arg_offset_rtx (cfun->arg_offset_rtx) +#define current_function_varargs (cfun->varargs) +#define current_function_stdarg (cfun->stdarg) +#define current_function_internal_arg_pointer (cfun->internal_arg_pointer) +#define current_function_return_rtx (cfun->return_rtx) +#define current_function_instrument_entry_exit (cfun->instrument_entry_exit) +#define current_function_profile (cfun->profile) +#define current_function_limit_stack (cfun->limit_stack) +#define current_function_uses_pic_offset_table (cfun->uses_pic_offset_table) +#define current_function_uses_const_pool (cfun->uses_const_pool) +#define current_function_cannot_inline (cfun->cannot_inline) +#define current_function_epilogue_delay_list (cfun->epilogue_delay_list) +#define current_function_has_nonlocal_label (cfun->has_nonlocal_label) +#define current_function_has_nonlocal_goto (cfun->has_nonlocal_goto) + +#define max_parm_reg (cfun->x_max_parm_reg) +#define parm_reg_stack_loc (cfun->x_parm_reg_stack_loc) +#define cleanup_label (cfun->x_cleanup_label) +#define return_label (cfun->x_return_label) +#define save_expr_regs (cfun->x_save_expr_regs) +#define stack_slot_list (cfun->x_stack_slot_list) +#define parm_birth_insn (cfun->x_parm_birth_insn) +#define frame_offset (cfun->x_frame_offset) +#define tail_recursion_label (cfun->x_tail_recursion_label) +#define tail_recursion_reentry (cfun->x_tail_recursion_reentry) +#define arg_pointer_save_area (cfun->x_arg_pointer_save_area) +#define rtl_expr_chain (cfun->x_rtl_expr_chain) +#define last_parm_insn (cfun->x_last_parm_insn) +#define context_display (cfun->x_context_display) +#define trampoline_list (cfun->x_trampoline_list) +#define function_call_count (cfun->x_function_call_count) +#define temp_slots (cfun->x_temp_slots) +#define temp_slot_level (cfun->x_temp_slot_level) +#define target_temp_slot_level (cfun->x_target_temp_slot_level) +#define var_temp_slot_level (cfun->x_var_temp_slot_level) +#define nonlocal_labels (cfun->x_nonlocal_labels) +#define nonlocal_goto_handler_slots (cfun->x_nonlocal_goto_handler_slots) +#define nonlocal_goto_handler_labels (cfun->x_nonlocal_goto_handler_labels) +#define nonlocal_goto_stack_level (cfun->x_nonlocal_goto_stack_level) + +/* The FUNCTION_DECL for an inline function currently being expanded. */ +extern tree inline_function_decl; /* Given a function decl for a containing function, return the `struct function' for it. */ -struct function *find_function_data PROTO((tree)); +struct function *find_function_data PARAMS ((tree)); -/* Pointer to chain of `struct function' for containing functions. */ -extern struct function *outer_function_chain; +/* Set NOTE_BLOCK for each block note in the current function. */ +extern void identify_blocks PARAMS ((void)); -/* Put all this function's BLOCK nodes into a vector and return it. - Also store in each NOTE for the beginning or end of a block - the index of that block in the vector. */ -extern tree *identify_blocks PROTO((tree, rtx)); +/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END}, + and create duplicate blocks. */ +extern void reorder_blocks PARAMS ((void)); + +/* Set BLOCK_NUMBER for all the blocks in FN. */ +extern void number_blocks PARAMS ((tree)); /* Return size needed for stack frame based on slots so far allocated. This size counts from zero. It is not rounded to STACK_BOUNDARY; the caller may have to do that. */ -extern HOST_WIDE_INT get_frame_size PROTO((void)); - -/* These variables hold pointers to functions to - save and restore machine-specific data, - in push_function_context and pop_function_context. */ -extern void (*save_machine_status) PROTO((struct function *)); -extern void (*restore_machine_status) PROTO((struct function *)); +extern HOST_WIDE_INT get_frame_size PARAMS ((void)); +/* Likewise, but for a different than the current function. */ +extern HOST_WIDE_INT get_func_frame_size PARAMS ((struct function *)); + +/* These variables hold pointers to functions to create and destroy + target specific, per-function data structures. */ +extern void (*init_machine_status) PARAMS ((struct function *)); +extern void (*free_machine_status) PARAMS ((struct function *)); +/* This variable holds a pointer to a function to register any + data items in the target specific, per-function data structure + that will need garbage collection. */ +extern void (*mark_machine_status) PARAMS ((struct function *)); + +/* Likewise, but for language-specific data. */ +extern void (*init_lang_status) PARAMS ((struct function *)); +extern void (*mark_lang_status) PARAMS ((struct function *)); +extern void (*save_lang_status) PARAMS ((struct function *)); +extern void (*restore_lang_status) PARAMS ((struct function *)); +extern void (*free_lang_status) PARAMS ((struct function *)); /* Save and restore status information for a nested function. */ -extern void save_tree_status PROTO((struct function *, tree)); -extern void restore_tree_status PROTO((struct function *, tree)); -extern void save_varasm_status PROTO((struct function *, tree)); -extern void restore_varasm_status PROTO((struct function *)); -extern void save_eh_status PROTO((struct function *)); -extern void restore_eh_status PROTO((struct function *)); -extern void save_stmt_status PROTO((struct function *)); -extern void restore_stmt_status PROTO((struct function *)); -extern void save_expr_status PROTO((struct function *)); -extern void restore_expr_status PROTO((struct function *)); -extern void save_emit_status PROTO((struct function *)); -extern void restore_emit_status PROTO((struct function *)); -extern void save_storage_status PROTO((struct function *)); -extern void restore_storage_status PROTO((struct function *)); - -extern rtx get_first_block_beg PROTO((void)); - -#ifdef rtx -#undef rtx +extern void restore_emit_status PARAMS ((struct function *)); +extern void free_after_parsing PARAMS ((struct function *)); +extern void free_after_compilation PARAMS ((struct function *)); + +extern void init_varasm_status PARAMS ((struct function *)); +extern void free_varasm_status PARAMS ((struct function *)); +extern void free_emit_status PARAMS ((struct function *)); +extern void free_stmt_status PARAMS ((struct function *)); +extern void free_eh_status PARAMS ((struct function *)); +extern void free_expr_status PARAMS ((struct function *)); + +extern rtx get_first_block_beg PARAMS ((void)); + +#ifdef RTX_CODE +extern void diddle_return_value PARAMS ((void (*)(rtx, void*), void*)); +extern void clobber_return_register PARAMS ((void)); +extern void use_return_register PARAMS ((void)); #endif -#ifdef tree -#undef tree -#endif +extern rtx get_arg_pointer_save_area PARAMS ((struct function *)); + +extern void init_virtual_regs PARAMS ((struct emit_status *)); + +/* Called once, at initialization, to initialize function.c. */ +extern void init_function_once PARAMS ((void)); -- cgit v1.1