gcc/

[pf3gnuchains/gcc-fork.git] / gcc / reload.c

diff --git a/gcc/reload.c b/gcc/reload.c
index e396e25..b1f94b2 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -264,7 +264,7 @@ static void combine_reloads (void);
 static int find_reusable_reload (rtx *, rtx, enum reg_class,
                                 enum reload_type, int, int);
 static rtx find_dummy_reload (rtx, rtx, rtx *, rtx *, enum machine_mode,
-                             enum machine_mode, enum reg_class, int, int);
+                             enum machine_mode, reg_class_t, int, int);
 static int hard_reg_set_here_p (unsigned int, unsigned int, rtx);
 static struct decomposition decompose (rtx);
 static int immune_p (rtx, rtx, struct decomposition);
@@ -1224,21 +1224,20 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc,
   /* Narrow down the class of register wanted if that is
      desirable on this machine for efficiency.  */
   {
-    enum reg_class preferred_class = rclass;
+    reg_class_t preferred_class = rclass;
 
     if (in != 0)
-      preferred_class = PREFERRED_RELOAD_CLASS (in, rclass);
+      preferred_class = targetm.preferred_reload_class (in, rclass);
 
-  /* Output reloads may need analogous treatment, different in detail.  */
-#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
+    /* Output reloads may need analogous treatment, different in detail.  */
     if (out != 0)
-      preferred_class = PREFERRED_OUTPUT_RELOAD_CLASS (out, preferred_class);
-#endif
+      preferred_class
+       = targetm.preferred_output_reload_class (out, preferred_class);
 
     /* Discard what the target said if we cannot do it.  */
     if (preferred_class != NO_REGS
        || (optional && type == RELOAD_FOR_OUTPUT))
-      rclass = preferred_class;
+      rclass = (enum reg_class) preferred_class;
   }
 
   /* Make sure we use a class that can handle the actual pseudo
@@ -1920,7 +1919,7 @@ combine_reloads (void)
 static rtx
 find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
                   enum machine_mode inmode, enum machine_mode outmode,
-                  enum reg_class rclass, int for_real, int earlyclobber)
+                  reg_class_t rclass, int for_real, int earlyclobber)
 {
   rtx in = real_in;
   rtx out = real_out;
@@ -1963,9 +1962,9 @@ find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc,
   /* Narrow down the reg class, the same way push_reload will;
      otherwise we might find a dummy now, but push_reload won't.  */
   {
-    enum reg_class preferred_class = PREFERRED_RELOAD_CLASS (in, rclass);
+    reg_class_t preferred_class = targetm.preferred_reload_class (in, rclass);
     if (preferred_class != NO_REGS)
-      rclass = preferred_class;
+      rclass = (enum reg_class) preferred_class;
   }
 
   /* See if OUT will do.  */
@@ -2588,14 +2587,14 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
   enum reload_usage { RELOAD_READ, RELOAD_READ_WRITE, RELOAD_WRITE } modified[MAX_RECOG_OPERANDS];
   int no_input_reloads = 0, no_output_reloads = 0;
   int n_alternatives;
-  enum reg_class this_alternative[MAX_RECOG_OPERANDS];
+  reg_class_t this_alternative[MAX_RECOG_OPERANDS];
   char this_alternative_match_win[MAX_RECOG_OPERANDS];
   char this_alternative_win[MAX_RECOG_OPERANDS];
   char this_alternative_offmemok[MAX_RECOG_OPERANDS];
   char this_alternative_earlyclobber[MAX_RECOG_OPERANDS];
   int this_alternative_matches[MAX_RECOG_OPERANDS];
   int swapped;
-  int goal_alternative[MAX_RECOG_OPERANDS];
+  reg_class_t goal_alternative[MAX_RECOG_OPERANDS];
   int this_alternative_number;
   int goal_alternative_number = 0;
   int operand_reloadnum[MAX_RECOG_OPERANDS];
@@ -3506,7 +3505,8 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
                 precisely the same as in the code below that calls
                 force_const_mem.  */
              if (CONST_POOL_OK_P (operand)
-                 && ((PREFERRED_RELOAD_CLASS (operand, this_alternative[i])
+                 && ((targetm.preferred_reload_class (operand,
+                                                      this_alternative[i])
                       == NO_REGS)
                      || no_input_reloads)
                  && operand_mode[i] != VOIDmode)
@@ -3534,17 +3534,15 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
 
              if (! CONSTANT_P (operand) && this_alternative[i] != NO_REGS)
                {
-                 if (PREFERRED_RELOAD_CLASS (operand, this_alternative[i])
+                 if (targetm.preferred_reload_class (operand, this_alternative[i])
                      == NO_REGS)
                    reject = 600;
 
-#ifdef PREFERRED_OUTPUT_RELOAD_CLASS
                  if (operand_type[i] == RELOAD_FOR_OUTPUT
-                     && (PREFERRED_OUTPUT_RELOAD_CLASS (operand,
-                                                       this_alternative[i])
+                     && (targetm.preferred_output_reload_class (operand,
+                                                                this_alternative[i])
                          == NO_REGS))
                    reject = 600;
-#endif
                }
 
              /* We prefer to reload pseudos over reloading other things,
@@ -3915,8 +3913,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
          }
 
        if (CONST_POOL_OK_P (op)
-           && ((PREFERRED_RELOAD_CLASS (op,
-                                        (enum reg_class) goal_alternative[i])
+           && ((targetm.preferred_reload_class (op, goal_alternative[i])
                 == NO_REGS)
                || no_input_reloads)
            && mode != VOIDmode)
@@ -4094,7 +4091,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
            /* If this is only for an output, the optional reload would not
               actually cause us to use a register now, just note that
               something is stored here.  */
-           && ((enum reg_class) goal_alternative[i] != NO_REGS
+           && (goal_alternative[i] != NO_REGS
                || modified[i] == RELOAD_WRITE)
            && ! no_input_reloads
            /* An optional output reload might allow to delete INSN later.
@@ -4168,8 +4165,7 @@ find_reloads (rtx insn, int replace, int ind_levels, int live_known,
        if ((MEM_P (operand)
             || (REG_P (operand)
                 && REGNO (operand) >= FIRST_PSEUDO_REGISTER))
-           && ((enum reg_class) goal_alternative[goal_alternative_matches[i]]
-               != NO_REGS))
+           && (goal_alternative[goal_alternative_matches[i]] != NO_REGS))
          operand_reloadnum[i] = operand_reloadnum[goal_alternative_matches[i]]
            = push_reload (recog_data.operand[goal_alternative_matches[i]],
                           recog_data.operand[i],
@@ -6048,7 +6044,7 @@ find_reloads_address_part (rtx x, rtx *loc, enum reg_class rclass,
 {
   if (CONSTANT_P (x)
       && (! LEGITIMATE_CONSTANT_P (x)
-         || PREFERRED_RELOAD_CLASS (x, rclass) == NO_REGS))
+         || targetm.preferred_reload_class (x, rclass) == NO_REGS))
     {
       x = force_const_mem (mode, x);
       find_reloads_address (mode, &x, XEXP (x, 0), &XEXP (x, 0),
@@ -6058,7 +6054,8 @@ find_reloads_address_part (rtx x, rtx *loc, enum reg_class rclass,
   else if (GET_CODE (x) == PLUS
           && CONSTANT_P (XEXP (x, 1))
           && (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
-              || PREFERRED_RELOAD_CLASS (XEXP (x, 1), rclass) == NO_REGS))
+              || targetm.preferred_reload_class (XEXP (x, 1), rclass)
+                  == NO_REGS))
     {
       rtx tem;