+Wed Nov 4 22:16:36 1998 Bernd Schmidt <crux@pool.informatik.rwth-aachen.de>
+
+ * recog.h (enum op_type): Define.
+ (constrain_operands): Adjust prototype.
+ (recog_op_type): Declare new variable.
+ * recog.c (recog_op_type): New variable.
+ (insn_invalid_p): Allow modifying an asm statement after reload.
+ (extract_insn): Set up recog_op_type.
+ (constrain_operands): Lose INSN_CODE_NUM arg. All callers changed.
+ Don't compute operand types, use recog_op_type.
+ Use the information computed by extract_insn instead of the previous
+ method of finding it by insn code number.
+ * caller-save.c (init_caller_save): Use extract_insn, not insn_extract.
+ * reorg.c (fill_slots_from_thread): Likewise.
+ * reload1.c (reload_as_needed): Likewise.
+ (gen_reload): Likewise.
+ (inc_for_reload): Likewise.
+ (reload_cse_simplify_operands): Likewise.
+ Use the information computed by extract_insn instead of the previous
+ method of finding it by insn code number.
+ * genattrtab.c (write_attr_case): Generate call to extract_insn, not
+ insn_extract.
+ * final.c (final_scan_insn): Use extract_insn, not insn_extract.
+ (cleanup_operand_subregs): Use extract_insn, not insn_extract.
+ Use the information computed by extract_insn instead of the previous
+ method of finding it by insn code number.
+ * regmove.c (find_matches): Likewise. Change meaning of the return
+ value to be nonzero if the optimization can be performed, zero if
+ not. All callers changed.
+ Shorten some variable names to fix formatting problems.
+ (regmove_optimize): Shorten some variable names to fix formatting
+ problems.
+ Use the information computed by extract_insn instead of the previous
+ method of finding it by insn code number.
+ * regclass.c (scan_one_insn): Likewise.
+ (record_reg_classes): Don't compute operand types, use recog_op_type.
+ * reload.c (find_reloads): Lose CONSTRAINTS1 variable; use
+ recog_constraints instead.
+
Wed Nov 4 21:37:46 1998 Jeffrey A Law (law@cygnus.com)
* rtl.h (flow2_completed): Declare.
&& reg_restore_code[i][j] != (enum insn_code)-1);
if (ok)
{
- insn_extract (saveinsn);
- ok = constrain_operands (reg_save_code[i][j], 1);
- insn_extract (restinsn);
- ok &= constrain_operands (reg_restore_code[i][j], 1);
+ extract_insn (saveinsn);
+ ok = constrain_operands (1);
+ extract_insn (restinsn);
+ ok &= constrain_operands (1);
}
if (! ok)
since `reload' should have changed them so that they do. */
insn_code_number = recog_memoized (insn);
- insn_extract (insn);
+ extract_insn (insn);
cleanup_subreg_operands (insn);
#ifdef REGISTER_CONSTRAINTS
- if (! constrain_operands (insn_code_number, 1))
+ if (! constrain_operands (1))
fatal_insn_not_found (insn);
#endif
it is output. */
#ifdef FINAL_PRESCAN_INSN
- FINAL_PRESCAN_INSN (insn, recog_operand,
- insn_n_operands[insn_code_number]);
+ FINAL_PRESCAN_INSN (insn, recog_operand, recog_n_operands);
#endif
#ifdef HAVE_cc0
since `reload' should have changed them so that they do. */
insn_code_number = recog_memoized (insn);
- insn_extract (insn);
- for (i = 0; i < insn_n_operands[insn_code_number]; i++)
+ extract_insn (insn);
+ for (i = 0; i < recog_n_operands; i++)
{
if (GET_CODE (recog_operand[i]) == SUBREG)
recog_operand[i] = alter_subreg (recog_operand[i]);
recog_operand[i] = walk_alter_subreg (recog_operand[i]);
}
- for (i = 0; i < insn_n_dups[insn_code_number]; i++)
+ for (i = 0; i < recog_n_dups; i++)
{
if (GET_CODE (*recog_dup_loc[i]) == SUBREG)
*recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]);
If the attribute `alternative', or a random C expression is present,
`constrain_operands' is called. If either of these cases of a reference to
- an operand is found, `insn_extract' is called.
+ an operand is found, `extract_insn' is called.
The special attribute `length' is also recognized. For this operand,
expressions involving the address of an operand or the current insn,
if (must_extract)
{
write_indent (indent + 2);
- printf ("insn_extract (insn);\n");
+ printf ("extract_insn (insn);\n");
}
if (must_constrain)
{
#ifdef REGISTER_CONSTRAINTS
write_indent (indent + 2);
- printf ("if (! constrain_operands (INSN_CODE (insn), reload_completed))\n");
+ printf ("if (! constrain_operands (reload_completed))\n");
write_indent (indent + 2);
printf (" fatal_insn_not_found (insn);\n");
#endif
int volatile_ok;
-/* The following vectors hold the results from insn_extract. */
+/* The next variables are set up by extract_insn. The first four of them
+ are also set up during insn_extract. */
/* Indexed by N, gives value of operand N. */
rtx recog_operand[MAX_RECOG_OPERANDS];
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;
/* Indexed by N, gives the constraint string for operand N. */
char *recog_constraints[MAX_RECOG_OPERANDS];
+/* Indexed by N, gives the type (in, out, inout) for operand N. */
+enum op_type recog_op_type[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];
int icode = recog_memoized (insn);
int is_asm = icode < 0 && asm_noperands (PATTERN (insn)) >= 0;
- if (is_asm)
- {
- if (! check_asm_operands (PATTERN (insn)))
- return 1;
-
- /* Disallow modification of ASM_OPERANDS after reload; verifying the
- constraints is too difficult. */
- if (reload_completed)
- return 1;
- }
- else if (icode < 0)
+ if (is_asm && ! check_asm_operands (PATTERN (insn)))
+ return 1;
+ if (! is_asm && icode < 0)
return 1;
/* After reload, verify that all constraints are satisfied. */
if (reload_completed)
{
- insn_extract (insn);
+ extract_insn (insn);
- if (! constrain_operands (INSN_CODE (insn), 1))
+ if (! constrain_operands (1))
return 1;
}
given a MEM and it still is a valid address, or if this is in insn
and it is recognized. In the latter case, if reload has completed,
we also require that the operands meet the constraints for
- the insn. We do not allow modifying an ASM_OPERANDS after reload
- has completed because verifying the constraints is too difficult. */
+ the insn. */
for (i = 0; i < num_changes; i++)
{
recog_operand_mode[i] = insn_operand_mode[icode][i];
}
}
+ for (i = 0; i < noperands; i++)
+ recog_op_type[i] = (recog_constraints[i][0] == '=' ? OP_OUT
+ : recog_constraints[i][0] == '+' ? OP_INOUT
+ : OP_IN);
}
#ifdef REGISTER_CONSTRAINTS
-/* Check the operands of an insn (found in recog_operands)
- against the insn's operand constraints (found via INSN_CODE_NUM)
+/* Check the operands of an insn against the insn's operand constraints
and return 1 if they are valid.
+ The information about the insn's operands, constraints, operand modes
+ etc. is obtained from the global variables set up by extract_insn.
WHICH_ALTERNATIVE is set to a number which indicates which
alternative of constraints was matched: 0 for the first alternative,
};
int
-constrain_operands (insn_code_num, strict)
- int insn_code_num;
+constrain_operands (strict)
int strict;
{
char *constraints[MAX_RECOG_OPERANDS];
int matching_operands[MAX_RECOG_OPERANDS];
- enum op_type {OP_IN, OP_OUT, OP_INOUT} op_types[MAX_RECOG_OPERANDS];
int earlyclobber[MAX_RECOG_OPERANDS];
register int c;
- int noperands = insn_n_operands[insn_code_num];
struct funny_match funny_match[MAX_RECOG_OPERANDS];
int funny_match_index;
- int nalternatives = insn_n_alternatives[insn_code_num];
- if (noperands == 0 || nalternatives == 0)
+ if (recog_n_operands == 0 || recog_n_alternatives == 0)
return 1;
- for (c = 0; c < noperands; c++)
+ for (c = 0; c < recog_n_operands; c++)
{
- constraints[c] = insn_operand_constraint[insn_code_num][c];
+ constraints[c] = recog_constraints[c];
matching_operands[c] = -1;
- op_types[c] = OP_IN;
}
which_alternative = 0;
- while (which_alternative < nalternatives)
+ while (which_alternative < recog_n_alternatives)
{
register int opno;
int lose = 0;
funny_match_index = 0;
- for (opno = 0; opno < noperands; opno++)
+ for (opno = 0; opno < recog_n_operands; opno++)
{
register rtx op = recog_operand[opno];
enum machine_mode mode = GET_MODE (op);
case '!':
case '*':
case '%':
+ case '=':
+ case '+':
break;
case '#':
p++;
break;
- case '=':
- op_types[opno] = OP_OUT;
- break;
-
- case '+':
- op_types[opno] = OP_INOUT;
- break;
-
case '&':
earlyclobber[opno] = 1;
break;
strictly valid, i.e., that all pseudos requiring hard regs
have gotten them. */
if (strict <= 0
- || (strict_memory_address_p
- (insn_operand_mode[insn_code_num][opno], op)))
+ || (strict_memory_address_p (recog_operand_mode[opno],
+ op)))
win = 1;
break;
operand. */
if (strict > 0)
- for (eopno = 0; eopno < noperands; eopno++)
+ for (eopno = 0; eopno < recog_n_operands; eopno++)
/* Ignore earlyclobber operands now in memory,
because we would often report failure when we have
two memory operands, one of which was formerly a REG. */
if (earlyclobber[eopno]
&& GET_CODE (recog_operand[eopno]) == REG)
- for (opno = 0; opno < noperands; opno++)
+ for (opno = 0; opno < recog_n_operands; opno++)
if ((GET_CODE (recog_operand[opno]) == MEM
- || op_types[opno] != OP_OUT)
+ || recog_op_type[opno] != OP_OUT)
&& opno != eopno
/* Ignore things like match_operator operands. */
- && *insn_operand_constraint[insn_code_num][opno] != 0
+ && *recog_constraints[opno] != 0
&& ! (matching_operands[opno] == eopno
&& operands_match_p (recog_operand[opno],
recog_operand[eopno]))
/* If we are about to reject this, but we are not to test strictly,
try a very loose test. Only return failure if it fails also. */
if (strict == 0)
- return constrain_operands (insn_code_num, -1);
+ return constrain_operands (-1);
else
return 0;
}
#include "gansidecl.h"
+/* Types of operands. */
+enum op_type {
+ OP_IN,
+ OP_OUT,
+ OP_INOUT
+};
+
extern void init_recog PROTO((void));
extern void init_recog_no_volatile PROTO((void));
extern int recog_memoized PROTO((rtx));
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, 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));
/* Indexed by N, gives the constraint string for operand N. */
extern char *recog_constraints[];
+/* Indexed by N, gives the type (in, out, inout) for operand N. */
+extern enum op_type recog_op_type[];
+
#ifndef REGISTER_CONSTRAINTS
/* Indexed by N, nonzero if operand N should be an address. */
extern char recog_operand_address_p[];
{
enum rtx_code code = GET_CODE (insn);
enum rtx_code pat_code;
-
char *constraints[MAX_RECOG_OPERANDS];
enum machine_mode modes[MAX_RECOG_OPERANDS];
- int nalternatives;
- int noperands;
- rtx set;
+ rtx set, note;
int i, j;
/* Show that an insn inside a loop is likely to be executed three
|| pat_code == ADDR_DIFF_VEC)
return insn;
- if (code == INSN
- && (noperands = asm_noperands (PATTERN (insn))) >= 0)
+ set = single_set (insn);
+ extract_insn (insn);
+
+ for (i = 0; i < recog_n_operands; i++)
{
- decode_asm_operands (PATTERN (insn), recog_operand, NULL_PTR,
- constraints, modes);
- nalternatives = (noperands == 0 ? 0
- : n_occurrences (',', constraints[0]) + 1);
+ constraints[i] = recog_constraints[i];
+ modes[i] = recog_operand_mode[i];
}
- else
- {
- int insn_code_number = recog_memoized (insn);
- rtx note;
- set = single_set (insn);
- insn_extract (insn);
+ /* If this insn loads a parameter from its stack slot, then
+ it represents a savings, rather than a cost, if the
+ parameter is stored in memory. Record this fact. */
- nalternatives = insn_n_alternatives[insn_code_number];
- noperands = insn_n_operands[insn_code_number];
+ if (set != 0 && GET_CODE (SET_DEST (set)) == REG
+ && GET_CODE (SET_SRC (set)) == MEM
+ && (note = find_reg_note (insn, REG_EQUIV,
+ NULL_RTX)) != 0
+ && GET_CODE (XEXP (note, 0)) == MEM)
+ {
+ costs[REGNO (SET_DEST (set))].mem_cost
+ -= (MEMORY_MOVE_COST (GET_MODE (SET_DEST (set)),
+ GENERAL_REGS, 1)
+ * loop_cost);
+ record_address_regs (XEXP (SET_SRC (set), 0),
+ BASE_REG_CLASS, loop_cost * 2);
+ return insn;
+ }
- /* If this insn loads a parameter from its stack slot, then
- it represents a savings, rather than a cost, if the
- parameter is stored in memory. Record this fact. */
+ /* Improve handling of two-address insns such as
+ (set X (ashift CONST Y)) where CONST must be made to
+ match X. Change it into two insns: (set X CONST)
+ (set X (ashift X Y)). If we left this for reloading, it
+ would probably get three insns because X and Y might go
+ in the same place. This prevents X and Y from receiving
+ the same hard reg.
+
+ We can only do this if the modes of operands 0 and 1
+ (which might not be the same) are tieable and we only need
+ do this during our first pass. */
+
+ if (pass == 0 && optimize
+ && recog_n_operands >= 3
+ && recog_constraints[1][0] == '0'
+ && recog_constraints[1][1] == 0
+ && CONSTANT_P (recog_operand[1])
+ && ! rtx_equal_p (recog_operand[0], recog_operand[1])
+ && ! rtx_equal_p (recog_operand[0], recog_operand[2])
+ && GET_CODE (recog_operand[0]) == REG
+ && MODES_TIEABLE_P (GET_MODE (recog_operand[0]),
+ recog_operand_mode[1]))
+ {
+ rtx previnsn = prev_real_insn (insn);
+ rtx dest
+ = gen_lowpart (recog_operand_mode[1],
+ recog_operand[0]);
+ rtx newinsn
+ = emit_insn_before (gen_move_insn (dest,
+ recog_operand[1]),
+ insn);
- if (set != 0 && GET_CODE (SET_DEST (set)) == REG
- && GET_CODE (SET_SRC (set)) == MEM
- && (note = find_reg_note (insn, REG_EQUIV,
- NULL_RTX)) != 0
- && GET_CODE (XEXP (note, 0)) == MEM)
+ /* If this insn was the start of a basic block,
+ include the new insn in that block.
+ We need not check for code_label here;
+ while a basic block can start with a code_label,
+ INSN could not be at the beginning of that block. */
+ if (previnsn == 0 || GET_CODE (previnsn) == JUMP_INSN)
{
- costs[REGNO (SET_DEST (set))].mem_cost
- -= (MEMORY_MOVE_COST (GET_MODE (SET_DEST (set)),
- GENERAL_REGS, 1)
- * loop_cost);
- record_address_regs (XEXP (SET_SRC (set), 0),
- BASE_REG_CLASS, loop_cost * 2);
- return insn;
+ int b;
+ for (b = 0; b < n_basic_blocks; b++)
+ if (insn == basic_block_head[b])
+ basic_block_head[b] = newinsn;
}
- /* Improve handling of two-address insns such as
- (set X (ashift CONST Y)) where CONST must be made to
- match X. Change it into two insns: (set X CONST)
- (set X (ashift X Y)). If we left this for reloading, it
- would probably get three insns because X and Y might go
- in the same place. This prevents X and Y from receiving
- the same hard reg.
-
- We can only do this if the modes of operands 0 and 1
- (which might not be the same) are tieable and we only need
- do this during our first pass. */
-
- if (pass == 0 && optimize
- && noperands >= 3
- && insn_operand_constraint[insn_code_number][1][0] == '0'
- && insn_operand_constraint[insn_code_number][1][1] == 0
- && CONSTANT_P (recog_operand[1])
- && ! rtx_equal_p (recog_operand[0], recog_operand[1])
- && ! rtx_equal_p (recog_operand[0], recog_operand[2])
- && GET_CODE (recog_operand[0]) == REG
- && MODES_TIEABLE_P (GET_MODE (recog_operand[0]),
- insn_operand_mode[insn_code_number][1]))
- {
- rtx previnsn = prev_real_insn (insn);
- rtx dest
- = gen_lowpart (insn_operand_mode[insn_code_number][1],
- recog_operand[0]);
- rtx newinsn
- = emit_insn_before (gen_move_insn (dest,
- recog_operand[1]),
- insn);
-
- /* If this insn was the start of a basic block,
- include the new insn in that block.
- We need not check for code_label here;
- while a basic block can start with a code_label,
- INSN could not be at the beginning of that block. */
- if (previnsn == 0 || GET_CODE (previnsn) == JUMP_INSN)
- {
- int b;
- for (b = 0; b < n_basic_blocks; b++)
- if (insn == basic_block_head[b])
- basic_block_head[b] = newinsn;
- }
-
- /* This makes one more setting of new insns's dest. */
- REG_N_SETS (REGNO (recog_operand[0]))++;
-
- *recog_operand_loc[1] = recog_operand[0];
- for (i = insn_n_dups[insn_code_number] - 1; i >= 0; i--)
- if (recog_dup_num[i] == 1)
- *recog_dup_loc[i] = recog_operand[0];
+ /* This makes one more setting of new insns's dest. */
+ REG_N_SETS (REGNO (recog_operand[0]))++;
- return PREV_INSN (newinsn);
- }
+ *recog_operand_loc[1] = recog_operand[0];
+ for (i = recog_n_dups - 1; i >= 0; i--)
+ if (recog_dup_num[i] == 1)
+ *recog_dup_loc[i] = recog_operand[0];
- for (i = 0; i < noperands; i++)
- {
- constraints[i]
- = insn_operand_constraint[insn_code_number][i];
- modes[i] = insn_operand_mode[insn_code_number][i];
- }
+ return PREV_INSN (newinsn);
}
/* If we get here, we are set up to record the costs of all the
classes for any pseudos, doing it twice if some pair of
operands are commutative. */
- for (i = 0; i < noperands; i++)
+ for (i = 0; i < recog_n_operands; i++)
{
op_costs[i] = init_cost;
have been initialized. We must do this even if one operand
is a constant--see addsi3 in m68k.md. */
- for (i = 0; i < noperands - 1; i++)
+ for (i = 0; i < recog_n_operands - 1; i++)
if (constraints[i][0] == '%')
{
char *xconstraints[MAX_RECOG_OPERANDS];
/* Handle commutative operands by swapping the constraints.
We assume the modes are the same. */
- for (j = 0; j < noperands; j++)
+ for (j = 0; j < recog_n_operands; j++)
xconstraints[j] = constraints[j];
xconstraints[i] = constraints[i+1];
xconstraints[i+1] = constraints[i];
- record_reg_classes (nalternatives, noperands,
+ record_reg_classes (recog_n_alternatives, recog_n_operands,
recog_operand, modes, xconstraints,
insn);
}
- record_reg_classes (nalternatives, noperands, recog_operand,
+ record_reg_classes (recog_n_alternatives, recog_n_operands, recog_operand,
modes, constraints, insn);
/* Now add the cost for each operand to the total costs for
its register. */
- for (i = 0; i < noperands; i++)
+ for (i = 0; i < recog_n_operands; i++)
if (GET_CODE (recog_operand[i]) == REG
&& REGNO (recog_operand[i]) >= FIRST_PSEUDO_REGISTER)
{
rtx insn;
{
int alt;
- enum op_type {OP_READ, OP_WRITE, OP_READ_WRITE} op_types[MAX_RECOG_OPERANDS];
int i, j;
rtx set;
- /* By default, each operand is an input operand. */
-
- for (i = 0; i < n_ops; i++)
- op_types[i] = OP_READ;
-
/* Process each alternative, each time minimizing an operand's cost with
the cost for each operand in that alternative. */
any modifiers for the operand before we can make this test. */
while (*p == '%' || *p == '=' || *p == '+' || *p == '&')
- {
- if (*p == '=')
- op_types[i] = OP_WRITE;
- else if (*p == '+')
- op_types[i] = OP_READ_WRITE;
-
- p++;
- }
+ p++;
if (p[0] >= '0' && p[0] <= '0' + i && (p[1] == ',' || p[1] == 0))
{
else if (classes[i] != NO_REGS)
{
- if (op_types[i] != OP_WRITE)
+ if (recog_op_type[i] != OP_OUT)
alt_cost += copy_cost (op, mode, classes[i], 1);
- if (op_types[i] != OP_READ)
+ if (recog_op_type[i] != OP_IN)
alt_cost += copy_cost (op, mode, classes[i], 0);
}
&& REGNO (ops[i]) >= FIRST_PSEUDO_REGISTER)
{
struct costs *pp = &op_costs[i], *qq = &this_op_costs[i];
- int scale = 1 + (op_types[i] == OP_READ_WRITE);
+ int scale = 1 + (recog_op_type[i] == OP_INOUT);
pp->mem_cost = MIN (pp->mem_cost,
(qq->mem_cost + alt_cost) * scale);
insn = pass ? PREV_INSN (insn) : NEXT_INSN (insn))
{
rtx set;
- int insn_code_number;
- int operand_number, match_number;
+ int op_no, match_no;
if (GET_CODE (insn) == NOTE)
{
}
}
}
-#ifdef REGISTER_CONSTRAINTS
- insn_code_number
- = find_matches (insn, &match);
- if (insn_code_number < 0)
+#ifdef REGISTER_CONSTRAINTS
+ if (find_matches (insn, &match) < 0)
continue;
/* Now scan through the operands looking for a source operand
If it dies there, then replace the dest in both operands with
the source operand. */
- for (operand_number = 0;
- operand_number < insn_n_operands[insn_code_number];
- operand_number++)
+ for (op_no = 0; op_no < recog_n_operands; op_no++)
{
rtx src, dst, src_subreg;
enum reg_class src_class, dst_class;
- match_number = match.with[operand_number];
+ match_no = match.with[op_no];
/* Nothing to do if the two operands aren't supposed to match. */
- if (match_number < 0)
+ if (match_no < 0)
continue;
- src = recog_operand[operand_number];
- dst = recog_operand[match_number];
+ src = recog_operand[op_no];
+ dst = recog_operand[match_no];
if (GET_CODE (src) != REG)
continue;
if (REGNO (src) < FIRST_PSEUDO_REGISTER)
{
- if (match.commutative[operand_number] < operand_number)
+ if (match.commutative[op_no] < op_no)
regno_src_regno[REGNO (dst)] = REGNO (src);
continue;
}
if (REG_LIVE_LENGTH (REGNO (src)) < 0)
continue;
- /* operand_number/src must be a read-only operand, and
+ /* op_no/src must be a read-only operand, and
match_operand/dst must be a write-only operand. */
- if (match.use[operand_number] != READ
- || match.use[match_number] != WRITE)
+ if (match.use[op_no] != READ
+ || match.use[match_no] != WRITE)
continue;
- if (match.early_clobber[match_number]
+ if (match.early_clobber[match_no]
&& count_occurrences (PATTERN (insn), src) > 1)
continue;
/* Make sure match_operand is the destination. */
- if (recog_operand[match_number] != SET_DEST (set))
+ if (recog_operand[match_no] != SET_DEST (set))
continue;
/* If the operands already match, then there is nothing to do. */
/* But in the commutative case, we might find a better match. */
if (operands_match_p (src, dst)
- || (match.commutative[operand_number] >= 0
+ || (match.commutative[op_no] >= 0
&& operands_match_p (recog_operand[match.commutative
- [operand_number]], dst)
+ [op_no]], dst)
&& (replacement_quality (recog_operand[match.commutative
- [operand_number]])
+ [op_no]])
>= replacement_quality (src))))
continue;
continue;
if (fixup_match_1 (insn, set, src, src_subreg, dst, pass,
- operand_number, match_number,
+ op_no, match_no,
regmove_dump_file))
break;
}
}
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
- int insn_code_number = find_matches (insn, &match);
- int operand_number, match_number;
+ int op_no, match_no;
int success = 0;
-
- if (insn_code_number < 0)
+
+ if (find_matches (insn, &match) < 0)
continue;
/* Now scan through the operands looking for a destination operand
copy_src = NULL_RTX;
copy_dst = NULL_RTX;
- for (operand_number = 0;
- operand_number < insn_n_operands[insn_code_number];
- operand_number++)
+ for (op_no = 0; op_no < recog_n_operands; op_no++)
{
rtx set, p, src, dst;
rtx src_note, dst_note;
enum reg_class src_class, dst_class;
int length;
- match_number = match.with[operand_number];
+ match_no = match.with[op_no];
/* Nothing to do if the two operands aren't supposed to match. */
- if (match_number < 0)
+ if (match_no < 0)
continue;
- dst = recog_operand[match_number];
- src = recog_operand[operand_number];
+ dst = recog_operand[match_no];
+ src = recog_operand[op_no];
if (GET_CODE (src) != REG)
continue;
/* If the operands already match, then there is nothing to do. */
if (operands_match_p (src, dst)
- || (match.commutative[operand_number] >= 0
- && operands_match_p (recog_operand[match.commutative[operand_number]], dst)))
+ || (match.commutative[op_no] >= 0
+ && operands_match_p (recog_operand[match.commutative[op_no]], dst)))
continue;
set = single_set (insn);
if (! set)
continue;
- /* match_number/dst must be a write-only operand, and
+ /* match_no/dst must be a write-only operand, and
operand_operand/src must be a read-only operand. */
- if (match.use[operand_number] != READ
- || match.use[match_number] != WRITE)
+ if (match.use[op_no] != READ
+ || match.use[match_no] != WRITE)
continue;
- if (match.early_clobber[match_number]
+ if (match.early_clobber[match_no]
&& count_occurrences (PATTERN (insn), src) > 1)
continue;
- /* Make sure match_number is the destination. */
- if (recog_operand[match_number] != SET_DEST (set))
+ /* Make sure match_no is the destination. */
+ if (recog_operand[match_no] != SET_DEST (set))
continue;
if (REGNO (src) < FIRST_PSEUDO_REGISTER)
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Could fix operand %d of insn %d matching operand %d.\n",
- operand_number, INSN_UID (insn), match_number);
+ op_no, INSN_UID (insn), match_no);
/* Scan backward to find the first instruction that uses
the input operand. If the operand is set here, then
- replace it in both instructions with match_number. */
+ replace it in both instructions with match_no. */
for (length = 0, p = PREV_INSN (insn); p; p = PREV_INSN (p))
{
validate_replace_rtx (dst, src, insn);
/* Now make sure the dst is right. */
validate_change (insn,
- recog_operand_loc[match_number],
+ recog_operand_loc[match_no],
dst, 0);
}
}
if (regmove_dump_file)
fprintf (regmove_dump_file,
"Fixed operand %d of insn %d matching operand %d.\n",
- operand_number, INSN_UID (insn), match_number);
+ op_no, INSN_UID (insn), match_no);
break;
}
}
}
-/* Returns the INSN_CODE for INSN if its pattern has matching constraints for
- any operand. Returns -1 if INSN can't be recognized, or if the alternative
- can't be determined.
+/* Returns nonzero if INSN's pattern has matching constraints for any operand.
+ Returns 0 if INSN can't be recognized, or if the alternative can't be
+ determined.
Initialize the info in MATCHP based on the constraints. */
struct match *matchp;
{
int likely_spilled[MAX_RECOG_OPERANDS];
- int operand_number;
- int insn_code_number = recog_memoized (insn);
+ int op_no;
int any_matches = 0;
- if (insn_code_number < 0)
- return -1;
-
- insn_extract (insn);
- if (! constrain_operands (insn_code_number, 0))
- return -1;
+ extract_insn (insn);
+ if (! constrain_operands (0))
+ return 0;
/* Must initialize this before main loop, because the code for
the commutative case may set matches for operands other than
the current one. */
- for (operand_number = insn_n_operands[insn_code_number];
- --operand_number >= 0; )
- matchp->with[operand_number] = matchp->commutative[operand_number] = -1;
+ for (op_no = recog_n_operands; --op_no >= 0; )
+ matchp->with[op_no] = matchp->commutative[op_no] = -1;
- for (operand_number = 0; operand_number < insn_n_operands[insn_code_number];
- operand_number++)
+ for (op_no = 0; op_no < recog_n_operands; op_no++)
{
char *p, c;
int i = 0;
- p = insn_operand_constraint[insn_code_number][operand_number];
+ p = recog_constraints[op_no];
- likely_spilled[operand_number] = 0;
- matchp->use[operand_number] = READ;
- matchp->early_clobber[operand_number] = 0;
+ likely_spilled[op_no] = 0;
+ matchp->use[op_no] = READ;
+ matchp->early_clobber[op_no] = 0;
if (*p == '=')
- matchp->use[operand_number] = WRITE;
+ matchp->use[op_no] = WRITE;
else if (*p == '+')
- matchp->use[operand_number] = READWRITE;
+ matchp->use[op_no] = READWRITE;
for (;*p && i < which_alternative; p++)
if (*p == ',')
case '+':
break;
case '&':
- matchp->early_clobber[operand_number] = 1;
+ matchp->early_clobber[op_no] = 1;
break;
case '%':
- matchp->commutative[operand_number] = operand_number + 1;
- matchp->commutative[operand_number + 1] = operand_number;
+ matchp->commutative[op_no] = op_no + 1;
+ matchp->commutative[op_no + 1] = op_no;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
c -= '0';
- if (c < operand_number && likely_spilled[(unsigned char) c])
+ if (c < op_no && likely_spilled[(unsigned char) c])
break;
- matchp->with[operand_number] = c;
+ matchp->with[op_no] = c;
any_matches = 1;
- if (matchp->commutative[operand_number] >= 0)
- matchp->with[matchp->commutative[operand_number]] = c;
+ if (matchp->commutative[op_no] >= 0)
+ matchp->with[matchp->commutative[op_no]] = c;
break;
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'h':
case 'j': case 'k': case 'l': case 'p': case 'q': case 't': case 'u':
case 'v': case 'w': case 'x': case 'y': case 'z': case 'A': case 'B':
case 'C': case 'D': case 'W': case 'Y': case 'Z':
if (CLASS_LIKELY_SPILLED_P (REG_CLASS_FROM_LETTER (c)))
- likely_spilled[operand_number] = 1;
+ likely_spilled[op_no] = 1;
break;
}
}
- return any_matches ? insn_code_number : -1;
+ return any_matches;
}
/* Try to replace output operand DST in SET, with input operand SRC. SET is
register int insn_code_number;
register int i, j;
int noperands;
- /* These are the constraints for the insn. We don't change them. */
- char *constraints1[MAX_RECOG_OPERANDS];
/* These start out as the constraints for the insn
and they are chewed up as we consider alternatives. */
char *constraints[MAX_RECOG_OPERANDS];
noperands * sizeof (enum machine_mode));
bcopy ((char *) recog_constraints, (char *) constraints,
noperands * sizeof (char *));
- bcopy ((char *) constraints, (char *) constraints1,
- noperands * sizeof (char *));
commutative = -1;
|| modified[j] != RELOAD_WRITE)
&& j != i
/* Ignore things like match_operator operands. */
- && *constraints1[j] != 0
+ && *recog_constraints[j] != 0
/* Don't count an input operand that is constrained to match
the early clobber operand. */
&& ! (this_alternative_matches[j] == i
pref_or_nothing[commutative] = pref_or_nothing[commutative + 1];
pref_or_nothing[commutative + 1] = t;
- bcopy ((char *) constraints1, (char *) constraints,
+ bcopy ((char *) recog_constraints, (char *) constraints,
noperands * sizeof (char *));
goto try_swapped;
}
= find_reloads_toplev (force_const_mem (operand_mode[i],
recog_operand[i]),
i, address_type[i], ind_levels, 0, insn);
- if (alternative_allows_memconst (constraints1[i],
+ if (alternative_allows_memconst (recog_constraints[i],
goal_alternative_number))
goal_alternative_win[i] = 1;
}
for (p = NEXT_INSN (prev); p != next; p = NEXT_INSN (p))
if (p != insn && GET_RTX_CLASS (GET_CODE (p)) == 'i'
&& (recog_memoized (p) < 0
- || (insn_extract (p),
- ! constrain_operands (INSN_CODE (p), 1))))
+ || (extract_insn (p), ! constrain_operands (1))))
{
error_for_asm (insn,
"`asm' operand requires impossible reload");
It might be better not to actually emit the insn unless it is valid,
but we need to pass the insn as an operand to `recog' and
- `insn_extract' and it is simpler to emit and then delete the insn if
+ `extract_insn' and it is simpler to emit and then delete the insn if
not valid than to dummy things up. */
rtx op0, op1, tem, insn;
if (code >= 0)
{
- insn_extract (insn);
+ extract_insn (insn);
/* We want constrain operands to treat this insn strictly in
its validity determination, i.e., the way it would after reload
has completed. */
- if (constrain_operands (code, 1))
+ if (constrain_operands (1))
return insn;
}
if (code >= 0)
{
- insn_extract (insn);
+ extract_insn (insn);
/* We want constrain operands to treat this insn strictly in
its validity determination, i.e., the way it would after reload
has completed. */
- if (constrain_operands (code, 1))
+ if (constrain_operands (1))
{
/* Add a REG_EQUIV note so that find_equiv_reg can find it. */
REG_NOTES (insn)
code = recog_memoized (add_insn);
if (code >= 0)
{
- insn_extract (add_insn);
- if (constrain_operands (code, 1))
+ extract_insn (add_insn);
+ if (constrain_operands (1))
{
/* If this is a pre-increment and we have incremented the value
where it lives, copy the incremented value to RELOADREG to
rtx insn;
{
#ifdef REGISTER_CONSTRAINTS
- int insn_code_number, n_operands, n_alternatives;
int i,j;
char *constraints[MAX_RECOG_OPERANDS];
int *alternative_order;
rtx reg = gen_rtx_REG (VOIDmode, -1);
- /* Find out some information about this insn. */
- insn_code_number = recog_memoized (insn);
- /* We don't modify asm instructions. */
- if (insn_code_number < 0)
- return 0;
+ extract_insn (insn);
- n_operands = insn_n_operands[insn_code_number];
- n_alternatives = insn_n_alternatives[insn_code_number];
-
- if (n_alternatives == 0 || n_operands == 0)
+ if (recog_n_alternatives == 0 || recog_n_operands == 0)
return 0;
- insn_extract (insn);
/* Figure out which alternative currently matches. */
- if (! constrain_operands (insn_code_number, 1))
+ if (! constrain_operands (1))
fatal_insn_not_found (insn);
- alternative_reject = (int *) alloca (n_alternatives * sizeof (int));
- alternative_nregs = (int *) alloca (n_alternatives * sizeof (int));
- alternative_order = (int *) alloca (n_alternatives * sizeof (int));
- bzero ((char *)alternative_reject, n_alternatives * sizeof (int));
- bzero ((char *)alternative_nregs, n_alternatives * sizeof (int));
+ alternative_reject = (int *) alloca (recog_n_alternatives * sizeof (int));
+ alternative_nregs = (int *) alloca (recog_n_alternatives * sizeof (int));
+ alternative_order = (int *) alloca (recog_n_alternatives * sizeof (int));
+ bzero ((char *)alternative_reject, recog_n_alternatives * sizeof (int));
+ bzero ((char *)alternative_nregs, recog_n_alternatives * sizeof (int));
- for (i = 0; i < n_operands; i++)
+ for (i = 0; i < recog_n_operands; i++)
{
enum machine_mode mode;
int regno;
char *p;
- op_alt_regno[i] = (int *) alloca (n_alternatives * sizeof (int));
- for (j = 0; j < n_alternatives; j++)
+ op_alt_regno[i] = (int *) alloca (recog_n_alternatives * sizeof (int));
+ for (j = 0; j < recog_n_alternatives; j++)
op_alt_regno[i][j] = -1;
- p = constraints[i] = insn_operand_constraint[insn_code_number][i];
- mode = insn_operand_mode[insn_code_number][i];
+ p = constraints[i] = recog_constraints[i];
+ mode = recog_operand_mode[i];
/* Add the reject values for each alternative given by the constraints
for this operand. */
/* Record all alternatives which are better or equal to the currently
matching one in the alternative_order array. */
- for (i = j = 0; i < n_alternatives; i++)
+ for (i = j = 0; i < recog_n_alternatives; i++)
if (alternative_reject[i] <= alternative_reject[which_alternative])
alternative_order[j++] = i;
- n_alternatives = j;
+ recog_n_alternatives = j;
/* Sort it. Given a small number of alternatives, a dumb algorithm
won't hurt too much. */
- for (i = 0; i < n_alternatives - 1; i++)
+ for (i = 0; i < recog_n_alternatives - 1; i++)
{
int best = i;
int best_reject = alternative_reject[alternative_order[i]];
int best_nregs = alternative_nregs[alternative_order[i]];
int tmp;
- for (j = i + 1; j < n_alternatives; j++)
+ for (j = i + 1; j < recog_n_alternatives; j++)
{
int this_reject = alternative_reject[alternative_order[j]];
int this_nregs = alternative_nregs[alternative_order[j]];
/* Pop back to the real obstacks while changing the insn. */
pop_obstacks ();
- for (i = 0; i < n_operands; i++)
+ for (i = 0; i < recog_n_operands; i++)
{
- enum machine_mode mode = insn_operand_mode[insn_code_number][i];
+ enum machine_mode mode = recog_operand_mode[i];
if (op_alt_regno[i][j] == -1)
continue;
gen_rtx_REG (mode, op_alt_regno[i][j]), 1);
}
- for (i = insn_n_dups[insn_code_number] - 1; i >= 0; i--)
+ for (i = recog_n_dups - 1; i >= 0; i--)
{
int op = recog_dup_num[i];
- enum machine_mode mode = insn_operand_mode[insn_code_number][op];
+ enum machine_mode mode = recog_operand_mode[op];
if (op_alt_regno[op][j] == -1)
continue;
insn);
if (recog_memoized (ninsn) < 0
- || (insn_extract (ninsn),
- ! constrain_operands (INSN_CODE (ninsn), 1)))
+ || (extract_insn (ninsn), ! constrain_operands (1)))
{
delete_insn (ninsn);
return 0;
OSDN Git Service
