* ggc-common.c: PROTO -> PARAMS.

        * ggc-page.c: Likewise.
        * ggc-simple.c: Likewise.
        * ggc.h: Likewise.
        * global.c: Likewise.
        * graph.c: Likewise.
        * gthr-win32.h: Likewise.
        * haifa-sched.c: Likewise.
        * halfpic.h: Likewise.
        * integrate.c: Likewise.
        * integrate.h: Likewise.
        * jump.c: Likewise.
        * lcm.c: Likewise.
        * local-alloc.c: Likewise.
        * loop.c: Likewise.
        * loop.h: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@31458 138bc75d-0d04-0410-961f-82ee72b054a4

17 files changed, 348 insertions, 329 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index cd990876255..3e27e91cc42 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,24 @@
 2000-01-17  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
+	* ggc-common.c: PROTO -> PARAMS.
+	* ggc-page.c: Likewise.
+	* ggc-simple.c: Likewise.
+	* ggc.h: Likewise.
+	* global.c: Likewise.
+	* graph.c: Likewise.
+	* gthr-win32.h: Likewise.
+	* haifa-sched.c: Likewise.
+	* halfpic.h: Likewise.
+	* integrate.c: Likewise.
+	* integrate.h: Likewise.
+	* jump.c: Likewise.
+	* lcm.c: Likewise.
+	* local-alloc.c: Likewise.
+	* loop.c: Likewise.
+	* loop.h: Likewise.
+
+2000-01-17  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
 	* genattr.c: PROTO -> PARAMS.
 	* genattrtab.c: Likewise.
 	* gencheck.c: Likewise.
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index 4fd9810e633..7691926d43e 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -51,7 +51,7 @@ struct ggc_root
   void *base;
   int nelt;
   int size;
-  void (*cb) PROTO ((void *));
+  void (*cb) PARAMS ((void *));
 };
 
 static struct ggc_root *roots;
@@ -117,7 +117,7 @@ void
 ggc_add_root (base, nelt, size, cb)
      void *base;
      int nelt, size;
-     void (*cb) PROTO ((void *));
+     void (*cb) PARAMS ((void *));
 {
   struct ggc_root *x = (struct ggc_root *) xmalloc (sizeof (*x));
 
@@ -217,7 +217,7 @@ ggc_mark_roots ()
     {
       char *elt = x->base;
       int s = x->size, n = x->nelt;
-      void (*cb) PROTO ((void *)) = x->cb;
+      void (*cb) PARAMS ((void *)) = x->cb;
       int i;
 
       for (i = 0; i < n; ++i, elt += s)
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index aa515eb3df3..f05d93af02f 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -266,22 +266,22 @@ static struct globals
 #define GGC_MIN_LAST_ALLOCATED (4 * 1024 * 1024)
 
 
-static int ggc_allocated_p PROTO ((const void *));
-static page_entry *lookup_page_table_entry PROTO ((const void *));
-static void set_page_table_entry PROTO ((void *, page_entry *));
-static char *alloc_anon PROTO ((char *, size_t));
-static struct page_entry * alloc_page PROTO ((unsigned));
-static void free_page PROTO ((struct page_entry *));
-static void release_pages PROTO ((void));
-static void clear_marks PROTO ((void));
-static void sweep_pages PROTO ((void));
-static void ggc_recalculate_in_use_p PROTO ((page_entry *));
+static int ggc_allocated_p PARAMS ((const void *));
+static page_entry *lookup_page_table_entry PARAMS ((const void *));
+static void set_page_table_entry PARAMS ((void *, page_entry *));
+static char *alloc_anon PARAMS ((char *, size_t));
+static struct page_entry * alloc_page PARAMS ((unsigned));
+static void free_page PARAMS ((struct page_entry *));
+static void release_pages PARAMS ((void));
+static void clear_marks PARAMS ((void));
+static void sweep_pages PARAMS ((void));
+static void ggc_recalculate_in_use_p PARAMS ((page_entry *));
 
 #ifdef GGC_POISON
-static void poison_pages PROTO ((void));
+static void poison_pages PARAMS ((void));
 #endif
 
-void debug_print_page_list PROTO ((int));
+void debug_print_page_list PARAMS ((int));
 
 /* Returns non-zero if P was allocated in GC'able memory.  */
 
diff --git a/gcc/ggc-simple.c b/gcc/ggc-simple.c
index 3fb25dd41ed..ea8544e7a13 100644
--- a/gcc/ggc-simple.c
+++ b/gcc/ggc-simple.c
@@ -135,15 +135,15 @@ static struct globals
 
 /* Local function prototypes.  */
 
-static void tree_insert PROTO ((struct ggc_mem *));
-static int tree_lookup PROTO ((struct ggc_mem *));
-static void clear_marks PROTO ((struct ggc_mem *));
-static void sweep_objs PROTO ((struct ggc_mem **));
-static void ggc_pop_context_1 PROTO ((struct ggc_mem *, int));
+static void tree_insert PARAMS ((struct ggc_mem *));
+static int tree_lookup PARAMS ((struct ggc_mem *));
+static void clear_marks PARAMS ((struct ggc_mem *));
+static void sweep_objs PARAMS ((struct ggc_mem **));
+static void ggc_pop_context_1 PARAMS ((struct ggc_mem *, int));
 
 #ifdef GGC_BALANCE
-extern void debug_ggc_balance PROTO ((void));
-static void tally_leaves PROTO ((struct ggc_mem *, int, size_t *, size_t *));
+extern void debug_ggc_balance PARAMS ((void));
+static void tally_leaves PARAMS ((struct ggc_mem *, int, size_t *, size_t *));
 #endif
 
 /* Insert V into the search tree.  */
diff --git a/gcc/ggc.h b/gcc/ggc.h
index 809edeca1a3..8ddae2b5667 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -46,23 +46,23 @@ struct varray_head_tag;
 extern char *empty_string;
 
 /* Manipulate global roots that are needed between calls to gc.  */
-void ggc_add_root PROTO ((void *base, int nelt, int size, void (*)(void *)));
-void ggc_add_rtx_root PROTO ((struct rtx_def **, int nelt));
-void ggc_add_tree_root PROTO ((union tree_node **, int nelt));
-void ggc_add_string_root PROTO ((char **, int nelt));
-void ggc_add_tree_varray_root PROTO ((struct varray_head_tag **, int nelt));
-void ggc_add_tree_hash_table_root PROTO ((struct hash_table **, int nelt));
-void ggc_del_root PROTO ((void *base));
+void ggc_add_root PARAMS ((void *base, int nelt, int size, void (*)(void *)));
+void ggc_add_rtx_root PARAMS ((struct rtx_def **, int nelt));
+void ggc_add_tree_root PARAMS ((union tree_node **, int nelt));
+void ggc_add_string_root PARAMS ((char **, int nelt));
+void ggc_add_tree_varray_root PARAMS ((struct varray_head_tag **, int nelt));
+void ggc_add_tree_hash_table_root PARAMS ((struct hash_table **, int nelt));
+void ggc_del_root PARAMS ((void *base));
 
 /* Mark nodes from the gc_add_root callback.  These functions follow
    pointers to mark other objects too.  */
-extern void ggc_mark_tree_varray PROTO ((struct varray_head_tag *));
-extern void ggc_mark_tree_hash_table PROTO ((struct hash_table *));
-extern void ggc_mark_roots PROTO((void));
+extern void ggc_mark_tree_varray PARAMS ((struct varray_head_tag *));
+extern void ggc_mark_tree_hash_table PARAMS ((struct hash_table *));
+extern void ggc_mark_roots PARAMS ((void));
 
-extern void ggc_mark_rtx_children PROTO ((struct rtx_def *));
-extern void ggc_mark_rtvec_children PROTO ((struct rtvec_def *));
-extern void ggc_mark_tree_children PROTO ((union tree_node *));
+extern void ggc_mark_rtx_children PARAMS ((struct rtx_def *));
+extern void ggc_mark_rtvec_children PARAMS ((struct rtvec_def *));
+extern void ggc_mark_tree_children PARAMS ((union tree_node *));
 
 /* If EXPR is not NULL and previously unmarked, mark it and evaluate
    to true.  Otherwise evaluate to false.  */
@@ -105,25 +105,25 @@ extern void ggc_mark_tree_children PROTO ((union tree_node *));
   } while (0)
 
 /* Mark, but only if it was allocated in collectable memory.  */
-extern void ggc_mark_if_gcable PROTO ((void *));
+extern void ggc_mark_if_gcable PARAMS ((void *));
 
 /* A GC implementation must provide these functions.  */
 
 /* Initialize the garbage collector.   */
-extern void init_ggc PROTO ((void));
+extern void init_ggc PARAMS ((void));
 
 /* Start a new GGC context.  Memory allocated in previous contexts
    will not be collected while the new context is active.  */
-extern void ggc_push_context PROTO ((void));
+extern void ggc_push_context PARAMS ((void));
 
 /* Finish a GC context.  Any uncollected memory in the new context
    will be merged with the old context.  */
-extern void ggc_pop_context PROTO ((void));
+extern void ggc_pop_context PARAMS ((void));
 
 /* Allocation.  */
 
 /* The internal primitive.  */
-void *ggc_alloc_obj PROTO ((size_t, int));
+void *ggc_alloc_obj PARAMS ((size_t, int));
 
 #define ggc_alloc_rtx(NSLOTS)						     \
   ((struct rtx_def *) ggc_alloc_obj (sizeof (struct rtx_def)		     \
@@ -138,38 +138,38 @@ void *ggc_alloc_obj PROTO ((size_t, int));
 
 #define ggc_alloc(SIZE)  ggc_alloc_obj((SIZE), 0)
 
-char *ggc_alloc_string PROTO ((const char *contents, int length));
+char *ggc_alloc_string PARAMS ((const char *contents, int length));
 
 /* Invoke the collector.  This is really just a hint, but in the case of
    the simple collector, the only time it will happen.  */
-void ggc_collect PROTO ((void));
+void ggc_collect PARAMS ((void));
 
 /* Actually set the mark on a particular region of memory, but don't
    follow pointers.  This function is called by ggc_mark_*.  It
    returns zero if the object was not previously marked; non-zero if
    the object was already marked, or if, for any other reason,
    pointers in this data structure should not be traversed.  */
-int ggc_set_mark PROTO ((void *));
+int ggc_set_mark PARAMS ((void *));
 
 /* Callbacks to the languages.  */
 
 /* This is the language's opportunity to mark nodes held through
    the lang_specific hooks in the tree.  */
-void lang_mark_tree PROTO ((union tree_node *));
+void lang_mark_tree PARAMS ((union tree_node *));
 
 /* The FALSE_LABEL_STACK, declared in except.h, has
    language-dependent semantics.  Each front-end should define this
    function appropriately.  */
-void lang_mark_false_label_stack PROTO ((struct label_node *));
+void lang_mark_false_label_stack PARAMS ((struct label_node *));
 
 /* Mark functions for various structs scattered about.  */
 
-void mark_eh_status PROTO ((struct eh_status *));
-void mark_emit_status PROTO ((struct emit_status *));
-void mark_expr_status PROTO ((struct expr_status *));
-void mark_stmt_status PROTO ((struct stmt_status *));
-void mark_varasm_status PROTO ((struct varasm_status *));
-void mark_optab PROTO ((void *));
+void mark_eh_status PARAMS ((struct eh_status *));
+void mark_emit_status PARAMS ((struct emit_status *));
+void mark_expr_status PARAMS ((struct expr_status *));
+void mark_stmt_status PARAMS ((struct stmt_status *));
+void mark_varasm_status PARAMS ((struct varasm_status *));
+void mark_optab PARAMS ((void *));
 
 /* Statistics.  */
 
@@ -198,8 +198,8 @@ typedef struct ggc_statistics
 } ggc_statistics;
 
 /* Return the number of bytes allocated at the indicated address.  */
-size_t ggc_get_size PROTO ((void *));
+size_t ggc_get_size PARAMS ((void *));
 
 /* Used by the various collectors to gather and print statistics that
    do not depend on the collector in use.  */
-void ggc_print_statistics PROTO ((FILE *, ggc_statistics *));
+void ggc_print_statistics PARAMS ((FILE *, ggc_statistics *));
diff --git a/gcc/global.c b/gcc/global.c
index 420d91b308a..4e0bed35822 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -287,25 +287,25 @@ static int n_regs_set;
 
 static HARD_REG_SET eliminable_regset;
 
-static int allocno_compare	PROTO((const PTR, const PTR));
-static void global_conflicts	PROTO((void));
-static void mirror_conflicts	PROTO((void));
-static void expand_preferences	PROTO((void));
-static void prune_preferences	PROTO((void));
-static void find_reg		PROTO((int, HARD_REG_SET, int, int, int));
-static void record_one_conflict PROTO((int));
-static void record_conflicts	PROTO((int *, int));
-static void mark_reg_store	PROTO((rtx, rtx, void *));
-static void mark_reg_clobber	PROTO((rtx, rtx, void *));
-static void mark_reg_conflicts	PROTO((rtx));
-static void mark_reg_death	PROTO((rtx));
-static void mark_reg_live_nc	PROTO((int, enum machine_mode));
-static void set_preference	PROTO((rtx, rtx));
-static void dump_conflicts	PROTO((FILE *));
-static void reg_becomes_live	PROTO((rtx, rtx, void *));
-static void reg_dies		PROTO((int, enum machine_mode,
+static int allocno_compare	PARAMS ((const PTR, const PTR));
+static void global_conflicts	PARAMS ((void));
+static void mirror_conflicts	PARAMS ((void));
+static void expand_preferences	PARAMS ((void));
+static void prune_preferences	PARAMS ((void));
+static void find_reg		PARAMS ((int, HARD_REG_SET, int, int, int));
+static void record_one_conflict PARAMS ((int));
+static void record_conflicts	PARAMS ((int *, int));
+static void mark_reg_store	PARAMS ((rtx, rtx, void *));
+static void mark_reg_clobber	PARAMS ((rtx, rtx, void *));
+static void mark_reg_conflicts	PARAMS ((rtx));
+static void mark_reg_death	PARAMS ((rtx));
+static void mark_reg_live_nc	PARAMS ((int, enum machine_mode));
+static void set_preference	PARAMS ((rtx, rtx));
+static void dump_conflicts	PARAMS ((FILE *));
+static void reg_becomes_live	PARAMS ((rtx, rtx, void *));
+static void reg_dies		PARAMS ((int, enum machine_mode,
 				       struct insn_chain *));
-static void build_insn_chain	PROTO((rtx));
+static void build_insn_chain	PARAMS ((rtx));
 
 /* Perform allocation of pseudo-registers not allocated by local_alloc.
    FILE is a file to output debugging information on,
diff --git a/gcc/graph.c b/gcc/graph.c
index 705cbd301e2..f40b0dd91ee 100644
--- a/gcc/graph.c
+++ b/gcc/graph.c
@@ -37,12 +37,12 @@ static const char *graph_ext[] =
   /* vcg */      ".vcg",
 };
 
-static void start_fct PROTO ((FILE *));
-static void start_bb PROTO ((FILE *, int));
-static void node_data PROTO ((FILE *, rtx));
-static void draw_edge PROTO ((FILE *, int, int, int, int));
-static void end_fct PROTO ((FILE *));
-static void end_bb PROTO ((FILE *));
+static void start_fct PARAMS ((FILE *));
+static void start_bb PARAMS ((FILE *, int));
+static void node_data PARAMS ((FILE *, rtx));
+static void draw_edge PARAMS ((FILE *, int, int, int, int));
+static void end_fct PARAMS ((FILE *));
+static void end_bb PARAMS ((FILE *));
 
 /* Output text for new basic block.  */
 static void
diff --git a/gcc/gthr-win32.h b/gcc/gthr-win32.h
index c5c5899c8f8..31b4779873b 100644
--- a/gcc/gthr-win32.h
+++ b/gcc/gthr-win32.h
@@ -85,7 +85,7 @@ typedef HANDLE __gthread_mutex_t;
 #if __MINGW32_MAJOR_VERSION >= 1 || \
   (__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
 #define MINGW32_SUPPORTS_MT_EH 1
-extern int __mingwthr_key_dtor PROTO((DWORD, void (*) (void *)));
+extern int __mingwthr_key_dtor PARAMS ((DWORD, void (*) (void *)));
 /* Mingw runtime >= v0.3 provides a magic variable that is set to non-zero
    if -mthreads option was specified, or 0 otherwise. This is to get around 
    the lack of weak symbols in PE-COFF.  */
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index 8261f2d76b1..b2ff9d6dbf5 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -464,37 +464,37 @@ static int q_size = 0;
 #define NEXT_Q_AFTER(X, C) (((X)+C) & (INSN_QUEUE_SIZE-1))
 
 /* Forward declarations.  */
-static void add_dependence PROTO ((rtx, rtx, enum reg_note));
+static void add_dependence PARAMS ((rtx, rtx, enum reg_note));
 #ifdef HAVE_cc0
-static void remove_dependence PROTO ((rtx, rtx));
+static void remove_dependence PARAMS ((rtx, rtx));
 #endif
-static rtx find_insn_list PROTO ((rtx, rtx));
-static int insn_unit PROTO ((rtx));
-static unsigned int blockage_range PROTO ((int, rtx));
-static void clear_units PROTO ((void));
-static int actual_hazard_this_instance PROTO ((int, int, rtx, int, int));
-static void schedule_unit PROTO ((int, rtx, int));
-static int actual_hazard PROTO ((int, rtx, int, int));
-static int potential_hazard PROTO ((int, rtx, int));
-static int insn_cost PROTO ((rtx, rtx, rtx));
-static int priority PROTO ((rtx));
-static void free_pending_lists PROTO ((void));
-static void add_insn_mem_dependence PROTO ((struct deps *, rtx *, rtx *, rtx,
+static rtx find_insn_list PARAMS ((rtx, rtx));
+static int insn_unit PARAMS ((rtx));
+static unsigned int blockage_range PARAMS ((int, rtx));
+static void clear_units PARAMS ((void));
+static int actual_hazard_this_instance PARAMS ((int, int, rtx, int, int));
+static void schedule_unit PARAMS ((int, rtx, int));
+static int actual_hazard PARAMS ((int, rtx, int, int));
+static int potential_hazard PARAMS ((int, rtx, int));
+static int insn_cost PARAMS ((rtx, rtx, rtx));
+static int priority PARAMS ((rtx));
+static void free_pending_lists PARAMS ((void));
+static void add_insn_mem_dependence PARAMS ((struct deps *, rtx *, rtx *, rtx,
 					    rtx));
-static void flush_pending_lists PROTO ((struct deps *, rtx, int));
-static void sched_analyze_1 PROTO ((struct deps *, rtx, rtx));
-static void sched_analyze_2 PROTO ((struct deps *, rtx, rtx));
-static void sched_analyze_insn PROTO ((struct deps *, rtx, rtx, rtx));
-static void sched_analyze PROTO ((struct deps *, rtx, rtx));
-static int rank_for_schedule PROTO ((const PTR, const PTR));
-static void swap_sort PROTO ((rtx *, int));
-static void queue_insn PROTO ((rtx, int));
-static int schedule_insn PROTO ((rtx, rtx *, int, int));
-static void find_insn_reg_weight PROTO ((int));
-static int schedule_block PROTO ((int, int));
-static char *safe_concat PROTO ((char *, char *, const char *));
-static int insn_issue_delay PROTO ((rtx));
-static void adjust_priority PROTO ((rtx));
+static void flush_pending_lists PARAMS ((struct deps *, rtx, int));
+static void sched_analyze_1 PARAMS ((struct deps *, rtx, rtx));
+static void sched_analyze_2 PARAMS ((struct deps *, rtx, rtx));
+static void sched_analyze_insn PARAMS ((struct deps *, rtx, rtx, rtx));
+static void sched_analyze PARAMS ((struct deps *, rtx, rtx));
+static int rank_for_schedule PARAMS ((const PTR, const PTR));
+static void swap_sort PARAMS ((rtx *, int));
+static void queue_insn PARAMS ((rtx, int));
+static int schedule_insn PARAMS ((rtx, rtx *, int, int));
+static void find_insn_reg_weight PARAMS ((int));
+static int schedule_block PARAMS ((int, int));
+static char *safe_concat PARAMS ((char *, char *, const char *));
+static int insn_issue_delay PARAMS ((rtx));
+static void adjust_priority PARAMS ((rtx));
 
 /* Control flow graph edges are kept in circular lists.  */
 typedef struct
@@ -525,9 +525,9 @@ static int *out_edges;
 
 
 
-static int is_cfg_nonregular PROTO ((void));
-static int build_control_flow PROTO ((struct edge_list *));
-static void new_edge PROTO ((int, int));
+static int is_cfg_nonregular PARAMS ((void));
+static int build_control_flow PARAMS ((struct edge_list *));
+static void new_edge PARAMS ((int, int));
 
 
 /* A region is the main entity for interblock scheduling: insns
@@ -563,12 +563,12 @@ static int *containing_rgn;
 #define BLOCK_TO_BB(block) (block_to_bb[block])
 #define CONTAINING_RGN(block) (containing_rgn[block])
 
-void debug_regions PROTO ((void));
-static void find_single_block_region PROTO ((void));
-static void find_rgns PROTO ((struct edge_list *, sbitmap *));
-static int too_large PROTO ((int, int *, int *));
+void debug_regions PARAMS ((void));
+static void find_single_block_region PARAMS ((void));
+static void find_rgns PARAMS ((struct edge_list *, sbitmap *));
+static int too_large PARAMS ((int, int *, int *));
 
-extern void debug_live PROTO ((int, int));
+extern void debug_live PARAMS ((int, int));
 
 /* Blocks of the current region being scheduled.  */
 static int current_nr_blocks;
@@ -593,8 +593,8 @@ static int bitlst_table_last;
 static int bitlst_table_size;
 static int *bitlst_table;
 
-static char bitset_member PROTO ((bitset, int, int));
-static void extract_bitlst PROTO ((bitset, int, int, bitlst *));
+static char bitset_member PARAMS ((bitset, int, int));
+static void extract_bitlst PARAMS ((bitset, int, int, bitlst *));
 
 /* Target info declarations.
 
@@ -635,10 +635,10 @@ static int target_bb;
 typedef bitlst edgelst;
 
 /* Target info functions.  */
-static void split_edges PROTO ((int, int, edgelst *));
-static void compute_trg_info PROTO ((int));
-void debug_candidate PROTO ((int));
-void debug_candidates PROTO ((int));
+static void split_edges PARAMS ((int, int, edgelst *));
+static void compute_trg_info PARAMS ((int));
+void debug_candidate PARAMS ((int));
+void debug_candidates PARAMS ((int));
 
 
 /* Bit-set of bbs, where bit 'i' stands for bb 'i'.  */
@@ -698,7 +698,7 @@ static edgeset *pot_split;
 /* For every bb, a set of its ancestor edges.  */
 static edgeset *ancestor_edges;
 
-static void compute_dom_prob_ps PROTO ((int));
+static void compute_dom_prob_ps PARAMS ((int));
 
 #define ABS_VALUE(x) (((x)<0)?(-(x)):(x))
 #define INSN_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (BLOCK_NUM (INSN))))
@@ -711,24 +711,24 @@ static void compute_dom_prob_ps PROTO ((int));
 #define MIN_PROB_DIFF 10
 
 /* Speculative scheduling functions.  */
-static int check_live_1 PROTO ((int, rtx));
-static void update_live_1 PROTO ((int, rtx));
-static int check_live PROTO ((rtx, int));
-static void update_live PROTO ((rtx, int));
-static void set_spec_fed PROTO ((rtx));
-static int is_pfree PROTO ((rtx, int, int));
-static int find_conditional_protection PROTO ((rtx, int));
-static int is_conditionally_protected PROTO ((rtx, int, int));
-static int may_trap_exp PROTO ((rtx, int));
-static int haifa_classify_insn PROTO ((rtx));
-static int is_prisky PROTO ((rtx, int, int));
-static int is_exception_free PROTO ((rtx, int, int));
-
-static char find_insn_mem_list PROTO ((rtx, rtx, rtx, rtx));
-static void compute_block_forward_dependences PROTO ((int));
-static void add_branch_dependences PROTO ((rtx, rtx));
-static void compute_block_backward_dependences PROTO ((int));
-void debug_dependencies PROTO ((void));
+static int check_live_1 PARAMS ((int, rtx));
+static void update_live_1 PARAMS ((int, rtx));
+static int check_live PARAMS ((rtx, int));
+static void update_live PARAMS ((rtx, int));
+static void set_spec_fed PARAMS ((rtx));
+static int is_pfree PARAMS ((rtx, int, int));
+static int find_conditional_protection PARAMS ((rtx, int));
+static int is_conditionally_protected PARAMS ((rtx, int, int));
+static int may_trap_exp PARAMS ((rtx, int));
+static int haifa_classify_insn PARAMS ((rtx));
+static int is_prisky PARAMS ((rtx, int, int));
+static int is_exception_free PARAMS ((rtx, int, int));
+
+static char find_insn_mem_list PARAMS ((rtx, rtx, rtx, rtx));
+static void compute_block_forward_dependences PARAMS ((int));
+static void add_branch_dependences PARAMS ((rtx, rtx));
+static void compute_block_backward_dependences PARAMS ((int));
+void debug_dependencies PARAMS ((void));
 
 /* Notes handling mechanism:
    =========================
@@ -753,41 +753,41 @@ void debug_dependencies PROTO ((void));
    unlink_other_notes ()).  After scheduling the block, these notes are
    inserted at the beginning of the block (in schedule_block()).  */
 
-static rtx unlink_other_notes PROTO ((rtx, rtx));
-static rtx unlink_line_notes PROTO ((rtx, rtx));
-static void rm_line_notes PROTO ((int));
-static void save_line_notes PROTO ((int));
-static void restore_line_notes PROTO ((int));
-static void rm_redundant_line_notes PROTO ((void));
-static void rm_other_notes PROTO ((rtx, rtx));
-static rtx reemit_notes PROTO ((rtx, rtx));
-
-static void get_block_head_tail PROTO ((int, rtx *, rtx *));
-static void get_bb_head_tail PROTO ((int, rtx *, rtx *));
-
-static int queue_to_ready PROTO ((rtx [], int));
-
-static void debug_ready_list PROTO ((rtx[], int));
-static void init_target_units PROTO ((void));
-static void insn_print_units PROTO ((rtx));
-static int get_visual_tbl_length PROTO ((void));
-static void init_block_visualization PROTO ((void));
-static void print_block_visualization PROTO ((int, const char *));
-static void visualize_scheduled_insns PROTO ((int, int));
-static void visualize_no_unit PROTO ((rtx));
-static void visualize_stall_cycles PROTO ((int, int));
-static void print_exp PROTO ((char *, rtx, int));
-static void print_value PROTO ((char *, rtx, int));
-static void print_pattern PROTO ((char *, rtx, int));
-static void print_insn PROTO ((char *, rtx, int));
-void debug_reg_vector PROTO ((regset));
-
-static rtx move_insn1 PROTO ((rtx, rtx));
-static rtx move_insn PROTO ((rtx, rtx));
-static rtx group_leader PROTO ((rtx));
-static int set_priorities PROTO ((int));
-static void init_deps PROTO ((struct deps *));
-static void schedule_region PROTO ((int));
+static rtx unlink_other_notes PARAMS ((rtx, rtx));
+static rtx unlink_line_notes PARAMS ((rtx, rtx));
+static void rm_line_notes PARAMS ((int));
+static void save_line_notes PARAMS ((int));
+static void restore_line_notes PARAMS ((int));
+static void rm_redundant_line_notes PARAMS ((void));
+static void rm_other_notes PARAMS ((rtx, rtx));
+static rtx reemit_notes PARAMS ((rtx, rtx));
+
+static void get_block_head_tail PARAMS ((int, rtx *, rtx *));
+static void get_bb_head_tail PARAMS ((int, rtx *, rtx *));
+
+static int queue_to_ready PARAMS ((rtx [], int));
+
+static void debug_ready_list PARAMS ((rtx[], int));
+static void init_target_units PARAMS ((void));
+static void insn_print_units PARAMS ((rtx));
+static int get_visual_tbl_length PARAMS ((void));
+static void init_block_visualization PARAMS ((void));
+static void print_block_visualization PARAMS ((int, const char *));
+static void visualize_scheduled_insns PARAMS ((int, int));
+static void visualize_no_unit PARAMS ((rtx));
+static void visualize_stall_cycles PARAMS ((int, int));
+static void print_exp PARAMS ((char *, rtx, int));
+static void print_value PARAMS ((char *, rtx, int));
+static void print_pattern PARAMS ((char *, rtx, int));
+static void print_insn PARAMS ((char *, rtx, int));
+void debug_reg_vector PARAMS ((regset));
+
+static rtx move_insn1 PARAMS ((rtx, rtx));
+static rtx move_insn PARAMS ((rtx, rtx));
+static rtx group_leader PARAMS ((rtx));
+static int set_priorities PARAMS ((int));
+static void init_deps PARAMS ((struct deps *));
+static void schedule_region PARAMS ((int));
 
 #endif /* INSN_SCHEDULING */
 
diff --git a/gcc/halfpic.h b/gcc/halfpic.h
index 562121e191c..c29f0d1b8f2 100644
--- a/gcc/halfpic.h
+++ b/gcc/halfpic.h
@@ -39,12 +39,12 @@ int (*ptr_half_pic_address_p) ();	/* ptr to half_pic_address_p () */
 
 extern int  half_pic_number_ptrs;				/* # distinct pointers found */
 extern int  half_pic_number_refs;				/* # half-pic references */
-extern void half_pic_encode PROTO((union tree_node *));		/* encode whether half-pic */
-extern void half_pic_declare PROTO((char *));			/* declare object local */
-extern void half_pic_external PROTO((char *));			/* declare object external */
-extern void half_pic_init PROTO((void));			/* half_pic initialization */
-extern int  half_pic_address_p PROTO((struct rtx_def *));	/* true if an address is half-pic */
-extern struct rtx_def *half_pic_ptr PROTO((struct rtx_def *));	/* return RTX for half-pic pointer */
+extern void half_pic_encode PARAMS ((union tree_node *));		/* encode whether half-pic */
+extern void half_pic_declare PARAMS ((char *));			/* declare object local */
+extern void half_pic_external PARAMS ((char *));			/* declare object external */
+extern void half_pic_init PARAMS ((void));			/* half_pic initialization */
+extern int  half_pic_address_p PARAMS ((struct rtx_def *));	/* true if an address is half-pic */
+extern struct rtx_def *half_pic_ptr PARAMS ((struct rtx_def *));	/* return RTX for half-pic pointer */
 /* Can't use prototype since FILE isn't defined yet.  */
 extern void half_pic_finish (/* FILE * */);		/* half_pic termination */
 
diff --git a/gcc/integrate.c b/gcc/integrate.c
index ca200e82bf3..bd48cd8e98d 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -62,24 +62,24 @@ extern struct obstack *function_maybepermanent_obstack;
    : (8 * (8 + list_length (DECL_ARGUMENTS (DECL)))))
 #endif
 
-static rtvec initialize_for_inline	PROTO((tree));
-static void note_modified_parmregs	PROTO((rtx, rtx, void *));
-static void integrate_parm_decls	PROTO((tree, struct inline_remap *,
+static rtvec initialize_for_inline	PARAMS ((tree));
+static void note_modified_parmregs	PARAMS ((rtx, rtx, void *));
+static void integrate_parm_decls	PARAMS ((tree, struct inline_remap *,
 					       rtvec));
-static tree integrate_decl_tree		PROTO((tree,
+static tree integrate_decl_tree		PARAMS ((tree,
 					       struct inline_remap *));
-static void subst_constants		PROTO((rtx *, rtx,
+static void subst_constants		PARAMS ((rtx *, rtx,
 					       struct inline_remap *, int));
-static void set_block_origin_self	PROTO((tree));
-static void set_decl_origin_self	PROTO((tree));
-static void set_block_abstract_flags	PROTO((tree, int));
-static void process_reg_param		PROTO((struct inline_remap *, rtx,
+static void set_block_origin_self	PARAMS ((tree));
+static void set_decl_origin_self	PARAMS ((tree));
+static void set_block_abstract_flags	PARAMS ((tree, int));
+static void process_reg_param		PARAMS ((struct inline_remap *, rtx,
 					       rtx));
-void set_decl_abstract_flags		PROTO((tree, int));
-static rtx expand_inline_function_eh_labelmap PROTO((rtx));
-static void mark_stores                 PROTO((rtx, rtx, void *));
-static int compare_blocks               PROTO((const PTR, const PTR));
-static int find_block                   PROTO((const PTR, const PTR));
+void set_decl_abstract_flags		PARAMS ((tree, int));
+static rtx expand_inline_function_eh_labelmap PARAMS ((rtx));
+static void mark_stores                 PARAMS ((rtx, rtx, void *));
+static int compare_blocks               PARAMS ((const PTR, const PTR));
+static int find_block                   PARAMS ((const PTR, const PTR));
 
 /* The maximum number of instructions accepted for inlining a
    function.  Increasing values mean more agressive inlining.
diff --git a/gcc/integrate.h b/gcc/integrate.h
index 4cc75fabbdc..53b78663fd7 100644
--- a/gcc/integrate.h
+++ b/gcc/integrate.h
@@ -116,18 +116,18 @@ struct inline_remap
 
 /* Return a copy of an rtx (as needed), substituting pseudo-register,
    labels, and frame-pointer offsets as necessary.  */
-extern rtx copy_rtx_and_substitute PROTO((rtx, struct inline_remap *, int));
+extern rtx copy_rtx_and_substitute PARAMS ((rtx, struct inline_remap *, int));
 
 /* Copy a declaration when one function is substituted inline into
    another.  */
-extern union tree_node *copy_decl_for_inlining PROTO((union tree_node *,
+extern union tree_node *copy_decl_for_inlining PARAMS ((union tree_node *,
 						      union tree_node *,
 						      union tree_node *));
 
-extern void try_constants PROTO((rtx, struct inline_remap *));
+extern void try_constants PARAMS ((rtx, struct inline_remap *));
 
 /* Return the label indicated.  */
-extern rtx get_label_from_map PROTO((struct inline_remap *, int));
+extern rtx get_label_from_map PARAMS ((struct inline_remap *, int));
 
 /* Set the label indicated.  */
 #define set_label_in_map(MAP, I, X) ((MAP)->label_map[I] = (X))
diff --git a/gcc/jump.c b/gcc/jump.c
index 2edd923d670..785aa41faa1 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -107,29 +107,29 @@ int can_reach_end;
 
 static int cross_jump_death_matters = 0;
 
-static int init_label_info		PROTO((rtx));
-static void delete_barrier_successors	PROTO((rtx));
-static void mark_all_labels		PROTO((rtx, int));
-static rtx delete_unreferenced_labels	PROTO((rtx));
-static void delete_noop_moves		PROTO((rtx));
-static int calculate_can_reach_end	PROTO((rtx, int, int));
-static int duplicate_loop_exit_test	PROTO((rtx));
-static void find_cross_jump		PROTO((rtx, rtx, int, rtx *, rtx *));
-static void do_cross_jump		PROTO((rtx, rtx, rtx));
-static int jump_back_p			PROTO((rtx, rtx));
-static int tension_vector_labels	PROTO((rtx, int));
-static void mark_jump_label		PROTO((rtx, rtx, int));
-static void delete_computation		PROTO((rtx));
-static void delete_from_jump_chain	PROTO((rtx));
-static int delete_labelref_insn		PROTO((rtx, rtx, int));
-static void mark_modified_reg		PROTO((rtx, rtx, void *));
-static void redirect_tablejump		PROTO((rtx, rtx));
-static void jump_optimize_1		PROTO ((rtx, int, int, int, int));
+static int init_label_info		PARAMS ((rtx));
+static void delete_barrier_successors	PARAMS ((rtx));
+static void mark_all_labels		PARAMS ((rtx, int));
+static rtx delete_unreferenced_labels	PARAMS ((rtx));
+static void delete_noop_moves		PARAMS ((rtx));
+static int calculate_can_reach_end	PARAMS ((rtx, int, int));
+static int duplicate_loop_exit_test	PARAMS ((rtx));
+static void find_cross_jump		PARAMS ((rtx, rtx, int, rtx *, rtx *));
+static void do_cross_jump		PARAMS ((rtx, rtx, rtx));
+static int jump_back_p			PARAMS ((rtx, rtx));
+static int tension_vector_labels	PARAMS ((rtx, int));
+static void mark_jump_label		PARAMS ((rtx, rtx, int));
+static void delete_computation		PARAMS ((rtx));
+static void delete_from_jump_chain	PARAMS ((rtx));
+static int delete_labelref_insn		PARAMS ((rtx, rtx, int));
+static void mark_modified_reg		PARAMS ((rtx, rtx, void *));
+static void redirect_tablejump		PARAMS ((rtx, rtx));
+static void jump_optimize_1		PARAMS ((rtx, int, int, int, int));
 #if ! defined(HAVE_cc0) && ! defined(HAVE_conditional_arithmetic)
-static rtx find_insert_position         PROTO((rtx, rtx));
+static rtx find_insert_position         PARAMS ((rtx, rtx));
 #endif
-static int returnjump_p_1	        PROTO((rtx *, void *));
-static void delete_prior_computation    PROTO((rtx, rtx));
+static int returnjump_p_1	        PARAMS ((rtx *, void *));
+static void delete_prior_computation    PARAMS ((rtx, rtx));
 
 /* Main external entry point into the jump optimizer.  See comments before
    jump_optimize_1 for descriptions of the arguments.  */
diff --git a/gcc/lcm.c b/gcc/lcm.c
index 64a00a422c1..f0fa6a9402e 100644
--- a/gcc/lcm.c
+++ b/gcc/lcm.c
@@ -63,24 +63,24 @@ Boston, MA 02111-1307, USA.  */
 #include "basic-block.h"
 
 /* Edge based LCM routines.  */
-static void compute_antinout_edge  PROTO ((sbitmap *, sbitmap *,
+static void compute_antinout_edge  PARAMS ((sbitmap *, sbitmap *,
 					   sbitmap *, sbitmap *));
-static void compute_earliest  PROTO((struct edge_list *, int, sbitmap *,
+static void compute_earliest  PARAMS ((struct edge_list *, int, sbitmap *,
 				     sbitmap *, sbitmap *, sbitmap *,
 				     sbitmap *));
-static void compute_laterin  PROTO((struct edge_list *, sbitmap *,
+static void compute_laterin  PARAMS ((struct edge_list *, sbitmap *,
 				    sbitmap *, sbitmap *, sbitmap *));
-static void compute_insert_delete  PROTO ((struct edge_list *edge_list,
+static void compute_insert_delete  PARAMS ((struct edge_list *edge_list,
 					   sbitmap *, sbitmap *, sbitmap *,
 					   sbitmap *, sbitmap *));
 
 /* Edge based LCM routines on a reverse flowgraph.  */
-static void compute_farthest	PROTO  ((struct edge_list *, int, sbitmap *,
+static void compute_farthest	PARAMS ((struct edge_list *, int, sbitmap *,
 					 sbitmap *, sbitmap*, sbitmap *,
 					 sbitmap *));
-static void compute_nearerout	PROTO((struct edge_list *, sbitmap *,
+static void compute_nearerout	PARAMS ((struct edge_list *, sbitmap *,
 				       sbitmap *, sbitmap *, sbitmap *));
-static void compute_rev_insert_delete  PROTO ((struct edge_list *edge_list,
+static void compute_rev_insert_delete  PARAMS ((struct edge_list *edge_list,
 					       sbitmap *, sbitmap *, sbitmap *,
 					       sbitmap *, sbitmap *));
 
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index 70e1ecc1062..20857a908ab 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -250,31 +250,31 @@ static rtx *reg_equiv_init_insns;
 /* Nonzero if we recorded an equivalence for a LABEL_REF.  */
 static int recorded_label_ref;
 
-static void alloc_qty		PROTO((int, enum machine_mode, int, int));
-static void validate_equiv_mem_from_store PROTO((rtx, rtx, void *));
-static int validate_equiv_mem	PROTO((rtx, rtx, rtx));
-static int contains_replace_regs PROTO((rtx, char *));
-static int memref_referenced_p	PROTO((rtx, rtx));
-static int memref_used_between_p PROTO((rtx, rtx, rtx));
-static void update_equiv_regs	PROTO((void));
-static void no_equiv		PROTO((rtx, rtx, void *));
-static void block_alloc		PROTO((int));
-static int qty_sugg_compare    	PROTO((int, int));
-static int qty_sugg_compare_1	PROTO((const PTR, const PTR));
-static int qty_compare    	PROTO((int, int));
-static int qty_compare_1	PROTO((const PTR, const PTR));
-static int combine_regs		PROTO((rtx, rtx, int, int, rtx, int));
-static int reg_meets_class_p	PROTO((int, enum reg_class));
-static void update_qty_class	PROTO((int, int));
-static void reg_is_set		PROTO((rtx, rtx, void *));
-static void reg_is_born		PROTO((rtx, int));
-static void wipe_dead_reg	PROTO((rtx, int));
-static int find_free_reg	PROTO((enum reg_class, enum machine_mode,
+static void alloc_qty		PARAMS ((int, enum machine_mode, int, int));
+static void validate_equiv_mem_from_store PARAMS ((rtx, rtx, void *));
+static int validate_equiv_mem	PARAMS ((rtx, rtx, rtx));
+static int contains_replace_regs PARAMS ((rtx, char *));
+static int memref_referenced_p	PARAMS ((rtx, rtx));
+static int memref_used_between_p PARAMS ((rtx, rtx, rtx));
+static void update_equiv_regs	PARAMS ((void));
+static void no_equiv		PARAMS ((rtx, rtx, void *));
+static void block_alloc		PARAMS ((int));
+static int qty_sugg_compare    	PARAMS ((int, int));
+static int qty_sugg_compare_1	PARAMS ((const PTR, const PTR));
+static int qty_compare    	PARAMS ((int, int));
+static int qty_compare_1	PARAMS ((const PTR, const PTR));
+static int combine_regs		PARAMS ((rtx, rtx, int, int, rtx, int));
+static int reg_meets_class_p	PARAMS ((int, enum reg_class));
+static void update_qty_class	PARAMS ((int, int));
+static void reg_is_set		PARAMS ((rtx, rtx, void *));
+static void reg_is_born		PARAMS ((rtx, int));
+static void wipe_dead_reg	PARAMS ((rtx, int));
+static int find_free_reg	PARAMS ((enum reg_class, enum machine_mode,
 				       int, int, int, int, int));
-static void mark_life		PROTO((int, enum machine_mode, int));
-static void post_mark_life	PROTO((int, enum machine_mode, int, int, int));
-static int no_conflict_p	PROTO((rtx, rtx, rtx));
-static int requires_inout	PROTO((const char *));
+static void mark_life		PARAMS ((int, enum machine_mode, int));
+static void post_mark_life	PARAMS ((int, enum machine_mode, int, int, int));
+static int no_conflict_p	PARAMS ((rtx, rtx, rtx));
+static int requires_inout	PARAMS ((const char *));
 
 /* Allocate a new quantity (new within current basic block)
    for register number REGNO which is born at index BIRTH
diff --git a/gcc/loop.c b/gcc/loop.c
index 8bddfe01b31..88782f6db90 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -234,70 +234,70 @@ FILE *loop_dump_stream;
 
 /* Forward declarations.  */
 
-static void verify_dominator PROTO((struct loop *));
-static void find_and_verify_loops PROTO((rtx, struct loops *));
-static void mark_loop_jump PROTO((rtx, struct loop *));
-static void prescan_loop PROTO((struct loop *));
-static int reg_in_basic_block_p PROTO((rtx, rtx));
-static int consec_sets_invariant_p PROTO((rtx, int, rtx));
-static int labels_in_range_p PROTO((rtx, int));
-static void count_one_set PROTO((rtx, rtx, varray_type, rtx *));
-
-static void count_loop_regs_set PROTO((rtx, rtx, varray_type, varray_type,
+static void verify_dominator PARAMS ((struct loop *));
+static void find_and_verify_loops PARAMS ((rtx, struct loops *));
+static void mark_loop_jump PARAMS ((rtx, struct loop *));
+static void prescan_loop PARAMS ((struct loop *));
+static int reg_in_basic_block_p PARAMS ((rtx, rtx));
+static int consec_sets_invariant_p PARAMS ((rtx, int, rtx));
+static int labels_in_range_p PARAMS ((rtx, int));
+static void count_one_set PARAMS ((rtx, rtx, varray_type, rtx *));
+
+static void count_loop_regs_set PARAMS ((rtx, rtx, varray_type, varray_type,
 				       int *, int)); 
-static void note_addr_stored PROTO((rtx, rtx, void *));
-static void note_set_pseudo_multiple_uses PROTO((rtx, rtx, void *));
-static int loop_reg_used_before_p PROTO((const struct loop *, rtx, rtx));
-static void scan_loop PROTO((struct loop*, int, int));
+static void note_addr_stored PARAMS ((rtx, rtx, void *));
+static void note_set_pseudo_multiple_uses PARAMS ((rtx, rtx, void *));
+static int loop_reg_used_before_p PARAMS ((const struct loop *, rtx, rtx));
+static void scan_loop PARAMS ((struct loop*, int, int));
 #if 0
-static void replace_call_address PROTO((rtx, rtx, rtx));
+static void replace_call_address PARAMS ((rtx, rtx, rtx));
 #endif
-static rtx skip_consec_insns PROTO((rtx, int));
-static int libcall_benefit PROTO((rtx));
-static void ignore_some_movables PROTO((struct movable *));
-static void force_movables PROTO((struct movable *));
-static void combine_movables PROTO((struct movable *, int));
-static int regs_match_p PROTO((rtx, rtx, struct movable *));
-static int rtx_equal_for_loop_p PROTO((rtx, rtx, struct movable *));
-static void add_label_notes PROTO((rtx, rtx));
-static void move_movables PROTO((struct movable *, int, int, rtx, rtx, int));
-static int count_nonfixed_reads PROTO((rtx));
-static void strength_reduce PROTO((struct loop *, int, int, int));
-static void find_single_use_in_loop PROTO((rtx, rtx, varray_type));
-static int valid_initial_value_p PROTO((rtx, rtx, int, rtx));
-static void find_mem_givs PROTO((rtx, rtx, int, int, rtx, rtx));
-static void record_biv PROTO((struct induction *, rtx, rtx, rtx, rtx, rtx *, int, int, int));
-static void check_final_value PROTO((struct induction *, rtx, rtx, 
+static rtx skip_consec_insns PARAMS ((rtx, int));
+static int libcall_benefit PARAMS ((rtx));
+static void ignore_some_movables PARAMS ((struct movable *));
+static void force_movables PARAMS ((struct movable *));
+static void combine_movables PARAMS ((struct movable *, int));
+static int regs_match_p PARAMS ((rtx, rtx, struct movable *));
+static int rtx_equal_for_loop_p PARAMS ((rtx, rtx, struct movable *));
+static void add_label_notes PARAMS ((rtx, rtx));
+static void move_movables PARAMS ((struct movable *, int, int, rtx, rtx, int));
+static int count_nonfixed_reads PARAMS ((rtx));
+static void strength_reduce PARAMS ((struct loop *, int, int, int));
+static void find_single_use_in_loop PARAMS ((rtx, rtx, varray_type));
+static int valid_initial_value_p PARAMS ((rtx, rtx, int, rtx));
+static void find_mem_givs PARAMS ((rtx, rtx, int, int, rtx, rtx));
+static void record_biv PARAMS ((struct induction *, rtx, rtx, rtx, rtx, rtx *, int, int, int));
+static void check_final_value PARAMS ((struct induction *, rtx, rtx, 
 				     unsigned HOST_WIDE_INT));
-static void record_giv PROTO((struct induction *, rtx, rtx, rtx, rtx, rtx, int, enum g_types, int, int, rtx *, rtx, rtx));
-static void update_giv_derive PROTO((rtx));
-static int basic_induction_var PROTO((rtx, enum machine_mode, rtx, rtx, int, rtx *, rtx *, rtx **, int *));
-static rtx simplify_giv_expr PROTO((rtx, int *));
-static int general_induction_var PROTO((rtx, rtx *, rtx *, rtx *, int, int *));
-static int consec_sets_giv PROTO((int, rtx, rtx, rtx, rtx *, rtx *, rtx *));
-static int check_dbra_loop PROTO((struct loop *, int));
-static rtx express_from_1 PROTO((rtx, rtx, rtx));
-static rtx combine_givs_p PROTO((struct induction *, struct induction *));
-static void combine_givs PROTO((struct iv_class *));
+static void record_giv PARAMS ((struct induction *, rtx, rtx, rtx, rtx, rtx, int, enum g_types, int, int, rtx *, rtx, rtx));
+static void update_giv_derive PARAMS ((rtx));
+static int basic_induction_var PARAMS ((rtx, enum machine_mode, rtx, rtx, int, rtx *, rtx *, rtx **, int *));
+static rtx simplify_giv_expr PARAMS ((rtx, int *));
+static int general_induction_var PARAMS ((rtx, rtx *, rtx *, rtx *, int, int *));
+static int consec_sets_giv PARAMS ((int, rtx, rtx, rtx, rtx *, rtx *, rtx *));
+static int check_dbra_loop PARAMS ((struct loop *, int));
+static rtx express_from_1 PARAMS ((rtx, rtx, rtx));
+static rtx combine_givs_p PARAMS ((struct induction *, struct induction *));
+static void combine_givs PARAMS ((struct iv_class *));
 struct recombine_givs_stats;
-static int find_life_end PROTO((rtx, struct recombine_givs_stats *, rtx, rtx));
-static void recombine_givs PROTO((struct iv_class *, rtx, rtx, int));
-static int product_cheap_p PROTO((rtx, rtx));
-static int maybe_eliminate_biv PROTO((struct iv_class *, rtx, rtx, int, int, int));
-static int maybe_eliminate_biv_1 PROTO((rtx, rtx, struct iv_class *, int, rtx));
-static int last_use_this_basic_block PROTO((rtx, rtx));
-static void record_initial PROTO((rtx, rtx, void *));
-static void update_reg_last_use PROTO((rtx, rtx));
-static rtx next_insn_in_loop PROTO((const struct loop *, rtx));
-static void load_mems_and_recount_loop_regs_set PROTO((const struct loop*,
+static int find_life_end PARAMS ((rtx, struct recombine_givs_stats *, rtx, rtx));
+static void recombine_givs PARAMS ((struct iv_class *, rtx, rtx, int));
+static int product_cheap_p PARAMS ((rtx, rtx));
+static int maybe_eliminate_biv PARAMS ((struct iv_class *, rtx, rtx, int, int, int));
+static int maybe_eliminate_biv_1 PARAMS ((rtx, rtx, struct iv_class *, int, rtx));
+static int last_use_this_basic_block PARAMS ((rtx, rtx));
+static void record_initial PARAMS ((rtx, rtx, void *));
+static void update_reg_last_use PARAMS ((rtx, rtx));
+static rtx next_insn_in_loop PARAMS ((const struct loop *, rtx));
+static void load_mems_and_recount_loop_regs_set PARAMS ((const struct loop*,
 						       int *));
-static void load_mems PROTO((const struct loop *));
-static int insert_loop_mem PROTO((rtx *, void *));
-static int replace_loop_mem PROTO((rtx *, void *));
-static int replace_loop_reg PROTO((rtx *, void *));
-static void note_reg_stored PROTO((rtx, rtx, void *));
-static void try_copy_prop PROTO((const struct loop *, rtx, int));
-static int replace_label PROTO((rtx *, void *));
+static void load_mems PARAMS ((const struct loop *));
+static int insert_loop_mem PARAMS ((rtx *, void *));
+static int replace_loop_mem PARAMS ((rtx *, void *));
+static int replace_loop_reg PARAMS ((rtx *, void *));
+static void note_reg_stored PARAMS ((rtx, rtx, void *));
+static void try_copy_prop PARAMS ((const struct loop *, rtx, int));
+static int replace_label PARAMS ((rtx *, void *));
 
 typedef struct rtx_and_int {
   rtx r;
@@ -317,19 +317,19 @@ typedef struct rtx_pair {
 
 #ifdef HAVE_decrement_and_branch_on_count
 /* Test whether BCT applicable and safe.  */
-static void insert_bct PROTO((struct loop *));
+static void insert_bct PARAMS ((struct loop *));
 
 /* Auxiliary function that inserts the BCT pattern into the loop.  */
-static void instrument_loop_bct PROTO((rtx, rtx, rtx));
+static void instrument_loop_bct PARAMS ((rtx, rtx, rtx));
 #endif /* HAVE_decrement_and_branch_on_count */
 
 /* Indirect_jump_in_function is computed once per function.  */
 int indirect_jump_in_function = 0;
-static int indirect_jump_in_function_p PROTO((rtx));
+static int indirect_jump_in_function_p PARAMS ((rtx));
 
-static int compute_luids PROTO((rtx, rtx, int));
+static int compute_luids PARAMS ((rtx, rtx, int));
 
-static int biv_elimination_giv_has_0_offset PROTO((struct induction *,
+static int biv_elimination_giv_has_0_offset PARAMS ((struct induction *,
 						   struct induction *, rtx));
 
 /* Relative gain of eliminating various kinds of operations.  */
diff --git a/gcc/loop.h b/gcc/loop.h
index 49fb4089e3d..b72034d186c 100644
--- a/gcc/loop.h
+++ b/gcc/loop.h
@@ -227,26 +227,26 @@ extern int first_increment_giv, last_increment_giv;
 
 /* Forward declarations for non-static functions declared in loop.c and
    unroll.c.  */
-int invariant_p PROTO((rtx));
-rtx get_condition_for_loop PROTO((rtx));
-void emit_iv_add_mult PROTO((rtx, rtx, rtx, rtx, rtx));
-rtx express_from PROTO((struct induction *, struct induction *));
-
-void unroll_loop PROTO((struct loop *, int, rtx, int));
-rtx biv_total_increment PROTO((struct iv_class *, rtx, rtx));
-unsigned HOST_WIDE_INT loop_iterations PROTO((struct loop *));
-int precondition_loop_p PROTO((rtx, struct loop_info *, 
+int invariant_p PARAMS ((rtx));
+rtx get_condition_for_loop PARAMS ((rtx));
+void emit_iv_add_mult PARAMS ((rtx, rtx, rtx, rtx, rtx));
+rtx express_from PARAMS ((struct induction *, struct induction *));
+
+void unroll_loop PARAMS ((struct loop *, int, rtx, int));
+rtx biv_total_increment PARAMS ((struct iv_class *, rtx, rtx));
+unsigned HOST_WIDE_INT loop_iterations PARAMS ((struct loop *));
+int precondition_loop_p PARAMS ((rtx, struct loop_info *, 
 			       rtx *, rtx *, rtx *, 
 			       enum machine_mode *mode));
-rtx final_biv_value PROTO((struct iv_class *, rtx, rtx,
+rtx final_biv_value PARAMS ((struct iv_class *, rtx, rtx,
 			   unsigned HOST_WIDE_INT));
-rtx final_giv_value PROTO((struct induction *, rtx, rtx,
+rtx final_giv_value PARAMS ((struct induction *, rtx, rtx,
 			   unsigned HOST_WIDE_INT));
-void emit_unrolled_add PROTO((rtx, rtx, rtx));
-int back_branch_in_range_p PROTO((rtx, rtx, rtx));
+void emit_unrolled_add PARAMS ((rtx, rtx, rtx));
+int back_branch_in_range_p PARAMS ((rtx, rtx, rtx));
 
-int loop_insn_first_p PROTO((rtx, rtx));
+int loop_insn_first_p PARAMS ((rtx, rtx));
 
 /* Forward declarations for non-static functions declared in stmt.c.  */
-void find_loop_tree_blocks PROTO((void));
-void unroll_block_trees PROTO((void));
+void find_loop_tree_blocks PARAMS ((void));
+void unroll_block_trees PARAMS ((void));