fold-const.c (negate_expr, [...]): Replace calls via (*lang_hooks.foo) () with lang_h...

	* fold-const.c (negate_expr, operand_equal_for_comparison_p,
	optimize_bit_field_compare, decode_field_reference, all_ones_mask_p,
	make_range, build_range_check, fold_range_test, unextend,
	constant_boolean_node, fold_binary_op_with_conditional_arg,
	fold_truthop, fold_mathfn_compare, fold_inf_compare,
	fold_single_bit_test, fold): Replace calls via (*lang_hooks.foo) ()
	with lang_hooks.foo ().

From-SVN: r79471

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 757d7625ac418d52819f45f5f8cf76310198b5b4..d5499d35263a2dce80ab3257c9038dccf79d4d1d 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2004-03-13  Roger Sayle  <roger@eyesopen.com>
+
+       * fold-const.c (negate_expr, operand_equal_for_comparison_p,
+       optimize_bit_field_compare, decode_field_reference, all_ones_mask_p,
+       make_range, build_range_check, fold_range_test, unextend,
+       constant_boolean_node, fold_binary_op_with_conditional_arg,
+       fold_truthop, fold_mathfn_compare, fold_inf_compare,
+       fold_single_bit_test, fold): Replace calls via (*lang_hooks.foo) ()
+       with lang_hooks.foo ().
+
 2004-03-14  Richard Earnshaw  <rearnsha@arm.com>
 
        * arm.h (EXTRA_CONSTRAINT_STR_ARM): Update comment.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 5e18d6862ac09477729a5d5fd99250a9f2ba2fc9..5e899fddc28b6df1f4c7c45aa6ac553f7d1d1de3 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1087,8 +1087,8 @@ negate_expr (tree t)
                 == TREE_INT_CST_LOW (op1))
            {
              tree ntype = TREE_UNSIGNED (type)
-                          ? (*lang_hooks.types.signed_type) (type)
-                          : (*lang_hooks.types.unsigned_type) (type);
+                          ? lang_hooks.types.signed_type (type)
+                          : lang_hooks.types.unsigned_type (type);
              tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
              temp = fold (build2 (RSHIFT_EXPR, ntype, temp, op1));
              return fold_convert (type, temp);
@@ -2419,7 +2419,7 @@ operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
 
       /* Make sure shorter operand is extended the right way
         to match the longer operand.  */
-      primarg1 = fold_convert ((*lang_hooks.types.signed_or_unsigned_type)
+      primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
                               (unsignedp1, TREE_TYPE (primarg1)), primarg1);
 
       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
@@ -2900,8 +2900,8 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
 
   /* Set signed and unsigned types of the precision of this mode for the
      shifts below.  */
-  signed_type = (*lang_hooks.types.type_for_mode) (nmode, 0);
-  unsigned_type = (*lang_hooks.types.type_for_mode) (nmode, 1);
+  signed_type = lang_hooks.types.type_for_mode (nmode, 0);
+  unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
 
   /* Compute the bit position and size for the new reference and our offset
      within it. If the new reference is the same size as the original, we
@@ -3074,7 +3074,7 @@ decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
     *punsignedp = TREE_UNSIGNED (outer_type);
 
   /* Compute the mask to access the bitfield.  */
-  unsigned_type = (*lang_hooks.types.type_for_size) (*pbitsize, 1);
+  unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
   precision = TYPE_PRECISION (unsigned_type);
 
   mask = build_int_2 (~0, ~0);
@@ -3104,7 +3104,7 @@ all_ones_mask_p (tree mask, int size)
   tree tmask;
 
   tmask = build_int_2 (~0, ~0);
-  TREE_TYPE (tmask) = (*lang_hooks.types.signed_type) (type);
+  TREE_TYPE (tmask) = lang_hooks.types.signed_type (type);
   force_fit_type (tmask, 0);
   return
     tree_int_cst_equal (mask,
@@ -3497,7 +3497,7 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
             be interpreted as positive.  */
          if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
            {
-             tree equiv_type = (*lang_hooks.types.type_for_mode)
+             tree equiv_type = lang_hooks.types.type_for_mode
                (TYPE_MODE (type), 1);
              tree high_positive;
 
@@ -3598,7 +3598,7 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree high)
     {
       if (! TREE_UNSIGNED (etype))
        {
-         etype = (*lang_hooks.types.unsigned_type) (etype);
+         etype = lang_hooks.types.unsigned_type (etype);
          high = fold_convert (etype, high);
          exp = fold_convert (etype, exp);
        }
@@ -3628,7 +3628,7 @@ build_range_check (tree type, tree exp, int in_p, tree low, tree high)
        {
          if (TREE_UNSIGNED (etype))
            {
-             etype = (*lang_hooks.types.signed_type) (etype);
+             etype = lang_hooks.types.signed_type (etype);
              exp = fold_convert (etype, exp);
            }
          return fold (build (GT_EXPR, type, exp,
@@ -3833,7 +3833,7 @@ fold_range_test (tree exp)
                      TREE_TYPE (exp), TREE_OPERAND (exp, 0),
                      TREE_OPERAND (exp, 1));
 
-      else if ((*lang_hooks.decls.global_bindings_p) () == 0
+      else if (lang_hooks.decls.global_bindings_p () == 0
               && ! CONTAINS_PLACEHOLDER_P (lhs))
        {
          tree common = save_expr (lhs);
@@ -3881,7 +3881,7 @@ unextend (tree c, int p, int unsignedp, tree mask)
      zero or one, and the conversion to a signed type can never overflow.
      We could get an overflow if this conversion is done anywhere else.  */
   if (TREE_UNSIGNED (type))
-    temp = fold_convert ((*lang_hooks.types.signed_type) (type), temp);
+    temp = fold_convert (lang_hooks.types.signed_type (type), temp);
 
   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
@@ -4127,7 +4127,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
 
   /* After this point all optimizations will generate bit-field
      references, which we might not want.  */
-  if (! (*lang_hooks.can_use_bit_fields_p) ())
+  if (! lang_hooks.can_use_bit_fields_p ())
     return 0;
 
   /* See if we can find a mode that contains both fields being compared on
@@ -4143,7 +4143,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
 
   lnbitsize = GET_MODE_BITSIZE (lnmode);
   lnbitpos = first_bit & ~ (lnbitsize - 1);
-  lntype = (*lang_hooks.types.type_for_size) (lnbitsize, 1);
+  lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
 
   if (BYTES_BIG_ENDIAN)
@@ -4214,7 +4214,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
 
       rnbitsize = GET_MODE_BITSIZE (rnmode);
       rnbitpos = first_bit & ~ (rnbitsize - 1);
-      rntype = (*lang_hooks.types.type_for_size) (rnbitsize, 1);
+      rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
 
       if (BYTES_BIG_ENDIAN)
@@ -4787,8 +4787,8 @@ constant_boolean_node (int value, tree type)
   if (type == integer_type_node)
     return value ? integer_one_node : integer_zero_node;
   else if (TREE_CODE (type) == BOOLEAN_TYPE)
-    return (*lang_hooks.truthvalue_conversion) (value ? integer_one_node :
-                                               integer_zero_node);
+    return lang_hooks.truthvalue_conversion (value ? integer_one_node
+                                                  : integer_zero_node);
   else
     {
       tree t = build_int_2 (value, 0);
@@ -4920,7 +4920,7 @@ fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
     save = 1;
   else if (lhs == 0 && rhs == 0
           && !TREE_CONSTANT (arg)
-          && (*lang_hooks.decls.global_bindings_p) () == 0
+          && lang_hooks.decls.global_bindings_p () == 0
           && ((TREE_CODE (arg) != VAR_DECL && TREE_CODE (arg) != PARM_DECL)
               || TREE_SIDE_EFFECTS (arg)))
     {
@@ -5095,7 +5095,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
                                    build_real (TREE_TYPE (arg), dconst0)));
 
              /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
-             if ((*lang_hooks.decls.global_bindings_p) () != 0
+             if (lang_hooks.decls.global_bindings_p () != 0
                  || CONTAINS_PLACEHOLDER_P (arg))
                return NULL_TREE;
 
@@ -5115,7 +5115,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
                                build_real (TREE_TYPE (arg), c2)));
 
          /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
-         if ((*lang_hooks.decls.global_bindings_p) () == 0
+         if (lang_hooks.decls.global_bindings_p () == 0
              && ! CONTAINS_PLACEHOLDER_P (arg))
            {
              arg = save_expr (arg);
@@ -5176,7 +5176,7 @@ fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
                                 arg0);
 
       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
-      if ((*lang_hooks.decls.global_bindings_p) () == 0
+      if (lang_hooks.decls.global_bindings_p () == 0
          && ! CONTAINS_PLACEHOLDER_P (arg0))
        {
          arg0 = save_expr (arg0);
@@ -5257,7 +5257,7 @@ fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
       arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
       if (arg00 != NULL_TREE)
        {
-         tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
+         tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
          return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, result_type,
                              fold_convert (stype, arg00),
                              fold_convert (stype, integer_zero_node)));
@@ -5293,8 +5293,8 @@ fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
       ops_unsigned = 1;
 #endif
 
-      signed_type = (*lang_hooks.types.type_for_mode) (operand_mode, 0);
-      unsigned_type = (*lang_hooks.types.type_for_mode) (operand_mode, 1);
+      signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
+      unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
       inner = fold_convert (intermediate_type, inner);
 
@@ -5609,7 +5609,7 @@ fold (tree expr)
               && (TREE_CODE (arg0) != COND_EXPR
                   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
               && (! TREE_SIDE_EFFECTS (arg0)
-                  || ((*lang_hooks.decls.global_bindings_p) () == 0
+                  || (lang_hooks.decls.global_bindings_p () == 0
                       && ! CONTAINS_PLACEHOLDER_P (arg0))))
        return
          fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
@@ -5623,7 +5623,7 @@ fold (tree expr)
               && (TREE_CODE (arg1) != COND_EXPR
                   || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
               && (! TREE_SIDE_EFFECTS (arg1)
-                  || ((*lang_hooks.decls.global_bindings_p) () == 0
+                  || (lang_hooks.decls.global_bindings_p () == 0
                       && ! CONTAINS_PLACEHOLDER_P (arg1))))
        return
          fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
@@ -5784,7 +5784,7 @@ fold (tree expr)
                  && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
                      == ZERO_EXTEND))
                {
-                 tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
+                 tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
                  and0 = fold_convert (uns, and0);
                  and1 = fold_convert (uns, and1);
                }
@@ -7544,8 +7544,8 @@ fold (tree expr)
                if (code == LE_EXPR || code == GT_EXPR)
                  {
                    tree st0, st1;
-                   st0 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg0));
-                   st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
+                   st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
+                   st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
                    return fold
                      (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
                              type, fold_convert (st0, arg0),
@@ -7668,7 +7668,7 @@ fold (tree expr)
              || TREE_CODE (arg0) == ROUND_MOD_EXPR)
          && integer_pow2p (TREE_OPERAND (arg0, 1)))
        {
-         tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
+         tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
          tree newmod = build (TREE_CODE (arg0), newtype,
                               fold_convert (newtype,
                                             TREE_OPERAND (arg0, 0)),
@@ -7895,7 +7895,7 @@ fold (tree expr)
 
       /* If this is a comparison of a field, we may be able to simplify it.  */
       if (((TREE_CODE (arg0) == COMPONENT_REF
-           && (*lang_hooks.can_use_bit_fields_p) ())
+           && lang_hooks.can_use_bit_fields_p ())
           || TREE_CODE (arg0) == BIT_FIELD_REF)
          && (code == EQ_EXPR || code == NE_EXPR)
          /* Handle the constant case even without -O
@@ -8045,7 +8045,7 @@ fold (tree expr)
 
       TREE_TYPE (t1) = type;
       if (TREE_CODE (type) == BOOLEAN_TYPE)
-       return (*lang_hooks.truthvalue_conversion) (t1);
+       return lang_hooks.truthvalue_conversion (t1);
       return t1;
 
     case COND_EXPR:
@@ -8115,14 +8115,14 @@ fold (tree expr)
              case GE_EXPR:
              case GT_EXPR:
                if (TREE_UNSIGNED (TREE_TYPE (arg1)))
-                 arg1 = fold_convert ((*lang_hooks.types.signed_type)
+                 arg1 = fold_convert (lang_hooks.types.signed_type
                                       (TREE_TYPE (arg1)), arg1);
                arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
                return pedantic_non_lvalue (fold_convert (type, arg1));
              case LE_EXPR:
              case LT_EXPR:
                if (TREE_UNSIGNED (TREE_TYPE (arg1)))
-                 arg1 = fold_convert ((lang_hooks.types.signed_type)
+                 arg1 = fold_convert (lang_hooks.types.signed_type
                                       (TREE_TYPE (arg1)), arg1);
                arg1 = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
                arg1 = negate_expr (fold_convert (type, arg1));