rtl.h (set_rtx_cost, [...]): New functions.

gcc/
	* rtl.h (set_rtx_cost, get_full_set_rtx_cost): New functions.
	* auto-inc-dec.c (attempt_change): Use set_rtx_cost.
	* cfgloopanal.c (seq_cost): Likewise.
	* loop-invariant.c (create_new_invariant): Likewise.
	* postreload.c (move2add_use_add2_insn, move2add_use_add3_insn)
	(reload_cse_move2add): Use get_full_set_rtx_cost.

From-SVN: r177850

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c9b49b67c0b42e09f61f3082abde9f14bc2e6279..f3a95bb3b0be342f64e54e9c47bbe3948c8ccc6a 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2011-08-18  Richard Sandiford  <richard.sandiford@linaro.org>
+
+       * rtl.h (set_rtx_cost, get_full_set_rtx_cost): New functions.
+       * auto-inc-dec.c (attempt_change): Use set_rtx_cost.
+       * cfgloopanal.c (seq_cost): Likewise.
+       * loop-invariant.c (create_new_invariant): Likewise.
+       * postreload.c (move2add_use_add2_insn, move2add_use_add3_insn)
+       (reload_cse_move2add): Use get_full_set_rtx_cost.
+
 2011-08-18  Richard Guenther  <rguenther@suse.de>
 
        * expr.c (get_inner_reference): Fix typo in last change.

diff --git a/gcc/auto-inc-dec.c b/gcc/auto-inc-dec.c
index dbd12e72f21e4f0fff9cba378d0ceb237d5f4365..0444daecf9be382d6e6fc469c2c9934ecef16128 100644 (file)
--- a/gcc/auto-inc-dec.c
+++ b/gcc/auto-inc-dec.c
@@ -484,7 +484,7 @@ attempt_change (rtx new_addr, rtx inc_reg)
   XEXP (mem_tmp, 0) = new_addr;
 
   old_cost = (rtx_cost (mem, SET, speed)
-             + rtx_cost (PATTERN (inc_insn.insn), SET, speed));
+             + set_rtx_cost (PATTERN (inc_insn.insn), speed));
   new_cost = rtx_cost (mem_tmp, SET, speed);
 
   /* The first item of business is to see if this is profitable.  */

diff --git a/gcc/cfgloopanal.c b/gcc/cfgloopanal.c
index 02f026576991ded3cf4e9396bd1abfacee2bd784..652fc4d8b622354171082982f8697e97f2d40204 100644 (file)
--- a/gcc/cfgloopanal.c
+++ b/gcc/cfgloopanal.c
@@ -314,7 +314,7 @@ seq_cost (const_rtx seq, bool speed)
     {
       set = single_set (seq);
       if (set)
-       cost += rtx_cost (set, SET, speed);
+       cost += set_rtx_cost (set, speed);
       else
        cost++;
     }

diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index b9238a9554fe30e6383f3d8c184367456bf85ce4..61ca446f079cc3dc8a27fdf367d4ce27f5f6f32f 100644 (file)
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -704,7 +704,7 @@ create_new_invariant (struct def *def, rtx insn, bitmap depends_on,
      the loop.  Otherwise we save only cost of the computation.  */
   if (def)
     {
-      inv->cost = rtx_cost (set, SET, speed);
+      inv->cost = set_rtx_cost (set, speed);
       /* ??? Try to determine cheapness of address computation.  Unfortunately
          the address cost is only a relative measure, we can't really compare
         it with any absolute number, but only with other address costs.

diff --git a/gcc/postreload.c b/gcc/postreload.c
index 72e487e057ff5abe4957e020500854caf8f1ea60..88b401f511ce21488ab1f78a95398aafe30c460c 100644 (file)
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -1683,9 +1683,9 @@ move2add_use_add2_insn (rtx reg, rtx sym, rtx off, rtx insn)
       struct full_rtx_costs oldcst, newcst;
       rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
 
-      get_full_rtx_cost (pat, SET, &oldcst);
+      get_full_set_rtx_cost (pat, &oldcst);
       SET_SRC (pat) = tem;
-      get_full_rtx_cost (pat, SET, &newcst);
+      get_full_set_rtx_cost (pat, &newcst);
       SET_SRC (pat) = src;
 
       if (costs_lt_p (&newcst, &oldcst, speed)
@@ -1752,7 +1752,7 @@ move2add_use_add3_insn (rtx reg, rtx sym, rtx off, rtx insn)
   rtx plus_expr;
 
   init_costs_to_max (&mincst);
-  get_full_rtx_cost (pat, SET, &oldcst);
+  get_full_set_rtx_cost (pat, &oldcst);
 
   plus_expr = gen_rtx_PLUS (GET_MODE (reg), reg, const0_rtx);
   SET_SRC (pat) = plus_expr;
@@ -1781,7 +1781,7 @@ move2add_use_add3_insn (rtx reg, rtx sym, rtx off, rtx insn)
        else
          {
            XEXP (plus_expr, 1) = new_src;
-           get_full_rtx_cost (pat, SET, &newcst);
+           get_full_set_rtx_cost (pat, &newcst);
 
            if (costs_lt_p (&newcst, &mincst, speed))
              {
@@ -1934,7 +1934,7 @@ reload_cse_move2add (rtx first)
                          struct full_rtx_costs oldcst, newcst;
                          rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
 
-                         get_full_rtx_cost (set, SET, &oldcst);
+                         get_full_set_rtx_cost (set, &oldcst);
                          SET_SRC (set) = tem;
                          get_full_rtx_cost (tem, SET, &newcst);
                          SET_SRC (set) = old_src;

diff --git a/gcc/rtl.h b/gcc/rtl.h
index d5d7b023ec570d413fef7064a239059cf87d9384..84166c47fc215e7b7b0271c4dff6fdc918e9b0d7 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1217,6 +1217,24 @@ extern bool constant_pool_constant_p (rtx);
 extern bool truncated_to_mode (enum machine_mode, const_rtx);
 extern int low_bitmask_len (enum machine_mode, unsigned HOST_WIDE_INT);
 
+#ifndef GENERATOR_FILE
+/* Return the cost of SET X.  SPEED_P is true if optimizing for speed
+   rather than size.  */
+
+static inline int
+set_rtx_cost (rtx x, bool speed_p)
+{
+  return rtx_cost (x, INSN, speed_p);
+}
+
+/* Like set_rtx_cost, but return both the speed and size costs in C.  */
+
+static inline void
+get_full_set_rtx_cost (rtx x, struct full_rtx_costs *c)
+{
+  get_full_rtx_cost (x, INSN, c);
+}
+#endif
 
 /* 1 if RTX is a subreg containing a reg that is already known to be
    sign- or zero-extended from the mode of the subreg to the mode of