+
+ /* Language-specific reason why the current function cannot be made
+ inline. */
+ const char *cannot_inline;
+
+ /* Nonzero if instrumentation calls for function entry and exit should be
+ generated. */
+ int instrument_entry_exit;
+
+ /* Nonzero if memory access checking be enabled in the current function. */
+ int check_memory_usage;
+
+ /* Nonzero if stack limit checking should be enabled in the current
+ function. */
+ int limit_stack;
+
+ /* Number of function calls seen so far in current function. */
+ int x_function_call_count;
+
+ /* 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. */
+ int x_whole_function_mode_p;
+
+ /* 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. */
+ int x_dont_save_pending_sizes_p;
+
+ /* 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;
+