caller-save.c: Convert to ISO C90.

	* caller-save.c: Convert to ISO C90.
	* calls.c: Likewise.
	* cfg.c: Likewise.
	* cfganal.c: Likewise.
	* cfgbuild.c: Likewise.
	* cfgcleanup.c: Likewise.
	* cfghooks.c: Likewise.
	* cfglayout.c: Likewise.
	* cfglayout.h: Likewise.
	* cfgloop.c: Likewise.
	* cfgloop.h: Likewise.
	* cfgloopanal.c: Likewise.
	* cfgloopmainip.c: Likewise.
	* cfgrtl.c: Likewise.

From-SVN: r68331

gcc/ChangeLog

+2003-06-22  Andreas Jaeger  <aj@suse.de>
+
+	* caller-save.c: Convert to ISO C90.
+	* calls.c: Likewise.
+	* cfg.c: Likewise.
+	* cfganal.c: Likewise.
+	* cfgbuild.c: Likewise.
+	* cfgcleanup.c: Likewise.
+	* cfghooks.c: Likewise.
+	* cfglayout.c: Likewise.
+	* cfglayout.h: Likewise.
+	* cfgloop.c: Likewise.
+	* cfgloop.h: Likewise.
+	* cfgloopanal.c: Likewise.
+	* cfgloopmainip.c: Likewise.
+	* cfgrtl.c: Likewise.
+
 2003-06-22  Richard Earnshaw  <rearnsha@arm.com>
 
 	* arm.h (BIGGEST_ALIGNMENT): Use TARGET_REALLY_IWMMXT for selecting

gcc/caller-save.c

 /* Save and restore call-clobbered registers which are live across a call.
    Copyright (C) 1989, 1992, 1994, 1995, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -88,16 +88,15 @@ static HARD_REG_SET referenced_regs;
 static HARD_REG_SET this_insn_sets;
 
 
-static void mark_set_regs		PARAMS ((rtx, rtx, void *));
-static void mark_referenced_regs	PARAMS ((rtx));
-static int insert_save			PARAMS ((struct insn_chain *, int, int,
-						 HARD_REG_SET *,
-						 enum machine_mode *));
-static int insert_restore		PARAMS ((struct insn_chain *, int, int,
-						 int, enum machine_mode *));
-static struct insn_chain *insert_one_insn PARAMS ((struct insn_chain *, int,
-						   int, rtx));
-static void add_stored_regs		PARAMS ((rtx, rtx, void *));
+static void mark_set_regs (rtx, rtx, void *);
+static void mark_referenced_regs (rtx);
+static int insert_save (struct insn_chain *, int, int, HARD_REG_SET *,
+			enum machine_mode *);
+static int insert_restore (struct insn_chain *, int, int, int,
+			   enum machine_mode *);
+static struct insn_chain *insert_one_insn (struct insn_chain *, int, int,
+					   rtx);
+static void add_stored_regs (rtx, rtx, void *);
 
 /* Initialize for caller-save.
 
@@ -110,7 +109,7 @@ static void add_stored_regs		PARAMS ((rtx, rtx, void *));
    machines directly into memory.  */
 
 void
-init_caller_save ()
+init_caller_save (void)
 {
   rtx addr_reg;
   int offset;
@@ -256,7 +255,7 @@ init_caller_save ()
 /* Initialize save areas by showing that we haven't allocated any yet.  */
 
 void
-init_save_areas ()
+init_save_areas (void)
 {
   int i, j;
 
@@ -284,7 +283,7 @@ init_save_areas ()
      registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
 
 void
-setup_save_areas ()
+setup_save_areas (void)
 {
   int i, j, k;
   unsigned int r;
@@ -367,7 +366,7 @@ setup_save_areas ()
 /* Find the places where hard regs are live across calls and save them.  */
 
 void
-save_call_clobbered_regs ()
+save_call_clobbered_regs (void)
 {
   struct insn_chain *chain, *next;
   enum machine_mode save_mode [FIRST_PSEUDO_REGISTER];
@@ -496,10 +495,8 @@ save_call_clobbered_regs ()
    been assigned hard regs have had their register number changed already,
    so we can ignore pseudos.  */
 static void
-mark_set_regs (reg, setter, data)
-     rtx reg;
-     rtx setter ATTRIBUTE_UNUSED;
-     void *data ATTRIBUTE_UNUSED;
+mark_set_regs (rtx reg, rtx setter ATTRIBUTE_UNUSED,
+	       void *data ATTRIBUTE_UNUSED)
 {
   int regno, endregno, i;
   enum machine_mode mode = GET_MODE (reg);
@@ -529,10 +526,7 @@ mark_set_regs (reg, setter, data)
    been assigned hard regs have had their register number changed already,
    so we can ignore pseudos.  */
 static void
-add_stored_regs (reg, setter, data)
-     rtx reg;
-     rtx setter;
-     void *data;
+add_stored_regs (rtx reg, rtx setter, void *data)
 {
   int regno, endregno, i;
   enum machine_mode mode = GET_MODE (reg);
@@ -562,8 +556,7 @@ add_stored_regs (reg, setter, data)
 
 /* Walk X and record all referenced registers in REFERENCED_REGS.  */
 static void
-mark_referenced_regs (x)
-     rtx x;
+mark_referenced_regs (rtx x)
 {
   enum rtx_code code = GET_CODE (x);
   const char *fmt;
@@ -639,12 +632,8 @@ mark_referenced_regs (x)
    Return the extra number of registers saved.  */
 
 static int
-insert_restore (chain, before_p, regno, maxrestore, save_mode)
-     struct insn_chain *chain;
-     int before_p;
-     int regno;
-     int maxrestore;
-     enum machine_mode *save_mode;
+insert_restore (struct insn_chain *chain, int before_p, int regno,
+		int maxrestore, enum machine_mode *save_mode)
 {
   int i, k;
   rtx pat = NULL_RTX;
@@ -715,12 +704,8 @@ insert_restore (chain, before_p, regno, maxrestore, save_mode)
 /* Like insert_restore above, but save registers instead.  */
 
 static int
-insert_save (chain, before_p, regno, to_save, save_mode)
-     struct insn_chain *chain;
-     int before_p;
-     int regno;
-     HARD_REG_SET *to_save;
-     enum machine_mode *save_mode;
+insert_save (struct insn_chain *chain, int before_p, int regno,
+	     HARD_REG_SET (*to_save), enum machine_mode *save_mode)
 {
   int i;
   unsigned int k;
@@ -790,11 +775,7 @@ insert_save (chain, before_p, regno, to_save, save_mode)
 
 /* Emit a new caller-save insn and set the code.  */
 static struct insn_chain *
-insert_one_insn (chain, before_p, code, pat)
-     struct insn_chain *chain;
-     int before_p;
-     int code;
-     rtx pat;
+insert_one_insn (struct insn_chain *chain, int before_p, int code, rtx pat)
 {
   rtx insn = chain->insn;
   struct insn_chain *new;

gcc/calls.c

@@ -140,59 +140,41 @@ static sbitmap stored_args_map;
    argument list for the constructor call.  */
 int stack_arg_under_construction;
 
-static int calls_function	PARAMS ((tree, int));
-static int calls_function_1	PARAMS ((tree, int));
-
-static void emit_call_1		PARAMS ((rtx, tree, tree, HOST_WIDE_INT,
-					 HOST_WIDE_INT, HOST_WIDE_INT, rtx,
-					 rtx, int, rtx, int,
-					 CUMULATIVE_ARGS *));
-static void precompute_register_parameters	PARAMS ((int,
-							 struct arg_data *,
-							 int *));
-static int store_one_arg	PARAMS ((struct arg_data *, rtx, int, int,
-					 int));
-static void store_unaligned_arguments_into_pseudos PARAMS ((struct arg_data *,
-							    int));
-static int finalize_must_preallocate		PARAMS ((int, int,
-							 struct arg_data *,
-							 struct args_size *));
-static void precompute_arguments 		PARAMS ((int, int,
-							 struct arg_data *));
-static int compute_argument_block_size		PARAMS ((int,
-							 struct args_size *,
-							 int));
-static void initialize_argument_information	PARAMS ((int,
-							 struct arg_data *,
-							 struct args_size *,
-							 int, tree, tree,
-							 CUMULATIVE_ARGS *,
-							 int, rtx *, int *,
-							 int *, int *));
-static void compute_argument_addresses		PARAMS ((struct arg_data *,
-							 rtx, int));
-static rtx rtx_for_function_call		PARAMS ((tree, tree));
-static void load_register_parameters		PARAMS ((struct arg_data *,
-							 int, rtx *, int,
-							 int, int *));
-static rtx emit_library_call_value_1 		PARAMS ((int, rtx, rtx,
-							 enum libcall_type,
-							 enum machine_mode,
-							 int, va_list));
-static int special_function_p			PARAMS ((tree, int));
-static rtx try_to_integrate			PARAMS ((tree, tree, rtx,
-							 int, tree, rtx));
-static int check_sibcall_argument_overlap_1	PARAMS ((rtx));
-static int check_sibcall_argument_overlap	PARAMS ((rtx, struct arg_data *,
-							 int));
-
-static int combine_pending_stack_adjustment_and_call
-                                                PARAMS ((int, struct args_size *, int));
-static tree fix_unsafe_tree		PARAMS ((tree));
+static int calls_function (tree, int);
+static int calls_function_1 (tree, int);
+
+static void emit_call_1 (rtx, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
+			 HOST_WIDE_INT, rtx, rtx, int, rtx, int,
+			 CUMULATIVE_ARGS *);
+static void precompute_register_parameters (int, struct arg_data *, int *);
+static int store_one_arg (struct arg_data *, rtx, int, int, int);
+static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
+static int finalize_must_preallocate (int, int, struct arg_data *,
+				      struct args_size *);
+static void precompute_arguments (int, int, struct arg_data *);
+static int compute_argument_block_size (int, struct args_size *, int);
+static void initialize_argument_information (int, struct arg_data *,
+					     struct args_size *, int, tree,
+					     tree, CUMULATIVE_ARGS *, int,
+					     rtx *, int *, int *, int *);
+static void compute_argument_addresses (struct arg_data *, rtx, int);
+static rtx rtx_for_function_call (tree, tree);
+static void load_register_parameters (struct arg_data *, int, rtx *, int,
+				      int, int *);
+static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
+				      enum machine_mode, int, va_list);
+static int special_function_p (tree, int);
+static rtx try_to_integrate (tree, tree, rtx, int, tree, rtx);
+static int check_sibcall_argument_overlap_1 (rtx);
+static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
+
+static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
+						      int);
+static tree fix_unsafe_tree (tree);
 
 #ifdef REG_PARM_STACK_SPACE
-static rtx save_fixed_argument_area	PARAMS ((int, rtx, int *, int *));
-static void restore_fixed_argument_area	PARAMS ((rtx, rtx, int, int));
+static rtx save_fixed_argument_area (int, rtx, int *, int *);
+static void restore_fixed_argument_area (rtx, rtx, int, int);
 #endif
 
 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
@@ -206,9 +188,7 @@ static void restore_fixed_argument_area	PARAMS ((rtx, rtx, int, int));
 static tree calls_function_save_exprs;
 
 static int
-calls_function (exp, which)
-     tree exp;
-     int which;
+calls_function (tree exp, int which)
 {
   int val;
 
@@ -221,9 +201,7 @@ calls_function (exp, which)
 /* Recursive function to do the work of above function.  */
 
 static int
-calls_function_1 (exp, which)
-     tree exp;
-     int which;
+calls_function_1 (tree exp, int which)
 {
   int i;
   enum tree_code code = TREE_CODE (exp);
@@ -323,12 +301,8 @@ calls_function_1 (exp, which)
    CALL_INSN_FUNCTION_USAGE information.  */
 
 rtx
-prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen, sibcallp)
-     rtx funexp;
-     tree fndecl;
-     rtx *call_fusage;
-     int reg_parm_seen;
-     int sibcallp;
+prepare_call_address (rtx funexp, tree fndecl, rtx *call_fusage,
+		      int reg_parm_seen, int sibcallp)
 {
   rtx static_chain_value = 0;
 
@@ -409,21 +383,13 @@ prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen, sibcallp)
    denote registers used by the called function.  */
 
 static void
-emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
-	     struct_value_size, next_arg_reg, valreg, old_inhibit_defer_pop,
-	     call_fusage, ecf_flags, args_so_far)
-     rtx funexp;
-     tree fndecl ATTRIBUTE_UNUSED;
-     tree funtype ATTRIBUTE_UNUSED;
-     HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED;
-     HOST_WIDE_INT rounded_stack_size;
-     HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED;
-     rtx next_arg_reg ATTRIBUTE_UNUSED;
-     rtx valreg;
-     int old_inhibit_defer_pop;
-     rtx call_fusage;
-     int ecf_flags;
-     CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED;
+emit_call_1 (rtx funexp, tree fndecl, tree funtype,
+	     HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
+	     HOST_WIDE_INT rounded_stack_size,
+	     HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
+	     rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
+	     int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
+	     CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED)
 {
   rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
   rtx call_insn;
@@ -643,9 +609,7 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
    space from the stack such as alloca.  */
 
 static int
-special_function_p (fndecl, flags)
-     tree fndecl;
-     int flags;
+special_function_p (tree fndecl, int flags)
 {
   if (! (flags & ECF_MALLOC)
       && fndecl && DECL_NAME (fndecl)
@@ -725,16 +689,14 @@ special_function_p (fndecl, flags)
 /* Return nonzero when tree represent call to longjmp.  */
 
 int
-setjmp_call_p (fndecl)
-     tree fndecl;
+setjmp_call_p (tree fndecl)
 {
   return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
 }
 
 /* Return true when exp contains alloca call.  */
 bool
-alloca_call_p (exp)
-     tree exp;
+alloca_call_p (tree exp)
 {
   if (TREE_CODE (exp) == CALL_EXPR
       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
@@ -749,8 +711,7 @@ alloca_call_p (exp)
 /* Detect flags (function attributes) from the function decl or type node.  */
 
 int
-flags_from_decl_or_type (exp)
-     tree exp;
+flags_from_decl_or_type (tree exp)
 {
   int flags = 0;
   tree type = exp;
@@ -805,10 +766,7 @@ flags_from_decl_or_type (exp)
    Set REG_PARM_SEEN if we encounter a register parameter.  */
 
 static void
-precompute_register_parameters (num_actuals, args, reg_parm_seen)
-     int num_actuals;
-     struct arg_data *args;
-     int *reg_parm_seen;
+precompute_register_parameters (int num_actuals, struct arg_data *args, int *reg_parm_seen)
 {
   int i;
 
@@ -873,12 +831,7 @@ precompute_register_parameters (num_actuals, args, reg_parm_seen)
      parameters, we must save and restore it.  */
 
 static rtx
-save_fixed_argument_area (reg_parm_stack_space, argblock,
-			  low_to_save, high_to_save)
-     int reg_parm_stack_space;
-     rtx argblock;
-     int *low_to_save;
-     int *high_to_save;
+save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
 {
   int low;
   int high;
@@ -945,11 +898,7 @@ save_fixed_argument_area (reg_parm_stack_space, argblock,
 }
 
 static void
-restore_fixed_argument_area (save_area, argblock, high_to_save, low_to_save)
-     rtx save_area;
-     rtx argblock;
-     int high_to_save;
-     int low_to_save;
+restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
 {
   enum machine_mode save_mode = GET_MODE (save_area);
   int delta;
@@ -984,9 +933,7 @@ restore_fixed_argument_area (save_area, argblock, high_to_save, low_to_save)
    the aligned_regs array if it is nonzero.  */
 
 static void
-store_unaligned_arguments_into_pseudos (args, num_actuals)
-     struct arg_data *args;
-     int num_actuals;
+store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
 {
   int i, j;
 
@@ -1067,23 +1014,15 @@ store_unaligned_arguments_into_pseudos (args, num_actuals)
    flags which may may be modified by this routine.  */
 
 static void
-initialize_argument_information (num_actuals, args, args_size, n_named_args,
-				 actparms, fndecl, args_so_far,
-				 reg_parm_stack_space, old_stack_level,
-				 old_pending_adj, must_preallocate,
-				 ecf_flags)
-     int num_actuals ATTRIBUTE_UNUSED;
-     struct arg_data *args;
-     struct args_size *args_size;
-     int n_named_args ATTRIBUTE_UNUSED;
-     tree actparms;
-     tree fndecl;
-     CUMULATIVE_ARGS *args_so_far;
-     int reg_parm_stack_space;
-     rtx *old_stack_level;
-     int *old_pending_adj;
-     int *must_preallocate;
-     int *ecf_flags;
+initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
+				 struct arg_data *args,
+				 struct args_size *args_size,
+				 int n_named_args ATTRIBUTE_UNUSED,
+				 tree actparms, tree fndecl,
+				 CUMULATIVE_ARGS *args_so_far,
+				 int reg_parm_stack_space,
+				 rtx *old_stack_level, int *old_pending_adj,
+				 int *must_preallocate, int *ecf_flags)
 {
   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
   int inc;
@@ -1324,11 +1263,9 @@ initialize_argument_information (num_actuals, args, args_size, n_named_args,
    for arguments passed in registers.  */
 
 static int
-compute_argument_block_size (reg_parm_stack_space, args_size,
-			     preferred_stack_boundary)
-     int reg_parm_stack_space;
-     struct args_size *args_size;
-     int preferred_stack_boundary ATTRIBUTE_UNUSED;
+compute_argument_block_size (int reg_parm_stack_space,
+			     struct args_size *args_size,
+			     int preferred_stack_boundary ATTRIBUTE_UNUSED)
 {
   int unadjusted_args_size = args_size->constant;
 
@@ -1411,10 +1348,7 @@ compute_argument_block_size (reg_parm_stack_space, args_size,
    precomputed argument.  */
 
 static void
-precompute_arguments (flags, num_actuals, args)
-     int flags;
-     int num_actuals;
-     struct arg_data *args;
+precompute_arguments (int flags, int num_actuals, struct arg_data *args)
 {
   int i;
 
@@ -1482,11 +1416,7 @@ precompute_arguments (flags, num_actuals, args)
    compute and return the final value for MUST_PREALLOCATE.  */
 
 static int
-finalize_must_preallocate (must_preallocate, num_actuals, args, args_size)
-     int must_preallocate;
-     int num_actuals;
-     struct arg_data *args;
-     struct args_size *args_size;
+finalize_must_preallocate (int must_preallocate, int num_actuals, struct arg_data *args, struct args_size *args_size)
 {
   /* See if we have or want to preallocate stack space.
 
@@ -1545,10 +1475,7 @@ finalize_must_preallocate (must_preallocate, num_actuals, args, args_size)
    ARGBLOCK is an rtx for the address of the outgoing arguments.  */
 
 static void
-compute_argument_addresses (args, argblock, num_actuals)
-     struct arg_data *args;
-     rtx argblock;
-     int num_actuals;
+compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
 {
   if (argblock)
     {
@@ -1609,9 +1536,7 @@ compute_argument_addresses (args, argblock, num_actuals)
    ADDR is the operand 0 of CALL_EXPR for this call.  */
 
 static rtx
-rtx_for_function_call (fndecl, addr)
-     tree fndecl;
-     tree addr;
+rtx_for_function_call (tree fndecl, tree addr)
 {
   rtx funexp;
 
@@ -1651,14 +1576,9 @@ rtx_for_function_call (fndecl, addr)
    checking, setting *SIBCALL_FAILURE if appropriate.  */
 
 static void
-load_register_parameters (args, num_actuals, call_fusage, flags, 
-			    is_sibcall, sibcall_failure)
-     struct arg_data *args;
-     int num_actuals;
-     rtx *call_fusage;
-     int flags;
-     int is_sibcall;
-     int *sibcall_failure;
+load_register_parameters (struct arg_data *args, int num_actuals,
+			  rtx *call_fusage, int flags, int is_sibcall,
+			  int *sibcall_failure)
 {
   int i, j;
 
@@ -1736,13 +1656,8 @@ load_register_parameters (args, num_actuals, call_fusage, flags,
    about the parameters.  */
 
 static rtx
-try_to_integrate (fndecl, actparms, target, ignore, type, structure_value_addr)
-     tree fndecl;
-     tree actparms;
-     rtx target;
-     int ignore;
-     tree type;
-     rtx structure_value_addr;
+try_to_integrate (tree fndecl, tree actparms, rtx target, int ignore,
+		  tree type, rtx structure_value_addr)
 {
   rtx temp;
   rtx before_call;
@@ -1864,12 +1779,9 @@ try_to_integrate (fndecl, actparms, target, ignore, type, structure_value_addr)
    be popped after the call.  Returns the adjustment.  */
 
 static int
-combine_pending_stack_adjustment_and_call (unadjusted_args_size,
-					   args_size,
-					   preferred_unit_stack_boundary)
-     int unadjusted_args_size;
-     struct args_size *args_size;
-     int preferred_unit_stack_boundary;
+combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
+					   struct args_size *args_size,
+					   int preferred_unit_stack_boundary)
 {
   /* The number of bytes to pop so that the stack will be
      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
@@ -1920,8 +1832,7 @@ combine_pending_stack_adjustment_and_call (unadjusted_args_size,
    zero otherwise.  */
 
 static int
-check_sibcall_argument_overlap_1 (x)
-     rtx x;
+check_sibcall_argument_overlap_1 (rtx x)
 {
   RTX_CODE code;
   int i, j;
@@ -1984,10 +1895,7 @@ check_sibcall_argument_overlap_1 (x)
    slots, zero otherwise.  */
 
 static int
-check_sibcall_argument_overlap (insn, arg, mark_stored_args_map)
-     rtx insn;
-     struct arg_data *arg;
-     int mark_stored_args_map;
+check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map)
 {
   int low, high;
 
@@ -2016,8 +1924,7 @@ check_sibcall_argument_overlap (insn, arg, mark_stored_args_map)
 }
 
 static tree
-fix_unsafe_tree (t)
-     tree t;
+fix_unsafe_tree (tree t)
 {
   switch (unsafe_for_reeval (t))
     {
@@ -2051,10 +1958,7 @@ fix_unsafe_tree (t)
    If IGNORE is nonzero, then we ignore the value of the function call.  */
 
 rtx
-expand_call (exp, target, ignore)
-     tree exp;
-     rtx target;
-     int ignore;
+expand_call (tree exp, rtx target, int ignore)
 {
   /* Nonzero if we are currently expanding a call.  */
   static int currently_expanding_call = 0;
@@ -3572,14 +3476,9 @@ split_complex_types (tree types)
    parameters are documented in the emit_library_call function below.  */
 
 static rtx
-emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
-     int retval;
-     rtx orgfun;
-     rtx value;
-     enum libcall_type fn_type;
-     enum machine_mode outmode;
-     int nargs;
-     va_list p;
+emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
+			   enum libcall_type fn_type,
+			   enum machine_mode outmode, int nargs, va_list p)
 {
   /* Total size in bytes of all the stack-parms scanned so far.  */
   struct args_size args_size;
@@ -4348,12 +4247,8 @@ emit_library_call_value (rtx orgfun, rtx value,
    zero otherwise.  */
 
 static int
-store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
-     struct arg_data *arg;
-     rtx argblock;
-     int flags;
-     int variable_size ATTRIBUTE_UNUSED;
-     int reg_parm_stack_space;
+store_one_arg (struct arg_data *arg, rtx argblock, int flags,
+	       int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
 {
   tree pval = arg->tree_value;
   rtx reg = 0;
@@ -4682,9 +4577,7 @@ store_one_arg (arg, argblock, flags, variable_size, reg_parm_stack_space)
    For a little-endian machine, the reverse is true.  */
 
 bool
-default_must_pass_in_stack (mode, type)
-     enum machine_mode mode;
-     tree type;
+default_must_pass_in_stack (enum machine_mode mode, tree type)
 {
   if (!type)
     return false;

gcc/cfg.c

 /* Control flow graph manipulation code for GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -138,13 +138,13 @@ struct basic_block_def entry_exit_blocks[2]
   }
 };
 
-void debug_flow_info			PARAMS ((void));
-static void free_edge			PARAMS ((edge));
+void debug_flow_info (void);
+static void free_edge (edge);
 
 /* Called once at initialization time.  */
 
 void
-init_flow ()
+init_flow (void)
 {
   static int initialized;
 
@@ -173,8 +173,7 @@ init_flow ()
    without actually unlinking it from the pred/succ lists.  */
 
 static void
-free_edge (e)
-     edge e;
+free_edge (edge e)
 {
   n_edges--;
   pool_free (edge_pool, e);
@@ -183,7 +182,7 @@ free_edge (e)
 /* Free the memory associated with the edge structures.  */
 
 void
-clear_edges ()
+clear_edges (void)
 {
   basic_block bb;
   edge e;
@@ -223,7 +222,7 @@ clear_edges ()
 /* Allocate memory for basic_block.  */
 
 basic_block
-alloc_block ()
+alloc_block (void)
 {
   basic_block bb;
   bb = pool_alloc (bb_pool);
@@ -233,8 +232,7 @@ alloc_block ()
 
 /* Link block B to chain after AFTER.  */
 void
-link_block (b, after)
-     basic_block b, after;
+link_block (basic_block b, basic_block after)
 {
   b->next_bb = after->next_bb;
   b->prev_bb = after;
@@ -244,8 +242,7 @@ link_block (b, after)
 
 /* Unlink block B from chain.  */
 void
-unlink_block (b)
-     basic_block b;
+unlink_block (basic_block b)
 {
   b->next_bb->prev_bb = b->prev_bb;
   b->prev_bb->next_bb = b->next_bb;
@@ -253,7 +250,7 @@ unlink_block (b)
 
 /* Sequentially order blocks and compact the arrays.  */
 void
-compact_blocks ()
+compact_blocks (void)
 {
   int i;
   basic_block bb;
@@ -275,8 +272,7 @@ compact_blocks ()
 /* Remove block B from the basic block array.  */
 
 void
-expunge_block (b)
-     basic_block b;
+expunge_block (basic_block b)
 {
   unlink_block (b);
   BASIC_BLOCK (b->index) = NULL;
@@ -289,9 +285,7 @@ expunge_block (b)
    possibly already exist.  */
 
 edge
-unchecked_make_edge (src, dst, flags)
-     basic_block src, dst;
-     int flags;
+unchecked_make_edge (basic_block src, basic_block dst, int flags)
 {
   edge e;
   e = pool_alloc (edge_pool);
@@ -314,10 +308,7 @@ unchecked_make_edge (src, dst, flags)
    edge cache CACHE.  Return the new edge, NULL if already exist.  */
 
 edge
-cached_make_edge (edge_cache, src, dst, flags)
-     sbitmap *edge_cache;
-     basic_block src, dst;
-     int flags;
+cached_make_edge (sbitmap *edge_cache, basic_block src, basic_block dst, int flags)
 {
   int use_edge_cache;
   edge e;
@@ -362,9 +353,7 @@ cached_make_edge (edge_cache, src, dst, flags)
    created edge or NULL if already exist.  */
 
 edge
-make_edge (src, dest, flags)
-     basic_block src, dest;
-     int flags;
+make_edge (basic_block src, basic_block dest, int flags)
 {
   return cached_make_edge (NULL, src, dest, flags);
 }
@@ -373,9 +362,7 @@ make_edge (src, dest, flags)
    that it is the single edge leaving SRC.  */
 
 edge
-make_single_succ_edge (src, dest, flags)
-     basic_block src, dest;
-     int flags;
+make_single_succ_edge (basic_block src, basic_block dest, int flags)
 {
   edge e = make_edge (src, dest, flags);
 
@@ -387,8 +374,7 @@ make_single_succ_edge (src, dest, flags)
 /* This function will remove an edge from the flow graph.  */
 
 void
-remove_edge (e)
-     edge e;
+remove_edge (edge e)
 {
   edge last_pred = NULL;
   edge last_succ = NULL;
@@ -423,9 +409,7 @@ remove_edge (e)
 /* Redirect an edge's successor from one block to another.  */
 
 void
-redirect_edge_succ (e, new_succ)
-     edge e;
-     basic_block new_succ;
+redirect_edge_succ (edge e, basic_block new_succ)
 {
   edge *pe;
 
@@ -443,9 +427,7 @@ redirect_edge_succ (e, new_succ)
 /* Like previous but avoid possible duplicate edge.  */
 
 edge
-redirect_edge_succ_nodup (e, new_succ)
-     edge e;
-     basic_block new_succ;
+redirect_edge_succ_nodup (edge e, basic_block new_succ)
 {
   edge s;
 
@@ -473,9 +455,7 @@ redirect_edge_succ_nodup (e, new_succ)
 /* Redirect an edge's predecessor from one block to another.  */
 
 void
-redirect_edge_pred (e, new_pred)
-     edge e;
-     basic_block new_pred;
+redirect_edge_pred (edge e, basic_block new_pred)
 {
   edge *pe;
 
@@ -492,7 +472,7 @@ redirect_edge_pred (e, new_pred)
 }
 
 void
-clear_bb_flags ()
+clear_bb_flags (void)
 {
   basic_block bb;
 
@@ -501,8 +481,7 @@ clear_bb_flags ()
 }
 
 void
-dump_flow_info (file)
-     FILE *file;
+dump_flow_info (FILE *file)
 {
   int i;
   int max_regno = max_reg_num ();
@@ -625,16 +604,13 @@ dump_flow_info (file)
 }
 
 void
-debug_flow_info ()
+debug_flow_info (void)
 {
   dump_flow_info (stderr);
 }
 
 void
-dump_edge_info (file, e, do_succ)
-     FILE *file;
-     edge e;
-     int do_succ;
+dump_edge_info (FILE *file, edge e, int do_succ)
 {
   basic_block side = (do_succ ? e->dest : e->src);
 
@@ -693,9 +669,7 @@ static void *first_edge_aux_obj = 0;
    be first initialized by alloc_aux_for_blocks.  */
 
 inline void
-alloc_aux_for_block (bb, size)
-     basic_block bb;
-     int size;
+alloc_aux_for_block (basic_block bb, int size)
 {
   /* Verify that aux field is clear.  */
   if (bb->aux || !first_block_aux_obj)
@@ -708,8 +682,7 @@ alloc_aux_for_block (bb, size)
    alloc_aux_for_block for each basic block.  */
 
 void
-alloc_aux_for_blocks (size)
-     int size;
+alloc_aux_for_blocks (int size)
 {
   static int initialized;
 
@@ -735,7 +708,7 @@ alloc_aux_for_blocks (size)
 /* Clear AUX pointers of all blocks.  */
 
 void
-clear_aux_for_blocks ()
+clear_aux_for_blocks (void)
 {
   basic_block bb;
 
@@ -747,7 +720,7 @@ clear_aux_for_blocks ()
    of all blocks.  */
 
 void
-free_aux_for_blocks ()
+free_aux_for_blocks (void)
 {
   if (!first_block_aux_obj)
     abort ();
@@ -761,9 +734,7 @@ free_aux_for_blocks ()
    be first initialized by alloc_aux_for_edges.  */
 
 inline void
-alloc_aux_for_edge (e, size)
-     edge e;
-     int size;
+alloc_aux_for_edge (edge e, int size)
 {
   /* Verify that aux field is clear.  */
   if (e->aux || !first_edge_aux_obj)
@@ -776,8 +747,7 @@ alloc_aux_for_edge (e, size)
    alloc_aux_for_edge for each basic edge.  */
 
 void
-alloc_aux_for_edges (size)
-     int size;
+alloc_aux_for_edges (int size)
 {
   static int initialized;
 
@@ -809,7 +779,7 @@ alloc_aux_for_edges (size)
 /* Clear AUX pointers of all edges.  */
 
 void
-clear_aux_for_edges ()
+clear_aux_for_edges (void)
 {
   basic_block bb;
   edge e;
@@ -825,7 +795,7 @@ clear_aux_for_edges ()
    of all edges.  */
 
 void
-free_aux_for_edges ()
+free_aux_for_edges (void)
 {
   if (!first_edge_aux_obj)
     abort ();
@@ -840,7 +810,7 @@ free_aux_for_edges ()
    Currently it does following checks edge and basic block list correctness
    and calls into IL dependent checking then.  */
 void
-verify_flow_info ()
+verify_flow_info (void)
 {
   size_t *edge_checksum;
   int num_bb_notes, err = 0;
@@ -984,9 +954,7 @@ verify_flow_info ()
 /* Print out one basic block with live information at start and end.  */
 
 void
-dump_bb (bb, outf)
-     basic_block bb;
-     FILE *outf;
+dump_bb (basic_block bb, FILE *outf)
 {
   edge e;
 
@@ -1004,15 +972,13 @@ dump_bb (bb, outf)
 }
 
 void
-debug_bb (bb)
-     basic_block bb;
+debug_bb (basic_block bb)
 {
   dump_bb (bb, stderr);
 }
 
 basic_block
-debug_bb_n (n)
-     int n;
+debug_bb_n (int n)
 {
   basic_block bb = BASIC_BLOCK (n);
   dump_bb (bb, stderr);

gcc/cfganal.c

@@ -46,24 +46,20 @@ struct depth_first_search_dsS {
 };
 typedef struct depth_first_search_dsS *depth_first_search_ds;
 
-static void flow_dfs_compute_reverse_init
-  PARAMS ((depth_first_search_ds));
-static void flow_dfs_compute_reverse_add_bb
-  PARAMS ((depth_first_search_ds, basic_block));
-static basic_block flow_dfs_compute_reverse_execute
-  PARAMS ((depth_first_search_ds));
-static void flow_dfs_compute_reverse_finish
-  PARAMS ((depth_first_search_ds));
-static void remove_fake_successors	PARAMS ((basic_block));
-static bool need_fake_edge_p		PARAMS ((rtx));
-static bool flow_active_insn_p		PARAMS ((rtx));
+static void flow_dfs_compute_reverse_init (depth_first_search_ds);
+static void flow_dfs_compute_reverse_add_bb (depth_first_search_ds,
+					     basic_block);
+static basic_block flow_dfs_compute_reverse_execute (depth_first_search_ds);
+static void flow_dfs_compute_reverse_finish (depth_first_search_ds);
+static void remove_fake_successors (basic_block);
+static bool need_fake_edge_p (rtx);
+static bool flow_active_insn_p (rtx);
 
 /* Like active_insn_p, except keep the return value clobber around
    even after reload.  */
 
 static bool
-flow_active_insn_p (insn)
-     rtx insn;
+flow_active_insn_p (rtx insn)
 {
   if (active_insn_p (insn))
     return true;
@@ -85,8 +81,7 @@ flow_active_insn_p (insn)
    its single destination.  */
 
 bool
-forwarder_block_p (bb)
-     basic_block bb;
+forwarder_block_p (basic_block bb)
 {
   rtx insn;
 
@@ -106,8 +101,7 @@ forwarder_block_p (bb)
 /* Return nonzero if we can reach target from src by falling through.  */
 
 bool
-can_fallthru (src, target)
-     basic_block src, target;
+can_fallthru (basic_block src, basic_block target)
 {
   rtx insn = src->end;
   rtx insn2 = target->head;
@@ -133,7 +127,7 @@ can_fallthru (src, target)
    and heavily borrowed from flow_depth_first_order_compute.  */
 
 bool
-mark_dfs_back_edges ()
+mark_dfs_back_edges (void)
 {
   edge *stack;
   int *pre;
@@ -217,7 +211,7 @@ mark_dfs_back_edges ()
 /* Set the flag EDGE_CAN_FALLTHRU for edges that can be fallthru.  */
 
 void
-set_edge_can_fallthru_flag ()
+set_edge_can_fallthru_flag (void)
 {
   basic_block bb;
 
@@ -252,8 +246,7 @@ set_edge_can_fallthru_flag ()
    Helper function for the flow_call_edges_add.  */
 
 static bool
-need_fake_edge_p (insn)
-     rtx insn;
+need_fake_edge_p (rtx insn)
 {
   if (!INSN_P (insn))
     return false;
@@ -282,8 +275,7 @@ need_fake_edge_p (insn)
    that all subsequent instructions must be executed.  */
 
 int
-flow_call_edges_add (blocks)
-     sbitmap blocks;
+flow_call_edges_add (sbitmap blocks)
 {
   int i;
   int blocks_split = 0;
@@ -405,7 +397,7 @@ flow_call_edges_add (blocks)
    block is reachable.  */
 
 void
-find_unreachable_blocks ()
+find_unreachable_blocks (void)
 {
   edge e;
   basic_block *tos, *worklist, bb;
@@ -461,7 +453,7 @@ find_unreachable_blocks ()
    and the data structure is filled in.  */
 
 struct edge_list *
-create_edge_list ()
+create_edge_list (void)
 {
   struct edge_list *elist;
   edge e;
@@ -499,8 +491,7 @@ create_edge_list ()
 /* This function free's memory associated with an edge list.  */
 
 void
-free_edge_list (elist)
-     struct edge_list *elist;
+free_edge_list (struct edge_list *elist)
 {
   if (elist)
     {
@@ -512,9 +503,7 @@ free_edge_list (elist)
 /* This function provides debug output showing an edge list.  */
 
 void
-print_edge_list (f, elist)
-     FILE *f;
-     struct edge_list *elist;
+print_edge_list (FILE *f, struct edge_list *elist)
 {
   int x;
 
@@ -541,9 +530,7 @@ print_edge_list (f, elist)
    extra edges.  */
 
 void
-verify_edge_list (f, elist)
-     FILE *f;
-     struct edge_list *elist;
+verify_edge_list (FILE *f, struct edge_list *elist)
 {
   int pred, succ, index;
   edge e;
@@ -608,9 +595,7 @@ verify_edge_list (f, elist)
    a specified predecessor and successor.  */
 
 int
-find_edge_index (edge_list, pred, succ)
-     struct edge_list *edge_list;
-     basic_block pred, succ;
+find_edge_index (struct edge_list *edge_list, basic_block pred, basic_block succ)
 {
   int x;
 
@@ -625,10 +610,7 @@ find_edge_index (edge_list, pred, succ)
 /* Dump the list of basic blocks in the bitmap NODES.  */
 
 void
-flow_nodes_print (str, nodes, file)
-     const char *str;
-     const sbitmap nodes;
-     FILE *file;
+flow_nodes_print (const char *str, const sbitmap nodes, FILE *file)
 {
   int node;
 
@@ -643,11 +625,7 @@ flow_nodes_print (str, nodes, file)
 /* Dump the list of edges in the array EDGE_LIST.  */
 
 void
-flow_edge_list_print (str, edge_list, num_edges, file)
-     const char *str;
-     const edge *edge_list;
-     int num_edges;
-     FILE *file;
+flow_edge_list_print (const char *str, const edge *edge_list, int num_edges, FILE *file)
 {
   int i;
 
@@ -668,8 +646,7 @@ flow_edge_list_print (str, edge_list, num_edges, file)
    list it is in.  */
 
 static void
-remove_fake_successors (bb)
-     basic_block bb;
+remove_fake_successors (basic_block bb)
 {
   edge e;
 
@@ -688,7 +665,7 @@ remove_fake_successors (bb)
    fake predecessors.  */
 
 void
-remove_fake_edges ()
+remove_fake_edges (void)
 {
   basic_block bb;
 
@@ -701,7 +678,7 @@ remove_fake_edges ()
    edges to exist.  */
 
 void
-add_noreturn_fake_exit_edges ()
+add_noreturn_fake_exit_edges (void)
 {
   basic_block bb;
 
@@ -722,7 +699,7 @@ add_noreturn_fake_exit_edges ()
    nodes not reachable from the exit block.  */
 
 void
-connect_infinite_loops_to_exit ()
+connect_infinite_loops_to_exit (void)
 {
   basic_block unvisited_block;
   struct depth_first_search_dsS dfs_ds;
@@ -750,8 +727,7 @@ connect_infinite_loops_to_exit ()
 /* Compute reverse top sort order */
 
 void
-flow_reverse_top_sort_order_compute (rts_order)
-     int *rts_order;
+flow_reverse_top_sort_order_compute (int *rts_order)
 {
   edge *stack;
   int sp;
@@ -819,9 +795,7 @@ flow_reverse_top_sort_order_compute (rts_order)
   possible.  */
 
 int
-flow_depth_first_order_compute (dfs_order, rc_order)
-     int *dfs_order;
-     int *rc_order;
+flow_depth_first_order_compute (int *dfs_order, int *rc_order)
 {
   edge *stack;
   int sp;
@@ -922,8 +896,7 @@ struct dfst_node
      2) Walking the resulting tree from right to left.  */
 
 void
-flow_preorder_transversal_compute (pot_order)
-     int *pot_order;
+flow_preorder_transversal_compute (int *pot_order)
 {
   edge e;
   edge *stack;
@@ -1062,8 +1035,7 @@ flow_preorder_transversal_compute (pot_order)
    element on the stack.  */
 
 static void
-flow_dfs_compute_reverse_init (data)
-     depth_first_search_ds data;
+flow_dfs_compute_reverse_init (depth_first_search_ds data)
 {
   /* Allocate stack for back-tracking up CFG.  */
   data->stack = (basic_block *) xmalloc ((n_basic_blocks - (INVALID_BLOCK + 1))
@@ -1084,9 +1056,7 @@ flow_dfs_compute_reverse_init (data)
    block.  */
 
 static void
-flow_dfs_compute_reverse_add_bb (data, bb)
-     depth_first_search_ds data;
-     basic_block bb;
+flow_dfs_compute_reverse_add_bb (depth_first_search_ds data, basic_block bb)
 {
   data->stack[data->sp++] = bb;
   SET_BIT (data->visited_blocks, bb->index - (INVALID_BLOCK + 1));
@@ -1098,8 +1068,7 @@ flow_dfs_compute_reverse_add_bb (data, bb)
    available.  */
 
 static basic_block
-flow_dfs_compute_reverse_execute (data)
-     depth_first_search_ds data;
+flow_dfs_compute_reverse_execute (depth_first_search_ds data)
 {
   basic_block bb;
   edge e;
@@ -1127,8 +1096,7 @@ flow_dfs_compute_reverse_execute (data)
    reverse graph.  */
 
 static void
-flow_dfs_compute_reverse_finish (data)
-     depth_first_search_ds data;
+flow_dfs_compute_reverse_finish (depth_first_search_ds data)
 {
   free (data->stack);
   sbitmap_free (data->visited_blocks);
@@ -1138,13 +1106,9 @@ flow_dfs_compute_reverse_finish (data)
    if REVERSE, go against direction of edges.  Returns number of blocks
    found and their list in RSLT.  RSLT can contain at most RSLT_MAX items.  */
 int
-dfs_enumerate_from (bb, reverse, predicate, rslt, rslt_max, data)
-     basic_block bb;
-     int reverse;
-     bool (*predicate) PARAMS ((basic_block, void *));
-     basic_block *rslt;
-     int rslt_max;
-     void *data;
+dfs_enumerate_from (basic_block bb, int reverse,
+		    bool (*predicate) (basic_block, void *),
+		    basic_block *rslt, int rslt_max, void *data)
 {
   basic_block *st, lbb;
   int sp = 0, tv = 0;

gcc/cfgbuild.c

@@ -48,23 +48,20 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "toplev.h"
 #include "timevar.h"
 
-static int count_basic_blocks		PARAMS ((rtx));
-static void find_basic_blocks_1		PARAMS ((rtx));
-static rtx find_label_refs		PARAMS ((rtx, rtx));
-static void make_edges			PARAMS ((rtx, basic_block,
-						 basic_block, int));
-static void make_label_edge		PARAMS ((sbitmap *, basic_block,
-						 rtx, int));
-static void make_eh_edge		PARAMS ((sbitmap *, basic_block, rtx));
-static void find_bb_boundaries		PARAMS ((basic_block));
-static void compute_outgoing_frequencies PARAMS ((basic_block));
+static int count_basic_blocks (rtx);
+static void find_basic_blocks_1 (rtx);
+static rtx find_label_refs (rtx, rtx);
+static void make_edges (rtx, basic_block, basic_block, int);
+static void make_label_edge (sbitmap *, basic_block, rtx, int);
+static void make_eh_edge (sbitmap *, basic_block, rtx);
+static void find_bb_boundaries (basic_block);
+static void compute_outgoing_frequencies (basic_block);
 
 /* Return true if insn is something that should be contained inside basic
    block.  */
 
 bool
-inside_basic_block_p (insn)
-     rtx insn;
+inside_basic_block_p (rtx insn)
 {
   switch (GET_CODE (insn))
     {
@@ -96,8 +93,7 @@ inside_basic_block_p (insn)
    the basic block.  */
 
 bool
-control_flow_insn_p (insn)
-     rtx insn;
+control_flow_insn_p (rtx insn)
 {
   rtx note;
 
@@ -138,8 +134,7 @@ control_flow_insn_p (insn)
 /* Count the basic blocks of the function.  */
 
 static int
-count_basic_blocks (f)
-     rtx f;
+count_basic_blocks (rtx f)
 {
   int count = 0;
   bool saw_insn = false;
@@ -180,9 +175,7 @@ count_basic_blocks (f)
    This is used to scan the alternatives of a call placeholder.  */
 
 static rtx
-find_label_refs (f, lvl)
-     rtx f;
-     rtx lvl;
+find_label_refs (rtx f, rtx lvl)
 {
   rtx insn;
 
@@ -229,11 +222,7 @@ find_label_refs (f, lvl)
 /* Create an edge from a basic block to a label.  */
 
 static void
-make_label_edge (edge_cache, src, label, flags)
-     sbitmap *edge_cache;
-     basic_block src;
-     rtx label;
-     int flags;
+make_label_edge (sbitmap *edge_cache, basic_block src, rtx label, int flags)
 {
   if (GET_CODE (label) != CODE_LABEL)
     abort ();
@@ -252,10 +241,7 @@ make_label_edge (edge_cache, src, label, flags)
 /* Create the edges generated by INSN in REGION.  */
 
 static void
-make_eh_edge (edge_cache, src, insn)
-     sbitmap *edge_cache;
-     basic_block src;
-     rtx insn;
+make_eh_edge (sbitmap *edge_cache, basic_block src, rtx insn)
 {
   int is_call = GET_CODE (insn) == CALL_INSN ? EDGE_ABNORMAL_CALL : 0;
   rtx handlers, i;
@@ -278,10 +264,7 @@ make_eh_edge (edge_cache, src, insn)
    the list of exception regions active at the end of the basic block.  */
 
 static void
-make_edges (label_value_list, min, max, update_p)
-     rtx label_value_list;
-     basic_block min, max;
-     int update_p;
+make_edges (rtx label_value_list, basic_block min, basic_block max, int update_p)
 {
   basic_block bb;
   sbitmap *edge_cache = NULL;
@@ -464,8 +447,7 @@ make_edges (label_value_list, min, max, update_p)
    will be used in make_edges for use with computed gotos.  */
 
 static void
-find_basic_blocks_1 (f)
-     rtx f;
+find_basic_blocks_1 (rtx f)
 {
   rtx insn, next;
   rtx bb_note = NULL_RTX;
@@ -604,10 +586,8 @@ find_basic_blocks_1 (f)
    numbers in use.  */
 
 void
-find_basic_blocks (f, nregs, file)
-     rtx f;
-     int nregs ATTRIBUTE_UNUSED;
-     FILE *file ATTRIBUTE_UNUSED;
+find_basic_blocks (rtx f, int nregs ATTRIBUTE_UNUSED,
+		   FILE *file ATTRIBUTE_UNUSED)
 {
   basic_block bb;
 
@@ -667,8 +647,7 @@ enum state {BLOCK_NEW = 0, BLOCK_ORIGINAL, BLOCK_TO_SPLIT};
    and create new basic blocks in the progress.  */
 
 static void
-find_bb_boundaries (bb)
-     basic_block bb;
+find_bb_boundaries (basic_block bb)
 {
   rtx insn = bb->head;
   rtx end = bb->end;
@@ -734,8 +713,7 @@ find_bb_boundaries (bb)
     and probabilities of outgoing edges.  */
 
 static void
-compute_outgoing_frequencies (b)
-     basic_block b;
+compute_outgoing_frequencies (basic_block b)
 {
   edge e, f;
 
@@ -771,8 +749,7 @@ compute_outgoing_frequencies (b)
    basic block.  Update the data structure.  */
 
 void
-find_many_sub_basic_blocks (blocks)
-     sbitmap blocks;
+find_many_sub_basic_blocks (sbitmap blocks)
 {
   basic_block bb, min, max;
 
@@ -826,8 +803,7 @@ find_many_sub_basic_blocks (blocks)
 /* Like above but for single basic block only.  */
 
 void
-find_sub_basic_blocks (bb)
-     basic_block bb;
+find_sub_basic_blocks (basic_block bb)
 {
   basic_block min, max, b;
   basic_block next = bb->next_bb;

gcc/cfgcleanup.c

 /* Control flow optimization code for GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -67,36 +67,30 @@ enum bb_flags
 
 #define FORWARDER_BLOCK_P(BB) (BB_FLAGS (BB) & BB_FORWARDER_BLOCK)
 
-static bool try_crossjump_to_edge	PARAMS ((int, edge, edge));
-static bool try_crossjump_bb		PARAMS ((int, basic_block));
-static bool outgoing_edges_match	PARAMS ((int,
-						 basic_block, basic_block));
-static int flow_find_cross_jump		PARAMS ((int, basic_block, basic_block,
-						 rtx *, rtx *));
-static bool insns_match_p		PARAMS ((int, rtx, rtx));
-
-static bool label_is_jump_target_p	PARAMS ((rtx, rtx));
-static bool tail_recursion_label_p	PARAMS ((rtx));
-static void merge_blocks_move_predecessor_nojumps PARAMS ((basic_block,
-							  basic_block));
-static void merge_blocks_move_successor_nojumps PARAMS ((basic_block,
-							basic_block));
-static basic_block merge_blocks		PARAMS ((edge,basic_block,basic_block,
-						 int));
-static bool try_optimize_cfg		PARAMS ((int));
-static bool try_simplify_condjump	PARAMS ((basic_block));
-static bool try_forward_edges		PARAMS ((int, basic_block));
-static edge thread_jump			PARAMS ((int, edge, basic_block));
-static bool mark_effect			PARAMS ((rtx, bitmap));
-static void notice_new_block		PARAMS ((basic_block));
-static void update_forwarder_flag	PARAMS ((basic_block));
-static int mentions_nonequal_regs	PARAMS ((rtx *, void *));
+static bool try_crossjump_to_edge (int, edge, edge);
+static bool try_crossjump_bb (int, basic_block);
+static bool outgoing_edges_match (int, basic_block, basic_block);
+static int flow_find_cross_jump (int, basic_block, basic_block, rtx *, rtx *);
+static bool insns_match_p (int, rtx, rtx);
+
+static bool label_is_jump_target_p (rtx, rtx);
+static bool tail_recursion_label_p (rtx);
+static void merge_blocks_move_predecessor_nojumps (basic_block, basic_block);
+static void merge_blocks_move_successor_nojumps (basic_block, basic_block);
+static basic_block merge_blocks (edge,basic_block,basic_block, int);
+static bool try_optimize_cfg (int);
+static bool try_simplify_condjump (basic_block);
+static bool try_forward_edges (int, basic_block);
+static edge thread_jump (int, edge, basic_block);
+static bool mark_effect (rtx, bitmap);
+static void notice_new_block (basic_block);
+static void update_forwarder_flag (basic_block);
+static int mentions_nonequal_regs (rtx *, void *);
 
 /* Set flags for newly created block.  */
 
 static void
-notice_new_block (bb)
-     basic_block bb;
+notice_new_block (basic_block bb)
 {
   if (!bb)
     return;
@@ -108,8 +102,7 @@ notice_new_block (bb)
 /* Recompute forwarder flag after block has been modified.  */
 
 static void
-update_forwarder_flag (bb)
-     basic_block bb;
+update_forwarder_flag (basic_block bb)
 {
   if (forwarder_block_p (bb))
     BB_SET_FLAG (bb, BB_FORWARDER_BLOCK);
@@ -121,8 +114,7 @@ update_forwarder_flag (bb)
    Return true if something changed.  */
 
 static bool
-try_simplify_condjump (cbranch_block)
-     basic_block cbranch_block;
+try_simplify_condjump (basic_block cbranch_block)
 {
   basic_block jump_block, jump_dest_block, cbranch_dest_block;
   edge cbranch_jump_edge, cbranch_fallthru_edge;
@@ -190,9 +182,7 @@ try_simplify_condjump (cbranch_block)
    on register.  Used by jump threading.  */
 
 static bool
-mark_effect (exp, nonequal)
-     rtx exp;
-     regset nonequal;
+mark_effect (rtx exp, regset nonequal)
 {
   int regno;
   rtx dest;
@@ -241,9 +231,7 @@ mark_effect (exp, nonequal)
 /* Return nonzero if X is an register set in regset DATA.
    Called via for_each_rtx.  */
 static int
-mentions_nonequal_regs (x, data)
-     rtx *x;
-     void *data;
+mentions_nonequal_regs (rtx *x, void *data)
 {
   regset nonequal = (regset) data;
   if (REG_P (*x))
@@ -268,10 +256,7 @@ mentions_nonequal_regs (x, data)
    if exist, NULL otherwise.  */
 
 static edge
-thread_jump (mode, e, b)
-     int mode;
-     edge e;
-     basic_block b;
+thread_jump (int mode, edge e, basic_block b)
 {
   rtx set1, set2, cond1, cond2, insn;
   enum rtx_code code1, code2, reversed_code2;
@@ -413,9 +398,7 @@ failed_exit:
    Return true if successful.  */
 
 static bool
-try_forward_edges (mode, b)
-     basic_block b;
-     int mode;
+try_forward_edges (int mode, basic_block b)
 {
   bool changed = false;
   edge e, next, *threaded_edges = NULL;
@@ -648,8 +631,7 @@ try_forward_edges (mode, b)
    not apply to the fallthru case of a conditional jump.  */
 
 static bool
-label_is_jump_target_p (label, jump_insn)
-     rtx label, jump_insn;
+label_is_jump_target_p (rtx label, rtx jump_insn)
 {
   rtx tmp = JUMP_LABEL (jump_insn);
 
@@ -672,8 +654,7 @@ label_is_jump_target_p (label, jump_insn)
 /* Return true if LABEL is used for tail recursion.  */
 
 static bool
-tail_recursion_label_p (label)
-     rtx label;
+tail_recursion_label_p (rtx label)
 {
   rtx x;
 
@@ -689,8 +670,7 @@ tail_recursion_label_p (label)
    any jumps (aside from the jump from A to B).  */
 
 static void
-merge_blocks_move_predecessor_nojumps (a, b)
-     basic_block a, b;
+merge_blocks_move_predecessor_nojumps (basic_block a, basic_block b)
 {
   rtx barrier;
 
@@ -732,8 +712,7 @@ merge_blocks_move_predecessor_nojumps (a, b)
    any jumps (aside from the jump from A to B).  */
 
 static void
-merge_blocks_move_successor_nojumps (a, b)
-     basic_block a, b;
+merge_blocks_move_successor_nojumps (basic_block a, basic_block b)
 {
   rtx barrier, real_b_end;
 
@@ -795,10 +774,7 @@ merge_blocks_move_successor_nojumps (a, b)
    relative ordering of these two.  Hopefully it is not too common.  */
 
 static basic_block
-merge_blocks (e, b, c, mode)
-     edge e;
-     basic_block b, c;
-     int mode;
+merge_blocks (edge e, basic_block b, basic_block c, int mode)
 {
   basic_block next;
   /* If C has a tail recursion label, do not merge.  There is no
@@ -895,9 +871,7 @@ merge_blocks (e, b, c, mode)
 /* Return true if I1 and I2 are equivalent and thus can be crossjumped.  */
 
 static bool
-insns_match_p (mode, i1, i2)
-     int mode ATTRIBUTE_UNUSED;
-     rtx i1, i2;
+insns_match_p (int mode ATTRIBUTE_UNUSED, rtx i1, rtx i2)
 {
   rtx p1, p2;
 
@@ -1010,10 +984,8 @@ insns_match_p (mode, i1, i2)
    store the head of the blocks in *F1 and *F2.  */
 
 static int
-flow_find_cross_jump (mode, bb1, bb2, f1, f2)
-     int mode ATTRIBUTE_UNUSED;
-     basic_block bb1, bb2;
-     rtx *f1, *f2;
+flow_find_cross_jump (int mode ATTRIBUTE_UNUSED, basic_block bb1,
+		      basic_block bb2, rtx *f1, rtx *f2)
 {
   rtx i1, i2, last1, last2, afterlast1, afterlast2;
   int ninsns = 0;
@@ -1122,10 +1094,7 @@ flow_find_cross_jump (mode, bb1, bb2, f1, f2)
    We may assume that there exists one edge with a common destination.  */
 
 static bool
-outgoing_edges_match (mode, bb1, bb2)
-     int mode;
-     basic_block bb1;
-     basic_block bb2;
+outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 {
   int nehedges1 = 0, nehedges2 = 0;
   edge fallthru1 = 0, fallthru2 = 0;
@@ -1394,9 +1363,7 @@ outgoing_edges_match (mode, bb1, bb2)
    (maybe the middle of) E1->SRC to (maybe the middle of) E2->SRC.  */
 
 static bool
-try_crossjump_to_edge (mode, e1, e2)
-     int mode;
-     edge e1, e2;
+try_crossjump_to_edge (int mode, edge e1, edge e2)
 {
   int nmatch;
   basic_block src1 = e1->src, src2 = e2->src;
@@ -1580,9 +1547,7 @@ try_crossjump_to_edge (mode, e1, e2)
    any changes made.  */
 
 static bool
-try_crossjump_bb (mode, bb)
-     int mode;
-     basic_block bb;
+try_crossjump_bb (int mode, basic_block bb)
 {
   edge e, e2, nexte2, nexte, fallthru;
   bool changed;
@@ -1675,8 +1640,7 @@ try_crossjump_bb (mode, bb)
    instructions etc.  Return nonzero if changes were made.  */
 
 static bool
-try_optimize_cfg (mode)
-     int mode;
+try_optimize_cfg (int mode)
 {
   bool changed_overall = false;
   bool changed;
@@ -1856,7 +1820,7 @@ try_optimize_cfg (mode)
 /* Delete all unreachable basic blocks.  */
 
 bool
-delete_unreachable_blocks ()
+delete_unreachable_blocks (void)
 {
   bool changed = false;
   basic_block b, next_bb;
@@ -1884,8 +1848,7 @@ delete_unreachable_blocks ()
 /* Tidy the CFG by deleting unreachable code and whatnot.  */
 
 bool
-cleanup_cfg (mode)
-     int mode;
+cleanup_cfg (int mode)
 {
   bool changed = false;
 

gcc/cfghooks.c

@@ -35,14 +35,14 @@ struct cfg_hooks *cfg_hooks;
 
 /* Initialization of functions specific to the rtl IR.  */
 void
-rtl_register_cfg_hooks ()
+rtl_register_cfg_hooks (void)
 {
   cfg_hooks = &rtl_cfg_hooks;
 }
 
 /* Initialization of functions specific to the rtl IR.  */
 void
-cfg_layout_rtl_register_cfg_hooks ()
+cfg_layout_rtl_register_cfg_hooks (void)
 {
   cfg_hooks = &cfg_layout_rtl_cfg_hooks;
 }

gcc/cfghooks.h

@@ -26,30 +26,30 @@ struct cfg_hooks
 {
   /* Debugging.  Do not use macros to hook these so they can be called from
      debugger!  */
-  int (*cfgh_verify_flow_info)	        PARAMS ((void));
-  void (*dump_bb)			PARAMS ((basic_block, FILE *));
+  int (*cfgh_verify_flow_info) (void);
+  void (*dump_bb) (basic_block, FILE *);
 
   /* Basic CFG manipulation.  */
 
   /* Redirect edge E to the given basic block B and update underlying program
      representation.  Returns false when edge is not easilly redirectable for
      whatever reason.  */
-  bool (*redirect_edge_and_branch)      PARAMS ((edge e, basic_block b));
+  bool (*redirect_edge_and_branch) (edge e, basic_block b);
 
   /* Same as the above but allows redirecting of fallthru edges.  In that case
      newly created forwarder basic block is returned.  It aborts when called
      on abnormal edge.  */
-  basic_block (*redirect_edge_and_branch_force)PARAMS ((edge, basic_block));
+  basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
 
   /* Remove given basic block and all edges possibly pointing into it.  */
-  void (*delete_block)PARAMS ((basic_block));
+  void (*delete_block) (basic_block);
 
   /* Split basic block B after specified instruction I.  */
-  edge (*split_block)			PARAMS ((basic_block b, void * i));
+  edge (*split_block) (basic_block b, void * i);
 
   /* Higher level functions representable by primitive operations above if
      we didn't have some oddities in RTL and Tree representations.  */
-  basic_block (*cfgh_split_edge)        PARAMS ((edge));
+  basic_block (*cfgh_split_edge) (edge);
 };
 
 #define redirect_edge_and_branch(e,b)        cfg_hooks->redirect_edge_and_branch (e,b)
@@ -65,7 +65,7 @@ extern struct cfg_hooks rtl_cfg_hooks;
 extern struct cfg_hooks *cfg_hooks;
 
 /* Declarations.  */
-extern void rtl_register_cfg_hooks     PARAMS ((void));
-extern void cfg_layout_rtl_register_cfg_hooks PARAMS ((void));
+extern void rtl_register_cfg_hooks (void);
+extern void cfg_layout_rtl_register_cfg_hooks (void);
 
 #endif  /* GCC_CFGHOOKS_H */

gcc/cfglayout.c

 /* Basic block reordering routines for the GNU compiler.
-   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -42,25 +42,23 @@ extern struct obstack flow_obstack;
 /* Holds the interesting trailing notes for the function.  */
 rtx cfg_layout_function_footer;
 
-static rtx skip_insns_after_block	PARAMS ((basic_block));
-static void record_effective_endpoints	PARAMS ((void));
-static rtx label_for_bb			PARAMS ((basic_block));
-static void fixup_reorder_chain		PARAMS ((void));
+static rtx skip_insns_after_block (basic_block);
+static void record_effective_endpoints (void);
+static rtx label_for_bb (basic_block);
+static void fixup_reorder_chain (void);
 
-static void set_block_levels		PARAMS ((tree, int));
-static void change_scope		PARAMS ((rtx, tree, tree));
+static void set_block_levels (tree, int);
+static void change_scope (rtx, tree, tree);
 
-void verify_insn_chain			PARAMS ((void));
-static void cleanup_unconditional_jumps	PARAMS ((struct loops *));
-static void fixup_fallthru_exit_predecessor PARAMS ((void));
-static rtx duplicate_insn_chain PARAMS ((rtx, rtx));
-static void break_superblocks PARAMS ((void));
-static tree insn_scope PARAMS ((rtx));
+void verify_insn_chain (void);
+static void cleanup_unconditional_jumps (struct loops *);
+static void fixup_fallthru_exit_predecessor (void);
+static rtx duplicate_insn_chain (rtx, rtx);
+static void break_superblocks (void);
+static tree insn_scope (rtx);
 
 rtx
-unlink_insn_chain (first, last)
-     rtx first;
-     rtx last;
+unlink_insn_chain (rtx first, rtx last)
 {
   rtx prevfirst = PREV_INSN (first);
   rtx nextlast = NEXT_INSN (last);
@@ -83,8 +81,7 @@ unlink_insn_chain (first, last)
    we return the last one. Otherwise, we return the end of BB.  */
 
 static rtx
-skip_insns_after_block (bb)
-     basic_block bb;
+skip_insns_after_block (basic_block bb)
 {
   rtx insn, last_insn, next_head, prev;
 
@@ -171,8 +168,7 @@ skip_insns_after_block (bb)
 /* Locate or create a label for a given basic block.  */
 
 static rtx
-label_for_bb (bb)
-     basic_block bb;
+label_for_bb (basic_block bb)
 {
   rtx label = bb->head;
 
@@ -191,7 +187,7 @@ label_for_bb (bb)
    block, as defined by skip_insns_after_block above.  */
 
 static void
-record_effective_endpoints ()
+record_effective_endpoints (void)
 {
   rtx next_insn = get_insns ();
   basic_block bb;
@@ -235,7 +231,7 @@ int epilogue_locator;
    INSN_LOCATORs.  */
 
 void
-insn_locators_initialize ()
+insn_locators_initialize (void)
 {
   tree block = NULL;
   tree last_block = NULL;
@@ -325,9 +321,7 @@ insn_locators_initialize ()
    found in the block tree.  */
 
 static void
-set_block_levels (block, level)
-     tree block;
-     int level;
+set_block_levels (tree block, int level)
 {
   while (block)
     {
@@ -339,8 +333,7 @@ set_block_levels (block, level)
 
 /* Return sope resulting from combination of S1 and S2.  */
 tree
-choose_inner_scope (s1, s2)
-     tree s1, s2;
+choose_inner_scope (tree s1, tree s2)
 {
    if (!s1)
      return s2;
@@ -354,9 +347,7 @@ choose_inner_scope (s1, s2)
 /* Emit lexical block notes needed to change scope from S1 to S2.  */
 
 static void
-change_scope (orig_insn, s1, s2)
-     rtx orig_insn;
-     tree s1, s2;
+change_scope (rtx orig_insn, tree s1, tree s2)
 {
   rtx insn = orig_insn;
   tree com = NULL_TREE;
@@ -400,8 +391,7 @@ change_scope (orig_insn, s1, s2)
 
 /* Return lexical scope block insn belong to.  */
 static tree
-insn_scope (insn)
-   rtx insn;
+insn_scope (rtx insn)
 {
   int max = VARRAY_ACTIVE_SIZE (block_locators_locs);
   int min = 0;
@@ -429,8 +419,7 @@ insn_scope (insn)
 
 /* Return line number of the statement that produced this insn.  */
 int
-insn_line (insn)
-   rtx insn;
+insn_line (rtx insn)
 {
   int max = VARRAY_ACTIVE_SIZE (line_locators_locs);
   int min = 0;
@@ -458,8 +447,7 @@ insn_line (insn)
 
 /* Return source file of the statement that produced this insn.  */
 const char *
-insn_file (insn)
-   rtx insn;
+insn_file (rtx insn)
 {
   int max = VARRAY_ACTIVE_SIZE (file_locators_locs);
   int min = 0;
@@ -489,7 +477,7 @@ insn_file (insn)
    on the scope tree and the newly reordered instructions.  */
 
 void
-reemit_insn_block_notes ()
+reemit_insn_block_notes (void)
 {
   tree cur_block = DECL_INITIAL (cfun->decl);
   rtx insn, note;
@@ -535,7 +523,7 @@ reemit_insn_block_notes ()
 /* Given a reorder chain, rearrange the code to match.  */
 
 static void
-fixup_reorder_chain ()
+fixup_reorder_chain (void)
 {
   basic_block bb, prev_bb;
   int index;
@@ -776,7 +764,7 @@ fixup_reorder_chain ()
    3. Check that get_last_insn () returns the actual end of chain.  */
 
 void
-verify_insn_chain ()
+verify_insn_chain (void)
 {
   rtx x, prevx, nextx;
   int insn_cnt1, insn_cnt2;
@@ -807,8 +795,7 @@ verify_insn_chain ()
    dominators.  */
 
 static void
-cleanup_unconditional_jumps (loops)
-     struct loops *loops;
+cleanup_unconditional_jumps (struct loops *loops)
 {
   basic_block bb;
 
@@ -885,7 +872,7 @@ cleanup_unconditional_jumps (loops)
 /* The block falling through to exit must be the last one in the
    reordered chain.  Ensure that this condition is met.  */
 static void
-fixup_fallthru_exit_predecessor ()
+fixup_fallthru_exit_predecessor (void)
 {
   edge e;
   basic_block bb = NULL;
@@ -913,8 +900,7 @@ fixup_fallthru_exit_predecessor ()
 /* Return true in case it is possible to duplicate the basic block BB.  */
 
 bool
-cfg_layout_can_duplicate_bb_p (bb)
-     basic_block bb;
+cfg_layout_can_duplicate_bb_p (basic_block bb)
 {
   edge s;
 
@@ -951,8 +937,7 @@ cfg_layout_can_duplicate_bb_p (bb)
 }
 
 static rtx
-duplicate_insn_chain (from, to)
-     rtx from, to;
+duplicate_insn_chain (rtx from, rtx to)
 {
   rtx insn, last;
 
@@ -1047,9 +1032,7 @@ duplicate_insn_chain (from, to)
 /* Create a duplicate of the basic block BB and redirect edge E into it.  */
 
 basic_block
-cfg_layout_duplicate_bb (bb, e)
-     basic_block bb;
-     edge e;
+cfg_layout_duplicate_bb (basic_block bb, edge e)
 {
   rtx insn;
   edge s, n;
@@ -1141,8 +1124,7 @@ cfg_layout_duplicate_bb (bb, e)
    CFG layout changes.  It keeps LOOPS up-to-date if not null.  */
 
 void
-cfg_layout_initialize (loops)
-     struct loops *loops;
+cfg_layout_initialize (struct loops *loops)
 {
   /* Our algorithm depends on fact that there are now dead jumptables
      around the code.  */
@@ -1156,7 +1138,7 @@ cfg_layout_initialize (loops)
 
 /* Splits superblocks.  */
 static void
-break_superblocks ()
+break_superblocks (void)
 {
   sbitmap superblocks;
   int i, need;
@@ -1187,7 +1169,7 @@ break_superblocks ()
    compensation code, rebuild scope forest.  */
 
 void
-cfg_layout_finalize ()
+cfg_layout_finalize (void)
 {
 #ifdef ENABLE_CHECKING
   verify_flow_info ();

gcc/cfglayout.h

 /* Basic block reordering routines for the GNU compiler.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2003 Free Software Foundation, Inc.
 
    This file is part of GCC.
 
@@ -37,9 +37,9 @@ typedef struct reorder_block_def
 
 extern rtx cfg_layout_function_footer;
 
-extern void cfg_layout_initialize	PARAMS ((struct loops *));
-extern void cfg_layout_finalize		PARAMS ((void));
-extern bool cfg_layout_can_duplicate_bb_p PARAMS ((basic_block));
-extern basic_block cfg_layout_duplicate_bb PARAMS ((basic_block, edge));
-extern void insn_locators_initialize	PARAMS ((void));
-extern void reemit_insn_block_notes	PARAMS ((void));
+extern void cfg_layout_initialize (struct loops *);
+extern void cfg_layout_finalize (void);
+extern bool cfg_layout_can_duplicate_bb_p (basic_block);
+extern basic_block cfg_layout_duplicate_bb (basic_block, edge);
+extern void insn_locators_initialize (void);
+extern void reemit_insn_block_notes (void);

gcc/cfgloop.c

 /* Natural loop discovery code for GNU compiler.
-   Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -33,29 +33,24 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    considered to belong to inner loop with same header.  */
 #define HEAVY_EDGE_RATIO 8
 
-static void flow_loops_cfg_dump		PARAMS ((const struct loops *,
-						 FILE *));
-static void flow_loop_entry_edges_find	PARAMS ((struct loop *));
-static void flow_loop_exit_edges_find	PARAMS ((struct loop *));
-static int flow_loop_nodes_find		PARAMS ((basic_block, struct loop *));
-static void flow_loop_pre_header_scan	PARAMS ((struct loop *));
-static basic_block flow_loop_pre_header_find PARAMS ((basic_block,
-						      dominance_info));
-static int flow_loop_level_compute	PARAMS ((struct loop *));
-static int flow_loops_level_compute	PARAMS ((struct loops *));
-static void establish_preds		PARAMS ((struct loop *));
-static basic_block make_forwarder_block PARAMS ((basic_block, int, int,
-						 edge, int));
-static void canonicalize_loop_headers   PARAMS ((void));
-static bool glb_enum_p PARAMS ((basic_block, void *));
-static void redirect_edge_with_latch_update PARAMS ((edge, basic_block));
+static void flow_loops_cfg_dump (const struct loops *, FILE *);
+static void flow_loop_entry_edges_find (struct loop *);
+static void flow_loop_exit_edges_find (struct loop *);
+static int flow_loop_nodes_find (basic_block, struct loop *);
+static void flow_loop_pre_header_scan (struct loop *);
+static basic_block flow_loop_pre_header_find (basic_block, dominance_info);
+static int flow_loop_level_compute (struct loop *);
+static int flow_loops_level_compute (struct loops *);
+static void establish_preds (struct loop *);
+static basic_block make_forwarder_block (basic_block, int, int, edge, int);
+static void canonicalize_loop_headers (void);
+static bool glb_enum_p (basic_block, void *);
+static void redirect_edge_with_latch_update (edge, basic_block);
 
 /* Dump loop related CFG information.  */
 
 static void
-flow_loops_cfg_dump (loops, file)
-     const struct loops *loops;
-     FILE *file;
+flow_loops_cfg_dump (const struct loops *loops, FILE *file)
 {
   int i;
   basic_block bb;
@@ -97,9 +92,7 @@ flow_loops_cfg_dump (loops, file)
 /* Return nonzero if the nodes of LOOP are a subset of OUTER.  */
 
 bool
-flow_loop_nested_p (outer, loop)
-     const struct loop *outer;
-     const struct loop *loop;
+flow_loop_nested_p (const struct loop *outer, const struct loop *loop)
 {
   return loop->depth > outer->depth
 	 && loop->pred[outer->depth] == outer;
@@ -109,11 +102,9 @@ flow_loop_nested_p (outer, loop)
    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
 
 void
-flow_loop_dump (loop, file, loop_dump_aux, verbose)
-     const struct loop *loop;
-     FILE *file;
-     void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
-     int verbose;
+flow_loop_dump (const struct loop *loop, FILE *file,
+		void (*loop_dump_aux) (const struct loop *, FILE *, int),
+		int verbose)
 {
   basic_block *bbs;
   unsigned i;
@@ -154,11 +145,7 @@ flow_loop_dump (loop, file, loop_dump_aux, verbose)
    using auxiliary dump callback function LOOP_DUMP_AUX if non null.  */
 
 void
-flow_loops_dump (loops, file, loop_dump_aux, verbose)
-     const struct loops *loops;
-     FILE *file;
-     void (*loop_dump_aux) PARAMS((const struct loop *, FILE *, int));
-     int verbose;
+flow_loops_dump (const struct loops *loops, FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
 {
   int i;
   int num_loops;
@@ -186,8 +173,7 @@ flow_loops_dump (loops, file, loop_dump_aux, verbose)
 
 /* Free data allocated for LOOP.  */
 void
-flow_loop_free (loop)
-     struct loop *loop;
+flow_loop_free (struct loop *loop)
 {
   if (loop->pre_header_edges)
     free (loop->pre_header_edges);
@@ -203,8 +189,7 @@ flow_loop_free (loop)
 /* Free all the memory allocated for LOOPS.  */
 
 void
-flow_loops_free (loops)
-     struct loops *loops;
+flow_loops_free (struct loops *loops)
 {
   if (loops->parray)
     {
@@ -241,8 +226,7 @@ flow_loops_free (loops)
 /* Find the entry edges into the LOOP.  */
 
 static void
-flow_loop_entry_edges_find (loop)
-     struct loop *loop;
+flow_loop_entry_edges_find (struct loop *loop)
 {
   edge e;
   int num_entries;
@@ -272,8 +256,7 @@ flow_loop_entry_edges_find (loop)
 /* Find the exit edges from the LOOP.  */
 
 static void
-flow_loop_exit_edges_find (loop)
-     struct loop *loop;
+flow_loop_exit_edges_find (struct loop *loop)
 {
   edge e;
   basic_block node, *bbs;
@@ -328,9 +311,7 @@ flow_loop_exit_edges_find (loop)
    Return the number of nodes within the loop.  */
 
 static int
-flow_loop_nodes_find (header, loop)
-     basic_block header;
-     struct loop *loop;
+flow_loop_nodes_find (basic_block header, struct loop *loop)
 {
   basic_block *stack;
   int sp;
@@ -378,8 +359,7 @@ flow_loop_nodes_find (header, loop)
    the edges along the trace from the root node to the loop header.  */
 
 static void
-flow_loop_pre_header_scan (loop)
-     struct loop *loop;
+flow_loop_pre_header_scan (struct loop *loop)
 {
   int num;
   basic_block ebb;
@@ -415,9 +395,7 @@ flow_loop_pre_header_scan (loop)
    there is no pre-header.  */
 
 static basic_block
-flow_loop_pre_header_find (header, dom)
-     basic_block header;
-     dominance_info dom;
+flow_loop_pre_header_find (basic_block header, dominance_info dom)
 {
   basic_block pre_header;
   edge e;
@@ -448,8 +426,7 @@ flow_loop_pre_header_find (header, dom)
 }
 
 static void
-establish_preds (loop)
-     struct loop *loop;
+establish_preds (struct loop *loop)
 {
   struct loop *ploop, *father = loop->outer;
 
@@ -469,9 +446,7 @@ establish_preds (loop)
    pred field will be initialized correctly.  */
 
 void
-flow_loop_tree_node_add (father, loop)
-     struct loop *father;
-     struct loop *loop;
+flow_loop_tree_node_add (struct loop *father, struct loop *loop)
 {
   loop->next = father->inner;
   father->inner = loop;
@@ -483,8 +458,7 @@ flow_loop_tree_node_add (father, loop)
 /* Remove LOOP from the loop hierarchy tree.  */
 
 void
-flow_loop_tree_node_remove (loop)
-     struct loop *loop;
+flow_loop_tree_node_remove (struct loop *loop)
 {
   struct loop *prev, *father;
 
@@ -509,8 +483,7 @@ flow_loop_tree_node_remove (loop)
    for the natural loop specified by LOOP.  Returns the loop level.  */
 
 static int
-flow_loop_level_compute (loop)
-     struct loop *loop;
+flow_loop_level_compute (struct loop *loop)
 {
   struct loop *inner;
   int level = 1;
@@ -540,8 +513,7 @@ flow_loop_level_compute (loop)
    level.  */
 
 static int
-flow_loops_level_compute (loops)
-     struct loops *loops;
+flow_loops_level_compute (struct loops *loops)
 {
   return flow_loop_level_compute (loops->tree_root);
 }
@@ -550,10 +522,7 @@ flow_loops_level_compute (loops)
    about it specified by FLAGS.  */
 
 int
-flow_loop_scan (loops, loop, flags)
-     struct loops *loops;
-     struct loop *loop;
-     int flags;
+flow_loop_scan (struct loops *loops, struct loop *loop, int flags)
 {
   if (flags & LOOP_ENTRY_EDGES)
     {
@@ -588,9 +557,7 @@ flow_loop_scan (loops, loop, flags)
 
 /* Redirect edge and update latch and header info.  */
 static void
-redirect_edge_with_latch_update (e, to)
-     edge e;
-     basic_block to;
+redirect_edge_with_latch_update (edge e, basic_block to)
 {
   basic_block jump;
 
@@ -612,13 +579,7 @@ redirect_edge_with_latch_update (e, to)
    part.  */
 
 static basic_block
-make_forwarder_block (bb, redirect_latch, redirect_nonlatch, except,
-		      conn_latch)
-     basic_block bb;
-     int redirect_latch;
-     int redirect_nonlatch;
-     edge except;
-     int conn_latch;
+make_forwarder_block (basic_block bb, int redirect_latch, int redirect_nonlatch, edge except, int conn_latch)
 {
   edge e, next_e, fallthru;
   basic_block dummy;
@@ -664,7 +625,7 @@ make_forwarder_block (bb, redirect_latch, redirect_nonlatch, except,
 
 /* Takes care of merging natural loops with shared headers.  */
 static void
-canonicalize_loop_headers ()
+canonicalize_loop_headers (void)
 {
   dominance_info dom;
   basic_block header;
@@ -776,9 +737,7 @@ canonicalize_loop_headers ()
    loops found.  */
 
 int
-flow_loops_find (loops, flags)
-     struct loops *loops;
-     int flags;
+flow_loops_find (struct loops *loops, int flags)
 {
   int i;
   int b;
@@ -961,9 +920,7 @@ flow_loops_find (loops, flags)
    specified by LOOPS.  */
 
 int
-flow_loops_update (loops, flags)
-     struct loops *loops;
-     int flags;
+flow_loops_update (struct loops *loops, int flags)
 {
   /* One day we may want to update the current loop data.  For now
      throw away the old stuff and rebuild what we need.  */
@@ -975,9 +932,7 @@ flow_loops_update (loops, flags)
 
 /* Return nonzero if basic block BB belongs to LOOP.  */
 bool
-flow_bb_inside_loop_p (loop, bb)
-     const struct loop *loop;
-     const basic_block bb;
+flow_bb_inside_loop_p (const struct loop *loop, const basic_block bb)
 {
   struct loop *source_loop;
 
@@ -991,9 +946,7 @@ flow_bb_inside_loop_p (loop, bb)
 /* Return nonzero if edge E enters header of LOOP from outside of LOOP.  */
 
 bool
-flow_loop_outside_edge_p (loop, e)
-     const struct loop *loop;
-     edge e;
+flow_loop_outside_edge_p (const struct loop *loop, edge e)
 {
   if (e->dest != loop->header)
     abort ();
@@ -1002,17 +955,14 @@ flow_loop_outside_edge_p (loop, e)
 
 /* Enumeration predicate for get_loop_body.  */
 static bool
-glb_enum_p (bb, glb_header)
-     basic_block bb;
-     void *glb_header;
+glb_enum_p (basic_block bb, void *glb_header)
 {
   return bb != (basic_block) glb_header;
 }
 
 /* Gets basic blocks of a loop.  */
 basic_block *
-get_loop_body (loop)
-     const struct loop *loop;
+get_loop_body (const struct loop *loop)
 {
   basic_block *tovisit, bb;
   unsigned tv = 0;
@@ -1046,9 +996,7 @@ get_loop_body (loop)
 
 /* Gets exit edges of a LOOP, returning their number in N_EDGES.  */
 edge *
-get_loop_exit_edges (loop, n_edges)
-     const struct loop *loop;
-     unsigned *n_edges;
+get_loop_exit_edges (const struct loop *loop, unsigned int *n_edges)
 {
   edge *edges, e;
   unsigned i, n;
@@ -1077,10 +1025,8 @@ get_loop_exit_edges (loop, n_edges)
 
 /* Adds basic block BB to LOOP.  */
 void
-add_bb_to_loop (bb, loop)
-     basic_block bb;
-     struct loop *loop;
- {
+add_bb_to_loop (basic_block bb, struct loop *loop)
+{
    int i;
 
    bb->loop_father = loop;
@@ -1092,9 +1038,8 @@ add_bb_to_loop (bb, loop)
 
 /* Remove basic block BB from loops.  */
 void
-remove_bb_from_loops (bb)
-     basic_block bb;
- {
+remove_bb_from_loops (basic_block bb)
+{
    int i;
    struct loop *loop = bb->loop_father;
 
@@ -1107,9 +1052,7 @@ remove_bb_from_loops (bb)
 
 /* Finds nearest common ancestor in loop tree for given loops.  */
 struct loop *
-find_common_loop (loop_s, loop_d)
-    struct loop *loop_s;
-    struct loop *loop_d;
+find_common_loop (struct loop *loop_s, struct loop *loop_d)
 {
   if (!loop_s) return loop_d;
   if (!loop_d) return loop_s;
@@ -1129,9 +1072,7 @@ find_common_loop (loop_s, loop_d)
 
 /* Cancels the LOOP; it must be innermost one.  */
 void
-cancel_loop (loops, loop)
-     struct loops *loops;
-     struct loop *loop;
+cancel_loop (struct loops *loops, struct loop *loop)
 {
   basic_block *bbs;
   unsigned i;
@@ -1156,9 +1097,7 @@ cancel_loop (loops, loop)
 
 /* Cancels LOOP and all its subloops.  */
 void
-cancel_loop_tree (loops, loop)
-     struct loops *loops;
-     struct loop *loop;
+cancel_loop_tree (struct loops *loops, struct loop *loop)
 {
   while (loop->inner)
     cancel_loop_tree (loops, loop->inner);
@@ -1173,8 +1112,7 @@ cancel_loop_tree (loops, loop)
      -- irreducible loops are correctly marked
   */
 void
-verify_loop_structure (loops)
-     struct loops *loops;
+verify_loop_structure (struct loops *loops)
 {
   unsigned *sizes, i, j;
   sbitmap irreds;
@@ -1332,8 +1270,7 @@ verify_loop_structure (loops)
 
 /* Returns latch edge of LOOP.  */
 edge
-loop_latch_edge (loop)
-     const struct loop *loop;
+loop_latch_edge (const struct loop *loop)
 {
   edge e;
 
@@ -1345,8 +1282,7 @@ loop_latch_edge (loop)
 
 /* Returns preheader edge of LOOP.  */
 edge
-loop_preheader_edge (loop)
-     const struct loop *loop;
+loop_preheader_edge (const struct loop *loop)
 {
   edge e;
 
@@ -1355,4 +1291,3 @@ loop_preheader_edge (loop)
 
   return e;
 }
-

gcc/cfgloop.h

@@ -255,47 +255,42 @@ struct loops
 #define LOOP_ALL	       15	/* All of the above  */
 
 /* Loop recognition.  */
-extern int flow_loops_find		PARAMS ((struct loops *, int flags));
-extern int flow_loops_update		PARAMS ((struct loops *, int flags));
-extern void flow_loops_free		PARAMS ((struct loops *));
-extern void flow_loops_dump		PARAMS ((const struct loops *, FILE *,
-						void (*)(const struct loop *,
-						FILE *, int), int));
-extern void flow_loop_dump		PARAMS ((const struct loop *, FILE *,
-						void (*)(const struct loop *,
-						FILE *, int), int));
-extern int flow_loop_scan		PARAMS ((struct loops *,
-						struct loop *, int));
-extern void flow_loop_free		PARAMS ((struct loop *));
-void mark_irreducible_loops		PARAMS ((struct loops *));
+extern int flow_loops_find (struct loops *, int flags);
+extern int flow_loops_update (struct loops *, int flags);
+extern void flow_loops_free (struct loops *);
+extern void flow_loops_dump (const struct loops *, FILE *,
+			     void (*)(const struct loop *, FILE *, int), int);
+extern void flow_loop_dump (const struct loop *, FILE *,
+			    void (*)(const struct loop *, FILE *, int), int);
+extern int flow_loop_scan (struct loops *, struct loop *, int);
+extern void flow_loop_free (struct loop *);
+void mark_irreducible_loops (struct loops *);
 
 /* Loop datastructure manipulation/querying.  */
-extern void flow_loop_tree_node_add	PARAMS ((struct loop *, struct loop *));
-extern void flow_loop_tree_node_remove	PARAMS ((struct loop *));
-extern bool flow_loop_outside_edge_p	PARAMS ((const struct loop *, edge));
-extern bool flow_loop_nested_p		PARAMS ((const struct loop *,
-						const struct loop *));
-extern bool flow_bb_inside_loop_p	PARAMS ((const struct loop *,
-						const basic_block));
-extern struct loop * find_common_loop	PARAMS ((struct loop *, struct loop *));
-extern int num_loop_insns		PARAMS ((struct loop *));
-extern int average_num_loop_insns	PARAMS ((struct loop *));
+extern void flow_loop_tree_node_add (struct loop *, struct loop *);
+extern void flow_loop_tree_node_remove (struct loop *);
+extern bool flow_loop_outside_edge_p (const struct loop *, edge);
+extern bool flow_loop_nested_p	(const struct loop *, const struct loop *);
+extern bool flow_bb_inside_loop_p (const struct loop *, const basic_block);
+extern struct loop * find_common_loop (struct loop *, struct loop *);
+extern int num_loop_insns (struct loop *);
+extern int average_num_loop_insns (struct loop *);
 
 /* Loops & cfg manipulation.  */
-extern basic_block *get_loop_body	PARAMS ((const struct loop *));
-extern edge *get_loop_exit_edges	PARAMS ((const struct loop *, unsigned *));
+extern basic_block *get_loop_body (const struct loop *);
+extern edge *get_loop_exit_edges (const struct loop *, unsigned *);
 
-extern edge loop_preheader_edge		PARAMS ((const struct loop *));
-extern edge loop_latch_edge		PARAMS ((const struct loop *));
+extern edge loop_preheader_edge (const struct loop *);
+extern edge loop_latch_edge (const struct loop *);
 
-extern void add_bb_to_loop		PARAMS ((basic_block, struct loop *));
-extern void remove_bb_from_loops	PARAMS ((basic_block));
+extern void add_bb_to_loop (basic_block, struct loop *);
+extern void remove_bb_from_loops (basic_block);
 
-extern void cancel_loop			PARAMS ((struct loops *, struct loop *));
-extern void cancel_loop_tree		PARAMS ((struct loops *, struct loop *));
+extern void cancel_loop (struct loops *, struct loop *);
+extern void cancel_loop_tree (struct loops *, struct loop *);
 
-extern basic_block loop_split_edge_with PARAMS ((edge, rtx, struct loops *));
-extern int fix_loop_placement		PARAMS ((struct loop *));
+extern basic_block loop_split_edge_with (edge, rtx, struct loops *);
+extern int fix_loop_placement (struct loop *);
 
 enum
 {
@@ -303,42 +298,38 @@ enum
   CP_INSIDE_CFGLAYOUT = 2
 };
 
-extern void create_preheaders		PARAMS ((struct loops *, int));
-extern void force_single_succ_latches	PARAMS ((struct loops *));
+extern void create_preheaders (struct loops *, int);
+extern void force_single_succ_latches (struct loops *);
 
-extern void verify_loop_structure	PARAMS ((struct loops *));
+extern void verify_loop_structure (struct loops *);
 
 /* Loop analysis.  */
-extern bool simple_loop_p		PARAMS ((struct loops *, struct loop *,
-						struct loop_desc *));
-extern rtx count_loop_iterations	PARAMS ((struct loop_desc *, rtx, rtx));
-extern bool just_once_each_iteration_p	PARAMS ((struct loops *,struct loop *,
-						 basic_block));
-extern unsigned expected_loop_iterations PARAMS ((const struct loop *));
+extern bool simple_loop_p (struct loops *, struct loop *, struct loop_desc *);
+extern rtx count_loop_iterations (struct loop_desc *, rtx, rtx);
+extern bool just_once_each_iteration_p (struct loops *,struct loop *,
+					basic_block);
+extern unsigned expected_loop_iterations (const struct loop *);
 
 /* Loop manipulation.  */
-extern bool can_duplicate_loop_p	PARAMS ((struct loop *loop));
+extern bool can_duplicate_loop_p (struct loop *loop);
 
 #define DLTHE_FLAG_UPDATE_FREQ	1	/* Update frequencies in
 					   duplicate_loop_to_header_edge.  */
 
-extern int duplicate_loop_to_header_edge PARAMS ((struct loop *, edge,
-						struct loops *, unsigned,
-						sbitmap, edge, edge *,
-						unsigned *, int));
-extern struct loop *loopify		PARAMS ((struct loops *, edge,
-						edge, basic_block));
-extern void unloop			PARAMS ((struct loops *, struct loop *));
-extern bool remove_path			PARAMS ((struct loops *, edge));
-extern edge split_loop_bb		PARAMS ((struct loops *, basic_block,
-						rtx));
+extern int duplicate_loop_to_header_edge (struct loop *, edge, struct loops *,
+					  unsigned, sbitmap, edge, edge *,
+					  unsigned *, int);
+extern struct loop *loopify (struct loops *, edge, edge, basic_block);
+extern void unloop (struct loops *, struct loop *);
+extern bool remove_path (struct loops *, edge);
+extern edge split_loop_bb (struct loops *, basic_block, rtx);
 
 /* Loop optimizer initialization.  */
-extern struct loops *loop_optimizer_init PARAMS ((FILE *));
-extern void loop_optimizer_finalize	PARAMS ((struct loops *, FILE *));
+extern struct loops *loop_optimizer_init (FILE *);
+extern void loop_optimizer_finalize (struct loops *, FILE *);
 
 /* Optimization passes.  */
-extern void unswitch_loops		PARAMS ((struct loops *));
+extern void unswitch_loops (struct loops *);
 
 enum
 {
@@ -347,4 +338,4 @@ enum
   UAP_UNROLL_ALL = 4	/* Enables peeling of all loops.  */
 };
 
-extern void unroll_and_peel_loops	PARAMS ((struct loops *, int));
+extern void unroll_and_peel_loops (struct loops *, int);

gcc/cfgloopanal.c

 /* Natural loop analysis code for GNU compiler.
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -30,33 +30,27 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "output.h"
 
 struct unmark_altered_insn_data;
-static void unmark_altered	 PARAMS ((rtx, rtx, regset));
-static void blocks_invariant_registers PARAMS ((basic_block *, int, regset));
-static void unmark_altered_insn	 PARAMS ((rtx, rtx, struct unmark_altered_insn_data *));
-static void blocks_single_set_registers PARAMS ((basic_block *, int, rtx *));
-static int invariant_rtx_wrto_regs_p_helper PARAMS ((rtx *, regset));
-static bool invariant_rtx_wrto_regs_p PARAMS ((rtx, regset));
-static rtx test_for_iteration PARAMS ((struct loop_desc *desc,
-				       unsigned HOST_WIDE_INT));
-static bool constant_iterations PARAMS ((struct loop_desc *,
-					 unsigned HOST_WIDE_INT *,
-					 bool *));
-static bool simple_loop_exit_p PARAMS ((struct loops *, struct loop *,
-					edge, regset, rtx *,
-					struct loop_desc *));
-static rtx variable_initial_value PARAMS ((rtx, regset, rtx, rtx *));
-static rtx variable_initial_values PARAMS ((edge, rtx));
-static bool simple_condition_p PARAMS ((struct loop *, rtx,
-					regset, struct loop_desc *));
-static basic_block simple_increment PARAMS ((struct loops *, struct loop *,
-					     rtx *, struct loop_desc *));
+static void unmark_altered (rtx, rtx, regset);
+static void blocks_invariant_registers (basic_block *, int, regset);
+static void unmark_altered_insn (rtx, rtx, struct unmark_altered_insn_data *);
+static void blocks_single_set_registers (basic_block *, int, rtx *);
+static int invariant_rtx_wrto_regs_p_helper (rtx *, regset);
+static bool invariant_rtx_wrto_regs_p (rtx, regset);
+static rtx test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT);
+static bool constant_iterations (struct loop_desc *, unsigned HOST_WIDE_INT *,
+				 bool *);
+static bool simple_loop_exit_p (struct loops *, struct loop *, edge, regset,
+				rtx *, struct loop_desc *);
+static rtx variable_initial_value (rtx, regset, rtx, rtx *);
+static rtx variable_initial_values (edge, rtx);
+static bool simple_condition_p (struct loop *, rtx, regset,
+				struct loop_desc *);
+static basic_block simple_increment (struct loops *, struct loop *, rtx *,
+				     struct loop_desc *);
 
 /* Checks whether BB is executed exactly once in each LOOP iteration.  */
 bool
-just_once_each_iteration_p (loops, loop, bb)
-     struct loops *loops;
-     struct loop *loop;
-     basic_block bb;
+just_once_each_iteration_p (struct loops *loops, struct loop *loop, basic_block bb)
 {
   /* It must be executed at least once each iteration.  */
   if (!dominated_by_p (loops->cfg.dom, loop->latch, bb))
@@ -76,10 +70,7 @@ just_once_each_iteration_p (loops, loop, bb)
 
 /* Unmarks modified registers; helper to blocks_invariant_registers.  */
 static void
-unmark_altered (what, by, regs)
-     rtx what;
-     rtx by ATTRIBUTE_UNUSED;
-     regset regs;
+unmark_altered (rtx what, rtx by ATTRIBUTE_UNUSED, regset regs)
 {
   if (GET_CODE (what) == SUBREG)
     what = SUBREG_REG (what);
@@ -90,10 +81,7 @@ unmark_altered (what, by, regs)
 
 /* Marks registers that are invariant inside blocks BBS.  */
 static void
-blocks_invariant_registers (bbs, nbbs, regs)
-     basic_block *bbs;
-     int nbbs;
-     regset regs;
+blocks_invariant_registers (basic_block *bbs, int nbbs, regset regs)
 {
   rtx insn;
   int i;
@@ -118,10 +106,8 @@ struct unmark_altered_insn_data
 };
 
 static void
-unmark_altered_insn (what, by, data)
-     rtx what;
-     rtx by ATTRIBUTE_UNUSED;
-     struct unmark_altered_insn_data *data;
+unmark_altered_insn (rtx what, rtx by ATTRIBUTE_UNUSED,
+		     struct unmark_altered_insn_data *data)
 {
   int rn;
 
@@ -138,10 +124,7 @@ unmark_altered_insn (what, by, data)
 /* Marks registers that have just single simple set in BBS; the relevant
    insn is returned in REGS.  */
 static void
-blocks_single_set_registers (bbs, nbbs, regs)
-     basic_block *bbs;
-     int nbbs;
-     rtx *regs;
+blocks_single_set_registers (basic_block *bbs, int nbbs, rtx *regs)
 {
   rtx insn;
   int i;
@@ -180,9 +163,7 @@ blocks_single_set_registers (bbs, nbbs, regs)
 
 /* Helper for invariant_rtx_wrto_regs_p.  */
 static int
-invariant_rtx_wrto_regs_p_helper (expr, invariant_regs)
-     rtx *expr;
-     regset invariant_regs;
+invariant_rtx_wrto_regs_p_helper (rtx *expr, regset invariant_regs)
 {
   switch (GET_CODE (*expr))
     {
@@ -216,9 +197,7 @@ invariant_rtx_wrto_regs_p_helper (expr, invariant_regs)
 
 /* Checks that EXPR is invariant provided that INVARIANT_REGS are invariant.  */
 static bool
-invariant_rtx_wrto_regs_p (expr, invariant_regs)
-     rtx expr;
-     regset invariant_regs;
+invariant_rtx_wrto_regs_p (rtx expr, regset invariant_regs)
 {
   return !for_each_rtx (&expr, (rtx_function) invariant_rtx_wrto_regs_p_helper,
 			invariant_regs);
@@ -228,11 +207,8 @@ invariant_rtx_wrto_regs_p (expr, invariant_regs)
    is register and the other one is invariant in the LOOP. Fills var, lim
    and cond fields in DESC.  */
 static bool
-simple_condition_p (loop, condition, invariant_regs, desc)
-     struct loop *loop ATTRIBUTE_UNUSED;
-     rtx condition;
-     regset invariant_regs;
-     struct loop_desc *desc;
+simple_condition_p (struct loop *loop ATTRIBUTE_UNUSED, rtx condition,
+		    regset invariant_regs, struct loop_desc *desc)
 {
   rtx op0, op1;
 
@@ -296,11 +272,8 @@ simple_condition_p (loop, condition, invariant_regs, desc)
    iteration.  Fills in DESC->stride and returns block in that DESC->var is
    modified.  */
 static basic_block
-simple_increment (loops, loop, simple_increment_regs, desc)
-     struct loops *loops;
-     struct loop *loop;
-     rtx *simple_increment_regs;
-     struct loop_desc *desc;
+simple_increment (struct loops *loops, struct loop *loop,
+		  rtx *simple_increment_regs, struct loop_desc *desc)
 {
   rtx mod_insn, set, set_src, set_add;
   basic_block mod_bb;
@@ -344,11 +317,7 @@ simple_increment (loops, loop, simple_increment_regs, desc)
    wrto INVARIANT_REGS.  If SET_INSN is not NULL, insn in that var is set is
    placed here.  */
 static rtx
-variable_initial_value (insn, invariant_regs, var, set_insn)
-     rtx insn;
-     regset invariant_regs;
-     rtx var;
-     rtx *set_insn;
+variable_initial_value (rtx insn, regset invariant_regs, rtx var, rtx *set_insn)
 {
   basic_block bb;
   rtx set;
@@ -407,9 +376,7 @@ variable_initial_value (insn, invariant_regs, var, set_insn)
 
 /* Returns list of definitions of initial value of VAR at Edge.  */
 static rtx
-variable_initial_values (e, var)
-     edge e;
-     rtx var;
+variable_initial_values (edge e, rtx var)
 {
   rtx set_insn, list;
   regset invariant_regs;
@@ -437,10 +404,8 @@ variable_initial_values (e, var)
 /* Counts constant number of iterations of the loop described by DESC;
    returns false if impossible.  */
 static bool
-constant_iterations (desc, niter, may_be_zero)
-     struct loop_desc *desc;
-     unsigned HOST_WIDE_INT *niter;
-     bool *may_be_zero;
+constant_iterations (struct loop_desc *desc, unsigned HOST_WIDE_INT *niter,
+		     bool *may_be_zero)
 {
   rtx test, expr;
   rtx ainit, alim;
@@ -496,10 +461,7 @@ constant_iterations (desc, niter, may_be_zero)
 
    When INIT/LIM are set, they are used instead of var/lim of DESC.  */
 rtx
-count_loop_iterations (desc, init, lim)
-     struct loop_desc *desc;
-     rtx init;
-     rtx lim;
+count_loop_iterations (struct loop_desc *desc, rtx init, rtx lim)
 {
   enum rtx_code cond = desc->cond;
   rtx stride = desc->stride;
@@ -618,9 +580,7 @@ count_loop_iterations (desc, init, lim)
    described of DESC at given iteration of loop.  */
 
 static rtx
-test_for_iteration (desc, iter)
-     struct loop_desc *desc;
-     unsigned HOST_WIDE_INT iter;
+test_for_iteration (struct loop_desc *desc, unsigned HOST_WIDE_INT iter)
 {
   enum rtx_code cond = desc->cond;
   rtx exp = XEXP (desc->var_alts, 0);
@@ -661,13 +621,9 @@ test_for_iteration (desc, iter)
    description joined to it in in DESC.  INVARIANT_REGS and SINGLE_SET_REGS
    are results of blocks_{invariant,single_set}_regs over BODY.  */
 static bool
-simple_loop_exit_p (loops, loop, exit_edge, invariant_regs, single_set_regs, desc)
-     struct loops *loops;
-     struct loop *loop;
-     edge exit_edge;
-     struct loop_desc *desc;
-     regset invariant_regs;
-     rtx *single_set_regs;
+simple_loop_exit_p (struct loops *loops, struct loop *loop, edge exit_edge,
+		    regset invariant_regs, rtx *single_set_regs,
+		    struct loop_desc *desc)
 {
   basic_block mod_bb, exit_bb;
   int fallthru_out;
@@ -729,10 +685,7 @@ simple_loop_exit_p (loops, loop, exit_edge, invariant_regs, single_set_regs, des
 /* Tests whether LOOP is simple for loop.  Returns simple loop description
    in DESC.  */
 bool
-simple_loop_p (loops, loop, desc)
-     struct loops *loops;
-     struct loop *loop;
-     struct loop_desc *desc;
+simple_loop_p (struct loops *loops, struct loop *loop, struct loop_desc *desc)
 {
   unsigned i;
   basic_block *body;
@@ -825,8 +778,7 @@ simple_loop_p (loops, loop, desc)
    each cycle, we want to mark blocks that belong directly to innermost
    loop containing the whole cycle.  */
 void
-mark_irreducible_loops (loops)
-     struct loops *loops;
+mark_irreducible_loops (struct loops *loops)
 {
   int *dfs_in, *closed, *mr, *mri, *n_edges, *stack;
   unsigned i;
@@ -1019,8 +971,7 @@ next:;
 
 /* Counts number of insns inside LOOP.  */
 int
-num_loop_insns (loop)
-     struct loop *loop;
+num_loop_insns (struct loop *loop)
 {
   basic_block *bbs, bb;
   unsigned i, ninsns = 0;
@@ -1042,8 +993,7 @@ num_loop_insns (loop)
 
 /* Counts number of insns executed on average per iteration LOOP.  */
 int
-average_num_loop_insns (loop)
-     struct loop *loop;
+average_num_loop_insns (struct loop *loop)
 {
   basic_block *bbs, bb;
   unsigned i, binsns, ninsns, ratio;
@@ -1078,8 +1028,7 @@ average_num_loop_insns (loop)
    Compute upper bound on number of iterations in case they do not fit integer
    to help loop peeling heuristics.  Use exact counts if at all possible.  */
 unsigned
-expected_loop_iterations (loop)
-     const struct loop *loop;
+expected_loop_iterations (const struct loop *loop)
 {
   edge e;
 

gcc/cfgloopmanip.c

@@ -29,44 +29,35 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "cfglayout.h"
 #include "output.h"
 
-static struct loop * duplicate_loop	PARAMS ((struct loops *,
-						struct loop *, struct loop *));
-static void duplicate_subloops		PARAMS ((struct loops *, struct loop *,
-						struct loop *));
-static void copy_loops_to		PARAMS ((struct loops *, struct loop **,
-						int, struct loop *));
-static void loop_redirect_edge		PARAMS ((edge, basic_block));
-static bool loop_delete_branch_edge	PARAMS ((edge, int));
-static void copy_bbs			PARAMS ((basic_block *, int, edge,
-						edge, basic_block **,
-						struct loops *, edge *,
-						edge *, int));
-static void remove_bbs			PARAMS ((dominance_info, basic_block *,
-						int));
-static bool rpe_enum_p			PARAMS ((basic_block, void *));
-static int find_path			PARAMS ((edge, dominance_info,
-						basic_block **));
-static bool alp_enum_p			PARAMS ((basic_block, void *));
-static void add_loop			PARAMS ((struct loops *, struct loop *));
-static void fix_loop_placements		PARAMS ((struct loop *));
-static bool fix_bb_placement		PARAMS ((struct loops *, basic_block));
-static void fix_bb_placements		PARAMS ((struct loops *, basic_block));
-static void place_new_loop		PARAMS ((struct loops *, struct loop *));
-static void scale_loop_frequencies	PARAMS ((struct loop *, int, int));
-static void scale_bbs_frequencies	PARAMS ((basic_block *, int, int, int));
-static void record_exit_edges		PARAMS ((edge, basic_block *, int,
-						edge *, unsigned *, int));
-static basic_block create_preheader	PARAMS ((struct loop *, dominance_info,
-						int));
-static void fix_irreducible_loops	PARAMS ((basic_block));
+static struct loop * duplicate_loop (struct loops *, struct loop *,
+				     struct loop *);
+static void duplicate_subloops (struct loops *, struct loop *, struct loop *);
+static void copy_loops_to (struct loops *, struct loop **, int,
+			   struct loop *);
+static void loop_redirect_edge (edge, basic_block);
+static bool loop_delete_branch_edge (edge, int);
+static void copy_bbs (basic_block *, int, edge, edge, basic_block **,
+		      struct loops *, edge *, edge *, int);
+static void remove_bbs (dominance_info, basic_block *, int);
+static bool rpe_enum_p (basic_block, void *);
+static int find_path (edge, dominance_info, basic_block **);
+static bool alp_enum_p (basic_block, void *);
+static void add_loop (struct loops *, struct loop *);
+static void fix_loop_placements (struct loop *);
+static bool fix_bb_placement (struct loops *, basic_block);
+static void fix_bb_placements (struct loops *, basic_block);
+static void place_new_loop (struct loops *, struct loop *);
+static void scale_loop_frequencies (struct loop *, int, int);
+static void scale_bbs_frequencies (basic_block *, int, int, int);
+static void record_exit_edges (edge, basic_block *, int, edge *, unsigned *,
+			       int);
+static basic_block create_preheader (struct loop *, dominance_info, int);
+static void fix_irreducible_loops (basic_block);
 
 /* Splits basic block BB after INSN, returns created edge.  Updates loops
    and dominators.  */
 edge
-split_loop_bb (loops, bb, insn)
-     struct loops *loops;
-     basic_block bb;
-     rtx insn;
+split_loop_bb (struct loops *loops, basic_block bb, rtx insn)
 {
   edge e;
   basic_block *dom_bbs;
@@ -98,9 +89,7 @@ struct rpe_data
  };
 
 static bool
-rpe_enum_p (bb, data)
-     basic_block bb;
-     void *data;
+rpe_enum_p (basic_block bb, void *data)
 {
   struct rpe_data *rpe = data;
   return dominated_by_p (rpe->doms, bb, rpe->dom);
@@ -109,10 +98,7 @@ rpe_enum_p (bb, data)
 /* Remove basic blocks BBS from loop structure and dominance info,
    and delete them afterwards.  */
 static void
-remove_bbs (dom, bbs, nbbs)
-     dominance_info dom;
-     basic_block *bbs;
-     int nbbs;
+remove_bbs (dominance_info dom, basic_block *bbs, int nbbs)
 {
   int i;
 
@@ -131,10 +117,7 @@ remove_bbs (dom, bbs, nbbs)
    alter anything by this function).  The number of basic blocks in the
    path is returned.  */
 static int
-find_path (e, doms, bbs)
-     edge e;
-     dominance_info doms;
-     basic_block **bbs;
+find_path (edge e, dominance_info doms, basic_block **bbs)
 {
   struct rpe_data rpe;
 
@@ -157,9 +140,7 @@ find_path (e, doms, bbs)
    false if the placement of BB was already correct (provided that placements
    of its successors are correct).  */
 static bool
-fix_bb_placement (loops, bb)
-     struct loops *loops;
-     basic_block bb;
+fix_bb_placement (struct loops *loops, basic_block bb)
 {
   edge e;
   struct loop *loop = loops->tree_root, *act;
@@ -195,9 +176,7 @@ fix_bb_placement (loops, bb)
    to this change; the condition for them is simmilar, except that instead of
    successors we consider edges coming out of the loops.  */
 static void
-fix_bb_placements (loops, from)
-     struct loops *loops;
-     basic_block from;
+fix_bb_placements (struct loops *loops, basic_block from)
 {
   sbitmap in_queue;
   basic_block *queue, *qtop, *qbeg, *qend;
@@ -290,8 +269,7 @@ fix_bb_placements (loops, from)
    mo longer be part irreducible loop.  Fix it and proceed recursively
    for its successors if needed.  */
 static void
-fix_irreducible_loops (from)
-     basic_block from;
+fix_irreducible_loops (basic_block from)
 {
   basic_block bb;
   basic_block *stack;
@@ -360,9 +338,7 @@ fix_irreducible_loops (from)
    we were able to remove the path, false otherwise (and nothing is affected
    then).  */
 bool
-remove_path (loops, e)
-     struct loops *loops;
-     edge e;
+remove_path (struct loops *loops, edge e)
 {
   edge ae;
   basic_block *rem_bbs, *bord_bbs, *dom_bbs, from, bb;
@@ -466,9 +442,7 @@ remove_path (loops, e)
 
 /* Predicate for enumeration in add_loop.  */
 static bool
-alp_enum_p (bb, alp_header)
-     basic_block bb;
-     void *alp_header;
+alp_enum_p (basic_block bb, void *alp_header)
 {
   return bb != (basic_block) alp_header;
 }
@@ -476,9 +450,7 @@ alp_enum_p (bb, alp_header)
 /* Given LOOP structure with filled header and latch, find the body of the
    corresponding loop and add it to LOOPS tree.  */
 static void
-add_loop (loops, loop)
-     struct loops *loops;
-     struct loop *loop;
+add_loop (struct loops *loops, struct loop *loop)
 {
   basic_block *bbs;
   int i, n;
@@ -502,11 +474,7 @@ add_loop (loops, loop)
 /* Multiply all frequencies of basic blocks in array BBS of lenght NBBS
    by NUM/DEN.  */
 static void
-scale_bbs_frequencies (bbs, nbbs, num, den)
-     basic_block *bbs;
-     int nbbs;
-     int num;
-     int den;
+scale_bbs_frequencies (basic_block *bbs, int nbbs, int num, int den)
 {
   int i;
   edge e;
@@ -522,10 +490,7 @@ scale_bbs_frequencies (bbs, nbbs, num, den)
 
 /* Multiply all frequencies in LOOP by NUM/DEN.  */
 static void
-scale_loop_frequencies (loop, num, den)
-     struct loop *loop;
-     int num;
-     int den;
+scale_loop_frequencies (struct loop *loop, int num, int den)
 {
   basic_block *bbs;
 
@@ -543,11 +508,7 @@ scale_loop_frequencies (loop, num, den)
    SWITCH_BB->succ->succ_next to original destination of HEADER_EDGE.
    Returns newly created loop.  */
 struct loop *
-loopify (loops, latch_edge, header_edge, switch_bb)
-     struct loops *loops;
-     edge latch_edge;
-     edge header_edge;
-     basic_block switch_bb;
+loopify (struct loops *loops, edge latch_edge, edge header_edge, basic_block switch_bb)
 {
   basic_block succ_bb = latch_edge->dest;
   basic_block pred_bb = header_edge->src;
@@ -634,9 +595,7 @@ loopify (loops, latch_edge, header_edge, switch_bb)
    the LOOP was removed.  After this function, original loop latch will
    have no successor, which caller is expected to fix somehow.  */
 void
-unloop (loops, loop)
-     struct loops *loops;
-     struct loop *loop;
+unloop (struct loops *loops, struct loop *loop)
 {
   basic_block *body;
   struct loop *ploop;
@@ -694,8 +653,7 @@ unloop (loops, loop)
    FATHER, and set it as outer loop of LOOP.  Return 1 if placement of
    LOOP changed.  */
 int
-fix_loop_placement (loop)
-     struct loop *loop;
+fix_loop_placement (struct loop *loop)
 {
   basic_block *body;
   unsigned i;
@@ -729,8 +687,7 @@ fix_loop_placement (loop)
    It is used in case when we removed some edges coming out of LOOP, which
    may cause the right placement of LOOP inside loop tree to change.  */
 static void
-fix_loop_placements (loop)
-     struct loop *loop;
+fix_loop_placements (struct loop *loop)
 {
   struct loop *outer;
 
@@ -745,9 +702,7 @@ fix_loop_placements (loop)
 
 /* Creates place for a new LOOP in LOOPS structure.  */
 static void
-place_new_loop (loops, loop)
-     struct loops *loops;
-     struct loop *loop;
+place_new_loop (struct loops *loops, struct loop *loop)
 {
   loops->parray =
     xrealloc (loops->parray, (loops->num + 1) * sizeof (struct loop *));
@@ -759,10 +714,7 @@ place_new_loop (loops, loop)
 /* Copies copy of LOOP as subloop of TARGET loop, placing newly
    created loop into LOOPS structure.  */
 static struct loop *
-duplicate_loop (loops, loop, target)
-     struct loops *loops;
-     struct loop *loop;
-     struct loop *target;
+duplicate_loop (struct loops *loops, struct loop *loop, struct loop *target)
 {
   struct loop *cloop;
   cloop = xcalloc (1, sizeof (struct loop));
@@ -783,10 +735,7 @@ duplicate_loop (loops, loop, target)
 /* Copies structure of subloops of LOOP into TARGET loop, placing
    newly created loops into loop tree stored in LOOPS.  */
 static void
-duplicate_subloops (loops, loop, target)
-     struct loops *loops;
-     struct loop *loop;
-     struct loop *target;
+duplicate_subloops (struct loops *loops, struct loop *loop, struct loop *target)
 {
   struct loop *aloop, *cloop;
 
@@ -800,11 +749,7 @@ duplicate_subloops (loops, loop, target)
 /* Copies structure of subloops of N loops, stored in array COPIED_LOOPS,
    into TARGET loop, placing newly created loops into loop tree LOOPS.  */
 static void
-copy_loops_to (loops, copied_loops, n, target)
-     struct loops *loops;
-     struct loop **copied_loops;
-     int n;
-     struct loop *target;
+copy_loops_to (struct loops *loops, struct loop **copied_loops, int n, struct loop *target)
 {
   struct loop *aloop;
   int i;
@@ -818,9 +763,7 @@ copy_loops_to (loops, copied_loops, n, target)
 
 /* Redirects edge E to basic block DEST.  */
 static void
-loop_redirect_edge (e, dest)
-     edge e;
-     basic_block dest;
+loop_redirect_edge (edge e, basic_block dest)
 {
   if (e->dest == dest)
     return;
@@ -831,9 +774,7 @@ loop_redirect_edge (e, dest)
 /* Deletes edge E from a branch if possible.  Unless REALLY_DELETE is set,
    just test whether it is possible to remove the edge.  */
 static bool
-loop_delete_branch_edge (e, really_delete)
-     edge e;
-     int really_delete;
+loop_delete_branch_edge (edge e, int really_delete)
 {
   basic_block src = e->src;
   int irr;
@@ -904,16 +845,9 @@ loop_delete_branch_edge (e, really_delete)
      original entry block to first block in peeled copy.
  */
 static void
-copy_bbs (bbs, n, entry, latch_edge, new_bbs, loops, header_edge, copy_header_edge, add_irreducible_flag)
-     basic_block *bbs;
-     int n;
-     edge entry;
-     edge latch_edge;
-     basic_block **new_bbs;
-     struct loops *loops;
-     edge *header_edge;
-     edge *copy_header_edge;
-     int add_irreducible_flag;
+copy_bbs (basic_block *bbs, int n, edge entry, edge latch_edge,
+	  basic_block **new_bbs, struct loops *loops, edge *header_edge,
+	  edge *copy_header_edge, int add_irreducible_flag)
 {
   int i;
   basic_block bb, new_bb, header = entry->dest, dom_bb;
@@ -1007,8 +941,7 @@ copy_bbs (bbs, n, entry, latch_edge, new_bbs, loops, header_edge, copy_header_ed
 
 /* Check whether LOOP's body can be duplicated.  */
 bool
-can_duplicate_loop_p (loop)
-     struct loop *loop;
+can_duplicate_loop_p (struct loop *loop)
 {
   basic_block *bbs;
   unsigned i;
@@ -1047,13 +980,8 @@ can_duplicate_loop_p (loop)
    into TO_REMOVE array that must be large enough to hold them all; their
    number is returned in N_TO_REMOVE.  */
 static void
-record_exit_edges (orig, bbs, nbbs, to_remove, n_to_remove, is_orig)
-     edge orig;
-     basic_block *bbs;
-     int nbbs;
-     edge *to_remove;
-     unsigned *n_to_remove;
-     int is_orig;
+record_exit_edges (edge orig, basic_block *bbs, int nbbs, edge *to_remove,
+		   unsigned int *n_to_remove, int is_orig)
 {
   sbitmap my_blocks;
   int i;
@@ -1106,17 +1034,10 @@ record_exit_edges (orig, bbs, nbbs, to_remove, n_to_remove, is_orig)
    other copies are numbered in order given by control flow through them)
    into TO_REMOVE array.  Returns false if duplication is impossible.  */
 int
-duplicate_loop_to_header_edge (loop, e, loops, ndupl, wont_exit, orig,
-			       to_remove, n_to_remove, flags)
-     struct loop *loop;
-     edge e;
-     struct loops *loops;
-     unsigned ndupl;
-     sbitmap wont_exit;
-     edge orig;
-     edge *to_remove;
-     unsigned *n_to_remove;
-     int flags;
+duplicate_loop_to_header_edge (struct loop *loop, edge e, struct loops *loops,
+			       unsigned int ndupl, sbitmap wont_exit,
+			       edge orig, edge *to_remove,
+			       unsigned int *n_to_remove, int flags)
 {
   struct loop *target, *aloop;
   struct loop **orig_loops;
@@ -1353,10 +1274,7 @@ duplicate_loop_to_header_edge (loop, e, loops, ndupl, wont_exit, orig,
    entry; otherwise we also force preheader block to have only one successor.
    The function also updates dominators stored in DOM.  */
 static basic_block
-create_preheader (loop, dom, flags)
-     struct loop *loop;
-     dominance_info dom;
-     int flags;
+create_preheader (struct loop *loop, dominance_info dom, int flags)
 {
   edge e, fallthru;
   basic_block dummy;
@@ -1442,9 +1360,7 @@ create_preheader (loop, dom, flags)
 /* Create preheaders for each loop from loop tree stored in LOOPS; for meaning
    of FLAGS see create_preheader.  */
 void
-create_preheaders (loops, flags)
-     struct loops *loops;
-     int flags;
+create_preheaders (struct loops *loops, int flags)
 {
   unsigned i;
   for (i = 1; i < loops->num; i++)
@@ -1455,8 +1371,7 @@ create_preheaders (loops, flags)
 /* Forces all loop latches of loops from loop tree LOOPS to have only single
    successor.  */
 void
-force_single_succ_latches (loops)
-     struct loops *loops;
+force_single_succ_latches (struct loops *loops)
 {
   unsigned i;
   struct loop *loop;
@@ -1481,10 +1396,7 @@ force_single_succ_latches (loops)
    be ok after this function.  The created block is placed on correct place
    in LOOPS structure and its dominator is set.  */
 basic_block
-loop_split_edge_with (e, insns, loops)
-     edge e;
-     rtx insns;
-     struct loops *loops;
+loop_split_edge_with (edge e, rtx insns, struct loops *loops)
 {
   basic_block src, dest, new_bb;
   struct loop *loop_c;

gcc/cfgrtl.c

 /* Control flow graph manipulation code for GNU compiler.
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -69,32 +69,31 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 rtx label_value_list;
 rtx tail_recursion_label_list;
 
-static int can_delete_note_p		PARAMS ((rtx));
-static int can_delete_label_p		PARAMS ((rtx));
-static void commit_one_edge_insertion	PARAMS ((edge, int));
-static bool try_redirect_by_replacing_jump PARAMS ((edge, basic_block));
-static rtx last_loop_beg_note		PARAMS ((rtx));
-static bool back_edge_of_syntactic_loop_p PARAMS ((basic_block, basic_block));
-basic_block force_nonfallthru_and_redirect PARAMS ((edge, basic_block));
-static basic_block rtl_split_edge	PARAMS ((edge));
-static int rtl_verify_flow_info		PARAMS ((void));
-static edge cfg_layout_split_block	PARAMS ((basic_block, void *));
-static bool cfg_layout_redirect_edge_and_branch	PARAMS ((edge, basic_block));
-static basic_block cfg_layout_redirect_edge_and_branch_force PARAMS ((edge, basic_block));
-static void cfg_layout_delete_block	PARAMS ((basic_block));
-static void rtl_delete_block		PARAMS ((basic_block));
-static basic_block rtl_redirect_edge_and_branch_force PARAMS ((edge, basic_block));
-static bool rtl_redirect_edge_and_branch PARAMS ((edge, basic_block));
-static edge rtl_split_block		PARAMS ((basic_block, void *));
-static void rtl_dump_bb			PARAMS ((basic_block, FILE *));
-static int rtl_verify_flow_info_1	PARAMS ((void));
+static int can_delete_note_p (rtx);
+static int can_delete_label_p (rtx);
+static void commit_one_edge_insertion (edge, int);
+static bool try_redirect_by_replacing_jump (edge, basic_block);
+static rtx last_loop_beg_note (rtx);
+static bool back_edge_of_syntactic_loop_p (basic_block, basic_block);
+basic_block force_nonfallthru_and_redirect (edge, basic_block);
+static basic_block rtl_split_edge (edge);
+static int rtl_verify_flow_info (void);
+static edge cfg_layout_split_block (basic_block, void *);
+static bool cfg_layout_redirect_edge_and_branch (edge, basic_block);
+static basic_block cfg_layout_redirect_edge_and_branch_force (edge, basic_block);
+static void cfg_layout_delete_block (basic_block);
+static void rtl_delete_block (basic_block);
+static basic_block rtl_redirect_edge_and_branch_force (edge, basic_block);
+static bool rtl_redirect_edge_and_branch (edge, basic_block);
+static edge rtl_split_block (basic_block, void *);
+static void rtl_dump_bb (basic_block, FILE *);
+static int rtl_verify_flow_info_1 (void);
 
 /* Return true if NOTE is not one of the ones that must be kept paired,
    so that we may simply delete it.  */
 
 static int
-can_delete_note_p (note)
-     rtx note;
+can_delete_note_p (rtx note)
 {
   return (NOTE_LINE_NUMBER (note) == NOTE_INSN_DELETED
 	  || NOTE_LINE_NUMBER (note) == NOTE_INSN_BASIC_BLOCK
@@ -104,8 +103,7 @@ can_delete_note_p (note)
 /* True if a given label can be deleted.  */
 
 static int
-can_delete_label_p (label)
-     rtx label;
+can_delete_label_p (rtx label)
 {
   return (!LABEL_PRESERVE_P (label)
 	  /* User declared labels must be preserved.  */
@@ -117,8 +115,7 @@ can_delete_label_p (label)
 /* Delete INSN by patching it out.  Return the next insn.  */
 
 rtx
-delete_insn (insn)
-     rtx insn;
+delete_insn (rtx insn)
 {
   rtx next = NEXT_INSN (insn);
   rtx note;
@@ -189,8 +186,7 @@ delete_insn (insn)
 
 /* Like delete_insn but also purge dead edges from BB.  */
 rtx
-delete_insn_and_edges (insn)
-     rtx insn;
+delete_insn_and_edges (rtx insn)
 {
   rtx x;
   bool purge = false;
@@ -209,8 +205,7 @@ delete_insn_and_edges (insn)
    that must be paired.  */
 
 void
-delete_insn_chain (start, finish)
-     rtx start, finish;
+delete_insn_chain (rtx start, rtx finish)
 {
   rtx next;
 
@@ -233,8 +228,7 @@ delete_insn_chain (start, finish)
 
 /* Like delete_insn but also purge dead edges from BB.  */
 void
-delete_insn_chain_and_edges (first, last)
-     rtx first, last;
+delete_insn_chain_and_edges (rtx first, rtx last)
 {
   bool purge = false;
 
@@ -256,9 +250,7 @@ delete_insn_chain_and_edges (first, last)
    AFTER is the basic block we should be put after.  */
 
 basic_block
-create_basic_block_structure (head, end, bb_note, after)
-     rtx head, end, bb_note;
-     basic_block after;
+create_basic_block_structure (rtx head, rtx end, rtx bb_note, basic_block after)
 {
   basic_block bb;
 
@@ -333,9 +325,7 @@ create_basic_block_structure (head, end, bb_note, after)
    create basic block at the end of INSN chain.  */
 
 basic_block
-create_basic_block (head, end, after)
-     rtx head, end;
-     basic_block after;
+create_basic_block (rtx head, rtx end, basic_block after)
 {
   basic_block bb;
 
@@ -358,8 +348,7 @@ create_basic_block (head, end, after)
    to post-process the stream to remove empty blocks, loops, ranges, etc.  */
 
 static void
-rtl_delete_block (b)
-     basic_block b;
+rtl_delete_block (basic_block b)
 {
   rtx insn, end, tmp;
 
@@ -420,7 +409,7 @@ rtl_delete_block (b)
 /* Records the basic block struct in BLOCK_FOR_INSN for every insn.  */
 
 void
-compute_bb_for_insn ()
+compute_bb_for_insn (void)
 {
   basic_block bb;
 
@@ -441,7 +430,7 @@ compute_bb_for_insn ()
 /* Release the basic_block_for_insn array.  */
 
 void
-free_bb_for_insn ()
+free_bb_for_insn (void)
 {
   rtx insn;
   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
@@ -452,8 +441,7 @@ free_bb_for_insn ()
 /* Update insns block within BB.  */
 
 void
-update_bb_for_insn (bb)
-     basic_block bb;
+update_bb_for_insn (basic_block bb)
 {
   rtx insn;
 
@@ -472,9 +460,7 @@ update_bb_for_insn (bb)
    one has a number one greater than the block split.  */
 
 static edge
-rtl_split_block (bb, insnp)
-     basic_block bb;
-     void *insnp;
+rtl_split_block (basic_block bb, void *insnp)
 {
   basic_block new_bb;
   edge new_edge;
@@ -533,8 +519,7 @@ rtl_split_block (bb, insnp)
    are already contiguous, hence `nomove'.  */
 
 void
-merge_blocks_nomove (a, b)
-     basic_block a, b;
+merge_blocks_nomove (basic_block a, basic_block b)
 {
   rtx b_head = b->head, b_end = b->end, a_end = a->end;
   rtx del_first = NULL_RTX, del_last = NULL_RTX;
@@ -641,8 +626,7 @@ merge_blocks_nomove (a, b)
    exist.  */
 
 rtx
-block_label (block)
-     basic_block block;
+block_label (basic_block block)
 {
   if (block == EXIT_BLOCK_PTR)
     return NULL_RTX;
@@ -661,9 +645,7 @@ block_label (block)
    return values are equivalent to redirect_edge_and_branch.  */
 
 static bool
-try_redirect_by_replacing_jump (e, target)
-     edge e;
-     basic_block target;
+try_redirect_by_replacing_jump (edge e, basic_block target)
 {
   basic_block src = e->src;
   rtx insn = src->end, kill_from;
@@ -785,8 +767,7 @@ try_redirect_by_replacing_jump (e, target)
    test.  */
 
 static rtx
-last_loop_beg_note (insn)
-     rtx insn;
+last_loop_beg_note (rtx insn)
 {
   rtx last = insn;
 
@@ -810,9 +791,7 @@ last_loop_beg_note (insn)
    stream.  */
 
 static bool
-rtl_redirect_edge_and_branch (e, target)
-     edge e;
-     basic_block target;
+rtl_redirect_edge_and_branch (edge e, basic_block target)
 {
   rtx tmp;
   rtx old_label = e->dest->head;
@@ -911,9 +890,7 @@ rtl_redirect_edge_and_branch (e, target)
    Used by redirect_edge_and_branch_force.  */
 
 basic_block
-force_nonfallthru_and_redirect (e, target)
-     edge e;
-     basic_block target;
+force_nonfallthru_and_redirect (edge e, basic_block target)
 {
   basic_block jump_block, new_bb = NULL, src = e->src;
   rtx note;
@@ -1064,8 +1041,7 @@ force_nonfallthru_and_redirect (e, target)
    Return newly created BB or NULL if none.  */
 
 basic_block
-force_nonfallthru (e)
-     edge e;
+force_nonfallthru (edge e)
 {
   return force_nonfallthru_and_redirect (e, e->dest);
 }
@@ -1075,9 +1051,7 @@ force_nonfallthru (e)
    Abort if conversion is impossible.  */
 
 static basic_block
-rtl_redirect_edge_and_branch_force (e, target)
-     edge e;
-     basic_block target;
+rtl_redirect_edge_and_branch_force (edge e, basic_block target)
 {
   if (redirect_edge_and_branch (e, target)
       || e->dest == target)
@@ -1092,9 +1066,7 @@ rtl_redirect_edge_and_branch_force (e, target)
    fact true, delete the jump and barriers that are in the way.  */
 
 void
-tidy_fallthru_edge (e, b, c)
-     edge e;
-     basic_block b, c;
+tidy_fallthru_edge (edge e, basic_block b, basic_block c)
 {
   rtx q;
 
@@ -1149,7 +1121,7 @@ tidy_fallthru_edge (e, b, c)
    is how find_basic_blocks created them.  */
 
 void
-tidy_fallthru_edges ()
+tidy_fallthru_edges (void)
 {
   basic_block b, c;
 
@@ -1189,8 +1161,7 @@ tidy_fallthru_edges ()
    is back edge of syntactic loop.  */
 
 static bool
-back_edge_of_syntactic_loop_p (bb1, bb2)
-	basic_block bb1, bb2;
+back_edge_of_syntactic_loop_p (basic_block bb1, basic_block bb2)
 {
   rtx insn;
   int count = 0;
@@ -1228,8 +1199,7 @@ back_edge_of_syntactic_loop_p (bb1, bb2)
    block with multiple predecessors is not handled optimally.  */
 
 basic_block
-rtl_split_edge (edge_in)
-     edge edge_in;
+rtl_split_edge (edge edge_in)
 {
   basic_block bb;
   rtx before;
@@ -1317,9 +1287,7 @@ rtl_split_edge (edge_in)
    CFG until commit_edge_insertions is called.  */
 
 void
-insert_insn_on_edge (pattern, e)
-     rtx pattern;
-     edge e;
+insert_insn_on_edge (rtx pattern, edge e)
 {
   /* We cannot insert instructions on an abnormal critical edge.
      It will be easier to find the culprit if we die now.  */
@@ -1340,9 +1308,7 @@ insert_insn_on_edge (pattern, e)
 /* Update the CFG for the instructions queued on edge E.  */
 
 static void
-commit_one_edge_insertion (e, watch_calls)
-     edge e;
-     int watch_calls;
+commit_one_edge_insertion (edge e, int watch_calls)
 {
   rtx before = NULL_RTX, after = NULL_RTX, insns, tmp, last;
   basic_block bb = NULL;
@@ -1467,7 +1433,7 @@ commit_one_edge_insertion (e, watch_calls)
 /* Update the CFG for all queued instructions.  */
 
 void
-commit_edge_insertions ()
+commit_edge_insertions (void)
 {
   basic_block bb;
   sbitmap blocks;
@@ -1515,7 +1481,7 @@ commit_edge_insertions ()
    code on edges between call and storing its return value.  */
 
 void
-commit_edge_insertions_watch_calls ()
+commit_edge_insertions_watch_calls (void)
 {
   basic_block bb;
   sbitmap blocks;
@@ -1562,9 +1528,7 @@ commit_edge_insertions_watch_calls ()
 /* Print out one basic block with live information at start and end.  */
 
 static void
-rtl_dump_bb (bb, outf)
-     basic_block bb;
-     FILE *outf;
+rtl_dump_bb (basic_block bb, FILE *outf)
 {
   rtx insn;
   rtx last;
@@ -1586,9 +1550,7 @@ rtl_dump_bb (bb, outf)
    basic block.  */
 
 void
-print_rtl_with_bb (outf, rtx_first)
-     FILE *outf;
-     rtx rtx_first;
+print_rtl_with_bb (FILE *outf, rtx rtx_first)
 {
   rtx tmp_rtx;
 
@@ -1674,8 +1636,7 @@ print_rtl_with_bb (outf, rtx_first)
 }
 
 void
-update_br_prob_note (bb)
-     basic_block bb;
+update_br_prob_note (basic_block bb)
 {
   rtx note;
   if (GET_CODE (bb->end) != JUMP_INSN)
@@ -1701,7 +1662,7 @@ update_br_prob_note (bb)
    In future it can be extended check a lot of other stuff as well
    (reachability of basic blocks, life information, etc. etc.).  */
 static int
-rtl_verify_flow_info_1 ()
+rtl_verify_flow_info_1 (void)
 {
   const int max_uid = get_max_uid ();
   rtx last_head = get_last_insn ();
@@ -1920,7 +1881,7 @@ rtl_verify_flow_info_1 ()
    - check that all returns are followed by barriers
    - check that all fallthru edge points to the adjacent blocks.  */
 static int
-rtl_verify_flow_info ()
+rtl_verify_flow_info (void)
 {
   basic_block bb;
   int err = rtl_verify_flow_info_1 ();
@@ -2044,8 +2005,7 @@ rtl_verify_flow_info ()
    Return true if any edges are eliminated.  */
 
 bool
-purge_dead_edges (bb)
-     basic_block bb;
+purge_dead_edges (basic_block bb)
 {
   edge e, next;
   rtx insn = bb->end, note;
@@ -2227,8 +2187,7 @@ purge_dead_edges (bb)
    true if some edge has been eliminated.  */
 
 bool
-purge_all_dead_edges (update_life_p)
-     int update_life_p;
+purge_all_dead_edges (int update_life_p)
 {
   int purged = false;
   sbitmap blocks = 0;
@@ -2261,9 +2220,7 @@ purge_all_dead_edges (update_life_p)
 
 /* Same as split_block but update cfg_layout structures.  */
 static edge
-cfg_layout_split_block (bb, insnp)
-     basic_block bb;
-     void *insnp;
+cfg_layout_split_block (basic_block bb, void *insnp)
 {
   rtx insn = insnp;
 
@@ -2278,9 +2235,7 @@ cfg_layout_split_block (bb, insnp)
 
 /* Redirect Edge to DEST.  */
 static bool
-cfg_layout_redirect_edge_and_branch (e, dest)
-     edge e;
-     basic_block dest;
+cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
 {
   basic_block src = e->src;
   basic_block old_next_bb = src->next_bb;
@@ -2332,9 +2287,7 @@ cfg_layout_redirect_edge_and_branch (e, dest)
 
 /* Simple wrapper as we always can redirect fallthru edges.  */
 static basic_block
-cfg_layout_redirect_edge_and_branch_force (e, dest)
-     edge e;
-     basic_block dest;
+cfg_layout_redirect_edge_and_branch_force (edge e, basic_block dest)
 {
   if (!cfg_layout_redirect_edge_and_branch (e, dest))
     abort ();
@@ -2343,8 +2296,7 @@ cfg_layout_redirect_edge_and_branch_force (e, dest)
 
 /* Same as flow_delete_block but update cfg_layout structures.  */
 static void
-cfg_layout_delete_block (bb)
-     basic_block bb;
+cfg_layout_delete_block (basic_block bb)
 {
   rtx insn, next, prev = PREV_INSN (bb->head), *to, remaints;