get rid of PROTO macros

1 files changed, 374 insertions, 374 deletions

diff --git a/gcc/tree.h b/gcc/tree.h
index e5d03d1..aa6a008 100755
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1373,102 +1373,102 @@ union tree_node
 #define exact_log2(N) exact_log2_wide ((unsigned HOST_WIDE_INT) (N))
 #define floor_log2(N) floor_log2_wide ((unsigned HOST_WIDE_INT) (N))
 #endif
-extern int exact_log2_wide             PROTO((unsigned HOST_WIDE_INT));
-extern int floor_log2_wide             PROTO((unsigned HOST_WIDE_INT));
+extern int exact_log2_wide             (unsigned HOST_WIDE_INT);
+extern int floor_log2_wide             (unsigned HOST_WIDE_INT);
 
-extern char *oballoc			PROTO((int));
-extern char *permalloc			PROTO((int));
-extern char *savealloc			PROTO((int));
-extern char *expralloc			PROTO((int));
+extern char *oballoc			(int);
+extern char *permalloc			(int);
+extern char *savealloc			(int);
+extern char *expralloc			(int);
 
 /* Lowest level primitive for allocating a node.
    The TREE_CODE is the only argument.  Contents are initialized
    to zero except for a few of the common fields.  */
 
-extern tree make_node			PROTO((enum tree_code));
+extern tree make_node			(enum tree_code);
 
 /* Make a copy of a node, with all the same contents except
    for TREE_PERMANENT.  (The copy is permanent
    iff nodes being made now are permanent.)  */
 
-extern tree copy_node			PROTO((tree));
+extern tree copy_node			(tree);
 
 /* Make a copy of a chain of TREE_LIST nodes.  */
 
-extern tree copy_list			PROTO((tree));
+extern tree copy_list			(tree);
 
 /* Make a TREE_VEC.  */
 
-extern tree make_tree_vec		PROTO((int));
+extern tree make_tree_vec		(int);
 
 /* Return the (unique) IDENTIFIER_NODE node for a given name.
    The name is supplied as a char *.  */
 
-extern tree get_identifier		PROTO((char *));
+extern tree get_identifier		(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 *));
+extern tree maybe_get_identifier	(char *);
 
 /* Construct various types of nodes.  */
 
 #define build_int_2(LO,HI)  \
   build_int_2_wide ((HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
 
-extern tree build			PVPROTO((enum tree_code, tree, ...));
-extern tree build_nt			PVPROTO((enum tree_code, ...));
-extern tree build_parse_node		PVPROTO((enum tree_code, ...));
-
-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, 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 build_expr_wfl              PROTO((tree, char *, int, int));
+extern tree build			(enum tree_code, tree, ...);
+extern tree build_nt			(enum tree_code, ...);
+extern tree build_parse_node		(enum tree_code, ...);
+
+extern tree build_int_2_wide		(HOST_WIDE_INT, HOST_WIDE_INT);
+extern tree build_real			(tree, REAL_VALUE_TYPE);
+extern tree build_real_from_int_cst 	(tree, tree);
+extern tree build_complex		(tree, tree, tree);
+extern tree build_string		(int, char *);
+extern tree build1			(enum tree_code, tree, tree);
+extern tree build_tree_list		(tree, tree);
+extern tree build_decl_list		(tree, tree);
+extern tree build_expr_list		(tree, tree);
+extern tree build_decl			(enum tree_code, tree, tree);
+extern tree build_block			(tree, tree, tree, tree, tree);
+extern tree build_expr_wfl              (tree, char *, int, int);
 
 /* Construct various nodes representing data types.  */
 
-extern tree make_signed_type		PROTO((int));
-extern tree make_unsigned_type		PROTO((int));
-extern void set_sizetype		PROTO((tree));
-extern tree signed_or_unsigned_type 	PROTO((int, tree));
-extern void fixup_unsigned_type		PROTO((tree));
-extern tree build_pointer_type		PROTO((tree));
-extern tree build_reference_type 	PROTO((tree));
-extern tree build_index_type		PROTO((tree));
-extern tree build_index_2_type		PROTO((tree, tree));
-extern tree build_array_type		PROTO((tree, tree));
-extern tree build_function_type		PROTO((tree, tree));
-extern tree build_method_type		PROTO((tree, tree));
-extern tree build_offset_type		PROTO((tree, tree));
-extern tree build_complex_type		PROTO((tree));
-extern tree array_type_nelts		PROTO((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 int tree_int_cst_lt		PROTO((tree, tree));
-extern int tree_int_cst_sgn		PROTO((tree));
-extern int index_type_equal		PROTO((tree, tree));
-extern tree get_inner_array_type	PROTO((tree));
+extern tree make_signed_type		(int);
+extern tree make_unsigned_type		(int);
+extern void set_sizetype		(tree);
+extern tree signed_or_unsigned_type 	(int, tree);
+extern void fixup_unsigned_type		(tree);
+extern tree build_pointer_type		(tree);
+extern tree build_reference_type 	(tree);
+extern tree build_index_type		(tree);
+extern tree build_index_2_type		(tree, tree);
+extern tree build_array_type		(tree, tree);
+extern tree build_function_type		(tree, tree);
+extern tree build_method_type		(tree, tree);
+extern tree build_offset_type		(tree, tree);
+extern tree build_complex_type		(tree);
+extern tree array_type_nelts		(tree);
+
+extern tree value_member		(tree, tree);
+extern tree purpose_member		(tree, tree);
+extern tree binfo_member		(tree, tree);
+extern int attribute_hash_list		(tree);
+extern int attribute_list_equal		(tree, tree);
+extern int attribute_list_contained	(tree, tree);
+extern int tree_int_cst_equal		(tree, tree);
+extern int tree_int_cst_lt		(tree, tree);
+extern int tree_int_cst_sgn		(tree);
+extern int index_type_equal		(tree, tree);
+extern tree get_inner_array_type	(tree);
 
 /* From expmed.c.  Since rtl.h is included after tree.h, we can't
    put the prototype here.  Rtl.h does declare the prototype if
    tree.h had been included.  */
 
-extern tree make_tree			PROTO((tree, struct rtx_def *));
+extern tree make_tree			(tree, struct rtx_def *);
 
 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
    is ATTRIBUTE.
@@ -1476,37 +1476,37 @@ extern tree make_tree			PROTO((tree, struct rtx_def *));
    Such modified types already made are recorded so that duplicates
    are not made. */
 
-extern tree build_type_attribute_variant PROTO((tree, tree));
-extern tree build_decl_attribute_variant PROTO((tree, tree));
+extern tree build_type_attribute_variant (tree, tree);
+extern tree build_decl_attribute_variant (tree, tree);
 
-extern tree merge_machine_decl_attributes PROTO((tree, tree));
-extern tree merge_machine_type_attributes PROTO((tree, tree));
+extern tree merge_machine_decl_attributes (tree, tree);
+extern tree merge_machine_type_attributes (tree, tree);
 
 /* Split a list of declspecs and attributes into two.  */
 
-extern void split_specs_attrs		PROTO((tree, tree *, tree *));
+extern void split_specs_attrs		(tree, tree *, tree *);
 
 /* Strip attributes from a list of combined specs and attrs.  */
 
-extern tree strip_attrs			PROTO((tree));
+extern tree strip_attrs			(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));
+extern int valid_machine_attribute	(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));
+extern int is_attribute_p		(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));
+extern tree lookup_attribute		(char *, tree);
 
 /* Given two attributes lists, return a list of their union.  */
 
-extern tree merge_attributes		PROTO((tree, tree));
+extern tree merge_attributes		(tree, tree);
 
 /* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
    the same kind of data as TYPE describes.  Variants point to the
@@ -1515,7 +1515,7 @@ extern tree merge_attributes		PROTO((tree, tree));
    variants are never made.  Only main variants should ever appear as
    types of expressions.  */
 
-extern tree build_qualified_type        PROTO((tree, int));
+extern tree build_qualified_type        (tree, int);
 
 /* Like build_qualified_type, but only deals with the `const' and
    `volatile' qualifiers.  This interface is retained for backwards
@@ -1529,21 +1529,21 @@ extern tree build_qualified_type        PROTO((tree, int));
 
 /* Make a copy of a type node.  */
 
-extern tree build_type_copy		PROTO((tree));
+extern tree build_type_copy		(tree);
 
 /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
    TYPE_ALIGN and TYPE_MODE fields.
    If called more than once on one node, does nothing except
    for the first time.  */
 
-extern void layout_type			PROTO((tree));
+extern void layout_type			(tree);
 
 /* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
    return a canonicalized ..._TYPE node, so that duplicates are not made.
    How the hash code is computed is up to the caller, as long as any two
    callers that could hash identical-looking type nodes agree.  */
 
-extern tree type_hash_canon		PROTO((int, tree));
+extern tree type_hash_canon		(int, tree);
 
 /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
    calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
@@ -1553,29 +1553,29 @@ extern tree type_hash_canon		PROTO((int, tree));
    be starting at (in bits).  Zero means it can be assumed aligned
    on any boundary that may be needed.  */
 
-extern void layout_decl			PROTO((tree, unsigned));
+extern void layout_decl			(tree, unsigned);
 
 /* Return an expr equal to X but certainly not valid as an lvalue.  */
 
-extern tree non_lvalue			PROTO((tree));
-extern tree pedantic_non_lvalue		PROTO((tree));
+extern tree non_lvalue			(tree);
+extern tree pedantic_non_lvalue		(tree);
 
-extern tree convert			PROTO((tree, tree));
-extern tree size_in_bytes		PROTO((tree));
-extern HOST_WIDE_INT int_size_in_bytes	PROTO((tree));
-extern tree size_binop			PROTO((enum tree_code, tree, tree));
-extern tree ssize_binop			PROTO((enum tree_code, tree, tree));
-extern tree size_int_wide		PROTO((unsigned HOST_WIDE_INT,
-					       unsigned HOST_WIDE_INT, int));
+extern tree convert			(tree, tree);
+extern tree size_in_bytes		(tree);
+extern HOST_WIDE_INT int_size_in_bytes	(tree);
+extern tree size_binop			(enum tree_code, tree, tree);
+extern tree ssize_binop			(enum tree_code, tree, tree);
+extern tree size_int_wide		(unsigned HOST_WIDE_INT,
+					       unsigned HOST_WIDE_INT, int);
 #define size_int(L) size_int_2 ((L), 0, 0)
 #define bitsize_int(L, H) size_int_2 ((L), (H), 1)
 #define size_int_2(L, H, T)			\
   size_int_wide ((unsigned HOST_WIDE_INT) (L),	\
 		 (unsigned HOST_WIDE_INT) (H), (T))
 
-extern tree round_up			PROTO((tree, int));
-extern tree get_pending_sizes		PROTO((void));
-extern void put_pending_sizes		PROTO((tree));
+extern tree round_up			(tree, int);
+extern tree get_pending_sizes		(void);
+extern void put_pending_sizes		(tree);
 
 /* Type for sizes of data-type.  */
 
@@ -1610,79 +1610,79 @@ extern int set_alignment;
    by making the last node in X point to Y.
    Returns X, except if X is 0 returns Y.  */
 
-extern tree chainon			PROTO((tree, tree));
+extern tree chainon			(tree, tree);
 
 /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.  */
 
-extern tree tree_cons			PROTO((tree, tree, tree));
-extern tree perm_tree_cons		PROTO((tree, tree, tree));
-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));
+extern tree tree_cons			(tree, tree, tree);
+extern tree perm_tree_cons		(tree, tree, tree);
+extern tree temp_tree_cons		(tree, tree, tree);
+extern tree saveable_tree_cons		(tree, tree, tree);
+extern tree decl_tree_cons		(tree, tree, tree);
+extern tree expr_tree_cons		(tree, tree, tree);
 
 /* Return the last tree node in a chain.  */
 
-extern tree tree_last			PROTO((tree));
+extern tree tree_last			(tree);
 
 /* Reverse the order of elements in a chain, and return the new head.  */
 
-extern tree nreverse			PROTO((tree));
+extern tree nreverse			(tree);
 
 /* Returns the length of a chain of nodes
    (number of chain pointers to follow before reaching a null pointer).  */
 
-extern int list_length			PROTO((tree));
+extern int list_length			(tree);
 
 /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
 
-extern int integer_zerop		PROTO((tree));
+extern int integer_zerop		(tree);
 
 /* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
 
-extern int integer_onep			PROTO((tree));
+extern int integer_onep			(tree);
 
 /* integer_all_onesp (tree x) is nonzero if X is an integer constant
    all of whose significant bits are 1.  */
 
-extern int integer_all_onesp		PROTO((tree));
+extern int integer_all_onesp		(tree);
 
 /* integer_pow2p (tree x) is nonzero is X is an integer constant with
    exactly one bit 1.  */
 
-extern int integer_pow2p		PROTO((tree));
+extern int integer_pow2p		(tree);
 
 /* staticp (tree x) is nonzero if X is a reference to data allocated
    at a fixed address in memory.  */
 
-extern int staticp			PROTO((tree));
+extern int staticp			(tree);
 
 /* Gets an error if argument X is not an lvalue.
    Also returns 1 if X is an lvalue, 0 if not.  */
 
-extern int lvalue_or_else		PROTO((tree, char *));
+extern int lvalue_or_else		(tree, char *);
 
 /* save_expr (EXP) returns an expression equivalent to EXP
    but it can be used multiple times within context CTX
    and only evaluate EXP once.  */
 
-extern tree save_expr			PROTO((tree));
+extern tree save_expr			(tree);
 
 /* Returns the index of the first non-tree operand for CODE, or the number
    of operands if all are trees.  */
 
-extern int first_rtl_op			PROTO((enum tree_code));
+extern int first_rtl_op			(enum tree_code);
 
 /* unsave_expr (EXP) returns an expression equivalent to EXP but it
    can be used multiple times and will evaluate EXP, in its entirety
    each time.  */
 
-extern tree unsave_expr			PROTO((tree));
+extern tree unsave_expr			(tree);
 
 /* unsave_expr_now (EXP) resets EXP in place, so that it can be
    expanded again.  */
 
-extern tree unsave_expr_now		PROTO((tree));
+extern tree unsave_expr_now		(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.
@@ -1690,19 +1690,19 @@ extern tree unsave_expr_now		PROTO((tree));
    Note that we only allow such expressions within simple arithmetic
    or a COND_EXPR.  */
 
-extern int contains_placeholder_p	PROTO((tree));
+extern int contains_placeholder_p	(tree);
 
 /* Return 1 if EXP contains any expressions that produce cleanups for an
    outer scope to deal with.  Used by fold.  */
 
-extern int has_cleanups			PROTO((tree));
+extern int has_cleanups			(tree);
 
 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
    return a tree with all occurrences of references to F in a
    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
    contains only arithmetic expressions.  */
 
-extern tree substitute_in_expr		PROTO((tree, tree, tree));
+extern tree substitute_in_expr		(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
@@ -1710,93 +1710,93 @@ extern tree substitute_in_expr		PROTO((tree, tree, tree));
    to compute the value at the right time when the data type
    belongs to a function parameter.  */
 
-extern tree variable_size		PROTO((tree));
+extern tree variable_size		(tree);
 
 /* stabilize_reference (EXP) returns an reference equivalent to EXP
    but it can be used multiple times
    and only evaluate the subexpressions once.  */
 
-extern tree stabilize_reference		PROTO((tree));
+extern tree stabilize_reference		(tree);
 
 /* Subroutine of stabilize_reference; this is called for subtrees of
    references.  Any expression with side-effects must be put in a SAVE_EXPR
    to ensure that it is only evaluated once.  */
 
-extern tree stabilize_reference_1	PROTO((tree));
+extern tree stabilize_reference_1	(tree);
 
 /* Return EXP, stripped of any conversions to wider types
    in such a way that the result of converting to type FOR_TYPE
    is the same as if EXP were converted to FOR_TYPE.
    If FOR_TYPE is 0, it signifies EXP's type.  */
 
-extern tree get_unwidened		PROTO((tree, tree));
+extern tree get_unwidened		(tree, tree);
 
 /* Return OP or a simpler expression for a narrower value
    which can be sign-extended or zero-extended to give back OP.
    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
    or 0 if the value should be sign-extended.  */
 
-extern tree get_narrower		PROTO((tree, int *));
+extern tree get_narrower		(tree, int *);
 
 /* Given MODE and UNSIGNEDP, return a suitable type-tree
    with that mode.
    The definition of this resides in language-specific code
    as the repertoire of available types may vary.  */
 
-extern tree type_for_mode		PROTO((enum machine_mode, int));
+extern tree type_for_mode		(enum machine_mode, int);
 
 /* Given PRECISION and UNSIGNEDP, return a suitable type-tree
    for an integer type with at least that precision.
    The definition of this resides in language-specific code
    as the repertoire of available types may vary.  */
 
-extern tree type_for_size		PROTO((unsigned, int));
+extern tree type_for_size		(unsigned, int);
 
 /* Given an integer type T, return a type like T but unsigned.
    If T is unsigned, the value is T.
    The definition of this resides in language-specific code
    as the repertoire of available types may vary.  */
 
-extern tree unsigned_type		PROTO((tree));
+extern tree unsigned_type		(tree);
 
 /* Given an integer type T, return a type like T but signed.
    If T is signed, the value is T.
    The definition of this resides in language-specific code
    as the repertoire of available types may vary.  */
 
-extern tree signed_type			PROTO((tree));
+extern tree signed_type			(tree);
 
 /* This function must be defined in the language-specific files.
    expand_expr calls it to build the cleanup-expression for a TARGET_EXPR.
    This is defined in a language-specific file.  */
 
-extern tree maybe_build_cleanup		PROTO((tree));
+extern tree maybe_build_cleanup		(tree);
 
 /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
    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 *,
+extern tree get_inner_reference		(tree, int *, int *, tree *,
 					       enum machine_mode *, int *,
-					       int *, int *));
+					       int *, int *);
 
 /* Return the FUNCTION_DECL which provides this _DECL with its context,
    or zero if none.  */
-extern tree decl_function_context 	PROTO((tree));
+extern tree decl_function_context 	(tree);
 
 /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
    this _DECL with its context, or zero if none.  */
-extern tree decl_type_context		PROTO((tree));
+extern tree decl_type_context		(tree);
 
 /* Given the FUNCTION_DECL for the current function,
    return zero if it is ok for this function to be inline.
    Otherwise return a warning message with a single %s
    for the function's name.  */
 
-extern char *function_cannot_inline_p 	PROTO((tree));
+extern char *function_cannot_inline_p 	(tree);
 
 /* Return 1 if EXPR is the real constant zero.  */
-extern int real_zerop PROTO((tree));
+extern int real_zerop (tree);
 
 /* Declare commonly used variables for tree structure.  */
 
@@ -1875,75 +1875,75 @@ extern int all_types_permanent;
      2: and any other information that might be interesting, such as function
         parameter types in C++.  */
 
-extern char *(*decl_printable_name)		PROTO((tree, int));
+extern char *(*decl_printable_name)		(tree, int);
 
 /* Pointer to function to finish handling an incomplete decl at the
    end of compilation.  */
 
-extern void (*incomplete_decl_finalize_hook)	PROTO((tree));
+extern void (*incomplete_decl_finalize_hook)	(tree);
 
 /* In tree.c */
-extern char *perm_calloc			PROTO((int, long));
-extern tree get_file_function_name		PROTO((int));
-extern tree get_file_function_name_long 	PROTO((char *));
-extern tree get_set_constructor_bits		PROTO((tree, char *, int));
-extern tree get_set_constructor_bytes		PROTO((tree,
-						       unsigned char *, int));
-extern int get_alias_set                        PROTO((tree));
-extern int new_alias_set			PROTO((void));
-extern int (*lang_get_alias_set)                PROTO((tree));
+extern char *perm_calloc			(int, long);
+extern tree get_file_function_name		(int);
+extern tree get_file_function_name_long 	(char *);
+extern tree get_set_constructor_bits		(tree, char *, int);
+extern tree get_set_constructor_bytes		(tree,
+						       unsigned char *, int);
+extern int get_alias_set                        (tree);
+extern int new_alias_set			(void);
+extern int (*lang_get_alias_set)                (tree);
 
 /* In stmt.c */
 
-extern void expand_fixups			PROTO((struct rtx_def *));
-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_goto				PROTO((tree));
-extern void expand_asm				PROTO((tree));
-extern void expand_start_cond			PROTO((tree, int));
-extern void expand_end_cond			PROTO((void));
-extern void expand_start_else			PROTO((void));
-extern void expand_start_elseif			PROTO((tree));
-extern struct nesting *expand_start_loop 	PROTO((int));
-extern struct nesting *expand_start_loop_continue_elsewhere 	PROTO((int));
-extern void expand_loop_continue_here		PROTO((void));
-extern void expand_end_loop			PROTO((void));
-extern int expand_continue_loop			PROTO((struct nesting *));
-extern int expand_exit_loop			PROTO((struct nesting *));
-extern int expand_exit_loop_if_false		PROTO((struct nesting *,
-						       tree));
-extern int expand_exit_something		PROTO((void));
-
-extern void expand_null_return			PROTO((void));
-extern void expand_return			PROTO((tree));
-extern int optimize_tail_recursion		PROTO((tree, struct rtx_def *));
-extern void expand_start_bindings		PROTO((int));
-extern void expand_end_bindings			PROTO((tree, int, int));
-extern void start_cleanup_deferral		PROTO((void));
-extern void end_cleanup_deferral		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 int pushcase				PROTO((tree,
+extern void expand_fixups			(struct rtx_def *);
+extern tree expand_start_stmt_expr		(void);
+extern tree expand_end_stmt_expr		(tree);
+extern void expand_expr_stmt			(tree);
+extern int warn_if_unused_value			(tree);
+extern void expand_decl_init			(tree);
+extern void clear_last_expr			(void);
+extern void expand_label			(tree);
+extern void expand_goto				(tree);
+extern void expand_asm				(tree);
+extern void expand_start_cond			(tree, int);
+extern void expand_end_cond			(void);
+extern void expand_start_else			(void);
+extern void expand_start_elseif			(tree);
+extern struct nesting *expand_start_loop 	(int);
+extern struct nesting *expand_start_loop_continue_elsewhere 	(int);
+extern void expand_loop_continue_here		(void);
+extern void expand_end_loop			(void);
+extern int expand_continue_loop			(struct nesting *);
+extern int expand_exit_loop			(struct nesting *);
+extern int expand_exit_loop_if_false		(struct nesting *,
+						       tree);
+extern int expand_exit_something		(void);
+
+extern void expand_null_return			(void);
+extern void expand_return			(tree);
+extern int optimize_tail_recursion		(tree, struct rtx_def *);
+extern void expand_start_bindings		(int);
+extern void expand_end_bindings			(tree, int, int);
+extern void start_cleanup_deferral		(void);
+extern void end_cleanup_deferral		(void);
+extern void mark_block_as_eh_region		(void);
+extern void mark_block_as_not_eh_region		(void);
+extern int is_eh_region				(void);
+extern int conditional_context			(void);
+extern tree last_cleanup_this_contour		(void);
+extern int expand_dhc_cleanup			(tree);
+extern int expand_dcc_cleanup			(tree);
+extern void expand_start_case			(int, tree, tree,
+						       char *);
+extern void expand_end_case			(tree);
+extern int pushcase				(tree,
 						       tree (*) (tree, tree),
-						       tree, tree *));
-extern int pushcase_range			PROTO((tree, tree,
+						       tree, tree *);
+extern int pushcase_range			(tree, tree,
 						       tree (*) (tree, tree),
-						       tree, tree *));
-extern void using_eh_for_cleanups		PROTO((void));
-extern int stmt_loop_nest_empty			PROTO((void));
+						       tree, tree *);
+extern void using_eh_for_cleanups		(void);
+extern int stmt_loop_nest_empty			(void);
 
 /* In fold-const.c */
 
@@ -1953,373 +1953,373 @@ extern int stmt_loop_nest_empty			PROTO((void));
    if the argument itself cannot be simplified, its
    subexpressions are not changed.  */
 
-extern tree fold		PROTO((tree));
+extern tree fold		(tree);
 
-extern int force_fit_type	PROTO((tree, int));
-extern int add_double		PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+extern int force_fit_type	(tree, int);
+extern int add_double		(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, HOST_WIDE_INT,
-				       HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int neg_double		PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
-				       HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern int mul_double		PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int neg_double		(HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int mul_double		(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, HOST_WIDE_INT,
-				       HOST_WIDE_INT *, HOST_WIDE_INT *));
-extern void lshift_double	PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void lshift_double	(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, int, HOST_WIDE_INT *,
-				       HOST_WIDE_INT *, int));
-extern void rshift_double	PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *, int);
+extern void rshift_double	(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, int,
-				       HOST_WIDE_INT *, HOST_WIDE_INT *, int));
-extern void lrotate_double	PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *, HOST_WIDE_INT *, int);
+extern void lrotate_double	(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, int, HOST_WIDE_INT *,
-				       HOST_WIDE_INT *));
-extern void rrotate_double	PROTO((HOST_WIDE_INT, HOST_WIDE_INT,
+				       HOST_WIDE_INT *);
+extern void rrotate_double	(HOST_WIDE_INT, HOST_WIDE_INT,
 				       HOST_WIDE_INT, int, HOST_WIDE_INT *,
-				       HOST_WIDE_INT *));
-extern int operand_equal_p	PROTO((tree, tree, int));
-extern tree invert_truthvalue	PROTO((tree));
+				       HOST_WIDE_INT *);
+extern int operand_equal_p	(tree, tree, int);
+extern tree invert_truthvalue	(tree);
 
 /* 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));
+extern int dwarf2out_do_frame		(void);
 
 /* Generate a new label for the CFI info to refer to.  */
 
-extern char *dwarf2out_cfi_label	PROTO((void));
+extern char *dwarf2out_cfi_label	(void);
 
 /* Entry point to update the canonical frame address (CFA).  */
 
-extern void dwarf2out_def_cfa		PROTO((char *, unsigned, long));
+extern void dwarf2out_def_cfa		(char *, unsigned, long);
 
 /* Add the CFI for saving a register window.  */
 
-extern void dwarf2out_window_save	PROTO((char *));
+extern void dwarf2out_window_save	(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));
+extern void dwarf2out_args_size		(char *, long);
 
 /* Entry point for saving a register to the stack.  */
 
-extern void dwarf2out_reg_save		PROTO((char *, unsigned, long));
+extern void dwarf2out_reg_save		(char *, unsigned, long);
 
 /* Entry point for saving the return address in the stack.  */
 
-extern void dwarf2out_return_save	PROTO((char *, long));
+extern void dwarf2out_return_save	(char *, long);
 
 /* Entry point for saving the return address in a register.  */
 
-extern void dwarf2out_return_reg	PROTO((char *, unsigned));
+extern void dwarf2out_return_reg	(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));
+extern void dwarf2out_begin_prologue	(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));
+extern void dwarf2out_end_epilogue	(void);
 
 /* The language front-end must define these functions.  */
 
 /* Function of no arguments for initializing lexical scanning.  */
-extern void init_lex				PROTO((void));
+extern void init_lex				(void);
 /* Function of no arguments for initializing the symbol table.  */
-extern void init_decl_processing		PROTO((void));
+extern void init_decl_processing		(void);
 
 /* Function to replace the DECL_LANG_SPECIFIC field of a DECL with a copy.  */
-extern void copy_lang_decl			PROTO((tree));
+extern void copy_lang_decl			(tree);
 
 /* Function called with no arguments to parse and compile the input.  */
-extern int yyparse				PROTO((void));
+extern int yyparse				(void);
 
 /* Functions for processing symbol declarations.  */
 /* Function to enter a new lexical scope.
    Takes one argument: always zero when called from outside the front end.  */
-extern void pushlevel				PROTO((int));
+extern void pushlevel				(int);
 /* Function to exit a lexical scope.  It returns a BINDING for that scope.
    Takes three arguments:
      KEEP -- nonzero if there were declarations in this scope.
      REVERSE -- reverse the order of decls before returning them.
      FUNCTIONBODY -- nonzero if this level is the body of a function.  */
-extern tree poplevel				PROTO((int, int, int));
+extern tree poplevel				(int, int, int);
 /* Set the BLOCK node for the current scope level.  */
-extern void set_block				PROTO((tree));
+extern void set_block				(tree);
 /* Function to add a decl to the current scope level.
    Takes one argument, a decl to add.
    Returns that decl, or, if the same symbol is already declared, may
    return a different decl for that name.  */
-extern tree pushdecl				PROTO((tree));
+extern tree pushdecl				(tree);
 /* Function to return the chain of decls so far in the current scope level.  */
-extern tree getdecls				PROTO((void));
+extern tree getdecls				(void);
 /* Function to return the chain of structure tags in the current scope level.  */
-extern tree gettags				PROTO((void));
+extern tree gettags				(void);
 
-extern tree build_range_type PROTO((tree, tree, tree));
+extern tree build_range_type (tree, tree, tree);
 
 /* Call when starting to parse a declaration:
    make expressions in the declaration last the length of the function.
    Returns an argument that should be passed to resume_momentary later.  */
-extern int suspend_momentary PROTO((void));
+extern int suspend_momentary (void);
 
-extern int allocation_temporary_p PROTO((void));
+extern int allocation_temporary_p (void);
 
 /* Call when finished parsing a declaration:
    restore the treatment of node-allocation that was
    in effect before the suspension.
    YES should be the value previously returned by suspend_momentary.  */
-extern void resume_momentary PROTO((int));
+extern void resume_momentary (int);
 
 /* Called after finishing a record, union or enumeral type.  */
-extern void rest_of_type_compilation PROTO((tree, int));
+extern void rest_of_type_compilation (tree, int);
 
 /* Save the current set of obstacks, but don't change them.  */
-extern void push_obstacks_nochange PROTO((void));
+extern void push_obstacks_nochange (void);
 
-extern void permanent_allocation PROTO((int));
+extern void permanent_allocation (int);
 
-extern void push_momentary PROTO((void));
+extern void push_momentary (void);
 
-extern void clear_momentary PROTO((void));
+extern void clear_momentary (void);
 
-extern void pop_momentary PROTO((void));
+extern void pop_momentary (void);
 
-extern void end_temporary_allocation PROTO((void));
+extern void end_temporary_allocation (void);
 
 /* Pop the obstack selection stack.  */
-extern void pop_obstacks PROTO((void));
+extern void pop_obstacks (void);
 
 /* In tree.c */
-extern int really_constant_p		PROTO ((tree));
-extern void push_obstacks		PROTO ((struct obstack *,
-						struct obstack *));
-extern void pop_momentary_nofree	PROTO ((void));
-extern void preserve_momentary		PROTO ((void));
-extern void saveable_allocation		PROTO ((void));
-extern void temporary_allocation	PROTO ((void));
-extern void resume_temporary_allocation	PROTO ((void));
-extern tree get_file_function_name	PROTO ((int));
-extern void set_identifier_size		PROTO ((int));
-extern int int_fits_type_p		PROTO ((tree, tree));
-extern int tree_log2			PROTO ((tree));
-extern void preserve_initializer	PROTO ((void));
-extern void preserve_data		PROTO ((void));
-extern int object_permanent_p		PROTO ((tree));
-extern int type_precision		PROTO ((tree));
-extern int simple_cst_equal		PROTO ((tree, tree));
-extern int type_list_equal		PROTO ((tree, tree));
-extern int chain_member			PROTO ((tree, tree));
-extern int chain_member_purpose		PROTO ((tree, tree));
-extern int chain_member_value		PROTO ((tree, tree));
-extern tree listify			PROTO ((tree));
-extern tree type_hash_lookup		PROTO ((int, tree));
-extern void type_hash_add		PROTO ((int, tree));
-extern int type_hash_list		PROTO ((tree));
-extern int simple_cst_list_equal	PROTO ((tree, tree));
-extern void debug_obstack		PROTO ((char *));
-extern void rtl_in_current_obstack	PROTO ((void));
-extern void rtl_in_saveable_obstack	PROTO ((void));
-extern void init_tree_codes		PROTO ((void));
-extern void dump_tree_statistics	PROTO ((void));
-extern void print_obstack_statistics	PROTO ((char *, struct obstack *));
+extern int really_constant_p		(tree);
+extern void push_obstacks		(struct obstack *,
+						struct obstack *);
+extern void pop_momentary_nofree	(void);
+extern void preserve_momentary		(void);
+extern void saveable_allocation		(void);
+extern void temporary_allocation	(void);
+extern void resume_temporary_allocation	(void);
+extern tree get_file_function_name	(int);
+extern void set_identifier_size		(int);
+extern int int_fits_type_p		(tree, tree);
+extern int tree_log2			(tree);
+extern void preserve_initializer	(void);
+extern void preserve_data		(void);
+extern int object_permanent_p		(tree);
+extern int type_precision		(tree);
+extern int simple_cst_equal		(tree, tree);
+extern int type_list_equal		(tree, tree);
+extern int chain_member			(tree, tree);
+extern int chain_member_purpose		(tree, tree);
+extern int chain_member_value		(tree, tree);
+extern tree listify			(tree);
+extern tree type_hash_lookup		(int, tree);
+extern void type_hash_add		(int, tree);
+extern int type_hash_list		(tree);
+extern int simple_cst_list_equal	(tree, tree);
+extern void debug_obstack		(char *);
+extern void rtl_in_current_obstack	(void);
+extern void rtl_in_saveable_obstack	(void);
+extern void init_tree_codes		(void);
+extern void dump_tree_statistics	(void);
+extern void print_obstack_statistics	(char *, struct obstack *);
 #ifdef BUFSIZ
-extern void print_obstack_name		PROTO ((char *, FILE *, char *));
+extern void print_obstack_name		(char *, FILE *, char *);
 #endif
-extern void expand_function_end		PROTO ((char *, int, int));
-extern void expand_function_start	PROTO ((tree, int));
-extern int real_onep			PROTO ((tree));
-extern int real_twop			PROTO ((tree));
-extern void start_identifier_warnings	PROTO ((void));
-extern void gcc_obstack_init		PROTO ((struct obstack *));
-extern void init_obstacks		PROTO ((void));
-extern void obfree			PROTO ((char *));
-extern tree tree_check                  PROTO ((tree, enum tree_code, char*, int, int));
-extern tree tree_class_check            PROTO ((tree, char, char*, int, int));
-extern tree expr_check                  PROTO ((tree, int, char*, int, int));
+extern void expand_function_end		(char *, int, int);
+extern void expand_function_start	(tree, int);
+extern int real_onep			(tree);
+extern int real_twop			(tree);
+extern void start_identifier_warnings	(void);
+extern void gcc_obstack_init		(struct obstack *);
+extern void init_obstacks		(void);
+extern void obfree			(char *);
+extern tree tree_check                  (tree, enum tree_code, char*, int, int);
+extern tree tree_class_check            (tree, char, char*, int, int);
+extern tree expr_check                  (tree, int, char*, int, int);
 
 /* In function.c */
-extern void setjmp_protect_args		PROTO ((void));
-extern void setjmp_protect		PROTO ((tree));
-extern void expand_main_function	PROTO ((void));
-extern void mark_varargs		PROTO ((void));
-extern void init_function_start		PROTO ((tree, char *, int));
-extern void assign_parms		PROTO ((tree, int));
-extern void put_var_into_stack		PROTO ((tree));
-extern void uninitialized_vars_warning	PROTO ((tree));
-extern void setjmp_args_warning		PROTO ((void));
-extern void mark_all_temps_used		PROTO ((void));
-extern void init_temp_slots		PROTO ((void));
-extern void combine_temp_slots		PROTO ((void));
-extern void free_temp_slots		PROTO ((void));
-extern void pop_temp_slots		PROTO ((void));
-extern void push_temp_slots		PROTO ((void));
-extern void preserve_temp_slots		PROTO ((struct rtx_def *));
-extern int aggregate_value_p		PROTO ((tree));
-extern tree reorder_blocks		PROTO ((tree *, tree,
-						struct rtx_def *));
-extern void free_temps_for_rtl_expr	PROTO ((tree));
-extern void instantiate_virtual_regs	PROTO ((tree, struct rtx_def *));
-extern int max_parm_reg_num		PROTO ((void));
-extern void push_function_context	PROTO ((void));
-extern void pop_function_context	PROTO ((void));
-extern void push_function_context_to	PROTO ((tree));
-extern void pop_function_context_from	PROTO ((tree));
+extern void setjmp_protect_args		(void);
+extern void setjmp_protect		(tree);
+extern void expand_main_function	(void);
+extern void mark_varargs		(void);
+extern void init_function_start		(tree, char *, int);
+extern void assign_parms		(tree, int);
+extern void put_var_into_stack		(tree);
+extern void uninitialized_vars_warning	(tree);
+extern void setjmp_args_warning		(void);
+extern void mark_all_temps_used		(void);
+extern void init_temp_slots		(void);
+extern void combine_temp_slots		(void);
+extern void free_temp_slots		(void);
+extern void pop_temp_slots		(void);
+extern void push_temp_slots		(void);
+extern void preserve_temp_slots		(struct rtx_def *);
+extern int aggregate_value_p		(tree);
+extern tree reorder_blocks		(tree *, tree,
+						struct rtx_def *);
+extern void free_temps_for_rtl_expr	(tree);
+extern void instantiate_virtual_regs	(tree, struct rtx_def *);
+extern int max_parm_reg_num		(void);
+extern void push_function_context	(void);
+extern void pop_function_context	(void);
+extern void push_function_context_to	(tree);
+extern void pop_function_context_from	(tree);
 
 /* In print-rtl.c */
 #ifdef BUFSIZ
-extern void print_rtl			PROTO ((FILE *, struct rtx_def *));
+extern void print_rtl			(FILE *, struct rtx_def *);
 #endif
 
 /* In print-tree.c */
-extern void debug_tree			PROTO ((tree));
+extern void debug_tree			(tree);
 #ifdef BUFSIZ
-extern void print_node			PROTO ((FILE *, char *, tree, int));
-extern void print_node_brief		PROTO ((FILE *, char *, tree, int));
-extern void indent_to			PROTO ((FILE *, int));
+extern void print_node			(FILE *, char *, tree, int);
+extern void print_node_brief		(FILE *, char *, tree, int);
+extern void indent_to			(FILE *, int);
 #endif
 
 /* In expr.c */
-extern void emit_queue				PROTO ((void));
-extern int apply_args_register_offset		PROTO ((int));
+extern void emit_queue				(void);
+extern int apply_args_register_offset		(int);
 extern struct rtx_def *expand_builtin_return_addr
-	PROTO ((enum built_in_function, int, struct rtx_def *));
-extern void do_pending_stack_adjust		PROTO ((void));
-extern struct rtx_def *expand_assignment	PROTO ((tree, tree, int, int));
-extern struct rtx_def *store_expr		PROTO ((tree, struct rtx_def *,
-							int));
-extern void check_max_integer_computation_mode	PROTO ((tree));
+	(enum built_in_function, int, struct rtx_def *);
+extern void do_pending_stack_adjust		(void);
+extern struct rtx_def *expand_assignment	(tree, tree, int, int);
+extern struct rtx_def *store_expr		(tree, struct rtx_def *,
+							int);
+extern void check_max_integer_computation_mode	(tree);
 
 /* In emit-rtl.c */
-extern void start_sequence_for_rtl_expr		PROTO ((tree));
-extern struct rtx_def *emit_line_note_after	PROTO ((char *, int,
-							struct rtx_def *));
-extern struct rtx_def *emit_line_note		PROTO ((char *, int));
-extern struct rtx_def *emit_line_note_force	PROTO ((char *, int));
+extern void start_sequence_for_rtl_expr		(tree);
+extern struct rtx_def *emit_line_note_after	(char *, int,
+							struct rtx_def *);
+extern struct rtx_def *emit_line_note		(char *, int);
+extern struct rtx_def *emit_line_note_force	(char *, int);
 
 /* In c-typeck.c */
-extern int mark_addressable		PROTO ((tree));
-extern void incomplete_type_error	PROTO ((tree, tree));
+extern int mark_addressable		(tree);
+extern void incomplete_type_error	(tree, tree);
 
 /* In c-common.c */
-extern tree truthvalue_conversion	PROTO ((tree));
-extern int min_precision		PROTO ((tree, int));
-extern void split_specs_attrs		PROTO ((tree, tree *, tree *));
+extern tree truthvalue_conversion	(tree);
+extern int min_precision		(tree, int);
+extern void split_specs_attrs		(tree, tree *, tree *);
 
 /* In c-decl.c */
 #ifdef BUFSIZ
-extern void print_lang_decl		PROTO ((FILE *, tree, int));
-extern void print_lang_type		PROTO ((FILE *, tree, int));
-extern void print_lang_identifier	PROTO ((FILE *, tree, int));
+extern void print_lang_decl		(FILE *, tree, int);
+extern void print_lang_type		(FILE *, tree, int);
+extern void print_lang_identifier	(FILE *, tree, int);
 #endif
-extern int global_bindings_p		PROTO ((void));
-extern void insert_block		PROTO ((tree));
+extern int global_bindings_p		(void);
+extern void insert_block		(tree);
 
 /* In integrate.c */
-extern void save_for_inline_nocopy	PROTO ((tree));
-extern void save_for_inline_copying	PROTO ((tree));
-extern void set_decl_abstract_flags	PROTO ((tree, int));
-extern void output_inline_function	PROTO ((tree));
+extern void save_for_inline_nocopy	(tree);
+extern void save_for_inline_copying	(tree);
+extern void set_decl_abstract_flags	(tree, int);
+extern void output_inline_function	(tree);
 
 /* In c-lex.c */
-extern void set_yydebug			PROTO ((int));
+extern void set_yydebug			(int);
 
 /* In stor-layout.c */
-extern void fixup_signed_type		PROTO ((tree));
+extern void fixup_signed_type		(tree);
 
 /* varasm.c */
-extern void make_decl_rtl		PROTO ((tree, char *, int));
-extern void make_decl_one_only		PROTO ((tree));
-extern int supports_one_only		PROTO ((void));
-extern void variable_section		PROTO ((tree, int));
+extern void make_decl_rtl		(tree, char *, int);
+extern void make_decl_one_only		(tree);
+extern int supports_one_only		(void);
+extern void variable_section		(tree, int);
 
 /* In fold-const.c */
-extern int div_and_round_double		PROTO ((enum tree_code, int,
+extern int div_and_round_double		(enum tree_code, int,
 						HOST_WIDE_INT, HOST_WIDE_INT,
 						HOST_WIDE_INT, HOST_WIDE_INT,
 						HOST_WIDE_INT *,
 						HOST_WIDE_INT *,
 						HOST_WIDE_INT *,
-						HOST_WIDE_INT *));
+						HOST_WIDE_INT *);
 
 /* In stmt.c */
-extern void emit_nop			PROTO ((void));
-extern void expand_computed_goto	PROTO ((tree));
-extern struct rtx_def *label_rtx	PROTO ((tree));
-extern void expand_asm_operands		PROTO ((tree, tree, tree, tree, int,
-						char *, int));
-extern int any_pending_cleanups		PROTO ((int));
-extern void init_stmt			PROTO ((void));
-extern void init_stmt_for_function	PROTO ((void));
-extern void remember_end_note		PROTO ((tree));
-extern int drop_through_at_end_p	PROTO ((void));
-extern void expand_start_target_temps	PROTO ((void));
-extern void expand_end_target_temps	PROTO ((void));
-extern void expand_elseif		PROTO ((tree));
-extern void expand_decl			PROTO ((tree));
-extern int expand_decl_cleanup		PROTO ((tree, tree));
-extern void expand_anon_union_decl	PROTO ((tree, tree, tree));
-extern void move_cleanups_up		PROTO ((void));
-extern void expand_start_case_dummy	PROTO ((void));
-extern void expand_end_case_dummy	PROTO ((void));
-extern tree case_index_expr_type	PROTO ((void));
-extern HOST_WIDE_INT all_cases_count	PROTO ((tree, int *));
-extern void check_for_full_enumeration_handling PROTO ((tree));
-extern void declare_nonlocal_label	PROTO ((tree));
+extern void emit_nop			(void);
+extern void expand_computed_goto	(tree);
+extern struct rtx_def *label_rtx	(tree);
+extern void expand_asm_operands		(tree, tree, tree, tree, int,
+						char *, int);
+extern int any_pending_cleanups		(int);
+extern void init_stmt			(void);
+extern void init_stmt_for_function	(void);
+extern void remember_end_note		(tree);
+extern int drop_through_at_end_p	(void);
+extern void expand_start_target_temps	(void);
+extern void expand_end_target_temps	(void);
+extern void expand_elseif		(tree);
+extern void expand_decl			(tree);
+extern int expand_decl_cleanup		(tree, tree);
+extern void expand_anon_union_decl	(tree, tree, tree);
+extern void move_cleanups_up		(void);
+extern void expand_start_case_dummy	(void);
+extern void expand_end_case_dummy	(void);
+extern tree case_index_expr_type	(void);
+extern HOST_WIDE_INT all_cases_count	(tree, int *);
+extern void check_for_full_enumeration_handling (tree);
+extern void declare_nonlocal_label	(tree);
 
 
 /* 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));
+extern tree get_file_function_name (int);
 
 /* 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));
+extern int dwarf2out_do_frame		(void);
 
 /* Generate a new label for the CFI info to refer to.  */
 
-extern char *dwarf2out_cfi_label	PROTO((void));
+extern char *dwarf2out_cfi_label	(void);
 
 /* Entry point to update the canonical frame address (CFA).  */
 
-extern void dwarf2out_def_cfa		PROTO((char *, unsigned, long));
+extern void dwarf2out_def_cfa		(char *, unsigned, long);
 
 /* Add the CFI for saving a register window.  */
 
-extern void dwarf2out_window_save	PROTO((char *));
+extern void dwarf2out_window_save	(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));
+extern void dwarf2out_args_size		(char *, long);
 
 /* Entry point for saving a register to the stack.  */
 
-extern void dwarf2out_reg_save		PROTO((char *, unsigned, long));
+extern void dwarf2out_reg_save		(char *, unsigned, long);
 
 /* Entry point for saving the return address in the stack.  */
 
-extern void dwarf2out_return_save	PROTO((char *, long));
+extern void dwarf2out_return_save	(char *, long);
 
 /* Entry point for saving the return address in a register.  */
 
-extern void dwarf2out_return_reg	PROTO((char *, unsigned));
+extern void dwarf2out_return_reg	(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));
+extern void dwarf2out_begin_prologue	(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));
+extern void dwarf2out_end_epilogue	(void);
 
 #endif /* _TREE_H */