From 96c822324894d7606144012d651b76d63ea465ee Mon Sep 17 00:00:00 2001 From: Richard Kenner Date: Mon, 29 Mar 1993 06:28:45 -0500 Subject: [PATCH] Add missing declarations for external functions in reload.c, reload1.c, and caller-save.c. (reload_strict_low, reload_needed_for_multiple, reload_needed_for): Deleted. (reload_opnum): New array. (enum reload_type): Renamed from reload_when_needed and expanded to include more reload types. (reload_n_operands): New variable. From-SVN: r3912 --- gcc/reload.h | 165 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 144 insertions(+), 21 deletions(-) diff --git a/gcc/reload.h b/gcc/reload.h index 4aaec8bb0b2..4369d23db3d 100644 --- a/gcc/reload.h +++ b/gcc/reload.h @@ -1,5 +1,5 @@ /* Communication between reload.c and reload1.c. - Copyright (C) 1987, 1991 Free Software Foundation, Inc. + Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU CC. @@ -27,6 +27,14 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #endif #endif +#ifndef STDIO_PROTO +#ifdef BUFSIZ +#define STDIO_PROTO(ARGS) PROTO(ARGS) +#else +#define STDIO_PROTO(ARGS) () +#endif +#endif + /* If secondary reloads are the same for inputs and outputs, define those macros here. */ @@ -53,11 +61,9 @@ extern rtx reload_in_reg[MAX_RELOADS]; extern enum reg_class reload_reg_class[MAX_RELOADS]; extern enum machine_mode reload_inmode[MAX_RELOADS]; extern enum machine_mode reload_outmode[MAX_RELOADS]; -extern char reload_strict_low[MAX_RELOADS]; extern char reload_optional[MAX_RELOADS]; extern int reload_inc[MAX_RELOADS]; -extern int reload_needed_for_multiple[MAX_RELOADS]; -extern rtx reload_needed_for[MAX_RELOADS]; +extern int reload_opnum[MAX_RELOADS]; extern int reload_secondary_reload[MAX_RELOADS]; extern int reload_secondary_p[MAX_RELOADS]; #ifdef MAX_INSN_CODE @@ -67,22 +73,34 @@ extern int n_reloads; extern rtx reload_reg_rtx[MAX_RELOADS]; -enum reload_when_needed +/* Encode the usage of a reload. The following codes are supported: + + RELOAD_FOR_INPUT reload of an input operand + RELOAD_FOR_OUTPUT likewise, for output + RELOAD_FOR_INSN a reload that must not conflict with anything + used in the insn, but may conflict with + something used before or after the insn + RELOAD_FOR_INPUT_ADDRESS reload for parts of the address of an object + that is an input reload + RELOAD_FOR_OUTPUT_ADDRESS likewise, for output reload + RELOAD_FOR_OPERAND_ADDRESS reload for the address of a non-reloaded + operand; these don't conflict with + any other addresses. + RELOAD_OTHER none of the above, usually multiple uses + RELOAD_FOR_OTHER_ADDRESS reload for part of the address of an input + that is marked RELOAD_OTHER. + + This used to be "enum reload_when_needed" but some debuggers have trouble + with an enum tag and variable of the same name. */ + +enum reload_type { - RELOAD_FOR_INPUT_RELOAD_ADDRESS, - RELOAD_FOR_OUTPUT_RELOAD_ADDRESS, - RELOAD_FOR_OPERAND_ADDRESS, - /* The following two are not fully implemented. - They are used in emitting insns, but they aren't distinguished from - RELOAD_OTHER when computing the number of spills. What they accomplish - is to avoid precluding inheritance of already loaded values - for input reloads when there are also output reloads. */ - RELOAD_FOR_INPUT, - RELOAD_FOR_OUTPUT, - RELOAD_OTHER + RELOAD_FOR_INPUT, RELOAD_FOR_OUTPUT, RELOAD_FOR_INSN, + RELOAD_FOR_INPUT_ADDRESS, RELOAD_FOR_OUTPUT_ADDRESS, + RELOAD_FOR_OPERAND_ADDRESS, RELOAD_OTHER, RELOAD_FOR_OTHER_ADDRESS }; -extern enum reload_when_needed reload_when_needed[MAX_RELOADS]; +extern enum reload_type reload_when_needed[MAX_RELOADS]; extern rtx *reg_equiv_constant; extern rtx *reg_equiv_memory_loc; @@ -94,6 +112,9 @@ extern rtx *reg_equiv_mem; extern int n_earlyclobbers; extern rtx reload_earlyclobbers[MAX_RECOG_OPERANDS]; +/* Save the number of operands. */ +extern int reload_n_operands; + /* First uid used by insns created by reload in this function. Used in find_equiv_reg. */ extern int reload_first_uid; @@ -115,10 +136,112 @@ extern enum insn_code reload_in_optab[]; extern enum insn_code reload_out_optab[]; #endif -extern void init_reload PROTO((void)); +/* Functions from reload.c: */ + +/* Return a memory location that will be used to copy X in mode MODE. + If we haven't already made a location for this mode in this insn, + call find_reloads_address on the location being returned. */ +extern rtx get_secondary_mem PROTO((rtx, enum machine_mode, + int, enum reload_type)); + +/* Clear any secondary memory locations we've made. */ +extern void clear_secondary_mem PROTO((void)); + +/* Transfer all replacements that used to be in reload FROM to be in + reload TO. */ +extern void transfer_replacements PROTO((int, int)); + +/* Return 1 if ADDR is a valid memory address for mode MODE, + and check that each pseudo reg has the proper kind of + hard reg. */ +extern int strict_memory_address_p PROTO((enum machine_mode, rtx)); + +/* Like rtx_equal_p except that it allows a REG and a SUBREG to match + if they are the same hard reg, and has special hacks for + autoincrement and autodecrement. */ +extern int operands_match_p PROTO((rtx, rtx)); + +/* Return the number of times character C occurs in string S. */ +extern int n_occurrences PROTO((int, char *)); + +/* Return 1 if altering OP will not modify the value of CLOBBER. */ +extern int safe_from_earlyclobber PROTO((rtx, rtx)); + +/* Search the body of INSN for values that need reloading and record them + with push_reload. REPLACE nonzero means record also where the values occur + so that subst_reloads can be used. extern void find_reloads PROTO((rtx, int, int, int, short *)); + +/* Compute the sum of X and Y, making canonicalizations assumed in an + address, namely: sum constant integers, surround the sum of two + constants with a CONST, put the constant as the second operand, and + group the constant on the outermost sum. */ +extern rtx form_sum PROTO((rtx, rtx)); + +/* Substitute into the current INSN the registers into which we have reloaded + the things that need reloading. */ extern void subst_reloads PROTO((void)); -extern rtx get_secondary_mem PROTO((rtx, enum machine_mode)); -extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx)); -extern rtx gen_input_reload PROTO((rtx, rtx, rtx)); + +/* Make a copy of any replacements being done into X and move those copies + to locations in Y, a copy of X. We only look at the highest level of + the RTL. */ +extern void copy_replacements PROTO((rtx, rtx)); + +/* If LOC was scheduled to be replaced by something, return the replacement. + Otherwise, return *LOC. */ extern rtx find_replacement PROTO((rtx *)); + +/* Return nonzero if register in range [REGNO, ENDREGNO) + appears either explicitly or implicitly in X + other than being stored into. */ +extern int refers_to_regno_for_reload_p PROTO((int, int, rtx, rtx *)); + +/* Nonzero if modifying X will affect IN. */ +extern int reg_overlap_mentioned_for_reload_p PROTO((rtx, rtx)); + +/* Return nonzero if anything in X contains a MEM. Look also for pseudo + registers. */ +extern int refers_to_mem_for_reload_p PROTO((rtx)); + +/* Check the insns before INSN to see if there is a suitable register + containing the same value as GOAL. */ +extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *, + int, enum machine_mode)); + +/* Return 1 if register REGNO is the subject of a clobber in insn INSN. */ +extern int regno_clobbered_p PROTO((int, rtx)); + + +/* Functions in reload1.c: */ + +/* Initialize the reload pass once per compilation. */ +extern void init_reload PROTO((void)); + +/* The reload pass itself. */ +extern int reload STDIO_PROTO((rtx, int, FILE *)); + +/* Mark the slots in regs_ever_live for the hard regs + used by pseudo-reg number REGNO. */ +extern void mark_home_live PROTO((int)); + +/* Scan X and replace any eliminable registers (such as fp) with a + replacement (such as sp), plus an offset. */ +extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx)); + +/* Emit code to perform an input reload of IN to RELOADREG. IN is from + operand OPNUM with reload type TYPE. */ +extern rtx gen_input_reload PROTO((rtx, rtx, int, enum reload_type)); + +/* Functions in caller-save.c: */ + +/* Initialize for caller-save. */ +extern void init_caller_save PROTO((void)); + +/* Initialize save areas by showing that we haven't allocated any yet. */ +extern void init_save_areas PROTO((void)); + +/* Allocate save areas for any hard registers that might need saving. */ +extern int setup_save_areas PROTO((int *)); + +/* Find the places where hard regs are live across calls and save them. */ +extern void save_call_clobbered_regs PROTO((enum machine_mode)); -- 2.30.2