Check SMALL_REGISTER_CLASSES at runtime

From-SVN: r13302

diff --git a/gcc/calls.c b/gcc/calls.c
index c9c2258361232d5d9a85e0f3a3cc55d0f94dc50c..b144845c7cd66d550101c0aab352e27f23eed40f 100644 (file)
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -271,10 +271,11 @@ prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
 #ifdef SMALL_REGISTER_CLASSES
     /* If we are using registers for parameters, force the
         function address into a register now.  */
-      reg_parm_seen ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
-                   :
+      (SMALL_REGISTER_CLASSES && reg_parm_seen)
+       ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
+       :
 #endif
-                     memory_address (FUNCTION_MODE, funexp);
+         memory_address (FUNCTION_MODE, funexp);
   else
     {
 #ifndef NO_FUNCTION_CSE
@@ -1657,7 +1658,8 @@ expand_call (exp, target, ignore)
            && args[i].mode != BLKmode
            && rtx_cost (args[i].value, SET) > 2
 #ifdef SMALL_REGISTER_CLASSES
-           && (reg_parm_seen || preserve_subexpressions_p ())
+           && ((SMALL_REGISTER_CLASSES && reg_parm_seen)
+               || preserve_subexpressions_p ())
 #else
            && preserve_subexpressions_p ()
 #endif

diff --git a/gcc/combine.c b/gcc/combine.c
index 472767ae6df2c19bef11c1016b6a3ca6ded6210c..38641104f19590dd11822b881e2d0f872fb12ae8 100644 (file)
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -967,9 +967,10 @@ can_combine_p (insn, i3, pred, succ, pdest, psrc)
              || (REGNO (src) < FIRST_PSEUDO_REGISTER
                  && (! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src))
 #ifdef SMALL_REGISTER_CLASSES
-                     || (! all_adjacent && ! REG_USERVAR_P (src))
-                     || (FUNCTION_VALUE_REGNO_P (REGNO (src))
-                         && ! REG_USERVAR_P (src))
+                     || (SMALL_REGISTER_CLASSES
+                         && ((! all_adjacent && ! REG_USERVAR_P (src))
+                             || (FUNCTION_VALUE_REGNO_P (REGNO (src))
+                                 && ! REG_USERVAR_P (src))))
 #endif
                      ))))
        return 0;
@@ -1152,7 +1153,8 @@ combinable_i3pat (i3, loc, i2dest, i1dest, i1_not_in_src, pi3dest_killed)
              && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
                                        GET_MODE (inner_dest))
 #ifdef SMALL_REGISTER_CLASSES
-                || (GET_CODE (src) != CALL && ! REG_USERVAR_P (inner_dest)
+                || (SMALL_REGISTER_CLASSES
+                    && GET_CODE (src) != CALL && ! REG_USERVAR_P (inner_dest)
                     && FUNCTION_VALUE_REGNO_P (REGNO (inner_dest)))
 #endif
                  ))
@@ -1296,7 +1298,8 @@ try_combine (i3, i2, i1)
       && GET_CODE (SET_SRC (PATTERN (i3))) == REG
       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
 #ifdef SMALL_REGISTER_CLASSES
-      && (GET_CODE (SET_DEST (PATTERN (i3))) != REG
+      && (! SMALL_REGISTER_CLASSES
+         || GET_CODE (SET_DEST (PATTERN (i3))) != REG
          || REGNO (SET_DEST (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
          || REG_USERVAR_P (SET_DEST (PATTERN (i3))))
 #endif

diff --git a/gcc/cse.c b/gcc/cse.c
index 3649e7b0ee6dd2d0e5eef3d1e1c065b46ed76cb8..e6c7e9f5e6e88f7f8bfea77a1eb74d9ec1fb6f9a 100644 (file)
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -1891,7 +1891,8 @@ canon_hash (x, mode)
        if (regno < FIRST_PSEUDO_REGISTER
            && (global_regs[regno]
 #ifdef SMALL_REGISTER_CLASSES
-               || (! fixed_regs[regno]
+               || (SMALL_REGISTER_CLASSES
+                   && ! fixed_regs[regno]
                    && regno != FRAME_POINTER_REGNUM
                    && regno != HARD_FRAME_POINTER_REGNUM
                    && regno != ARG_POINTER_REGNUM

diff --git a/gcc/function.c b/gcc/function.c
index 77a7566a6a84a49dac0744cb69193aed81bb06fc..d488be1936c1acb92bc7cf4981216e1d17f79235 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -1578,27 +1578,30 @@ fixup_var_refs_insns (var, promoted_mode, unsignedp, insn, toplevel)
                 of the CALL_INSN and see if the next insn uses both that
                 and VAR.  */
 
-             if (call_dest != 0 && GET_CODE (insn) == INSN
-                 && reg_mentioned_p (var, PATTERN (insn))
-                 && reg_mentioned_p (call_dest, PATTERN (insn)))
+             if (SMALL_REGISTER_CLASSES)
                {
-                 rtx temp = gen_reg_rtx (GET_MODE (call_dest));
+                 if (call_dest != 0 && GET_CODE (insn) == INSN
+                     && reg_mentioned_p (var, PATTERN (insn))
+                     && reg_mentioned_p (call_dest, PATTERN (insn)))
+                   {
+                     rtx temp = gen_reg_rtx (GET_MODE (call_dest));
 
-                 emit_insn_before (gen_move_insn (temp, call_dest), insn);
+                     emit_insn_before (gen_move_insn (temp, call_dest), insn);
 
-                 PATTERN (insn) = replace_rtx (PATTERN (insn),
-                                               call_dest, temp);
-               }
+                     PATTERN (insn) = replace_rtx (PATTERN (insn),
+                                                   call_dest, temp);
+                   }
              
-             if (GET_CODE (insn) == CALL_INSN
-                 && GET_CODE (PATTERN (insn)) == SET)
-               call_dest = SET_DEST (PATTERN (insn));
-             else if (GET_CODE (insn) == CALL_INSN
-                      && GET_CODE (PATTERN (insn)) == PARALLEL
-                      && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
-               call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
-             else
-               call_dest = 0;
+                 if (GET_CODE (insn) == CALL_INSN
+                     && GET_CODE (PATTERN (insn)) == SET)
+                   call_dest = SET_DEST (PATTERN (insn));
+                 else if (GET_CODE (insn) == CALL_INSN
+                          && GET_CODE (PATTERN (insn)) == PARALLEL
+                          && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
+                   call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
+                 else
+                   call_dest = 0;
+               }
 #endif
 
              /* See if we have to do anything to INSN now that VAR is in
@@ -5163,7 +5166,8 @@ expand_function_start (subr, parms_have_cleanups)
 #ifdef SMALL_REGISTER_CLASSES
       /* Delay copying static chain if it is not a register to avoid
         conflicts with regs used for parameters.  */
-      if (GET_CODE (static_chain_incoming_rtx) == REG)
+      if (! SMALL_REGISTER_CLASSES
+         || GET_CODE (static_chain_incoming_rtx) == REG)
 #endif
         emit_move_insn (last_ptr, static_chain_incoming_rtx);
     }
@@ -5277,7 +5281,7 @@ expand_function_start (subr, parms_have_cleanups)
   /* Copy the static chain now if it wasn't a register.  The delay is to
      avoid conflicts with the parameter passing registers.  */
 
-  if (current_function_needs_context)
+  if (SMALL_REGISTER_CLASSES && current_function_needs_context)
       if (GET_CODE (static_chain_incoming_rtx) != REG)
         emit_move_insn (last_ptr, static_chain_incoming_rtx);
 #endif
@@ -5319,7 +5323,8 @@ expand_function_start (subr, parms_have_cleanups)
          /* If the static chain originally came in a register, put it back
             there, then move it out in the next insn.  The reason for
             this peculiar code is to satisfy function integration.  */
-         if (GET_CODE (static_chain_incoming_rtx) == REG)
+         if (SMALL_REGISTER_CLASSES
+             && GET_CODE (static_chain_incoming_rtx) == REG)
            emit_move_insn (static_chain_incoming_rtx, last_ptr);
 #endif
 

diff --git a/gcc/jump.c b/gcc/jump.c
index 839421f5a0f3e8b68304ef19194e7c85b0f71366..5353c58fdccea0d2ac8a229faa021961fe67c021 100644 (file)
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -761,7 +761,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && (temp4 = single_set (temp3)) != 0
              && GET_CODE (temp1 = SET_DEST (temp4)) == REG
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
 #endif
              && (temp2 = next_active_insn (insn)) != 0
              && GET_CODE (temp2) == INSN
@@ -898,7 +899,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && (temp4 = single_set (temp2)) != 0
              && GET_CODE (temp1 = SET_DEST (temp4)) == REG
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
 #endif
 
              && (temp3 = prev_active_insn (insn)) != 0
@@ -987,7 +989,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 #endif
              && GET_CODE (SET_SRC (temp1)) != REG
              && GET_CODE (SET_SRC (temp1)) != SUBREG
@@ -1029,7 +1032,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && (temp2 = SET_DEST (temp1), GET_CODE (temp2) == REG)
              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 #endif
              && ! side_effects_p (SET_SRC (temp1))
              && ! may_trap_p (SET_SRC (temp1))
@@ -1090,7 +1094,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && (temp2 = SET_DEST (temp4), GET_CODE (temp2) == REG)
              && GET_MODE_CLASS (GET_MODE (temp2)) == MODE_INT
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp2) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp2) >= FIRST_PSEUDO_REGISTER)
 #endif
              && rtx_equal_p (SET_DEST (temp4), temp2)
              && ! side_effects_p (SET_SRC (temp4))
@@ -1143,7 +1148,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
              && GET_CODE (PATTERN (temp)) == SET
              && GET_CODE (temp1 = SET_DEST (PATTERN (temp))) == REG
 #ifdef SMALL_REGISTER_CLASSES
-             && REGNO (temp1) >= FIRST_PSEUDO_REGISTER
+             && (! SMALL_REGISTER_CLASSES
+                 || REGNO (temp1) >= FIRST_PSEUDO_REGISTER)
 #endif
              && (GET_CODE (temp2 = SET_SRC (PATTERN (temp))) == REG
                  || GET_CODE (temp2) == SUBREG

diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index ab8f47a2d9c8df604e37186aa114c513b72d0544..b41a99b75f9892d59d884b9f62079e16c3df2a88 100644 (file)
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -715,7 +715,9 @@ optimize_reg_copy_1 (insn, dest, src)
   if (sregno == dregno
 #ifdef SMALL_REGISTER_CLASSES
       /* We don't want to mess with hard regs if register classes are small. */
-      || sregno < FIRST_PSEUDO_REGISTER || dregno < FIRST_PSEUDO_REGISTER
+      || (SMALL_REGISTER_CLASSES
+         && (sregno < FIRST_PSEUDO_REGISTER
+             || dregno < FIRST_PSEUDO_REGISTER))
 #endif
       /* We don't see all updates to SP if they are in an auto-inc memory
         reference, so we must disallow this optimization on them.  */

diff --git a/gcc/loop.c b/gcc/loop.c
index ab20d99f3ee233f15e0c3d98273b97e8b98674d8..2ffad5fe41d302fe3b715ecae9773f30442a0b5e 100644 (file)
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -742,7 +742,8 @@ scan_loop (loop_start, end, nregs)
                  && ! side_effects_p (SET_SRC (set))
                  && ! find_reg_note (p, REG_RETVAL, NULL_RTX)
 #ifdef SMALL_REGISTER_CLASSES
-                 && ! (GET_CODE (SET_SRC (set)) == REG
+                 && ! (SMALL_REGISTER_CLASSES
+                       && GET_CODE (SET_SRC (set)) == REG
                        && REGNO (SET_SRC (set)) < FIRST_PSEUDO_REGISTER)
 #endif
                  /* This test is not redundant; SET_SRC (set) might be
@@ -4257,9 +4258,13 @@ valid_initial_value_p (x, insn, call_seen, loop_start)
   /* Don't use call-clobbered registers across a call which clobbers it.  On
      some machines, don't use any hard registers at all.  */
   if (REGNO (x) < FIRST_PSEUDO_REGISTER
-#ifndef SMALL_REGISTER_CLASSES
-      && call_used_regs[REGNO (x)] && call_seen
+      && (
+#ifdef SMALL_REGISTER_CLASSES
+          SMALL_REGISTER_CLASSES
+#else
+         0
 #endif
+           || (call_used_regs[REGNO (x)] && call_seen))
       )
     return 0;
 

diff --git a/gcc/reload.c b/gcc/reload.c
index 049c3a008b25f1d4fcf86e236308165c63adf777..6d8b2b9a5c4721a43c387de4b8a58db91d221175 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -477,7 +477,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
                              == CODE_FOR_nothing)))
            && (reg_class_size[(int) t_class] == 1
 #ifdef SMALL_REGISTER_CLASSES
-               || 1
+               || SMALL_REGISTER_CLASSES
 #endif
                )
            && MERGABLE_RELOADS (secondary_type,
@@ -538,7 +538,7 @@ push_secondary_reload (in_p, x, opnum, optional, reload_class, reload_mode,
            || (! in_p && reload_secondary_out_icode[s_reload] == t_icode))
        && (reg_class_size[(int) class] == 1
 #ifdef SMALL_REGISTER_CLASSES
-           || 1
+           || SMALL_REGISTER_CLASSES
 #endif
            )
        && MERGABLE_RELOADS (secondary_type, reload_when_needed[s_reload],
@@ -1157,7 +1157,7 @@ push_reload (in, out, inloc, outloc, class,
             && (in == 0 || reload_in[i] == 0 || MATCHES (reload_in[i], in))))
        && (reg_class_size[(int) class] == 1
 #ifdef SMALL_REGISTER_CLASSES
-           || 1
+           || SMALL_REGISTER_CLASSES
 #endif
            )
        && MERGABLE_RELOADS (type, reload_when_needed[i],
@@ -1193,7 +1193,7 @@ push_reload (in, out, inloc, outloc, class,
               && MATCHES (XEXP (in, 0), reload_in[i])))
          && (reg_class_size[(int) class] == 1
 #ifdef SMALL_REGISTER_CLASSES
-             || 1
+             || SMALL_REGISTER_CLASSES
 #endif
              )
          && MERGABLE_RELOADS (type, reload_when_needed[i],
@@ -1534,14 +1534,17 @@ combine_reloads ()
            || rtx_equal_p (secondary_memlocs_elim[(int) reload_outmode[output_reload]][reload_opnum[i]],
                            secondary_memlocs_elim[(int) reload_outmode[output_reload]][reload_opnum[output_reload]]))
 #endif
+       && (
 #ifdef SMALL_REGISTER_CLASSES
-       && reload_reg_class[i] == reload_reg_class[output_reload]
+           SMALL_REGISTER_CLASSES
 #else
-       && (reg_class_subset_p (reload_reg_class[i],
-                               reload_reg_class[output_reload])
-           || reg_class_subset_p (reload_reg_class[output_reload],
-                                  reload_reg_class[i]))
+           0
 #endif
+             ? reload_reg_class[i] == reload_reg_class[output_reload]
+             : (reg_class_subset_p (reload_reg_class[i],
+                                    reload_reg_class[output_reload])
+                || reg_class_subset_p (reload_reg_class[output_reload],
+                                       reload_reg_class[i])))
        && (MATCHES (reload_in[i], reload_out[output_reload])
            /* Args reversed because the first arg seems to be
               the one that we imagine being modified
@@ -1559,7 +1562,7 @@ combine_reloads ()
                                                             reload_out[output_reload]))))
        && (reg_class_size[(int) reload_reg_class[i]]
 #ifdef SMALL_REGISTER_CLASSES
-            || 1
+            || SMALL_REGISTER_CLASSES
 #endif
            )
        /* We will allow making things slightly worse by combining an

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 3bde16541abd3cae57b9ed68db1738289d9f591c..a102ccbaa0c881b5cc157b2d604645116b8c8e78 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -544,7 +544,8 @@ reload (first, global, dumpfile)
   bzero (cannot_omit_stores, max_regno);
 
 #ifdef SMALL_REGISTER_CLASSES
-  CLEAR_HARD_REG_SET (forbidden_regs);
+  if (SMALL_REGISTER_CLASSES)
+    CLEAR_HARD_REG_SET (forbidden_regs);
 #endif
 
   /* Look for REG_EQUIV notes; record what each pseudo is equivalent to.
@@ -722,9 +723,10 @@ reload (first, global, dumpfile)
      rtl as a spill register.  But on some, we have to.  Those will have
      taken care to keep the life of hard regs as short as possible.  */
 
-#ifndef SMALL_REGISTER_CLASSES
-  COPY_HARD_REG_SET (forbidden_regs, bad_spill_regs);
+#ifdef SMALL_REGISTER_CLASSES
+  if (! SMALL_REGISTER_CLASSES)
 #endif
+    COPY_HARD_REG_SET (forbidden_regs, bad_spill_regs);
 
   /* Spill any hard regs that we know we can't eliminate.  */
   for (ep = reg_eliminate; ep < &reg_eliminate[NUM_ELIMINABLE_REGS]; ep++)
@@ -986,7 +988,7 @@ reload (first, global, dumpfile)
 #ifdef SMALL_REGISTER_CLASSES
              /* Set avoid_return_reg if this is an insn
                 that might use the value of a function call.  */
-             if (GET_CODE (insn) == CALL_INSN)
+             if (SMALL_REGISTER_CLASSES && GET_CODE (insn) == CALL_INSN)
                {
                  if (GET_CODE (PATTERN (insn)) == SET)
                    after_call = SET_DEST (PATTERN (insn));
@@ -996,7 +998,8 @@ reload (first, global, dumpfile)
                  else
                    after_call = 0;
                }
-             else if (after_call != 0
+             else if (SMALL_REGISTER_CLASSES
+                      && after_call != 0
                       && !(GET_CODE (PATTERN (insn)) == SET
                            && SET_DEST (PATTERN (insn)) == stack_pointer_rtx))
                {
@@ -1344,7 +1347,7 @@ reload (first, global, dumpfile)
                 This makes sure we have a register available that does
                 not overlap the return value.  */
 
-             if (avoid_return_reg)
+             if (SMALL_REGISTER_CLASSES && avoid_return_reg)
                {
                  int regno = REGNO (avoid_return_reg);
                  int nregs
@@ -1702,7 +1705,7 @@ reload (first, global, dumpfile)
                  /* We can't complete a group, so start one.  */
 #ifdef SMALL_REGISTER_CLASSES
                  /* Look for a pair neither of which is explicitly used.  */
-                 if (i == FIRST_PSEUDO_REGISTER)
+                 if (SMALL_REGISTER_CLASSES && i == FIRST_PSEUDO_REGISTER)
                    for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
                      {
                        int k;
@@ -3584,7 +3587,9 @@ scan_paradoxical_subregs (x)
     {
     case REG:
 #ifdef SMALL_REGISTER_CLASSES
-      if (REGNO (x) < FIRST_PSEUDO_REGISTER && REG_USERVAR_P (x))
+      if (SMALL_REGISTER_CLASSES
+         && REGNO (x) < FIRST_PSEUDO_REGISTER
+         && REG_USERVAR_P (x))
        SET_HARD_REG_BIT (forbidden_regs, REGNO (x));
 #endif
       return;
@@ -3698,14 +3703,15 @@ order_regs_for_reload (global)
       else if (regs_explicitly_used[i])
        {
          hard_reg_n_uses[i].uses += large + 1;
-#ifndef SMALL_REGISTER_CLASSES
          /* ??? We are doing this here because of the potential that
             bad code may be generated if a register explicitly used in
             an insn was used as a spill register for that insn.  But
             not using these are spill registers may lose on some machine.
             We'll have to see how this works out.  */
-         SET_HARD_REG_BIT (bad_spill_regs, i);
+#ifdef SMALL_REGISTER_CLASSES
+         if (! SMALL_REGISTER_CLASSES)
 #endif
+           SET_HARD_REG_BIT (bad_spill_regs, i);
        }
     }
   hard_reg_n_uses[HARD_FRAME_POINTER_REGNUM].uses += 2 * large + 2;
@@ -3859,7 +3865,7 @@ reload_as_needed (first, live_known)
 #ifdef SMALL_REGISTER_CLASSES
          /* Set avoid_return_reg if this is an insn
             that might use the value of a function call.  */
-         if (GET_CODE (insn) == CALL_INSN)
+         if (SMALL_REGISTER_CLASSES && GET_CODE (insn) == CALL_INSN)
            {
              if (GET_CODE (PATTERN (insn)) == SET)
                after_call = SET_DEST (PATTERN (insn));
@@ -3869,7 +3875,8 @@ reload_as_needed (first, live_known)
              else
                after_call = 0;
            }
-         else if (after_call != 0
+         else if (SMALL_REGISTER_CLASSES
+                  && after_call != 0
                   && !(GET_CODE (PATTERN (insn)) == SET
                        && SET_DEST (PATTERN (insn)) == stack_pointer_rtx))
            {
@@ -3947,7 +3954,8 @@ reload_as_needed (first, live_known)
              /* Merge any reloads that we didn't combine for fear of 
                 increasing the number of spill registers needed but now
                 discover can be safely merged.  */
-             merge_assigned_reloads (insn);
+             if (SMALL_REGISTER_CLASSES)
+               merge_assigned_reloads (insn);
 #endif
 
              /* Generate the insns to reload operands into or out of
@@ -4991,7 +4999,7 @@ choose_reload_regs (insn, avoid_return_reg)
 #ifdef SMALL_REGISTER_CLASSES
   /* Don't bother with avoiding the return reg
      if we have no mandatory reload that could use it.  */
-  if (avoid_return_reg)
+  if (SMALL_REGISTER_CLASSES && avoid_return_reg)
     {
       int do_avoid = 0;
       int regno = REGNO (avoid_return_reg);
@@ -5024,7 +5032,8 @@ choose_reload_regs (insn, avoid_return_reg)
   {
     int tem = 0;
 #ifdef SMALL_REGISTER_CLASSES
-    int tem = (avoid_return_reg != 0);
+    if (SMALL_REGISTER_CLASSES)
+      tem = (avoid_return_reg != 0);
 #endif
     for (j = 0; j < n_reloads; j++)
       if (! reload_optional[j]
@@ -5041,7 +5050,7 @@ choose_reload_regs (insn, avoid_return_reg)
 #ifdef SMALL_REGISTER_CLASSES
   /* Don't use the subroutine call return reg for a reload
      if we are supposed to avoid it.  */
-  if (avoid_return_reg)
+  if (SMALL_REGISTER_CLASSES && avoid_return_reg)
     {
       int regno = REGNO (avoid_return_reg);
       int nregs