Patch installed: more PROTO->PARAMS part3

Kaveh R. Ghazi ghazi@caip.rutgers.edu
Mon Jan 17 07:38:00 GMT 2000


Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/egcs/gcc/ChangeLog,v
retrieving revision 1.5457
diff -u -p -r1.5457 ChangeLog
--- ChangeLog	2000/01/17 15:28:04	1.5457
+++ ChangeLog	2000/01/17 15:33:19
@@ -1,5 +1,23 @@
 2000-01-17  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
+	* machmode.h: PROTO -> PARAMS.
+	* mbchar.h: Likewise.
+	* mips-tdump.c: Likewise.
+	* mips-tfile.c: Likewise.
+	* optabs.c: Likewise.
+	* output.h: Likewise.
+	* prefix.c: Likewise.
+	* profile.c: Likewise.
+	* protoize.c: Likewise.
+	* real.h: Likewise.
+	* recog.c: Likewise.
+	* recog.h: Likewise.
+	* regclass.c: Likewise.
+	* regmove.c: Likewise.
+	* regs.h: Likewise.
+
+2000-01-17  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
 	* ggc-common.c: PROTO -> PARAMS.
 	* ggc-page.c: Likewise.
 	* ggc-simple.c: Likewise.
Index: machmode.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/machmode.h,v
retrieving revision 1.16
diff -u -p -r1.16 machmode.h
--- machmode.h	1999/09/21 22:31:29	1.16
+++ machmode.h	2000/01/17 15:33:19
@@ -105,22 +105,22 @@ extern const unsigned char mode_wider_mo
    If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
    The value is BLKmode if no other mode is found.  */
 
-extern enum machine_mode mode_for_size PROTO((unsigned int, enum mode_class, int));
+extern enum machine_mode mode_for_size PARAMS ((unsigned int, enum mode_class, int));
 
 /* Similar, but find the smallest mode for a given width.  */
 
-extern enum machine_mode smallest_mode_for_size  PROTO((unsigned int,
+extern enum machine_mode smallest_mode_for_size  PARAMS ((unsigned int,
                                                         enum mode_class));
 
 
 /* Return an integer mode of the exact same size as the input mode,
    or BLKmode on failure.  */
 
-extern enum machine_mode int_mode_for_mode PROTO((enum machine_mode));
+extern enum machine_mode int_mode_for_mode PARAMS ((enum machine_mode));
 
 /* Find the best mode to use to access a bit field.  */
 
-extern enum machine_mode get_best_mode PROTO((int, int, int, enum machine_mode, int));
+extern enum machine_mode get_best_mode PARAMS ((int, int, int, enum machine_mode, int));
 
 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 
Index: mbchar.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/mbchar.h,v
retrieving revision 1.6
diff -u -p -r1.6 mbchar.h
--- mbchar.h	1999/10/05 16:21:34	1.6
+++ mbchar.h	2000/01/17 15:33:19
@@ -31,9 +31,9 @@ Boston, MA 02111-1307, USA.  */
 #define ISEUCJP(c)   ((c) >= 0xa1 && (c) <= 0xfe)
 #define ISJIS(c)     ((c) >= 0x21 && (c) <= 0x7e)
 
-extern int local_mbtowc     PROTO ((wchar_t *, const char *, size_t));
-extern int local_mblen      PROTO ((const char *, size_t));
-extern int local_mb_cur_max PROTO ((void));
+extern int local_mbtowc     PARAMS ((wchar_t *, const char *, size_t));
+extern int local_mblen      PARAMS ((const char *, size_t));
+extern int local_mb_cur_max PARAMS ((void));
 
 /* The locale being used for multibyte characters in string/char literals.  */
 extern const char *literal_codeset;
Index: mips-tdump.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/mips-tdump.c,v
retrieving revision 1.14
diff -u -p -r1.14 mips-tdump.c
--- mips-tdump.c	1999/09/14 18:19:08	1.14
+++ mips-tdump.c	2000/01/17 15:33:20
@@ -56,8 +56,8 @@ typedef const PTR_T CPTR_T;
 #define uint	unsigned int
 #define ulong	unsigned long
 
-void fatal PROTO ((const char *)) ATTRIBUTE_NORETURN;
-void fancy_abort PROTO ((void)) ATTRIBUTE_NORETURN;
+void fatal PARAMS ((const char *)) ATTRIBUTE_NORETURN;
+void fancy_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
   
 void
 fatal(s)
@@ -1441,7 +1441,7 @@ read_tfile __proto((void))
 
 
 
-extern int main PROTO ((int, char **));
+extern int main PARAMS ((int, char **));
 
 int
 main (argc, argv)
Index: mips-tfile.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/mips-tfile.c,v
retrieving revision 1.27
diff -u -p -r1.27 mips-tfile.c
--- mips-tfile.c	1999/11/25 16:58:32	1.27
+++ mips-tfile.c	2000/01/17 15:33:22
@@ -637,8 +637,8 @@ extern void	pfatal_with_name
 extern void	fancy_abort	__proto((void)) ATTRIBUTE_NORETURN;
        void	botch		__proto((const char *)) ATTRIBUTE_NORETURN;
 
-extern void	fatal		PVPROTO((const char *format, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
-extern void	error		PVPROTO((const char *format, ...)) ATTRIBUTE_PRINTF_1;
+extern void	fatal		PARAMS ((const char *format, ...)) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
+extern void	error		PARAMS ((const char *format, ...)) ATTRIBUTE_PRINTF_1;
 
 #ifndef MIPS_DEBUGGING_INFO
 
@@ -4801,7 +4801,7 @@ copy_object __proto((void))
 
 /* Ye olde main program.  */
 
-extern int main PROTO ((int, char **));
+extern int main PARAMS ((int, char **));
 
 int
 main (argc, argv)
@@ -5554,7 +5554,7 @@ free_thead (ptr)
 
 /*VARARGS*/
 void
-fatal VPROTO((const char *format, ...))
+fatal VPARAMS ((const char *format, ...))
 {
 #ifndef ANSI_PROTOTYPES
   const char *format;
@@ -5584,7 +5584,7 @@ fatal VPROTO((const char *format, ...))
 
 /*VARARGS*/
 void
-error VPROTO((const char *format, ...))
+error VPARAMS ((const char *format, ...))
 {
 #ifndef ANSI_PROTOTYPES
   char *format;
Index: optabs.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/optabs.c,v
retrieving revision 1.58
diff -u -p -r1.58 optabs.c
--- optabs.c	2000/01/11 00:12:38	1.58
+++ optabs.c	2000/01/17 15:33:24
@@ -83,32 +83,32 @@ enum insn_code setcc_gen_code[NUM_RTX_CO
 enum insn_code movcc_gen_code[NUM_MACHINE_MODES];
 #endif
 
-static int add_equal_note	PROTO((rtx, rtx, enum rtx_code, rtx, rtx));
-static rtx widen_operand	PROTO((rtx, enum machine_mode,
+static int add_equal_note	PARAMS ((rtx, rtx, enum rtx_code, rtx, rtx));
+static rtx widen_operand	PARAMS ((rtx, enum machine_mode,
 				       enum machine_mode, int, int));
-static int expand_cmplxdiv_straight PROTO((rtx, rtx, rtx, rtx,
+static int expand_cmplxdiv_straight PARAMS ((rtx, rtx, rtx, rtx,
 					   rtx, rtx, enum machine_mode,
 					   int, enum optab_methods,
 					   enum mode_class, optab));
-static int expand_cmplxdiv_wide PROTO((rtx, rtx, rtx, rtx,
+static int expand_cmplxdiv_wide PARAMS ((rtx, rtx, rtx, rtx,
 				       rtx, rtx, enum machine_mode,
 				       int, enum optab_methods,
 				       enum mode_class, optab));
-static enum insn_code can_fix_p	PROTO((enum machine_mode, enum machine_mode,
+static enum insn_code can_fix_p	PARAMS ((enum machine_mode, enum machine_mode,
 				       int, int *));
-static enum insn_code can_float_p PROTO((enum machine_mode, enum machine_mode,
+static enum insn_code can_float_p PARAMS ((enum machine_mode, enum machine_mode,
 					 int));
-static rtx ftruncify	PROTO((rtx));
-static optab init_optab	PROTO((enum rtx_code));
-static void init_libfuncs PROTO((optab, int, int, const char *, int));
-static void init_integral_libfuncs PROTO((optab, const char *, int));
-static void init_floating_libfuncs PROTO((optab, const char *, int));
+static rtx ftruncify	PARAMS ((rtx));
+static optab init_optab	PARAMS ((enum rtx_code));
+static void init_libfuncs PARAMS ((optab, int, int, const char *, int));
+static void init_integral_libfuncs PARAMS ((optab, const char *, int));
+static void init_floating_libfuncs PARAMS ((optab, const char *, int));
 #ifdef HAVE_conditional_trap
-static void init_traps PROTO((void));
+static void init_traps PARAMS ((void));
 #endif
-static void emit_cmp_and_jump_insn_1 PROTO((rtx, rtx, enum machine_mode,
+static void emit_cmp_and_jump_insn_1 PARAMS ((rtx, rtx, enum machine_mode,
 					    enum rtx_code, int, rtx));
-static void prepare_float_lib_cmp PROTO((rtx *, rtx *, enum rtx_code *,
+static void prepare_float_lib_cmp PARAMS ((rtx *, rtx *, enum rtx_code *,
 					 enum machine_mode *, int *));
 
 /* Add a REG_EQUAL note to the last insn in SEQ.  TARGET is being set to
Index: output.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/output.h,v
retrieving revision 1.40
diff -u -p -r1.40 output.h
--- output.h	2000/01/11 22:57:39	1.40
+++ output.h	2000/01/17 15:33:25
@@ -20,144 +20,144 @@ the Free Software Foundation, 59 Temple 
 Boston, MA 02111-1307, USA.  */
 
 /* Initialize data in final at the beginning of a compilation.  */
-extern void init_final		PROTO((const char *));
+extern void init_final		PARAMS ((const char *));
 
 /* Called at end of source file,
    to output the block-profiling table for this entire compilation.  */
-extern void end_final		PROTO((const char *));
+extern void end_final		PARAMS ((const char *));
 
 /* Enable APP processing of subsequent output.
    Used before the output from an `asm' statement.  */
-extern void app_enable		PROTO((void));
+extern void app_enable		PARAMS ((void));
 
 /* Disable APP processing of subsequent output.
    Called from varasm.c before most kinds of output.  */
-extern void app_disable		PROTO((void));
+extern void app_disable		PARAMS ((void));
 
 /* Return the number of slots filled in the current 
    delayed branch sequence (we don't count the insn needing the
    delay slot).   Zero if not in a delayed branch sequence.  */
-extern int dbr_sequence_length	PROTO((void));
+extern int dbr_sequence_length	PARAMS ((void));
 
 /* Indicate that branch shortening hasn't yet been done.  */
-extern void init_insn_lengths	PROTO((void));
+extern void init_insn_lengths	PARAMS ((void));
 
 #ifdef RTX_CODE
 /* Obtain the current length of an insn.  If branch shortening has been done,
    get its actual length.  Otherwise, get its maximum length.  */
-extern int get_attr_length	PROTO((rtx));
+extern int get_attr_length	PARAMS ((rtx));
 
 /* Make a pass over all insns and compute their actual lengths by shortening
    any branches of variable length if possible.  */
-extern void shorten_branches	PROTO((rtx));
+extern void shorten_branches	PARAMS ((rtx));
 
 /* Output assembler code for the start of a function,
    and initialize some of the variables in this file
    for the new function.  The label for the function and associated
    assembler pseudo-ops have already been output in
    `assemble_start_function'.  */
-extern void final_start_function  PROTO((rtx, FILE *, int));
+extern void final_start_function  PARAMS ((rtx, FILE *, int));
 
 /* Output assembler code for the end of a function.
    For clarity, args are same as those of `final_start_function'
    even though not all of them are needed.  */
-extern void final_end_function  PROTO((rtx, FILE *, int));
+extern void final_end_function  PARAMS ((rtx, FILE *, int));
 
 /* Output assembler code for some insns: all or part of a function.  */
-extern void final		PROTO((rtx, FILE *, int, int));
+extern void final		PARAMS ((rtx, FILE *, int, int));
 
 /* The final scan for one insn, INSN.  Args are same as in `final', except
    that INSN is the insn being scanned.  Value returned is the next insn to
    be scanned.  */
-extern rtx final_scan_insn	PROTO((rtx, FILE *, int, int, int));
+extern rtx final_scan_insn	PARAMS ((rtx, FILE *, int, int, int));
 
 /* Replace a SUBREG with a REG or a MEM, based on the thing it is a
    subreg of.  */
-extern rtx alter_subreg PROTO((rtx));
+extern rtx alter_subreg PARAMS ((rtx));
 
 /* Report inconsistency between the assembler template and the operands.
    In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
-extern void output_operand_lossage  PROTO((const char *));
+extern void output_operand_lossage  PARAMS ((const char *));
 
 /* Output a string of assembler code, substituting insn operands.
    Defined in final.c.  */
-extern void output_asm_insn	PROTO((const char *, rtx *));
+extern void output_asm_insn	PARAMS ((const char *, rtx *));
 
 /* Compute a worst-case reference address of a branch so that it
    can be safely used in the presence of aligned labels.
    Defined in final.c.  */
-extern int insn_current_reference_address	PROTO((rtx));
+extern int insn_current_reference_address	PARAMS ((rtx));
 
 /* Find the alignment associated with a CODE_LABEL.
    Defined in final.c.  */
-extern int label_to_alignment	PROTO((rtx));
+extern int label_to_alignment	PARAMS ((rtx));
 
 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol.  */
-extern void output_asm_label	PROTO((rtx));
+extern void output_asm_label	PARAMS ((rtx));
 
 /* Print a memory reference operand for address X
    using machine-dependent assembler syntax.  */
-extern void output_address	PROTO((rtx));
+extern void output_address	PARAMS ((rtx));
 
 /* Print an integer constant expression in assembler syntax.
    Addition and subtraction are the only arithmetic
    that may appear in these expressions.  */
-extern void output_addr_const PROTO((FILE *, rtx));
+extern void output_addr_const PARAMS ((FILE *, rtx));
 
 /* Output a string of assembler code, substituting numbers, strings
    and fixed syntactic prefixes.  */
-extern void asm_fprintf		PVPROTO((FILE *file, const char *p, ...));
+extern void asm_fprintf		PARAMS ((FILE *file, const char *p, ...));
 
 /* Split up a CONST_DOUBLE or integer constant rtx into two rtx's for single
    words.  */
-extern void split_double	PROTO((rtx, rtx *, rtx *));
+extern void split_double	PARAMS ((rtx, rtx *, rtx *));
 
 /* Return nonzero if this function has no function calls.  */
-extern int leaf_function_p	PROTO((void));
+extern int leaf_function_p	PARAMS ((void));
 
 /* Return 1 if this function uses only the registers that can be
    safely renumbered.  */
-extern int only_leaf_regs_used	PROTO((void));
+extern int only_leaf_regs_used	PARAMS ((void));
 
 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
    available in leaf functions.  */
-extern void leaf_renumber_regs_insn PROTO((rtx));
+extern void leaf_renumber_regs_insn PARAMS ((rtx));
 
 /* Locate the proper template for the given insn-code.  */
-extern const char *get_insn_template PROTO((int, rtx));
+extern const char *get_insn_template PARAMS ((int, rtx));
 
 /* Functions in flow.c */
-extern void allocate_for_life_analysis	PROTO((void));
-extern int regno_uninitialized		PROTO((int));
-extern int regno_clobbered_at_setjmp	PROTO((int));
-extern void dump_flow_info		PROTO((FILE *));
-extern void find_basic_blocks         PROTO((rtx, int, FILE *, int));
-extern void calculate_loop_depth      PROTO((FILE *));
-extern void free_basic_block_vars     PROTO((int));
-extern void set_block_num             PROTO((rtx, int));
-extern void life_analysis             PROTO((rtx, int, FILE *, int));
+extern void allocate_for_life_analysis	PARAMS ((void));
+extern int regno_uninitialized		PARAMS ((int));
+extern int regno_clobbered_at_setjmp	PARAMS ((int));
+extern void dump_flow_info		PARAMS ((FILE *));
+extern void find_basic_blocks         PARAMS ((rtx, int, FILE *, int));
+extern void calculate_loop_depth      PARAMS ((FILE *));
+extern void free_basic_block_vars     PARAMS ((int));
+extern void set_block_num             PARAMS ((rtx, int));
+extern void life_analysis             PARAMS ((rtx, int, FILE *, int));
 #endif
 
 /* Functions in varasm.c.  */
 
 /* Tell assembler to switch to text section.  */
-extern void text_section		PROTO((void));
+extern void text_section		PARAMS ((void));
 
 /* Tell assembler to switch to data section.  */
-extern void data_section		PROTO((void));
+extern void data_section		PARAMS ((void));
 
 /* Tell assembler to make sure its in the data section.  */
-extern void force_data_section		PROTO((void));
+extern void force_data_section		PARAMS ((void));
 
 /* Tell assembler to switch to read-only data section.  This is normally
    the text section.  */
-extern void readonly_data_section	PROTO((void));
+extern void readonly_data_section	PARAMS ((void));
 
 /* Determine if we're in the text section. */
-extern int in_text_section		PROTO((void));
+extern int in_text_section		PARAMS ((void));
 
 #ifdef EH_FRAME_SECTION_ASM_OP
-extern void eh_frame_section		PROTO ((void));
+extern void eh_frame_section		PARAMS ((void));
 #endif
 
 #ifdef CTORS_SECTION_ASM_OP
@@ -193,25 +193,25 @@ extern void tdesc_section PARAMS ((void)
    If DECL is NULL, just switch to section NAME.
    If NAME is NULL, get the name from DECL.
    If RELOC is 1, the initializer for DECL contains relocs.  */
-extern void named_section		PROTO((tree, const char *, int));
+extern void named_section		PARAMS ((tree, const char *, int));
 
 /* Tell assembler to switch to the section for function DECL.  */
-extern void function_section		PROTO((tree));
+extern void function_section		PARAMS ((tree));
 
 /* Tell assembler to switch to the section for the exception table.  */
-extern void exception_section		PROTO((void));
+extern void exception_section		PARAMS ((void));
 
 /* Create the rtl to represent a function, for a function definition.
    DECL is a FUNCTION_DECL node which describes which function.
    The rtl is stored into DECL.  */
-extern void make_function_rtl		PROTO((tree));
+extern void make_function_rtl		PARAMS ((tree));
 
 /* Declare DECL to be a weak symbol.  */
-extern void declare_weak		PROTO ((tree));
+extern void declare_weak		PARAMS ((tree));
 #endif /* TREE_CODE */
 
 /* Emit any pending weak declarations.  */
-extern void weak_finish			PROTO ((void));
+extern void weak_finish			PARAMS ((void));
 
 /* Decode an `asm' spec for a declaration as a register name.
    Return the register number, or -1 if nothing specified,
@@ -220,7 +220,7 @@ extern void weak_finish			PROTO ((void))
    or -4 if ASMSPEC is `memory' and is not recognized.
    Accept an exact spelling or a decimal number.
    Prefixes such as % are optional.  */
-extern int decode_reg_name		PROTO((const char *));
+extern int decode_reg_name		PARAMS ((const char *));
 
 #ifdef TREE_CODE
 /* Create the DECL_RTL for a declaration for a static or external variable
@@ -230,30 +230,30 @@ extern int decode_reg_name		PROTO((const
    TOP_LEVEL is nonzero if this is a file-scope variable.
 
    This is never called for PARM_DECL nodes.  */
-extern void make_decl_rtl		PROTO((tree, const char *, int));
+extern void make_decl_rtl		PARAMS ((tree, const char *, int));
 
 /* Make the rtl for variable VAR be volatile.
    Use this only for static variables.  */
-extern void make_var_volatile		PROTO((tree));
+extern void make_var_volatile		PARAMS ((tree));
 
 /* Output alignment directive to align for constant expression EXP.  */
-extern void assemble_constant_align	PROTO((tree));
+extern void assemble_constant_align	PARAMS ((tree));
 
-extern void assemble_alias		PROTO((tree, tree));
+extern void assemble_alias		PARAMS ((tree, tree));
 
 /* Output a string of literal assembler code
    for an `asm' keyword used between functions.  */
-extern void assemble_asm		PROTO((tree));
+extern void assemble_asm		PARAMS ((tree));
 
 /* Output assembler code for the constant pool of a function and associated
    with defining the name of the function.  DECL describes the function.
    NAME is the function's name.  For the constant pool, we use the current
    constant pool data.  */
-extern void assemble_start_function	PROTO((tree, char *));
+extern void assemble_start_function	PARAMS ((tree, char *));
 
 /* Output assembler code associated with defining the size of the
    function.  DECL describes the function.  NAME is the function's name.  */
-extern void assemble_end_function	PROTO((tree, const char *));
+extern void assemble_end_function	PARAMS ((tree, const char *));
 
 /* Assemble everything that is needed for a variable or function declaration.
    Not used for automatic variables, and not used for function definitions.
@@ -264,12 +264,12 @@ extern void assemble_end_function	PROTO(
    to define things that have had only tentative definitions.
    DONT_OUTPUT_DATA if nonzero means don't actually output the
    initial value (that will be done by the caller).  */
-extern void assemble_variable		PROTO((tree, int, int, int));
+extern void assemble_variable		PARAMS ((tree, int, int, int));
 
 /* Output something to declare an external symbol to the assembler.
    (Most assemblers don't need this, so we normally output nothing.)
    Do nothing if DECL is not external.  */
-extern void assemble_external		PROTO((tree));
+extern void assemble_external		PARAMS ((tree));
 #endif /* TREE_CODE */
 
 /* Record an element in the table of global destructors.
@@ -278,41 +278,41 @@ extern void assemble_external		PROTO((tr
 
    NAME should be the name of a global function to be called
    at exit time.  This name is output using assemble_name.  */
-extern void assemble_destructor		PROTO((const char *));
+extern void assemble_destructor		PARAMS ((const char *));
 
 /* Likewise for global constructors.  */
-extern void assemble_constructor	PROTO((const char *));
+extern void assemble_constructor	PARAMS ((const char *));
 
 /* Likewise for entries we want to record for garbage collection.
    Garbage collection is still under development.  */
-extern void assemble_gc_entry		PROTO((const char *));
+extern void assemble_gc_entry		PARAMS ((const char *));
 
 /* Assemble code to leave SIZE bytes of zeros.  */
-extern void assemble_zeros		PROTO((int));
+extern void assemble_zeros		PARAMS ((int));
 
 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
-extern void assemble_align		PROTO((int));
+extern void assemble_align		PARAMS ((int));
 
 /* Assemble a string constant with the specified C string as contents.  */
-extern void assemble_string		PROTO((const char *, int));
+extern void assemble_string		PARAMS ((const char *, int));
 
 #ifdef RTX_CODE
 /* Similar, for calling a library function FUN.  */
-extern void assemble_external_libcall	PROTO((rtx));
+extern void assemble_external_libcall	PARAMS ((rtx));
 #endif
 
 /* Declare the label NAME global.  */
-extern void assemble_global		PROTO((const char *));
+extern void assemble_global		PARAMS ((const char *));
 
 /* Assemble a label named NAME.  */
-extern void assemble_label		PROTO((const char *));
+extern void assemble_label		PARAMS ((const char *));
 
 /* Output to FILE a reference to the assembler name of a C-level name NAME.
    If NAME starts with a *, the rest of NAME is output verbatim.
    Otherwise NAME is transformed in an implementation-defined way
    (usually by the addition of an underscore).
    Many macros in the tm file are defined to call this function.  */
-extern void assemble_name		PROTO((FILE *, const char *));
+extern void assemble_name		PARAMS ((FILE *, const char *));
 
 #ifdef RTX_CODE
 /* Assemble the integer constant X into an object of SIZE bytes.
@@ -320,11 +320,11 @@ extern void assemble_name		PROTO((FILE *
 
    Return 1 if we were able to output the constant, otherwise 0.  If FORCE is
    non-zero, abort if we can't output the constant.  */
-extern int assemble_integer		PROTO((rtx, int, int));
+extern int assemble_integer		PARAMS ((rtx, int, int));
 
 #ifdef EMUSHORT
 /* Assemble the floating-point constant D into an object of size MODE.  */
-extern void assemble_real		PROTO((REAL_VALUE_TYPE,
+extern void assemble_real		PARAMS ((REAL_VALUE_TYPE,
 					       enum machine_mode));
 #endif
 #endif
@@ -332,25 +332,25 @@ extern void assemble_real		PROTO((REAL_V
 /* At the end of a function, forget the memory-constants
    previously made for CONST_DOUBLEs.  Mark them as not on real_constant_chain.
    Also clear out real_constant_chain and clear out all the chain-pointers.  */
-extern void clear_const_double_mem	PROTO((void));
+extern void clear_const_double_mem	PARAMS ((void));
 
 /* Start deferring output of subconstants.  */
-extern void defer_addressed_constants	PROTO((void));
+extern void defer_addressed_constants	PARAMS ((void));
 
 /* Stop deferring output of subconstants,
    and output now all those that have been deferred.  */
-extern void output_deferred_addressed_constants PROTO((void));
+extern void output_deferred_addressed_constants PARAMS ((void));
 
 /* Return the size of the constant pool.  */
-extern int get_pool_size		PROTO((void));
+extern int get_pool_size		PARAMS ((void));
 
 #ifdef HAVE_peephole
-extern rtx peephole			PROTO((rtx));
+extern rtx peephole			PARAMS ((rtx));
 #endif
 
 #ifdef TREE_CODE
 /* Write all the constants in the constant pool.  */
-extern void output_constant_pool	PROTO((const char *, tree));
+extern void output_constant_pool	PARAMS ((const char *, tree));
 
 /* Return nonzero if VALUE is a valid constant-valued expression
    for use in initializing a static variable; one that can be an
@@ -361,7 +361,7 @@ extern void output_constant_pool	PROTO((
    We assume that VALUE has been folded as much as possible;
    therefore, we do not need to check for such things as
    arithmetic-combinations of integers.  */
-extern tree initializer_constant_valid_p	PROTO((tree, tree));
+extern tree initializer_constant_valid_p	PARAMS ((tree, tree));
 
 /* Output assembler code for constant EXP to FILE, with no label.
    This includes the pseudo-op such as ".int" or ".byte", and a newline.
@@ -369,7 +369,7 @@ extern tree initializer_constant_valid_p
 
    Generate exactly SIZE bytes of assembler data, padding at the end
    with zeros if necessary.  SIZE must always be specified.  */
-extern void output_constant		PROTO((tree, int));
+extern void output_constant		PARAMS ((tree, int));
 #endif
 
 /* When outputting assembler code, indicates which alternative
Index: prefix.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/prefix.c,v
retrieving revision 1.21
diff -u -p -r1.21 prefix.c
--- prefix.c	2000/01/07 00:16:51	1.21
+++ prefix.c	2000/01/17 15:33:25
@@ -73,12 +73,12 @@ Boston, MA 02111-1307, USA.  */
 
 static const char *std_prefix = PREFIX;
 
-static const char *get_key_value	PROTO((char *));
-static const char *translate_name	PROTO((const char *));
-static char *save_string		PROTO((const char *, int));
+static const char *get_key_value	PARAMS ((char *));
+static const char *translate_name	PARAMS ((const char *));
+static char *save_string		PARAMS ((const char *, int));
 
 #if defined(_WIN32) && defined(ENABLE_WIN32_REGISTRY)
-static char *lookup_key		PROTO((char *));
+static char *lookup_key		PARAMS ((char *));
 static HKEY reg_key = (HKEY) INVALID_HANDLE_VALUE;
 #endif
 
@@ -112,7 +112,7 @@ get_key_value (key)
    This function is based on the one in libiberty.  */
 
 char *
-concat VPROTO((const char *first, ...))
+concat VPARAMS ((const char *first, ...))
 {
   register int length;
   register char *newstr;
Index: profile.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/profile.c,v
retrieving revision 1.38
diff -u -p -r1.38 profile.c
--- profile.c	1999/12/16 09:46:28	1.38
+++ profile.c	2000/01/17 15:33:26
@@ -150,16 +150,16 @@ static int total_num_never_executed;
 static int total_num_branches;
 
 /* Forward declarations.  */
-static void init_arc PROTO((struct adj_list *, int, int, rtx));
-static void find_spanning_tree PROTO((int));
-static void expand_spanning_tree PROTO((int));
-static void fill_spanning_tree PROTO((int));
-static void init_arc_profiler PROTO((void));
-static void output_arc_profiler PROTO((int, rtx));
-static void instrument_arcs PROTO((rtx, int, FILE *));
-static void output_gcov_string PROTO((const char *, long));
-static int tablejump_entry_p PROTO((rtx, rtx));
-static void compute_branch_probabilities PROTO((int, FILE *));
+static void init_arc PARAMS ((struct adj_list *, int, int, rtx));
+static void find_spanning_tree PARAMS ((int));
+static void expand_spanning_tree PARAMS ((int));
+static void fill_spanning_tree PARAMS ((int));
+static void init_arc_profiler PARAMS ((void));
+static void output_arc_profiler PARAMS ((int, rtx));
+static void instrument_arcs PARAMS ((rtx, int, FILE *));
+static void output_gcov_string PARAMS ((const char *, long));
+static int tablejump_entry_p PARAMS ((rtx, rtx));
+static void compute_branch_probabilities PARAMS ((int, FILE *));
 
 #ifndef LONG_TYPE_SIZE
 #define LONG_TYPE_SIZE BITS_PER_WORD
Index: protoize.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/protoize.c,v
retrieving revision 1.46
diff -u -p -r1.46 protoize.c
--- protoize.c	2000/01/07 00:42:11	1.46
+++ protoize.c	2000/01/17 15:33:27
@@ -74,7 +74,7 @@ static int directory_specified_p PARAMS 
 static int file_excluded_p PARAMS ((const char *));
 static char *unexpand_if_needed PARAMS ((const char *));
 static char *abspath PARAMS ((const char *, const char *));
-static int is_abspath PVPROTO ((const char *));
+static int is_abspath PARAMS ((const char *));
 static void check_aux_info PARAMS ((int));
 static const char *find_corresponding_lparen PARAMS ((const char *));
 static int referenced_file_is_newer PARAMS ((const char *, time_t));
Index: real.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/real.h,v
retrieving revision 1.16
diff -u -p -r1.16 real.h
--- real.h	2000/01/11 00:12:38	1.16
+++ real.h	2000/01/17 15:33:27
@@ -115,7 +115,7 @@ typedef struct {
 #endif /* no TFmode support */
 #endif /* no XFmode support */
 
-extern int significand_size	PROTO((enum machine_mode));
+extern int significand_size	PARAMS ((enum machine_mode));
 
 /* If emulation has been enabled by defining REAL_ARITHMETIC or by
    setting LONG_DOUBLE_TYPE_SIZE to 96 or 128, then define macros so that
@@ -128,36 +128,36 @@ extern int significand_size	PROTO((enum 
   earith (&(value), (code), &(d1), &(d2))
 
 /* Declare functions in real.c. */
-extern void earith		PROTO((REAL_VALUE_TYPE *, int,
+extern void earith		PARAMS ((REAL_VALUE_TYPE *, int,
 				       REAL_VALUE_TYPE *, REAL_VALUE_TYPE *));
-extern REAL_VALUE_TYPE etrunci	PROTO((REAL_VALUE_TYPE));
-extern REAL_VALUE_TYPE etruncui	PROTO((REAL_VALUE_TYPE));
-extern REAL_VALUE_TYPE ereal_atof PROTO((const char *, enum machine_mode));
-extern REAL_VALUE_TYPE ereal_negate PROTO((REAL_VALUE_TYPE));
-extern HOST_WIDE_INT efixi	PROTO((REAL_VALUE_TYPE));
-extern unsigned HOST_WIDE_INT efixui PROTO((REAL_VALUE_TYPE));
-extern void ereal_from_int	PROTO((REAL_VALUE_TYPE *,
+extern REAL_VALUE_TYPE etrunci	PARAMS ((REAL_VALUE_TYPE));
+extern REAL_VALUE_TYPE etruncui	PARAMS ((REAL_VALUE_TYPE));
+extern REAL_VALUE_TYPE ereal_atof PARAMS ((const char *, enum machine_mode));
+extern REAL_VALUE_TYPE ereal_negate PARAMS ((REAL_VALUE_TYPE));
+extern HOST_WIDE_INT efixi	PARAMS ((REAL_VALUE_TYPE));
+extern unsigned HOST_WIDE_INT efixui PARAMS ((REAL_VALUE_TYPE));
+extern void ereal_from_int	PARAMS ((REAL_VALUE_TYPE *,
 				       HOST_WIDE_INT, HOST_WIDE_INT,
 				       enum machine_mode));
-extern void ereal_from_uint	PROTO((REAL_VALUE_TYPE *,
+extern void ereal_from_uint	PARAMS ((REAL_VALUE_TYPE *,
 				       unsigned HOST_WIDE_INT,
 				       unsigned HOST_WIDE_INT,
 				       enum machine_mode));
-extern void ereal_to_int	PROTO((HOST_WIDE_INT *, HOST_WIDE_INT *,
+extern void ereal_to_int	PARAMS ((HOST_WIDE_INT *, HOST_WIDE_INT *,
 				       REAL_VALUE_TYPE));
-extern REAL_VALUE_TYPE ereal_ldexp PROTO((REAL_VALUE_TYPE, int));
+extern REAL_VALUE_TYPE ereal_ldexp PARAMS ((REAL_VALUE_TYPE, int));
 
-extern void etartdouble		PROTO((REAL_VALUE_TYPE, long *));
-extern void etarldouble		PROTO((REAL_VALUE_TYPE, long *));
-extern void etardouble		PROTO((REAL_VALUE_TYPE, long *));
-extern long etarsingle		PROTO((REAL_VALUE_TYPE));
-extern void ereal_to_decimal	PROTO((REAL_VALUE_TYPE, char *));
-extern int ereal_cmp		PROTO((REAL_VALUE_TYPE, REAL_VALUE_TYPE));
-extern int ereal_isneg		PROTO((REAL_VALUE_TYPE));
-extern REAL_VALUE_TYPE ereal_unto_float PROTO((long));
-extern REAL_VALUE_TYPE ereal_unto_double PROTO((long *));
-extern REAL_VALUE_TYPE ereal_from_float PROTO((HOST_WIDE_INT));
-extern REAL_VALUE_TYPE ereal_from_double PROTO((HOST_WIDE_INT *));
+extern void etartdouble		PARAMS ((REAL_VALUE_TYPE, long *));
+extern void etarldouble		PARAMS ((REAL_VALUE_TYPE, long *));
+extern void etardouble		PARAMS ((REAL_VALUE_TYPE, long *));
+extern long etarsingle		PARAMS ((REAL_VALUE_TYPE));
+extern void ereal_to_decimal	PARAMS ((REAL_VALUE_TYPE, char *));
+extern int ereal_cmp		PARAMS ((REAL_VALUE_TYPE, REAL_VALUE_TYPE));
+extern int ereal_isneg		PARAMS ((REAL_VALUE_TYPE));
+extern REAL_VALUE_TYPE ereal_unto_float PARAMS ((long));
+extern REAL_VALUE_TYPE ereal_unto_double PARAMS ((long *));
+extern REAL_VALUE_TYPE ereal_from_float PARAMS ((HOST_WIDE_INT));
+extern REAL_VALUE_TYPE ereal_from_double PARAMS ((HOST_WIDE_INT *));
 
 #define REAL_VALUES_EQUAL(x, y) (ereal_cmp ((x), (y)) == 0)
 /* true if x < y : */
@@ -167,7 +167,7 @@ extern REAL_VALUE_TYPE ereal_from_double
 /* These return REAL_VALUE_TYPE: */
 #define REAL_VALUE_RNDZINT(x) (etrunci (x))
 #define REAL_VALUE_UNSIGNED_RNDZINT(x) (etruncui (x))
-extern REAL_VALUE_TYPE real_value_truncate	PROTO ((enum machine_mode,
+extern REAL_VALUE_TYPE real_value_truncate	PARAMS ((enum machine_mode,
 							REAL_VALUE_TYPE));
 #define REAL_VALUE_TRUNCATE(mode, x)  real_value_truncate (mode, x)
 
@@ -357,7 +357,7 @@ extern double ldexp ();
 #ifndef REAL_VALUE_ATOF
 #if 1
 /* Use real.c to convert decimal numbers to binary, ... */
-extern REAL_VALUE_TYPE ereal_atof PROTO((const char *, enum machine_mode));
+extern REAL_VALUE_TYPE ereal_atof PARAMS ((const char *, enum machine_mode));
 #define REAL_VALUE_ATOF(x, s) ereal_atof (x, s)
 /* Could use ereal_atof here for hexadecimal floats too, but real_hex_to_f
    is OK and it uses faster native fp arithmetic.  */
@@ -379,7 +379,7 @@ extern double (atof) ();
 /* Hexadecimal floating constant input for use with host computer's
    fp arithmetic.  */
 #ifndef REAL_VALUE_HTOF
-extern REAL_VALUE_TYPE real_hex_to_f PROTO((char *, enum machine_mode));
+extern REAL_VALUE_TYPE real_hex_to_f PARAMS ((char *, enum machine_mode));
 #define REAL_VALUE_HTOF(s,m) real_hex_to_f(s,m)
 #endif
 
@@ -393,7 +393,7 @@ extern REAL_VALUE_TYPE real_hex_to_f PRO
    size and where `float' is SFmode.  */
 
 /* Don't use REAL_VALUE_TRUNCATE directly--always call real_value_truncate.  */
-extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode,
+extern REAL_VALUE_TYPE real_value_truncate PARAMS ((enum machine_mode,
 						  REAL_VALUE_TYPE));
 
 #ifndef REAL_VALUE_TRUNCATE
@@ -417,9 +417,9 @@ extern REAL_VALUE_TYPE real_value_trunca
 #define REAL_VALUE_NEGATIVE(x) (target_negative (x))
 #endif
 
-extern int target_isnan			PROTO((REAL_VALUE_TYPE));
-extern int target_isinf			PROTO((REAL_VALUE_TYPE));
-extern int target_negative		PROTO((REAL_VALUE_TYPE));
+extern int target_isnan			PARAMS ((REAL_VALUE_TYPE));
+extern int target_isinf			PARAMS ((REAL_VALUE_TYPE));
+extern int target_negative		PARAMS ((REAL_VALUE_TYPE));
 
 /* Determine whether a floating-point value X is minus 0. */
 #ifndef REAL_VALUE_MINUS_ZERO
@@ -463,7 +463,7 @@ union real_extract 
 /* Function to return a real value (not a tree node)
    from a given integer constant.  */
 union tree_node;
-REAL_VALUE_TYPE real_value_from_int_cst	PROTO ((union tree_node *,
+REAL_VALUE_TYPE real_value_from_int_cst	PARAMS ((union tree_node *,
 						union tree_node *));
 
 #define REAL_VALUE_FROM_CONST_DOUBLE(to, from)		\
@@ -474,7 +474,7 @@ do { union real_extract u;				\
 /* Return a CONST_DOUBLE with value R and mode M.  */
 
 #define CONST_DOUBLE_FROM_REAL_VALUE(r, m) immed_real_const_1 (r,  m)
-extern struct rtx_def *immed_real_const_1	PROTO((REAL_VALUE_TYPE,
+extern struct rtx_def *immed_real_const_1	PARAMS ((REAL_VALUE_TYPE,
 						       enum machine_mode));
 
 
@@ -486,18 +486,18 @@ extern struct rtx_def *immed_real_const_
 #endif
 
 /* Replace R by 1/R in the given machine mode, if the result is exact.  */
-extern int exact_real_inverse	PROTO((enum machine_mode, REAL_VALUE_TYPE *));
-extern int target_isnan		PROTO((REAL_VALUE_TYPE));
-extern int target_isinf		PROTO((REAL_VALUE_TYPE));
-extern int target_negative	PROTO((REAL_VALUE_TYPE));
-extern void debug_real		PROTO((REAL_VALUE_TYPE));
+extern int exact_real_inverse	PARAMS ((enum machine_mode, REAL_VALUE_TYPE *));
+extern int target_isnan		PARAMS ((REAL_VALUE_TYPE));
+extern int target_isinf		PARAMS ((REAL_VALUE_TYPE));
+extern int target_negative	PARAMS ((REAL_VALUE_TYPE));
+extern void debug_real		PARAMS ((REAL_VALUE_TYPE));
 
 /* In varasm.c */
-extern void assemble_real		PROTO((REAL_VALUE_TYPE,
+extern void assemble_real		PARAMS ((REAL_VALUE_TYPE,
 					       enum machine_mode));
-extern void debug_real			PROTO((REAL_VALUE_TYPE));
+extern void debug_real			PARAMS ((REAL_VALUE_TYPE));
 
 /* In varasm.c */
-extern void assemble_real		PROTO((REAL_VALUE_TYPE,
+extern void assemble_real		PARAMS ((REAL_VALUE_TYPE,
 					       enum machine_mode));
 #endif /* Not REAL_H_INCLUDED */
Index: recog.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/recog.c,v
retrieving revision 1.52
diff -u -p -r1.52 recog.c
--- recog.c	2000/01/13 00:17:32	1.52
+++ recog.c	2000/01/17 15:33:28
@@ -54,10 +54,10 @@ Boston, MA 02111-1307, USA.  */
 #endif
 #endif
 
-static void validate_replace_rtx_1	PROTO((rtx *, rtx, rtx, rtx));
-static rtx *find_single_use_1		PROTO((rtx, rtx *));
-static rtx *find_constant_term_loc	PROTO((rtx *));
-static int insn_invalid_p		PROTO((rtx));
+static void validate_replace_rtx_1	PARAMS ((rtx *, rtx, rtx, rtx));
+static rtx *find_single_use_1		PARAMS ((rtx, rtx *));
+static rtx *find_constant_term_loc	PARAMS ((rtx *));
+static int insn_invalid_p		PARAMS ((rtx));
 
 /* Nonzero means allow operands to be volatile.
    This should be 0 if you are generating rtl, such as if you are calling
@@ -1846,7 +1846,7 @@ offsettable_address_p (strictp, mode, y)
   register rtx z;
   rtx y1 = y;
   rtx *y2;
-  int (*addressp) PROTO ((enum machine_mode, rtx)) =
+  int (*addressp) PARAMS ((enum machine_mode, rtx)) =
     (strictp ? strict_memory_address_p : memory_address_p);
 
   if (CONSTANT_ADDRESS_P (y))
Index: recog.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/recog.h,v
retrieving revision 1.26
diff -u -p -r1.26 recog.h
--- recog.h	1999/10/22 22:02:17	1.26
+++ recog.h	2000/01/17 15:33:28
@@ -66,58 +66,58 @@ struct operand_alternative
 };
 
 
-extern void init_recog			PROTO((void));
-extern void init_recog_no_volatile	PROTO((void));
-extern int recog_memoized		PROTO((rtx));
-extern int check_asm_operands		PROTO((rtx));
-extern int asm_operand_ok		PROTO((rtx, const char *));
-extern int validate_change		PROTO((rtx, rtx *, rtx, int));
-extern int apply_change_group		PROTO((void));
-extern int num_validated_changes	PROTO((void));
-extern void cancel_changes		PROTO((int));
-extern int constrain_operands		PROTO((int));
-extern int memory_address_p		PROTO((enum machine_mode, rtx));
-extern int strict_memory_address_p	PROTO((enum machine_mode, rtx));
-extern int validate_replace_rtx		PROTO((rtx, rtx, rtx));
-extern void validate_replace_rtx_group	PROTO((rtx, rtx, rtx));
-extern int validate_replace_src		PROTO((rtx, rtx, rtx));
+extern void init_recog			PARAMS ((void));
+extern void init_recog_no_volatile	PARAMS ((void));
+extern int recog_memoized		PARAMS ((rtx));
+extern int check_asm_operands		PARAMS ((rtx));
+extern int asm_operand_ok		PARAMS ((rtx, const char *));
+extern int validate_change		PARAMS ((rtx, rtx *, rtx, int));
+extern int apply_change_group		PARAMS ((void));
+extern int num_validated_changes	PARAMS ((void));
+extern void cancel_changes		PARAMS ((int));
+extern int constrain_operands		PARAMS ((int));
+extern int memory_address_p		PARAMS ((enum machine_mode, rtx));
+extern int strict_memory_address_p	PARAMS ((enum machine_mode, rtx));
+extern int validate_replace_rtx		PARAMS ((rtx, rtx, rtx));
+extern void validate_replace_rtx_group	PARAMS ((rtx, rtx, rtx));
+extern int validate_replace_src		PARAMS ((rtx, rtx, rtx));
 #ifdef HAVE_cc0
-extern int next_insn_tests_no_inequality PROTO ((rtx));
+extern int next_insn_tests_no_inequality PARAMS ((rtx));
 #endif
-extern int reg_fits_class_p		PROTO((rtx, enum reg_class, int,
+extern int reg_fits_class_p		PARAMS ((rtx, enum reg_class, int,
 					       enum machine_mode));
-extern rtx *find_single_use		PROTO((rtx, rtx, rtx *));
+extern rtx *find_single_use		PARAMS ((rtx, rtx, rtx *));
 
-extern int general_operand		PROTO((rtx, enum machine_mode));
-extern int address_operand		PROTO((rtx, enum machine_mode));
-extern int register_operand		PROTO((rtx, enum machine_mode));
-extern int pmode_register_operand	PROTO((rtx, enum machine_mode));
-extern int scratch_operand		PROTO((rtx, enum machine_mode));
-extern int immediate_operand		PROTO((rtx, enum machine_mode));
-extern int const_int_operand		PROTO((rtx, enum machine_mode));
-extern int const_double_operand		PROTO((rtx, enum machine_mode));
-extern int nonimmediate_operand		PROTO((rtx, enum machine_mode));
-extern int nonmemory_operand		PROTO((rtx, enum machine_mode));
-extern int push_operand			PROTO((rtx, enum machine_mode));
-extern int pop_operand			PROTO((rtx, enum machine_mode));
-extern int memory_operand		PROTO((rtx, enum machine_mode));
-extern int indirect_operand		PROTO((rtx, enum machine_mode));
-extern int mode_independent_operand	PROTO((rtx, enum machine_mode));
-extern int comparison_operator		PROTO((rtx, enum machine_mode));
-
-extern int offsettable_memref_p		PROTO((rtx));
-extern int offsettable_nonstrict_memref_p	PROTO((rtx));
-extern int offsettable_address_p	PROTO((int, enum machine_mode, rtx));
-extern int mode_dependent_address_p	PROTO((rtx));
-
-extern int recog			PROTO((rtx, rtx, int *));
-extern void add_clobbers		PROTO((rtx, int));
-extern void insn_extract		PROTO((rtx));
-extern void extract_insn		PROTO((rtx));
-extern void preprocess_constraints	PROTO((void));
-extern rtx recog_next_insn		PROTO((rtx, int));
-extern void peephole2_optimize		PROTO((FILE *));
-extern rtx peephole2_insns		PROTO((rtx, rtx, rtx *));
+extern int general_operand		PARAMS ((rtx, enum machine_mode));
+extern int address_operand		PARAMS ((rtx, enum machine_mode));
+extern int register_operand		PARAMS ((rtx, enum machine_mode));
+extern int pmode_register_operand	PARAMS ((rtx, enum machine_mode));
+extern int scratch_operand		PARAMS ((rtx, enum machine_mode));
+extern int immediate_operand		PARAMS ((rtx, enum machine_mode));
+extern int const_int_operand		PARAMS ((rtx, enum machine_mode));
+extern int const_double_operand		PARAMS ((rtx, enum machine_mode));
+extern int nonimmediate_operand		PARAMS ((rtx, enum machine_mode));
+extern int nonmemory_operand		PARAMS ((rtx, enum machine_mode));
+extern int push_operand			PARAMS ((rtx, enum machine_mode));
+extern int pop_operand			PARAMS ((rtx, enum machine_mode));
+extern int memory_operand		PARAMS ((rtx, enum machine_mode));
+extern int indirect_operand		PARAMS ((rtx, enum machine_mode));
+extern int mode_independent_operand	PARAMS ((rtx, enum machine_mode));
+extern int comparison_operator		PARAMS ((rtx, enum machine_mode));
+
+extern int offsettable_memref_p		PARAMS ((rtx));
+extern int offsettable_nonstrict_memref_p	PARAMS ((rtx));
+extern int offsettable_address_p	PARAMS ((int, enum machine_mode, rtx));
+extern int mode_dependent_address_p	PARAMS ((rtx));
+
+extern int recog			PARAMS ((rtx, rtx, int *));
+extern void add_clobbers		PARAMS ((rtx, int));
+extern void insn_extract		PARAMS ((rtx));
+extern void extract_insn		PARAMS ((rtx));
+extern void preprocess_constraints	PARAMS ((void));
+extern rtx recog_next_insn		PARAMS ((rtx, int));
+extern void peephole2_optimize		PARAMS ((FILE *));
+extern rtx peephole2_insns		PARAMS ((rtx, rtx, rtx *));
 
 /* Nonzero means volatile operands are recognized.  */
 extern int volatile_ok;
@@ -192,10 +192,10 @@ extern struct operand_alternative recog_
 /* A table defined in insn-output.c that give information about
    each insn-code value.  */
 
-typedef int (*insn_operand_predicate_fn) PROTO ((rtx, enum machine_mode));
-typedef const char * (*insn_output_fn) PROTO ((rtx *, rtx));
+typedef int (*insn_operand_predicate_fn) PARAMS ((rtx, enum machine_mode));
+typedef const char * (*insn_output_fn) PARAMS ((rtx *, rtx));
 #ifndef NO_MD_PROTOTYPES
-typedef rtx (*insn_gen_fn) PROTO ((rtx, ...));
+typedef rtx (*insn_gen_fn) PARAMS ((rtx, ...));
 #else
 typedef rtx (*insn_gen_fn) ();
 #endif
Index: regclass.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/regclass.c,v
retrieving revision 1.91
diff -u -p -r1.91 regclass.c
--- regclass.c	2000/01/13 00:17:32	1.91
+++ regclass.c	2000/01/17 15:33:29
@@ -44,8 +44,8 @@ Boston, MA 02111-1307, USA.  */
 #define REGISTER_MOVE_COST(x, y) 2
 #endif
 
-static void init_reg_sets_1	PROTO((void));
-static void init_reg_modes	PROTO((void));
+static void init_reg_sets_1	PARAMS ((void));
+static void init_reg_modes	PARAMS ((void));
 
 /* If we have auto-increment or auto-decrement and we can have secondary
    reloads, we are not allowed to use classes requiring secondary
@@ -717,19 +717,19 @@ static struct reg_pref *reg_pref_buffer;
 
 static int loop_cost;
 
-static rtx scan_one_insn	PROTO((rtx, int));
-static void record_operand_costs PROTO((rtx, struct costs *, struct reg_pref *));
-static void dump_regclass	PROTO((FILE *));
-static void record_reg_classes	PROTO((int, int, rtx *, enum machine_mode *,
+static rtx scan_one_insn	PARAMS ((rtx, int));
+static void record_operand_costs PARAMS ((rtx, struct costs *, struct reg_pref *));
+static void dump_regclass	PARAMS ((FILE *));
+static void record_reg_classes	PARAMS ((int, int, rtx *, enum machine_mode *,
 				       char *, const char **, rtx,
 				       struct costs *, struct reg_pref *));
-static int copy_cost		PROTO((rtx, enum machine_mode, 
+static int copy_cost		PARAMS ((rtx, enum machine_mode, 
 				       enum reg_class, int));
-static void record_address_regs	PROTO((rtx, enum reg_class, int));
+static void record_address_regs	PARAMS ((rtx, enum reg_class, int));
 #ifdef FORBIDDEN_INC_DEC_CLASSES
-static int auto_inc_dec_reg_p	PROTO((rtx, enum machine_mode));
+static int auto_inc_dec_reg_p	PARAMS ((rtx, enum machine_mode));
 #endif
-static void reg_scan_mark_refs	PROTO((rtx, rtx, int, int));
+static void reg_scan_mark_refs	PARAMS ((rtx, rtx, int, int));
 
 /* Return the reg_class in which pseudo reg number REGNO is best allocated.
    This function is sometimes called before the info has been computed.
Index: regmove.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/regmove.c,v
retrieving revision 1.78
diff -u -p -r1.78 regmove.c
--- regmove.c	2000/01/04 16:29:40	1.78
+++ regmove.c	2000/01/17 15:33:29
@@ -41,11 +41,11 @@ Boston, MA 02111-1307, USA.  */
 #include "basic-block.h"
 #include "toplev.h"
 
-static int optimize_reg_copy_1	PROTO((rtx, rtx, rtx));
-static void optimize_reg_copy_2	PROTO((rtx, rtx, rtx));
-static void optimize_reg_copy_3	PROTO((rtx, rtx, rtx));
-static rtx gen_add3_insn	PROTO((rtx, rtx, rtx));
-static void copy_src_to_dest	PROTO((rtx, rtx, rtx, int));
+static int optimize_reg_copy_1	PARAMS ((rtx, rtx, rtx));
+static void optimize_reg_copy_2	PARAMS ((rtx, rtx, rtx));
+static void optimize_reg_copy_3	PARAMS ((rtx, rtx, rtx));
+static rtx gen_add3_insn	PARAMS ((rtx, rtx, rtx));
+static void copy_src_to_dest	PARAMS ((rtx, rtx, rtx, int));
 static int *regmove_bb_head;
 
 struct match {
@@ -55,19 +55,19 @@ struct match {
   int early_clobber[MAX_RECOG_OPERANDS];
 };
 
-static rtx discover_flags_reg PROTO((void));
-static void mark_flags_life_zones PROTO((rtx));
-static void flags_set_1 PROTO((rtx, rtx, void *));
+static rtx discover_flags_reg PARAMS ((void));
+static void mark_flags_life_zones PARAMS ((rtx));
+static void flags_set_1 PARAMS ((rtx, rtx, void *));
 
-static int try_auto_increment PROTO((rtx, rtx, rtx, rtx, HOST_WIDE_INT, int));
-static int find_matches PROTO((rtx, struct match *));
-static int fixup_match_1 PROTO((rtx, rtx, rtx, rtx, rtx, int, int, int, FILE *))
+static int try_auto_increment PARAMS ((rtx, rtx, rtx, rtx, HOST_WIDE_INT, int));
+static int find_matches PARAMS ((rtx, struct match *));
+static int fixup_match_1 PARAMS ((rtx, rtx, rtx, rtx, rtx, int, int, int, FILE *))
 ;
-static int reg_is_remote_constant_p PROTO((rtx, rtx, rtx));
-static int stable_and_no_regs_but_for_p PROTO((rtx, rtx, rtx));
-static int regclass_compatible_p PROTO((int, int));
-static int replacement_quality PROTO((rtx));
-static int fixup_match_2 PROTO((rtx, rtx, rtx, rtx, FILE *));
+static int reg_is_remote_constant_p PARAMS ((rtx, rtx, rtx));
+static int stable_and_no_regs_but_for_p PARAMS ((rtx, rtx, rtx));
+static int regclass_compatible_p PARAMS ((int, int));
+static int replacement_quality PARAMS ((rtx));
+static int fixup_match_2 PARAMS ((rtx, rtx, rtx, rtx, FILE *));
 
 /* Return non-zero if registers with CLASS1 and CLASS2 can be merged without
    causing too much register allocation problems.  */
Index: regs.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/regs.h,v
retrieving revision 1.12
diff -u -p -r1.12 regs.h
--- regs.h	1999/12/18 21:33:23	1.12
+++ regs.h	2000/01/17 15:33:29
@@ -202,4 +202,4 @@ extern int caller_save_needed;
 #endif
 
 /* Allocate reg_n_info tables */
-extern void allocate_reg_info PROTO((size_t, int, int));
+extern void allocate_reg_info PARAMS ((size_t, int, int));


More information about the Gcc-patches mailing list