* expmed.c (expand_mult): Force operand to register before computing

	cost.
	* i386.c (x86_decompose_lea): New global vairable.
	* i386.h (x86_decompose_lea): Declare.
	(TARGET_DECOMPOSE_LEA): New macro.
	(RTX_COST): Handle leas properly.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@46823 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f2f2c5b..fcac3da 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+Wed Nov  7 13:33:34 CET 2001  Jan Hubicka  <jh@suse.cz>
+
+       * expmed.c (expand_mult): Force operand to register before computing
+       cost.
+       * i386.c (x86_decompose_lea): New global vairable.
+       * i386.h (x86_decompose_lea): Declare.
+       (TARGET_DECOMPOSE_LEA): New macro.
+       (RTX_COST): Handle leas properly.
+
 2001-11-06  Richard Henderson  <rth@redhat.com>
 
        * config/alpha/elf.h (DO_SELECT_SECTION): TREE_READONLY is not

diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 44353a9..47f8e78 100644 (file)
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -375,6 +375,7 @@ const int x86_memory_mismatch_stall = m_ATHLON | m_PENT4;
 const int x86_accumulate_outgoing_args = m_ATHLON | m_PENT4 | m_PPRO;
 const int x86_prologue_using_move = m_ATHLON | m_PENT4 | m_PPRO;
 const int x86_epilogue_using_move = m_ATHLON | m_PENT4 | m_PPRO;
+const int x86_decompose_lea = m_PENT4;
 
 /* In case the avreage insn count for single function invocation is
    lower than this constant, emit fast (but longer) prologue and

diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index a23644a..7edfc28 100644 (file)
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -218,7 +218,7 @@ extern const int x86_promote_hi_regs, x86_integer_DFmode_moves;
 extern const int x86_add_esp_4, x86_add_esp_8, x86_sub_esp_4, x86_sub_esp_8;
 extern const int x86_partial_reg_dependency, x86_memory_mismatch_stall;
 extern const int x86_accumulate_outgoing_args, x86_prologue_using_move;
-extern const int x86_epilogue_using_move;
+extern const int x86_epilogue_using_move, x86_decompose_lea;
 
 #define TARGET_USE_LEAVE (x86_use_leave & CPUMASK)
 #define TARGET_PUSH_MEMORY (x86_push_memory & CPUMASK)
@@ -256,6 +256,7 @@ extern const int x86_epilogue_using_move;
 #define TARGET_MEMORY_MISMATCH_STALL (x86_memory_mismatch_stall & CPUMASK)
 #define TARGET_PROLOGUE_USING_MOVE (x86_prologue_using_move & CPUMASK)
 #define TARGET_EPILOGUE_USING_MOVE (x86_epilogue_using_move & CPUMASK)
+#define TARGET_DECOMPOSE_LEA (x86_decompose_lea & CPUMASK)
 
 #define TARGET_STACK_PROBE (target_flags & MASK_STACK_PROBE)
 
@@ -2485,7 +2486,9 @@ while (0)
        HOST_WIDE_INT value = INTVAL (XEXP (X, 1));                     \
        if (value == 1)                                                 \
          TOPLEVEL_COSTS_N_INSNS (ix86_cost->add);                      \
-       if (value == 2 || value == 3)                                   \
+       if ((value == 2 || value == 3)                                  \
+           && !TARGET_DECOMPOSE_LEA                                    \
+           && ix86_cost->lea <= ix86_cost->shift_const)                \
          TOPLEVEL_COSTS_N_INSNS (ix86_cost->lea);                      \
       }                                                                        \
     /* fall through */                                                 \
@@ -2546,38 +2549,43 @@ while (0)
     TOPLEVEL_COSTS_N_INSNS (ix86_cost->divide);                                \
                                                                        \
   case PLUS:                                                           \
-    if (GET_CODE (XEXP (X, 0)) == PLUS                                 \
-       && GET_CODE (XEXP (XEXP (X, 0), 0)) == MULT                     \
-       && GET_CODE (XEXP (XEXP (XEXP (X, 0), 0), 1)) == CONST_INT      \
-       && GET_CODE (XEXP (X, 1)) == CONST_INT)                         \
+    if (!TARGET_DECOMPOSE_LEA                                          \
+       && INTEGRAL_MODE_P (GET_MODE (X))                               \
+       && GET_MODE_BITSIZE (GET_MODE (X)) <= GET_MODE_BITSIZE (Pmode)) \
       {                                                                        \
-       HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (X, 0), 0), 1));   \
-       if (val == 2 || val == 4 || val == 8)                           \
+        if (GET_CODE (XEXP (X, 0)) == PLUS                             \
+           && GET_CODE (XEXP (XEXP (X, 0), 0)) == MULT                 \
+           && GET_CODE (XEXP (XEXP (XEXP (X, 0), 0), 1)) == CONST_INT  \
+           && CONSTANT_P (XEXP (X, 1)))                                \
          {                                                             \
-            return (COSTS_N_INSNS (ix86_cost->lea)                     \
-                   + rtx_cost (XEXP (XEXP (X, 0), 1), OUTER_CODE)      \
-                   + rtx_cost (XEXP (XEXP (XEXP (X, 0), 0), 0), OUTER_CODE) \
-                   + rtx_cost (XEXP (X, 1), OUTER_CODE));              \
+           HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (X, 0), 0), 1));\
+           if (val == 2 || val == 4 || val == 8)                       \
+             {                                                         \
+               return (COSTS_N_INSNS (ix86_cost->lea)                  \
+                       + rtx_cost (XEXP (XEXP (X, 0), 1), OUTER_CODE)  \
+                       + rtx_cost (XEXP (XEXP (XEXP (X, 0), 0), 0), OUTER_CODE) \
+                       + rtx_cost (XEXP (X, 1), OUTER_CODE));          \
+             }                                                         \
          }                                                             \
-      }                                                                        \
-    else if (GET_CODE (XEXP (X, 0)) == MULT                            \
-            && GET_CODE (XEXP (XEXP (X, 0), 1)) == CONST_INT)          \
-      {                                                                        \
-       HOST_WIDE_INT val = INTVAL (XEXP (XEXP (X, 0), 1));             \
-       if (val == 2 || val == 4 || val == 8)                           \
+       else if (GET_CODE (XEXP (X, 0)) == MULT                         \
+                && GET_CODE (XEXP (XEXP (X, 0), 1)) == CONST_INT)      \
+         {                                                             \
+           HOST_WIDE_INT val = INTVAL (XEXP (XEXP (X, 0), 1));         \
+           if (val == 2 || val == 4 || val == 8)                       \
+             {                                                         \
+               return (COSTS_N_INSNS (ix86_cost->lea)                  \
+                       + rtx_cost (XEXP (XEXP (X, 0), 0), OUTER_CODE)  \
+                       + rtx_cost (XEXP (X, 1), OUTER_CODE));          \
+             }                                                         \
+         }                                                             \
+       else if (GET_CODE (XEXP (X, 0)) == PLUS)                        \
          {                                                             \
            return (COSTS_N_INSNS (ix86_cost->lea)                      \
                    + rtx_cost (XEXP (XEXP (X, 0), 0), OUTER_CODE)      \
+                   + rtx_cost (XEXP (XEXP (X, 0), 1), OUTER_CODE)      \
                    + rtx_cost (XEXP (X, 1), OUTER_CODE));              \
          }                                                             \
       }                                                                        \
-    else if (GET_CODE (XEXP (X, 0)) == PLUS)                           \
-      {                                                                        \
-       return (COSTS_N_INSNS (ix86_cost->lea)                          \
-               + rtx_cost (XEXP (XEXP (X, 0), 0), OUTER_CODE)          \
-               + rtx_cost (XEXP (XEXP (X, 0), 1), OUTER_CODE)          \
-               + rtx_cost (XEXP (X, 1), OUTER_CODE));                  \
-      }                                                                        \
                                                                        \
     /* fall through */                                                 \
   case AND:                                                            \

diff --git a/gcc/expmed.c b/gcc/expmed.c
index 10c5141..9435a62 100644 (file)
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -2406,6 +2406,10 @@ expand_mult (mode, op0, op1, target, unsignedp)
       int mult_cost;
       enum {basic_variant, negate_variant, add_variant} variant = basic_variant;
 
+      /* op0 must be register to make mult_cost match the precomputed
+         shiftadd_cost array.  */
+      op0 = force_reg (mode, op0);
+
       /* Try to do the computation three ways: multiply by the negative of OP1
         and then negate, do the multiplication directly, or do multiplication
         by OP1 - 1.  */