/* Front-end tree definitions for GNU compiler.
- Copyright (C) 1989, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include "machmode.h"
BUILT_IN_CONSTANT_P,
BUILT_IN_FRAME_ADDRESS,
BUILT_IN_RETURN_ADDRESS,
+ BUILT_IN_AGGREGATE_INCOMING_ADDRESS,
BUILT_IN_CALLER_RETURN_ADDRESS,
BUILT_IN_APPLY_ARGS,
BUILT_IN_APPLY,
BUILT_IN_RETURN,
+ BUILT_IN_SETJMP,
+ BUILT_IN_LONGJMP,
+
+ /* Various hooks for the DWARF 2 __throw routine. */
+ BUILT_IN_FP, BUILT_IN_SP,
+ BUILT_IN_UNWIND_INIT,
+ BUILT_IN_DWARF_FP_REGNUM,
+ BUILT_IN_DWARF_REG_SIZE,
+ BUILT_IN_FROB_RETURN_ADDR,
+ BUILT_IN_EXTRACT_RETURN_ADDR,
+ BUILT_IN_SET_RETURN_ADDR_REG,
+ BUILT_IN_EH_STUB,
+ BUILT_IN_SET_EH_REGS,
/* C++ extensions */
BUILT_IN_NEW,
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
- /* There is room for two more flags. */
+ /* There is room for three more flags. */
};
+/* The following table lists the uses of each of the above flags and
+ for which types of nodes they are defined. Note that expressions
+ include decls.
+
+ addressable_flag:
+
+ TREE_ADDRESSABLE in
+ VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, LABEL_DECL, ..._TYPE
+ IDENTIFIER_NODE
+
+ static_flag:
+
+ TREE_STATIC in
+ VAR_DECL, FUNCTION_DECL, CONSTRUCTOR
+ TREE_NO_UNUSED_WARNING in
+ CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR
+ TREE_VIA_VIRTUAL in
+ TREE_LIST or TREE_VEC
+ TREE_CONSTANT_OVERFLOW in
+ INTEGER_CST, REAL_CST, COMPLEX_CST
+ TREE_SYMBOL_REFERENCED in
+ IDENTIFIER_NODE
+
+ public_flag:
+
+ TREE_OVERFLOW in
+ INTEGER_CST, REAL_CST, COMPLEX_CST
+ TREE_PUBLIC in
+ VAR_DECL or FUNCTION_DECL
+ TREE_VIA_PUBLIC in
+ TREE_LIST or TREE_VEC
+
+ private_flag:
+
+ TREE_VIA_PRIVATE in
+ TREE_LIST or TREE_VEC
+ TREE_PRIVATE in
+ ??? unspecified nodes
+
+ protected_flag:
+
+ TREE_VIA_PROTECTED in
+ TREE_LIST
+ TREE_PROTECTED in
+ BLOCK
+ ??? unspecified nodes
+
+ side_effects_flag:
+
+ TREE_SIDE_EFFECTS in
+ all expressions
+
+ volatile_flag:
+
+ TREE_THIS_VOLATILE in
+ all expressions
+ TYPE_VOLATILE in
+ ..._TYPE
+
+ readonly_flag:
+
+ TREE_READONLY in
+ VAR_DECL, PARM_DECL, FIELD_DECL, ..._REF
+ ITERATOR_BOUND_P in
+ VAR_DECL if iterator (C)
+ TYPE_READONLY in
+ ..._TYPE
+
+ constant_flag:
+
+ TREE_CONSTANT in
+ all expressions
+
+ permanent_flag: TREE_PERMANENT in all nodes
+
+ unsigned_flag:
+
+ TREE_UNSIGNED in
+ INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
+ DECL_BUILT_IN_NONANSI in
+ FUNCTION_DECL
+ TREE_PARMLIST in
+ TREE_PARMLIST (C++)
+ SAVE_EXPR_NOPLACEHOLDER in
+ SAVE_EXPR
+
+ asm_written_flag:
+
+ TREE_ASM_WRITTEN in
+ VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
+ BLOCK
+
+ used_flag:
+
+ TREE_USED in
+ expressions, IDENTIFIER_NODE
+
+ raises_flag:
+
+ TREE_RAISES in
+ expressions
+
+ */
/* Define accessors for the fields that all tree nodes have
(though some fields are not used for all kinds of nodes). */
struct tree_int_cst
{
char common[sizeof (struct tree_common)];
+ struct rtx_def *rtl; /* acts as link to register transfer language
+ (rtl) info */
HOST_WIDE_INT int_cst_low;
HOST_WIDE_INT int_cst_high;
};
/* In a SAVE_EXPR node. */
#define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND(NODE, 1)
#define SAVE_EXPR_RTL(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[2])
+#define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (NODE)
/* In a RTL_EXPR node. */
#define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &(NODE)->exp.operands[0])
#define TYPE_MIN_VALUE(NODE) ((NODE)->type.minval)
#define TYPE_MAX_VALUE(NODE) ((NODE)->type.maxval)
#define TYPE_PRECISION(NODE) ((NODE)->type.precision)
-#define TYPE_PARSE_INFO(NODE) ((NODE)->type.parse_info)
#define TYPE_SYMTAB_ADDRESS(NODE) ((NODE)->type.symtab.address)
#define TYPE_SYMTAB_POINTER(NODE) ((NODE)->type.symtab.pointer)
#define TYPE_NAME(NODE) ((NODE)->type.name)
If set in a SET_TYPE, indicates a bitstring type. */
#define TYPE_STRING_FLAG(NODE) ((NODE)->type.string_flag)
+/* If non-NULL, this is a upper bound of the size (in bytes) of an
+ object of the given ARRAY_TYPE. This allows temporaries to be allocated. */
+#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) TYPE_MAX_VALUE (ARRAY_TYPE)
+
/* Indicates that objects of this type must be initialized by calling a
function when they are created. */
#define TYPE_NEEDS_CONSTRUCTING(NODE) ((NODE)->type.needs_constructing_flag)
the same way that the first union alternative would be passed. */
#define TYPE_TRANSPARENT_UNION(NODE) ((NODE)->type.transparent_union_flag)
+/* Indicated that objects of this type should be layed out in as
+ compact a way as possible. */
+#define TYPE_PACKED(NODE) ((NODE)->type.packed_flag)
+
struct tree_type
{
char common[sizeof (struct tree_common)];
unsigned no_force_blk_flag : 1;
unsigned needs_constructing_flag : 1;
unsigned transparent_union_flag : 1;
+ unsigned packed_flag : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_2 : 1;
unsigned lang_flag_4 : 1;
unsigned lang_flag_5 : 1;
unsigned lang_flag_6 : 1;
- /* room for 5 more bits */
+ /* room for 4 more bits */
unsigned int align;
union tree_node *pointer_to;
union tree_node *reference_to;
- int parse_info;
union {int address; char *pointer; } symtab;
union tree_node *name;
union tree_node *minval;
/* For FIELD_DECLs, this is the
RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is
a member of. For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
- and CONST_DECL nodes, this points to the FUNCTION_DECL for the
- containing function, or else yields NULL_TREE if the given decl has "file scope". */
+ and CONST_DECL nodes, this points to either the FUNCTION_DECL for the
+ containing function, the RECORD_TYPE or UNION_TYPE for the containing
+ type, or NULL_TREE if the given decl has "file scope". */
#define DECL_CONTEXT(NODE) ((NODE)->decl.context)
#define DECL_FIELD_CONTEXT(NODE) ((NODE)->decl.context)
/* In a DECL this is the field where configuration dependent machine
#define DECL_ARGUMENTS(NODE) ((NODE)->decl.arguments)
/* In FUNCTION_DECL, holds the decl for the return value. */
#define DECL_RESULT(NODE) ((NODE)->decl.result)
+/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
+#define DECL_ORIGINAL_TYPE(NODE) ((NODE)->decl.result)
/* In PARM_DECL, holds the type as written (perhaps a function or array). */
#define DECL_ARG_TYPE_AS_WRITTEN(NODE) ((NODE)->decl.result)
/* For a FUNCTION_DECL, holds the tree of BINDINGs.
/* For any sort of a ..._DECL node, this points to the original (abstract)
decl node which this decl is an instance of, or else it is NULL indicating
- that this decl is not an instance of some other decl. */
+ that this decl is not an instance of some other decl. For example,
+ in a nested declaration of an inline function, this points back to the
+ definition. */
#define DECL_ABSTRACT_ORIGIN(NODE) ((NODE)->decl.abstract_origin)
/* Nonzero for any sort of ..._DECL node means this decl node represents
/* Nonzero for a given ..._DECL node means that this node represents an
"abstract instance" of the given declaration (e.g. in the original
declaration of an inline function). When generating symbolic debugging
- information, we musn't try to generate any address information for nodes
+ information, we mustn't try to generate any address information for nodes
marked as "abstract instances" because we don't actually generate
any code or allocate any data space for such instances. */
#define DECL_ABSTRACT(NODE) ((NODE)->decl.abstract_flag)
#define TYPE_DECL_SUPPRESS_DEBUG(NODE) ((NODE)->decl.external_flag)
-/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.
- In LABEL_DECL nodes, nonzero means that an error message about
- jumping into such a binding contour has been printed for this label. */
+/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
#define DECL_REGISTER(NODE) ((NODE)->decl.regdecl_flag)
+/* In LABEL_DECL nodes, nonzero means that an error message about
+ jumping into such a binding contour has been printed for this label. */
+#define DECL_ERROR_ISSUED(NODE) ((NODE)->decl.regdecl_flag)
/* In a FIELD_DECL, indicates this field should be bit-packed. */
#define DECL_PACKED(NODE) ((NODE)->decl.regdecl_flag)
+/* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a
+ static chain is not needed. */
+#define DECL_NO_STATIC_CHAIN(NODE) ((NODE)->decl.regdecl_flag)
/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
#define DECL_STATIC_CONSTRUCTOR(NODE) ((NODE)->decl.static_ctor_flag)
#define DECL_STATIC_DESTRUCTOR(NODE) ((NODE)->decl.static_dtor_flag)
+/* Used to indicate that this DECL represents a compiler-generated entity. */
+#define DECL_ARTIFICIAL(NODE) ((NODE)->decl.artificial_flag)
+
+/* Used to indicate that this DECL has weak linkage. */
+#define DECL_WEAK(NODE) ((NODE)->decl.weak_flag)
+
+/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
+ multiple translation units should be merged. */
+#define DECL_ONE_ONLY(NODE) ((NODE)->decl.transparent_union)
+
/* Additional flags for language-specific uses. */
#define DECL_LANG_FLAG_0(NODE) ((NODE)->decl.lang_flag_0)
#define DECL_LANG_FLAG_1(NODE) ((NODE)->decl.lang_flag_1)
char common[sizeof (struct tree_common)];
char *filename;
int linenum;
- union tree_node *size;
unsigned int uid;
+ union tree_node *size;
#ifdef ONLY_INT_FIELDS
int mode : 8;
#else
unsigned transparent_union : 1;
unsigned static_ctor_flag : 1;
unsigned static_dtor_flag : 1;
- /* room for two more */
+ unsigned artificial_flag : 1;
+ unsigned weak_flag : 1;
+ /* room for no more */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
+ /* For a FUNCTION_DECL, if inline, this is the size of frame needed.
+ If built-in, this is the code for which built-in function.
+ For other kinds of decls, this is DECL_ALIGN. */
+ union {
+ int i;
+ unsigned int u;
+ enum built_in_function f;
+ } frame_size;
+
union tree_node *name;
union tree_node *context;
union tree_node *arguments;
union tree_node *machine_attributes;
struct rtx_def *rtl; /* acts as link to register transfer language
(rtl) info */
- /* For a FUNCTION_DECL, if inline, this is the size of frame needed.
- If built-in, this is the code for which built-in function.
- For other kinds of decls, this is DECL_ALIGN. */
- union {
- int i;
- unsigned int u;
- enum built_in_function f;
- } frame_size;
/* For FUNCTION_DECLs: points to insn that constitutes its definition
on the permanent obstack. For any other kind of decl, this is the
alignment. */
union {
struct rtx_def *r;
- int i;
+ HOST_WIDE_INT i;
} saved_insns;
union tree_node *vindex;
/* Points to a structure whose details depend on the language in use. */
struct tree_exp exp;
struct tree_block block;
};
-
-/* Add prototype support. */
-#ifndef PROTO
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define PROTO(ARGS) ARGS
-#else
-#define PROTO(ARGS) ()
-#endif
-#endif
-
-#ifndef VPROTO
-#ifdef __STDC__
-#define PVPROTO(ARGS) ARGS
-#define VPROTO(ARGS) ARGS
-#define VA_START(va_list,var) va_start(va_list,var)
-#else
-#define PVPROTO(ARGS) ()
-#define VPROTO(ARGS) (va_alist) va_dcl
-#define VA_START(va_list,var) va_start(va_list)
-#endif
-#endif
-
-#ifndef STDIO_PROTO
-#ifdef BUFSIZ
-#define STDIO_PROTO(ARGS) PROTO(ARGS)
-#else
-#define STDIO_PROTO(ARGS) ()
-#endif
-#endif
+\f
+#include "gansidecl.h"
#define NULL_TREE (tree) NULL
-/* Define a generic NULL if one hasn't already been defined. */
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef GENERIC_PTR
-#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
-#define GENERIC_PTR void *
-#else
-#define GENERIC_PTR char *
-#endif
-#endif
-
-#ifndef NULL_PTR
-#define NULL_PTR ((GENERIC_PTR)0)
-#endif
-\f
/* The following functions accept a wide integer argument. Rather than
having to cast on every function call, we use a macro instead, that is
defined here and in rtl.h. */
extern char *xrealloc ();
#endif
+extern char *xstrdup PROTO((char *));
+
extern char *oballoc PROTO((int));
extern char *permalloc PROTO((int));
extern char *savealloc PROTO((int));
+extern char *expralloc PROTO((int));
extern void free PROTO((void *));
/* Lowest level primitive for allocating a node.
extern tree get_identifier PROTO((char *));
+/* If an identifier with the name TEXT (a null-terminated string) has
+ previously been referred to, return that node; otherwise return
+ NULL_TREE. */
+
+extern tree maybe_get_identifier PROTO((char *));
+
/* Construct various types of nodes. */
#define build_int_2(LO,HI) \
extern tree build_int_2_wide PROTO((HOST_WIDE_INT, HOST_WIDE_INT));
extern tree build_real PROTO((tree, REAL_VALUE_TYPE));
extern tree build_real_from_int_cst PROTO((tree, tree));
-extern tree build_complex PROTO((tree, tree));
+extern tree build_complex PROTO((tree, tree, tree));
extern tree build_string PROTO((int, char *));
extern tree build1 PROTO((enum tree_code, tree, tree));
extern tree build_tree_list PROTO((tree, tree));
extern tree build_decl_list PROTO((tree, tree));
+extern tree build_expr_list PROTO((tree, tree));
extern tree build_decl PROTO((enum tree_code, tree, tree));
extern tree build_block PROTO((tree, tree, tree, tree, tree));
extern tree value_member PROTO((tree, tree));
extern tree purpose_member PROTO((tree, tree));
extern tree binfo_member PROTO((tree, tree));
+extern int attribute_hash_list PROTO((tree));
extern int attribute_list_equal PROTO((tree, tree));
extern int attribute_list_contained PROTO((tree, tree));
extern int tree_int_cst_equal PROTO((tree, tree));
extern tree build_type_attribute_variant PROTO((tree, tree));
extern tree build_decl_attribute_variant PROTO((tree, tree));
+/* Return 1 if an attribute and its arguments are valid for a decl or type. */
+
+extern int valid_machine_attribute PROTO((tree, tree, tree, tree));
+
+/* Given a tree node and a string, return non-zero if the tree node is
+ a valid attribute name for the string. */
+
+extern int is_attribute_p PROTO((char *, tree));
+
+/* Given an attribute name and a list of attributes, return the list element
+ of the attribute or NULL_TREE if not found. */
+
+extern tree lookup_attribute PROTO((char *, tree));
+
+/* Given two attributes lists, return a list of their union. */
+
+extern tree merge_attributes PROTO((tree, tree));
+
/* Given a type node TYPE, and CONSTP and VOLATILEP, return a type
for the same kind of data as TYPE describes.
Variants point to the "main variant" (which has neither CONST nor VOLATILE)
extern tree size_in_bytes PROTO((tree));
extern int int_size_in_bytes PROTO((tree));
extern tree size_binop PROTO((enum tree_code, tree, tree));
-extern tree size_int PROTO((unsigned));
+extern tree size_int PROTO((unsigned HOST_WIDE_INT));
extern tree round_up PROTO((tree, int));
extern tree get_pending_sizes PROTO((void));
+extern void put_pending_sizes PROTO((tree));
/* Type for sizes of data-type. */
/* If nonzero, an upper limit on alignment of structure fields, in bits. */
extern int maximum_field_alignment;
-/* If non-zero, the alignment of a bitsting or (power-)set value, in bits. */
+/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
extern int set_alignment;
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
extern tree temp_tree_cons PROTO((tree, tree, tree));
extern tree saveable_tree_cons PROTO((tree, tree, tree));
extern tree decl_tree_cons PROTO((tree, tree, tree));
+extern tree expr_tree_cons PROTO((tree, tree, tree));
/* Return the last tree node in a chain. */
extern tree save_expr PROTO((tree));
+/* unsave_expr (EXP) returns an expression equivalent to EXP but it
+ can be used multiple times and will evaluate EXP, in it's entirety
+ each time. */
+
+extern tree unsave_expr PROTO((tree));
+
+/* unsave_expr_now (EXP) resets EXP in place, so that it can be
+ expanded again. */
+
+extern tree unsave_expr_now PROTO((tree));
+
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
or offset that depends on a field within a record.
extern tree substitute_in_expr PROTO((tree, tree, tree));
-/* Given a type T, a FIELD_DECL F, and a replacement value R,
- return a new type with all size expressions that contain F
- updated by replacing the reference to F with R. */
-
-extern tree substitute_in_type PROTO((tree, tree, tree));
-
/* variable_size (EXP) is like save_expr (EXP) except that it
is for the special case of something that is part of a
variable size for a data type. It makes special arrangements
look for nested component-refs or array-refs at constant positions
and find the ultimate containing object, which is returned. */
-extern tree get_inner_reference PROTO((tree, int *, int *, tree *, enum machine_mode *, int *, int *));
+extern tree get_inner_reference PROTO((tree, int *, int *, tree *,
+ enum machine_mode *, int *,
+ int *, int *));
/* Return the FUNCTION_DECL which provides this _DECL with its context,
or zero if none. */
extern int all_types_permanent;
-/* Pointer to function to compute the name to use to print a declaration. */
+/* Pointer to function to compute the name to use to print a declaration.
+ DECL is the declaration in question.
+ VERBOSITY determines what information will be printed:
+ 0: DECL_NAME, demangled as necessary.
+ 1: and scope information.
+ 2: and any other information that might be interesting, such as function
+ parameter types in C++. */
-extern char *(*decl_printable_name) ();
+extern char *(*decl_printable_name) (/* tree decl, int verbosity */);
/* Pointer to function to finish handling an incomplete decl at the
end of compilation. */
\f
/* In tree.c */
extern char *perm_calloc PROTO((int, long));
-extern tree get_set_constructor_bits PROTO((tree, char*, int));
+extern tree get_file_function_name PROTO((int));
+extern tree get_set_constructor_bits PROTO((tree, char *, int));
extern tree get_set_constructor_bytes PROTO((tree,
- unsigned char*, int));
+ unsigned char *, int));
\f
/* In stmt.c */
extern tree expand_start_stmt_expr PROTO((void));
extern tree expand_end_stmt_expr PROTO((tree));
extern void expand_expr_stmt PROTO((tree));
+extern int warn_if_unused_value PROTO((tree));
extern void expand_decl_init PROTO((tree));
extern void clear_last_expr PROTO((void));
extern void expand_label PROTO((tree));
extern void expand_return PROTO((tree));
extern void expand_start_bindings PROTO((int));
extern void expand_end_bindings PROTO((tree, int, int));
+extern void start_cleanup_deferal PROTO((void));
+extern void end_cleanup_deferal PROTO((void));
+extern void mark_block_as_eh_region PROTO((void));
+extern void mark_block_as_not_eh_region PROTO((void));
+extern int is_eh_region PROTO((void));
+extern int conditional_context PROTO((void));
extern tree last_cleanup_this_contour PROTO((void));
+extern int expand_dhc_cleanup PROTO((tree));
+extern int expand_dcc_cleanup PROTO((tree));
extern void expand_start_case PROTO((int, tree, tree,
char *));
extern void expand_end_case PROTO((tree));
extern void lang_init PROTO((void));
extern void lang_finish PROTO((void));
-/* Funtion to identify which front-end produced the output file. */
+/* Function to identify which front-end produced the output file. */
extern char *lang_identify PROTO((void));
/* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy. */
/* Pop the obstack selection stack. */
extern void pop_obstacks PROTO((void));
+
+/* If KIND=='I', return a suitable global initializer (constructor) name.
+ If KIND=='D', return a suitable global clean-up (destructor) name. */
+extern tree get_file_function_name PROTO((int));
+\f
+/* Interface of the DWARF2 unwind info support. */
+
+/* Decide whether we want to emit frame unwind information for the current
+ translation unit. */
+
+extern int dwarf2out_do_frame PROTO((void));
+
+/* Generate a new label for the CFI info to refer to. */
+
+extern char *dwarf2out_cfi_label PROTO((void));
+
+/* Entry point to update the canonical frame address (CFA). */
+
+extern void dwarf2out_def_cfa PROTO((char *, unsigned, long));
+
+/* Add the CFI for saving a register window. */
+
+extern void dwarf2out_window_save PROTO((char *));
+
+/* Add a CFI to update the running total of the size of arguments pushed
+ onto the stack. */
+
+extern void dwarf2out_args_size PROTO((char *, long));
+
+/* Entry point for saving a register to the stack. */
+
+extern void dwarf2out_reg_save PROTO((char *, unsigned, long));
+
+/* Entry point for saving the return address in the stack. */
+
+extern void dwarf2out_return_save PROTO((char *, long));
+
+/* Entry point for saving the return address in a register. */
+
+extern void dwarf2out_return_reg PROTO((char *, unsigned));
+
+/* Output a marker (i.e. a label) for the beginning of a function, before
+ the prologue. */
+
+extern void dwarf2out_begin_prologue PROTO((void));
+
+/* Output a marker (i.e. a label) for the absolute end of the generated
+ code for a function definition. */
+
+extern void dwarf2out_end_epilogue PROTO((void));
OSDN Git Service
