This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Unifying asm and normal insn handling
- To: Jeffrey A Law <law at cygnus dot com>
- Subject: Re: Unifying asm and normal insn handling
- From: Bernd Schmidt <crux at pool dot informatik dot rwth-aachen dot de>
- Date: Fri, 16 Oct 1998 13:55:57 +0200 (MET DST)
- cc: egcs-patches at cygnus dot com
>
> > + /* Just return "no reloads" if insn has no operands with constraints. */
> > + if (noperands == 0 || n_alternatives == 0)
> > + return;
> I'm not sure this is safe, believe it or not.
I re-checked the existing code now. My memory wasn't completely correct;
this check is already done for normal insns in find_reloads, but it is
not done for asm statements (for the very simple reason that no asm
statement will ever result in a value of n_alternative < 1). Thus, I think
that my patch did not modify the functionality in find_reloads. Below is
an updated version with the necessary comments added, but no changes in the
part that affect find_reloads. If the test is incorrect, we should fix it
in a separate change.
BTW, the documentation says that all current machine descriptions use
register classes. Is the [! REGISTER_CLASSES] code still maintained?
Bernd
* Makefile.in (insn-extract.o): Fix dependencies.
* genextract.c (main): Generate includes for insn-config.h and
recog.h.
Delete generation of declarations which are now in recog.h.
* genrecog.c (main): Delete generation of definitions which are
now in recog.c.
* local-alloc.c (block_alloc): Use extract_insn and the variables
it sets up instead of looking up values by insn_code.
* recog.c (recog_operand, recog_operand_loc, recog_dup_loc,
recog_dup_num): Define here instead of generating the definition in
genrecog.c.
(recog_n_operands, recog_n_dups, recog_n_alternatives,
recog_operand_mode, recog_constraints, recog_operand_address_p):
New variables.
(extract_insn): New function.
* recog.h (extract_insn): Declare function.
(which_alternative, recog_n_operands, recog_n_dups,
recog_n_alternatives, recog_operand_mode, recog_constraints,
recog_operand_address_p): Declare variables.
* regclass.c (n_occurrences): New static function.
* reload.c (n_occurrences): Delete function.
(find_reloads): Use extract_insn.
* reload.h (n_occurrences): Delete declaration.
Index: Makefile.in
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/Makefile.in,v
retrieving revision 1.1.1.65
diff -u -p -r1.1.1.65 Makefile.in
--- Makefile.in 1998/10/15 13:28:54 1.1.1.65
+++ Makefile.in 1998/10/15 18:40:19
@@ -1627,7 +1627,8 @@ s-opinit : $(md_file) genopinit $(srcdir
$(srcdir)/move-if-change tmp-opinit.c insn-opinit.c
touch s-opinit
-insn-extract.o : insn-extract.c $(CONFIG_H) $(RTL_H) system.h toplev.h
+insn-extract.o : insn-extract.c $(CONFIG_H) $(RTL_H) system.h toplev.h \
+ insn-config.h recog.h
$(CC) $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) -c insn-extract.c
insn-extract.c: s-extract ; @true
Index: genextract.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/genextract.c,v
retrieving revision 1.1.1.12
diff -u -p -r1.1.1.12 genextract.c
--- genextract.c 1998/10/15 13:29:27 1.1.1.12
+++ genextract.c 1998/10/15 18:40:19
@@ -460,16 +460,13 @@ from the machine description file `md'.
printf ("#include \"config.h\"\n");
printf ("#include \"system.h\"\n");
printf ("#include \"rtl.h\"\n");
+ printf ("#include \"insn-config.h\"\n");
+ printf ("#include \"recog.h\"\n");
printf ("#include \"toplev.h\"\n\n");
/* This variable exists only so it can be the "location"
of any missing operand whose numbers are skipped by a given pattern. */
printf ("static rtx junk ATTRIBUTE_UNUSED;\n");
-
- printf ("extern rtx recog_operand[];\n");
- printf ("extern rtx *recog_operand_loc[];\n");
- printf ("extern rtx *recog_dup_loc[];\n");
- printf ("extern char recog_dup_num[];\n");
printf ("void\ninsn_extract (insn)\n");
printf (" rtx insn;\n");
Index: genrecog.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/genrecog.c,v
retrieving revision 1.1.1.17
diff -u -p -r1.1.1.17 genrecog.c
--- genrecog.c 1998/10/15 16:58:42 1.1.1.17
+++ genrecog.c 1998/10/15 18:40:19
@@ -1802,10 +1802,6 @@ from the machine description file `md'.
printf ("*/\n\n");
- printf ("rtx recog_operand[MAX_RECOG_OPERANDS];\n\n");
- printf ("rtx *recog_operand_loc[MAX_RECOG_OPERANDS];\n\n");
- printf ("rtx *recog_dup_loc[MAX_DUP_OPERANDS];\n\n");
- printf ("char recog_dup_num[MAX_DUP_OPERANDS];\n\n");
printf ("#define operands recog_operand\n\n");
next_subroutine_number = 0;
Index: local-alloc.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/local-alloc.c,v
retrieving revision 1.1.1.23
diff -u -p -r1.1.1.23 local-alloc.c
--- local-alloc.c 1998/10/15 13:29:33 1.1.1.23
+++ local-alloc.c 1998/10/15 18:40:19
@@ -955,13 +955,11 @@ block_alloc (b)
register rtx r0, r1;
int combined_regno = -1;
int i;
- int insn_code_number = recog_memoized (insn);
this_insn_number = insn_number;
this_insn = insn;
- if (insn_code_number >= 0)
- insn_extract (insn);
+ extract_insn (insn);
which_alternative = -1;
/* Is this insn suitable for tying two registers?
@@ -982,11 +980,11 @@ block_alloc (b)
If tying is done, WIN is set nonzero. */
- if (insn_code_number >= 0
+ if (1
#ifdef REGISTER_CONSTRAINTS
- && insn_n_operands[insn_code_number] > 1
- && insn_operand_constraint[insn_code_number][0][0] == '='
- && insn_operand_constraint[insn_code_number][0][1] != '&'
+ && recog_n_operands > 1
+ && recog_constraints[0][0] == '='
+ && recog_constraints[0][1] != '&'
#else
&& GET_CODE (PATTERN (insn)) == SET
&& rtx_equal_p (SET_DEST (PATTERN (insn)), recog_operand[0])
@@ -1000,19 +998,19 @@ block_alloc (b)
operand 0. */
int n_matching_alts = 0;
- for (i = 1; i < insn_n_operands[insn_code_number]; i++)
+ for (i = 1; i < recog_n_operands; i++)
{
- char *p = insn_operand_constraint[insn_code_number][i];
+ char *p = recog_constraints[i];
int this_match = (requires_inout (p));
n_matching_alts += this_match;
- if (this_match == insn_n_alternatives[insn_code_number])
+ if (this_match == recog_n_alternatives)
must_match_0 = i;
}
#endif
r0 = recog_operand[0];
- for (i = 1; i < insn_n_operands[insn_code_number]; i++)
+ for (i = 1; i < recog_n_operands; i++)
{
#ifdef REGISTER_CONSTRAINTS
/* Skip this operand if we found an operand that
@@ -1021,9 +1019,9 @@ block_alloc (b)
if (must_match_0 >= 0 && i != must_match_0
&& ! (i == must_match_0 + 1
- && insn_operand_constraint[insn_code_number][i-1][0] == '%')
+ && recog_constraints[i-1][0] == '%')
&& ! (i == must_match_0 - 1
- && insn_operand_constraint[insn_code_number][i][0] == '%'))
+ && recog_constraints[i][0] == '%'))
continue;
/* Likewise if each alternative has some operand that
@@ -1031,9 +1029,8 @@ block_alloc (b)
operand that doesn't list operand 0 since we know that
the operand always conflicts with operand 0. We
ignore commutatity in this case to keep things simple. */
- if (n_matching_alts == insn_n_alternatives[insn_code_number]
- && (0 == requires_inout
- (insn_operand_constraint[insn_code_number][i])))
+ if (n_matching_alts == recog_n_alternatives
+ && 0 == requires_inout (recog_constraints[i]))
continue;
#endif
@@ -1044,9 +1041,9 @@ block_alloc (b)
of them. */
if (
#ifdef REGISTER_CONSTRAINTS
- insn_operand_constraint[insn_code_number][i][0] == 'p'
+ recog_constraints[i][0] == 'p'
#else
- insn_operand_address_p[insn_code_number][i]
+ recog_operand_address_p[i]
#endif
)
while (GET_CODE (r1) == PLUS || GET_CODE (r1) == MULT)
Index: recog.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/recog.c,v
retrieving revision 1.1.1.15
diff -u -p -r1.1.1.15 recog.c
--- recog.c 1998/10/15 13:29:42 1.1.1.15
+++ recog.c 1998/10/15 18:44:55
@@ -54,6 +54,45 @@ static rtx *find_constant_term_loc PROTO
int volatile_ok;
+/* The following vectors hold the results from insn_extract. */
+
+/* Indexed by N, gives value of operand N. */
+rtx recog_operand[MAX_RECOG_OPERANDS];
+
+/* Indexed by N, gives location where operand N was found. */
+rtx *recog_operand_loc[MAX_RECOG_OPERANDS];
+
+/* Indexed by N, gives location where the Nth duplicate-appearance of
+ an operand was found. This is something that matched MATCH_DUP. */
+rtx *recog_dup_loc[MAX_RECOG_OPERANDS];
+
+/* Indexed by N, gives the operand number that was duplicated in the
+ Nth duplicate-appearance of an operand. */
+char recog_dup_num[MAX_RECOG_OPERANDS];
+
+
+/* The next variables are set up by extract_insn. */
+
+/* The number of operands of the insn. */
+int recog_n_operands;
+
+/* The number of MATCH_DUPs in the insn. */
+int recog_n_dups;
+
+/* The number of alternatives in the constraints for the insn. */
+int recog_n_alternatives;
+
+/* Indexed by N, gives the mode of operand N. */
+enum machine_mode recog_operand_mode[MAX_RECOG_OPERANDS];
+
+/* Indexed by N, gives the constraint string for operand N. */
+char *recog_constraints[MAX_RECOG_OPERANDS];
+
+#ifndef REGISTER_CONSTRAINTS
+/* Indexed by N, nonzero if operand N should be an address. */
+char recog_operand_address_p[MAX_RECOG_OPERANDS];
+#endif
+
/* On return from `constrain_operands', indicate which alternative
was satisfied. */
@@ -1656,6 +1695,90 @@ adj_offsettable_operand (op, offset)
abort ();
}
+/* Analyze INSN and compute the variables recog_n_operands, recog_n_dups,
+ recog_n_alternatives, recog_operand, recog_operand_loc, recog_constraints,
+ recog_operand_mode, recog_dup_loc and recog_dup_num.
+ If REGISTER_CONSTRAINTS is not defined, also compute
+ recog_operand_address_p. */
+void
+extract_insn (insn)
+ rtx insn;
+{
+ int i;
+ int icode;
+ int noperands;
+ rtx body = PATTERN (insn);
+
+ recog_n_operands = 0;
+ recog_n_alternatives = 0;
+ recog_n_dups = 0;
+
+ switch (GET_CODE (body))
+ {
+ case USE:
+ case CLOBBER:
+ case ASM_INPUT:
+ case ADDR_VEC:
+ case ADDR_DIFF_VEC:
+ return;
+
+ case SET:
+ case PARALLEL:
+ case ASM_OPERANDS:
+ recog_n_operands = noperands = asm_noperands (body);
+ if (noperands >= 0)
+ {
+ char *p;
+ /* This insn is an `asm' with operands. */
+
+ /* expand_asm_operands makes sure there aren't too many operands. */
+ if (noperands > MAX_RECOG_OPERANDS)
+ abort ();
+
+ /* Now get the operand values and constraints out of the insn. */
+ decode_asm_operands (body, recog_operand, recog_operand_loc,
+ recog_constraints, recog_operand_mode);
+ if (noperands > 0)
+ {
+ char *p = recog_constraints[0];
+ recog_n_alternatives = 1;
+ while (*p)
+ recog_n_alternatives += (*p++ == ',');
+ }
+#ifndef REGISTER_CONSTRAINTS
+ bzero (recog_operand_address_p, sizeof recog_operand_address_p);
+#endif
+ break;
+ }
+
+ /* FALLTHROUGH */
+
+ default:
+ /* Ordinary insn: recognize it, get the operands via insn_extract
+ and get the constraints. */
+
+ icode = recog_memoized (insn);
+ if (icode < 0)
+ fatal_insn_not_found (insn);
+
+ recog_n_operands = noperands = insn_n_operands[icode];
+ recog_n_alternatives = insn_n_alternatives[icode];
+ recog_n_dups = insn_n_dups[icode];
+
+ insn_extract (insn);
+
+ for (i = 0; i < noperands; i++)
+ {
+#ifdef REGISTER_CONSTRAINTS
+ recog_constraints[i] = insn_operand_constraint[icode][i];
+#else
+ recog_operand_address_p[i] = insn_operand_address_p[icode][i];
+#endif
+ recog_operand_mode[i] = insn_operand_mode[icode][i];
+ }
+ }
+}
+
#ifdef REGISTER_CONSTRAINTS
/* Check the operands of an insn (found in recog_operands)
Index: recog.h
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/recog.h,v
retrieving revision 1.1.1.4
diff -u -p -r1.1.1.4 recog.h
--- recog.h 1998/09/07 20:54:38 1.1.1.4
+++ recog.h 1998/10/15 18:40:19
@@ -61,10 +61,15 @@ extern int mode_dependent_address_p PROT
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));
/* Nonzero means volatile operands are recognized. */
extern int volatile_ok;
+/* Set by constrain_operands to the number of the alternative that
+ matched. */
+extern int which_alternative;
+
/* The following vectors hold the results from insn_extract. */
/* Indexed by N, gives value of operand N. */
@@ -80,6 +85,28 @@ extern rtx *recog_dup_loc[];
/* Indexed by N, gives the operand number that was duplicated in the
Nth duplicate-appearance of an operand. */
extern char recog_dup_num[];
+
+/* The next variables are set up by extract_insn. */
+
+/* The number of operands of the insn. */
+extern int recog_n_operands;
+
+/* The number of MATCH_DUPs in the insn. */
+extern int recog_n_dups;
+
+/* The number of alternatives in the constraints for the insn. */
+extern int recog_n_alternatives;
+
+/* Indexed by N, gives the mode of operand N. */
+extern enum machine_mode recog_operand_mode[];
+
+/* Indexed by N, gives the constraint string for operand N. */
+extern char *recog_constraints[];
+
+#ifndef REGISTER_CONSTRAINTS
+/* Indexed by N, nonzero if operand N should be an address. */
+extern char recog_operand_address_p[];
+#endif
/* Access the output function for CODE. */
Index: regclass.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/regclass.c,v
retrieving revision 1.1.1.24
diff -u -p -r1.1.1.24 regclass.c
--- regclass.c 1998/10/15 13:29:42 1.1.1.24
+++ regclass.c 1998/10/15 18:40:19
@@ -665,6 +665,7 @@ static int loop_depth;
static int loop_cost;
+static int n_occurrences PROTO((int, char *));
static void record_reg_classes PROTO((int, int, rtx *, enum machine_mode *,
char **, rtx));
static int copy_cost PROTO((rtx, enum machine_mode,
@@ -707,6 +708,18 @@ regclass_init ()
prefclass = 0;
}
+/* Return the number of times character C occurs in string S. */
+static int
+n_occurrences (c, s)
+ int c;
+ char *s;
+{
+ int n = 0;
+ while (*s)
+ n += (*s++ == c);
+ return n;
+}
+
/* This is a pass of the compiler that scans all instructions
and calculates the preferred class for each pseudo-register.
This information can be accessed later by calling `reg_preferred_class'.
Index: reload.c
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/reload.c,v
retrieving revision 1.1.1.40
diff -u -p -r1.1.1.40 reload.c
--- reload.c 1998/10/15 13:29:43 1.1.1.40
+++ reload.c 1998/10/15 18:40:19
@@ -2080,19 +2080,6 @@ operands_match_p (x, y)
return 1 + success_2;
}
-/* Return the number of times character C occurs in string S. */
-
-int
-n_occurrences (c, s)
- int c;
- char *s;
-{
- int n = 0;
- while (*s)
- n += (*s++ == c);
- return n;
-}
-
/* Describe the range of registers or memory referenced by X.
If X is a register, set REG_FLAG and put the first register
number into START and the last plus one into END.
@@ -2362,7 +2349,6 @@ find_reloads (insn, replace, ind_levels,
static int last_output_reload_regno = -1;
this_insn = insn;
- this_insn_is_asm = 0; /* Tentative. */
n_reloads = 0;
n_replacements = 0;
n_memlocs = 0;
@@ -2390,86 +2376,37 @@ find_reloads (insn, replace, ind_levels,
bzero ((char *) secondary_memlocs_elim, sizeof secondary_memlocs_elim);
#endif
-
- /* Find what kind of insn this is. NOPERANDS gets number of operands.
- Make OPERANDS point to a vector of operand values.
- Make OPERAND_LOCS point to a vector of pointers to
- where the operands were found.
- Fill CONSTRAINTS and CONSTRAINTS1 with pointers to the
- constraint-strings for this insn.
- Return if the insn needs no reload processing. */
- switch (GET_CODE (body))
- {
- case USE:
- case CLOBBER:
- case ASM_INPUT:
- case ADDR_VEC:
- case ADDR_DIFF_VEC:
- return;
-
- case SET:
- /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
- is cheap to move between them. If it is not, there may not be an insn
- to do the copy, so we may need a reload. */
- if (GET_CODE (SET_DEST (body)) == REG
- && REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
- && GET_CODE (SET_SRC (body)) == REG
- && REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
- && REGISTER_MOVE_COST (REGNO_REG_CLASS (REGNO (SET_SRC (body))),
- REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
- return;
- case PARALLEL:
- case ASM_OPERANDS:
- reload_n_operands = noperands = asm_noperands (body);
- if (noperands >= 0)
- {
- /* This insn is an `asm' with operands. */
-
- insn_code_number = -1;
- this_insn_is_asm = 1;
+ /* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
+ is cheap to move between them. If it is not, there may not be an insn
+ to do the copy, so we may need a reload. */
+ if (GET_CODE (body) == SET
+ && GET_CODE (SET_DEST (body)) == REG
+ && REGNO (SET_DEST (body)) < FIRST_PSEUDO_REGISTER
+ && GET_CODE (SET_SRC (body)) == REG
+ && REGNO (SET_SRC (body)) < FIRST_PSEUDO_REGISTER
+ && REGISTER_MOVE_COST (REGNO_REG_CLASS (REGNO (SET_SRC (body))),
+ REGNO_REG_CLASS (REGNO (SET_DEST (body)))) == 2)
+ return;
- /* expand_asm_operands makes sure there aren't too many operands. */
- if (noperands > MAX_RECOG_OPERANDS)
- abort ();
+ extract_insn (insn);
- /* Now get the operand values and constraints out of the insn. */
+ noperands = reload_n_operands = recog_n_operands;
+ n_alternatives = recog_n_alternatives;
- decode_asm_operands (body, recog_operand, recog_operand_loc,
- constraints, operand_mode);
- if (noperands > 0)
- {
- bcopy ((char *) constraints, (char *) constraints1,
- noperands * sizeof (char *));
- n_alternatives = n_occurrences (',', constraints[0]) + 1;
- }
- break;
- }
+ /* Just return "no reloads" if insn has no operands with constraints. */
+ if (noperands == 0 || n_alternatives == 0)
+ return;
- default:
- /* Ordinary insn: recognize it, get the operands via insn_extract
- and get the constraints. */
-
- insn_code_number = recog_memoized (insn);
- if (insn_code_number < 0)
- fatal_insn_not_found (insn);
-
- reload_n_operands = noperands = insn_n_operands[insn_code_number];
- n_alternatives = insn_n_alternatives[insn_code_number];
- /* Just return "no reloads" if insn has no operands with constraints. */
- if (n_alternatives == 0)
- return;
- insn_extract (insn);
- for (i = 0; i < noperands; i++)
- {
- constraints[i] = constraints1[i]
- = insn_operand_constraint[insn_code_number][i];
- operand_mode[i] = insn_operand_mode[insn_code_number][i];
- }
- }
+ insn_code_number = INSN_CODE (insn);
+ this_insn_is_asm = insn_code_number < 0;
- if (noperands == 0)
- return;
+ bcopy ((char *) recog_operand_mode, (char *) operand_mode,
+ noperands * sizeof (enum machine_mode));
+ bcopy ((char *) recog_constraints, (char *) constraints,
+ noperands * sizeof (char *));
+ bcopy ((char *) constraints, (char *) constraints1,
+ noperands * sizeof (char *));
commutative = -1;
@@ -4176,51 +4113,12 @@ find_reloads (insn, replace, ind_levels,
n_earlyclobbers = 0;
replace_reloads = replace;
this_insn = insn;
-
- /* Find what kind of insn this is. NOPERANDS gets number of operands.
- Store the operand values in RECOG_OPERAND and the locations
- of the words in the insn that point to them in RECOG_OPERAND_LOC.
- Return if the insn needs no reload processing. */
- switch (GET_CODE (body))
- {
- case USE:
- case CLOBBER:
- case ASM_INPUT:
- case ADDR_VEC:
- case ADDR_DIFF_VEC:
- return;
-
- case PARALLEL:
- case SET:
- noperands = asm_noperands (body);
- if (noperands >= 0)
- {
- /* This insn is an `asm' with operands.
- First, find out how many operands, and allocate space. */
+ extract_insn (insn);
- insn_code_number = -1;
- /* ??? This is a bug! ???
- Give up and delete this insn if it has too many operands. */
- if (noperands > MAX_RECOG_OPERANDS)
- abort ();
-
- /* Now get the operand values out of the insn. */
-
- decode_asm_operands (body, recog_operand, recog_operand_loc,
- NULL_PTR, NULL_PTR);
- break;
- }
-
- default:
- /* Ordinary insn: recognize it, allocate space for operands and
- constraints, and get them out via insn_extract. */
-
- insn_code_number = recog_memoized (insn);
- noperands = insn_n_operands[insn_code_number];
- insn_extract (insn);
- }
+ noperands = reload_n_operands = recog_n_operands;
+ /* Return if the insn needs no reload processing. */
if (noperands == 0)
return;
Index: reload.h
===================================================================
RCS file: /usr/local/cvs/gcs/gcc/reload.h,v
retrieving revision 1.1.1.12
diff -u -p -r1.1.1.12 reload.h
--- reload.h 1998/10/15 13:29:43 1.1.1.12
+++ reload.h 1998/10/15 18:40:19
@@ -241,9 +241,6 @@ extern void remove_replacements PROTO((i
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));