recog.h (alternative_class): New function.

gcc/
	* recog.h (alternative_class): New function.
	(which_op_alt): Return a const recog_op_alt.
	* reg-stack.c (check_asm_stack_operands): Update type accordingly.
	(subst_asm_stack_regs): Likewise.
	* config/arm/arm.c (note_invalid_constants): Likewise.
	* regcprop.c (copyprop_hardreg_forward_1): Likewise.  Don't modify
	the operand_alternative; use alternative class instead.
	* sel-sched.c (get_reg_class): Likewise.
	* regrename.c (build_def_use): Likewise.
	(hide_operands, restore_operands, record_out_operands): Update type
	accordingly.

From-SVN: r211238

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 43de8fb37442e3e16b552be7b6f57ef1a4b6a375..c585b9395a69267cfefcdf104440d172461b1e7f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2014-06-04  Richard Sandiford  <rdsandiford@googlemail.com>
+
+       * recog.h (alternative_class): New function.
+       (which_op_alt): Return a const recog_op_alt.
+       * reg-stack.c (check_asm_stack_operands): Update type accordingly.
+       (subst_asm_stack_regs): Likewise.
+       * config/arm/arm.c (note_invalid_constants): Likewise.
+       * regcprop.c (copyprop_hardreg_forward_1): Likewise.  Don't modify
+       the operand_alternative; use alternative class instead.
+       * sel-sched.c (get_reg_class): Likewise.
+       * regrename.c (build_def_use): Likewise.
+       (hide_operands, restore_operands, record_out_operands): Update type
+       accordingly.
+
 2014-06-04  Richard Sandiford  <rdsandiford@googlemail.com>
 
        * recog.h (recog_op_alt): Convert to a flat array.

diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index 061c7586fc2cbaeef44d2767db6dcc4d2c2d1023..d5d958ebec51d4930abe2e03f15f33d7f1320bb1 100644 (file)
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -16878,7 +16878,7 @@ note_invalid_constants (rtx insn, HOST_WIDE_INT address, int do_pushes)
      this insn.  */
   preprocess_constraints ();
 
-  operand_alternative *op_alt = which_op_alt ();
+  const operand_alternative *op_alt = which_op_alt ();
   for (opno = 0; opno < recog_data.n_operands; opno++)
     {
       /* Things we need to fix can only occur in inputs.  */

diff --git a/gcc/recog.h b/gcc/recog.h
index 1473486db326db3e43213e825aa08a441311fa88..3dae18ba26a4cc8be192bb73c5e7edcce56767c1 100644 (file)
--- a/gcc/recog.h
+++ b/gcc/recog.h
@@ -79,6 +79,14 @@ struct operand_alternative
   unsigned int anything_ok:1;
 };
 
+/* Return the class for operand I of alternative ALT, taking matching
+   constraints into account.  */
+
+static inline enum reg_class
+alternative_class (const operand_alternative *alt, int i)
+{
+  return alt[i].matches >= 0 ? alt[alt[i].matches].cl : alt[i].cl;
+}
 
 extern void init_recog (void);
 extern void init_recog_no_volatile (void);
@@ -263,7 +271,7 @@ extern struct operand_alternative recog_op_alt[MAX_RECOG_OPERANDS
    on operand OP of the current instruction alternative (which_alternative).
    Only valid after calling preprocess_constraints and constrain_operands.  */
 
-inline static operand_alternative *
+inline static const operand_alternative *
 which_op_alt ()
 {
   gcc_checking_assert (IN_RANGE (which_alternative, 0,

diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index a2d76b44b9a235b9fde12278fc605b2ba88d7eaa..443a65a504bcc029c8b1ff470fcb670dc8fc7208 100644 (file)
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -482,7 +482,7 @@ check_asm_stack_operands (rtx insn)
       PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
       return 0;
     }
-  operand_alternative *op_alt = which_op_alt ();
+  const operand_alternative *op_alt = which_op_alt ();
 
   /* Strip SUBREGs here to make the following code simpler.  */
   for (i = 0; i < recog_data.n_operands; i++)
@@ -2030,7 +2030,7 @@ subst_asm_stack_regs (rtx insn, stack_ptr regstack)
   constrain_operands (1);
 
   preprocess_constraints ();
-  operand_alternative *op_alt = which_op_alt ();
+  const operand_alternative *op_alt = which_op_alt ();
 
   get_asm_operands_in_out (body, &n_outputs, &n_inputs);
 

diff --git a/gcc/regcprop.c b/gcc/regcprop.c
index d55ee33a9e1bd828e2ab837691f309e37a4a541c..56efc948a7c795d1cf18b109dadf22a2ef41f4bd 100644 (file)
--- a/gcc/regcprop.c
+++ b/gcc/regcprop.c
@@ -775,20 +775,17 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
       if (! constrain_operands (1))
        fatal_insn_not_found (insn);
       preprocess_constraints ();
-      operand_alternative *op_alt = which_op_alt ();
+      const operand_alternative *op_alt = which_op_alt ();
       n_ops = recog_data.n_operands;
       is_asm = asm_noperands (PATTERN (insn)) >= 0;
 
-      /* Simplify the code below by rewriting things to reflect
-        matching constraints.  Also promote OP_OUT to OP_INOUT
+      /* Simplify the code below by promoting OP_OUT to OP_INOUT
         in predicated instructions.  */
 
       predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
       for (i = 0; i < n_ops; ++i)
        {
          int matches = op_alt[i].matches;
-         if (matches >= 0)
-           op_alt[i].cl = op_alt[matches].cl;
          if (matches >= 0 || op_alt[i].matched >= 0
              || (predicated && recog_data.operand_type[i] == OP_OUT))
            recog_data.operand_type[i] = OP_INOUT;
@@ -939,12 +936,14 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
              if (op_alt[i].is_address)
                replaced[i]
                  = replace_oldest_value_addr (recog_data.operand_loc[i],
-                                              op_alt[i].cl, VOIDmode,
-                                              ADDR_SPACE_GENERIC, insn, vd);
+                                              alternative_class (op_alt, i),
+                                              VOIDmode, ADDR_SPACE_GENERIC,
+                                              insn, vd);
              else if (REG_P (recog_data.operand[i]))
                replaced[i]
                  = replace_oldest_value_reg (recog_data.operand_loc[i],
-                                             op_alt[i].cl, insn, vd);
+                                             alternative_class (op_alt, i),
+                                             insn, vd);
              else if (MEM_P (recog_data.operand[i]))
                replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
                                                        insn, vd);

diff --git a/gcc/regrename.c b/gcc/regrename.c
index df543c3697aa8b49b1e929e1ec89b68301a39808..fa6ed49d1dfddce44645ed5ddd360269c6438acc 100644 (file)
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -1427,7 +1427,7 @@ hide_operands (int n_ops, rtx *old_operands, rtx *old_dups,
               unsigned HOST_WIDE_INT do_not_hide, bool inout_and_ec_only)
 {
   int i;
-  operand_alternative *op_alt = which_op_alt ();
+  const operand_alternative *op_alt = which_op_alt ();
   for (i = 0; i < n_ops; i++)
     {
       old_operands[i] = recog_data.operand[i];
@@ -1478,7 +1478,7 @@ static void
 record_out_operands (rtx insn, bool earlyclobber, insn_rr_info *insn_info)
 {
   int n_ops = recog_data.n_operands;
-  operand_alternative *op_alt = which_op_alt ();
+  const operand_alternative *op_alt = which_op_alt ();
 
   int i;
 
@@ -1489,7 +1489,7 @@ record_out_operands (rtx insn, bool earlyclobber, insn_rr_info *insn_info)
                  ? recog_data.operand_loc[opn]
                  : recog_data.dup_loc[i - n_ops]);
       rtx op = *loc;
-      enum reg_class cl = op_alt[opn].cl;
+      enum reg_class cl = alternative_class (op_alt, opn);
 
       struct du_head *prev_open;
 
@@ -1571,7 +1571,7 @@ build_def_use (basic_block bb)
          if (! constrain_operands (1))
            fatal_insn_not_found (insn);
          preprocess_constraints ();
-         operand_alternative *op_alt = which_op_alt ();
+         const operand_alternative *op_alt = which_op_alt ();
          n_ops = recog_data.n_operands;
          untracked_operands = 0;
 
@@ -1584,8 +1584,7 @@ build_def_use (basic_block bb)
                      sizeof (operand_rr_info) * recog_data.n_operands);
            }
 
-         /* Simplify the code below by rewriting things to reflect
-            matching constraints.  Also promote OP_OUT to OP_INOUT in
+         /* Simplify the code below by promoting OP_OUT to OP_INOUT in
             predicated instructions, but only for register operands
             that are already tracked, so that we can create a chain
             when the first SET makes a register live.  */
@@ -1595,8 +1594,6 @@ build_def_use (basic_block bb)
            {
              rtx op = recog_data.operand[i];
              int matches = op_alt[i].matches;
-             if (matches >= 0)
-               op_alt[i].cl = op_alt[matches].cl;
              if (matches >= 0 || op_alt[i].matched >= 0
                  || (predicated && recog_data.operand_type[i] == OP_OUT))
                {
@@ -1681,7 +1678,7 @@ build_def_use (basic_block bb)
              rtx *loc = (i < n_ops
                          ? recog_data.operand_loc[opn]
                          : recog_data.dup_loc[i - n_ops]);
-             enum reg_class cl = op_alt[opn].cl;
+             enum reg_class cl = alternative_class (op_alt, opn);
              enum op_type type = recog_data.operand_type[opn];
 
              /* Don't scan match_operand here, since we've no reg class

diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index 435cfa535a7df9344b09cde82f7ad7b5c15a00b4..fb93f92a2bc9e85089e4dd27e922395cc55df19a 100644 (file)
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -1022,14 +1022,7 @@ get_reg_class (rtx insn)
   preprocess_constraints ();
   n_ops = recog_data.n_operands;
 
-  operand_alternative *op_alt = which_op_alt ();
-  for (i = 0; i < n_ops; ++i)
-    {
-      int matches = op_alt[i].matches;
-      if (matches >= 0)
-       op_alt[i].cl = op_alt[matches].cl;
-    }
-
+  const operand_alternative *op_alt = which_op_alt ();
   if (asm_noperands (PATTERN (insn)) > 0)
     {
       for (i = 0; i < n_ops; i++)
@@ -1037,7 +1030,7 @@ get_reg_class (rtx insn)
          {
            rtx *loc = recog_data.operand_loc[i];
            rtx op = *loc;
-           enum reg_class cl = op_alt[i].cl;
+           enum reg_class cl = alternative_class (op_alt, i);
 
            if (REG_P (op)
                && REGNO (op) == ORIGINAL_REGNO (op))
@@ -1051,7 +1044,7 @@ get_reg_class (rtx insn)
       for (i = 0; i < n_ops + recog_data.n_dups; i++)
        {
         int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
-        enum reg_class cl = op_alt[opn].cl;
+        enum reg_class cl = alternative_class (op_alt, opn);
 
         if (recog_data.operand_type[opn] == OP_OUT ||
             recog_data.operand_type[opn] == OP_INOUT)