Fix some formatting. Put stuff on a single line where shorter wide-int code

makes that possible.  Undo some spurious differences with trunk.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/wide-int@204613 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/c-family/cilk.c b/gcc/c-family/cilk.c
index 1fde1c549c26b6b642dddafd7673f801849c41a2..ea97fbdc59fe72789fdc2e0fed35ea4ee0de556b 100644 (file)
--- a/gcc/c-family/cilk.c
+++ b/gcc/c-family/cilk.c
@@ -662,8 +662,7 @@ declare_one_free_variable (const void *var0, void **map0,
 
   /* Maybe promote to int.  */
   if (INTEGRAL_TYPE_P (var_type) && COMPLETE_TYPE_P (var_type)
-      && INT_CST_LT (TYPE_SIZE (var_type),
-                    TYPE_SIZE (integer_type_node)))
+      && INT_CST_LT (TYPE_SIZE (var_type), TYPE_SIZE (integer_type_node)))
     arg_type = integer_type_node;
   else
     arg_type = var_type;

diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 38207593187da0238a725d364e2a6eab72d0719f..9ab4670a641f6144d1b251631d247469382c3353 100644 (file)
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -4757,8 +4757,7 @@ build_c_cast (location_t loc, tree type, tree expr)
            }
          else if (TREE_OVERFLOW (value))
            /* Reset VALUE's overflow flags, ensuring constant sharing.  */
-           value = wide_int_to_tree (TREE_TYPE (value),
-                                     value);
+           value = wide_int_to_tree (TREE_TYPE (value), value);
        }
     }
 

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index dbd77d89b1673473e7905c74f5c860d52bfe694e..413ad2d61fca5a82cf6b1c8c6bef9936565cba47 100644 (file)
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -1143,7 +1143,8 @@ defer_stack_allocation (tree var, bool toplevel)
      "small" aggregates to the list at all.  */
   if (optimize == 0
       && (tree_to_uhwi (DECL_SIZE_UNIT (var))
-          < (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING)))
+          < ((unsigned HOST_WIDE_INT)
+            PARAM_VALUE (PARAM_MIN_SIZE_FOR_STACK_SHARING))))
     return false;
 
   return true;

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 07cb28e8d3c4a6bb69d12649c12e20e6073e8708..dbd1154ac0ae07af06ff1311be9280abb60ab9d0 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -5390,9 +5390,11 @@ print_die (dw_die_ref die, FILE *outfile)
            gcc_assert (i > 0);
            if (a->dw_attr_val.v.val_wide->elt (i) == 0)
              fprintf (outfile, "0x");
-           fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_wide->elt (--i));
+           fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
+                    a->dw_attr_val.v.val_wide->elt (--i));
            while (-- i >= 0)
-             fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, a->dw_attr_val.v.val_wide->elt (i));
+             fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
+                      a->dw_attr_val.v.val_wide->elt (i));
            fprintf (outfile, ")");
            break;
          }
@@ -15108,15 +15110,13 @@ insert_wide_int (const wide_int &val, unsigned char *dest)
   if (WORDS_BIG_ENDIAN)
     for (i = (int)get_full_len (val) - 1; i >= 0; i--)
       {
-       insert_int ((HOST_WIDE_INT) val.elt (i), 
-                   sizeof (HOST_WIDE_INT), dest);
+       insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
        dest += sizeof (HOST_WIDE_INT);
       }
   else
     for (i = 0; i < (int)get_full_len (val); i++)
       {
-       insert_int ((HOST_WIDE_INT) val.elt (i), 
-                   sizeof (HOST_WIDE_INT), dest);
+       insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
        dest += sizeof (HOST_WIDE_INT);
       }
 }

diff --git a/gcc/expr.c b/gcc/expr.c
index cb3abcdab8999b9736f7f9b3805fada82b27088a..aae57ac65de23659710b81bc4c8c4116cb5daa8d 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -9721,7 +9721,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                  {
                    tree type = TREE_TYPE (TREE_TYPE (init));
                    enum machine_mode mode = TYPE_MODE (type);
-                   
+
                    if (GET_MODE_CLASS (mode) == MODE_INT
                        && GET_MODE_SIZE (mode) == 1)
                      return gen_int_mode (TREE_STRING_POINTER (init)

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 3a841fefdf02a96ad2c2fd879c4b5cd2a639cc56..f91a4b191c673831f4a5155d375bfb2880623a2c 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1795,8 +1795,7 @@ fold_convert_const_fixed_from_int (tree type, const_tree arg1)
   else 
     di.high = TREE_INT_CST_ELT (arg1, 1);
 
-  overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
-                                      di,
+  overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type), di,
                                       TYPE_UNSIGNED (TREE_TYPE (arg1)),
                                       TYPE_SATURATING (type));
   t = build_fixed (type, value);
@@ -6388,7 +6387,7 @@ fold_div_compare (location_t loc,
   tree prod, tmp, hi, lo;
   tree arg00 = TREE_OPERAND (arg0, 0);
   tree arg01 = TREE_OPERAND (arg0, 1);
-  signop sign  = TYPE_SIGN (TREE_TYPE (arg0));
+  signop sign = TYPE_SIGN (TREE_TYPE (arg0));
   bool neg_overflow = false;
   bool overflow;
 
@@ -11785,7 +11784,7 @@ fold_binary_loc (location_t loc,
                }
            }
        }
-      
+
       t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
       if (t1 != NULL_TREE)
        return t1;

diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index a7366858d1e92e23520780537a5a414f014b0939..1a8b20d983afb6bfdd79616497e77be01ffcbe84 100644 (file)
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -985,8 +985,7 @@ trans_this_image (gfc_se * se, gfc_expr *expr)
       if (INTEGER_CST_P (dim_arg))
        {
          if (wi::ltu_p (dim_arg, 1)
-             || wi::gtu_p (dim_arg,
-                           GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
+             || wi::gtu_p (dim_arg, GFC_TYPE_ARRAY_CORANK (TREE_TYPE (desc))))
            gfc_error ("'dim' argument of %s intrinsic at %L is not a valid "
                       "dimension index", expr->value.function.isym->name,
                       &expr->where);

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 6ad5981cc1bd6b58f78ca021ab0395f179d2ce12..d102f63872977ee02a5c49972fd8dffe945aab1b 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -3047,8 +3047,8 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
          tree unit_size = array_ref_element_size (t);
 
          /* If the resulting bit-offset is constant, track it.  */
-         if ((TREE_CODE (low_bound) == INTEGER_CST)
-             && (tree_fits_uhwi_p (unit_size)))
+         if (TREE_CODE (low_bound) == INTEGER_CST
+             && tree_fits_uhwi_p (unit_size))
            {
              offset_int woffset
                = wi::sext (wi::to_offset (idx) - wi::to_offset (low_bound),

diff --git a/gcc/optabs.c b/gcc/optabs.c
index a9b0c1985577734a6b85427bfa59c9be18ffb6e8..54164124cf1a23e1da27692d268c6082836f6e53 100644 (file)
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -3710,6 +3710,7 @@ expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target,
        op0 = expand_binop (imode, and_optab, op0,
                            immed_wide_int_const (~mask, imode),
                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
+
       temp = expand_binop (imode, ior_optab, op0, op1,
                           gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
       target = lowpart_subreg_maybe_copy (mode, temp, imode);

diff --git a/gcc/real.c b/gcc/real.c
index f9651163aaff1216bf9082716a68f9ee37b1c3d1..7d2d611c113f43063302e378050b59e8cae30628 100644 (file)
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -1378,9 +1378,8 @@ real_to_integer (const REAL_VALUE_TYPE *r)
     }
 }
 
-/* Likewise, but producing a wide-int of PRECISION.  If
-   the value cannot be represented in precision, FAIL is set to
-   TRUE.  */
+/* Likewise, but producing a wide-int of PRECISION.  If the value cannot
+   be represented in precision, *FAIL is set to TRUE.  */
 
 wide_int
 real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
@@ -1448,8 +1447,8 @@ real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
        }
 #endif 
       w = SIGSZ * HOST_BITS_PER_LONG + words * HOST_BITS_PER_WIDE_INT; 
-      result = wide_int::from_array (val, 
-         (w + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT, w, w); 
+      result = wide_int::from_array
+       (val, (w + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT, w);
       result = wi::lrshift (result, (words * HOST_BITS_PER_WIDE_INT) - exp);
       result = wide_int::from (result, precision, UNSIGNED);
 
@@ -2152,8 +2151,7 @@ real_from_string3 (REAL_VALUE_TYPE *r, const char *s, enum machine_mode mode)
 
 void
 real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
-                  HOST_WIDE_INT val,
-                  signop sgn)
+                  HOST_WIDE_INT val, signop sgn)
 {
   if (val == 0)
     get_zero (r, 0);
@@ -2198,9 +2196,10 @@ real_from_integer (REAL_VALUE_TYPE *r, enum machine_mode mode,
   else
     {
       unsigned int len = val_in.get_precision ();
-      int i, j, e=0;
+      int i, j, e = 0;
       int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
-      const unsigned int realmax = SIGNIFICAND_BITS/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
+      const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
+                                   * HOST_BITS_PER_WIDE_INT);
 
       memset (r, 0, sizeof (*r));
       r->cl = rvc_normal;

diff --git a/gcc/recog.c b/gcc/recog.c
index 821ce267edec13da4a75380e35162a5bc95ad5e4..ae2152eba7c3256c5c4fa2b42e5e9f428773c1e0 100644 (file)
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -1248,8 +1248,7 @@ nonimmediate_operand (rtx op, enum machine_mode mode)
   return (general_operand (op, mode) && ! CONSTANT_P (op));
 }
 
-/* Return 1 if OP is a register reference or immediate value of mode
-   MODE.  */
+/* Return 1 if OP is a register reference or immediate value of mode MODE.  */
 
 int
 nonmemory_operand (rtx op, enum machine_mode mode)

diff --git a/gcc/rtl.c b/gcc/rtl.c
index 5c61e87dcd71250ac4d4e4abee9ccac52c917a95..a361d4fa8918341df4a9ac4de8ffbead064368d0 100644 (file)
--- a/gcc/rtl.c
+++ b/gcc/rtl.c
@@ -457,6 +457,7 @@ rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
          if (XWINT (x, i) != XWINT (y, i))
            return 0;
          break;
+
        case 'n':
        case 'i':
          if (XINT (x, i) != XINT (y, i))

diff --git a/gcc/rtl.h b/gcc/rtl.h
index df4de48f280a598d3d9c8164a0ce8a9cdb87dd09..4f52740077be1971d2fa880d7ab0b599c6921359 100644 (file)
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -350,9 +350,9 @@ struct GTY((chain_next ("RTX_NEXT (&%h)"),
   union {
     /* RTXs are free to use up to 32 bit from here.  */
 
-    /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of HOST_WIDE_INTs
-       in the hwivec_def.  */
-    unsigned  GTY ((tag ("CONST_WIDE_INT"))) num_elem:32;
+    /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of
+       HOST_WIDE_INTs in the hwivec_def.  */
+    unsigned GTY ((tag ("CONST_WIDE_INT"))) num_elem:32;
   } GTY ((desc ("GET_CODE (&%0)"))) u2;
 
   /* The first element of the operands of this rtx.
@@ -404,13 +404,13 @@ struct GTY((chain_next ("RTX_NEXT (&%h)"),
    for a variable number of things.  The principle use is inside
    PARALLEL expressions.  */
 
-#define NULL_RTVEC (rtvec) 0
-
 struct GTY((variable_size)) rtvec_def {
   int num_elem;                /* number of elements */
   rtx GTY ((length ("%h.num_elem"))) elem[1];
 };
 
+#define NULL_RTVEC (rtvec) 0
+
 #define GET_NUM_ELEM(RTVEC)            ((RTVEC)->num_elem)
 #define PUT_NUM_ELEM(RTVEC, NUM)       ((RTVEC)->num_elem = (NUM))
 

diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 3757ff7592e11218874fe9a9c347af3e89a5aba6..8ab4454138ccb3ecd5749115e461dadd712c5fb1 100644 (file)
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -1686,7 +1686,7 @@ simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
        case CLRSB:
          result = wi::shwi (wi::clrsb (op0), mode);
          break;
-         
+
        case CTZ:
          result = wi::shwi (wi::ctz (op0), mode);
          break;
@@ -5122,7 +5122,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
     value_bit = 8,
     value_mask = (1 << value_bit) - 1
   };
-  unsigned char value[MAX_BITSIZE_MODE_ANY_MODE/value_bit];
+  unsigned char value[MAX_BITSIZE_MODE_ANY_MODE / value_bit];
   int value_start;
   int i;
   int elem;

diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index 9ba2a38814e158fde4644c6c964c35614e5956f4..b24f2321d1e8930b56fcc4f0a0636d1d3cadb0f6 100644 (file)
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -1078,7 +1078,7 @@ tm_log_add (basic_block entry_block, tree addr, gimple stmt)
          && transaction_invariant_address_p (lp->addr, entry_block)
          && TYPE_SIZE_UNIT (type) != NULL
          && tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))
-         && ((HOST_WIDE_INT)(tree_to_uhwi (TYPE_SIZE_UNIT (type)))
+         && ((HOST_WIDE_INT) tree_to_uhwi (TYPE_SIZE_UNIT (type))
              < PARAM_VALUE (PARAM_TM_MAX_AGGREGATE_SIZE))
          /* We must be able to copy this type normally.  I.e., no
             special constructors and the like.  */

diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c
index a8a039f9809d1e402d372fd2cfdaf8d6ad44d438..239b780992561c4d069ce7d61f5c13ecc079a728 100644 (file)
--- a/gcc/tree-affine.c
+++ b/gcc/tree-affine.c
@@ -29,7 +29,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "dumpfile.h"
 #include "wide-int-print.h"
 
-
 /* Extends CST as appropriate for the affine combinations COMB.  */
 
 widest_int

diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c
index d97f7bbdf7a5d05ee9eda6bfb15714d8749b5c9c..cf210ccd933841fa1116cca003db97b9d44baa91 100644 (file)
--- a/gcc/tree-ssa-address.c
+++ b/gcc/tree-ssa-address.c
@@ -881,8 +881,8 @@ copy_ref_info (tree new_ref, tree old_ref)
                           && (tree_to_hwi (TMR_STEP (new_ref))
                               < align)))))
            {
-             unsigned int inc = mem_ref_offset (old_ref).to_uhwi ()
-                                 - mem_ref_offset (new_ref).to_uhwi ();
+             unsigned int inc = (mem_ref_offset (old_ref).to_uhwi ()
+                                 - mem_ref_offset (new_ref).to_uhwi ());
              adjust_ptr_info_misalignment (new_pi, inc);
            }
          else

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 12236ac2f5826ff158a5ee1bba6aea6bbfcb4ed8..a85cb5bd35883d9bf3705904d4b0f3dc71c34b16 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -489,8 +489,7 @@ set_lattice_value (tree var, prop_value_t new_val)
       || (new_val.lattice_val == CONSTANT
          && TREE_CODE (new_val.value) == INTEGER_CST
          && (TREE_CODE (old_val->value) != INTEGER_CST
-             || new_val.mask 
-             != old_val->mask)))
+             || new_val.mask != old_val->mask)))
     {
       /* ???  We would like to delay creation of INTEGER_CSTs from
         partially constants here.  */
@@ -1749,7 +1748,8 @@ evaluate_stmt (gimple stmt)
     {
       tree lhs = gimple_get_lhs (stmt);
       widest_int nonzero_bits = get_nonzero_bits (lhs);
-      widest_int mask = wi::mask <widest_int> (TYPE_PRECISION (TREE_TYPE (lhs)), false);
+      widest_int mask
+       = wi::mask <widest_int> (TYPE_PRECISION (TREE_TYPE (lhs)), false);
       if (nonzero_bits != -1 && nonzero_bits != mask)
        {
          if (!is_constant)

diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index b0054d9fb3bd18d0e81b0be0df8ea242783cf9e2..fe9a1dca81150ef775ca1d8ea0e703d70880717b 100644 (file)
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -3498,7 +3498,6 @@ get_shiftadd_cost (tree expr, enum machine_mode mode, comp_cost cost0,
     res = add_costs (res, force_expr_to_var_cost (multop, speed));
 
   *cost = res;
-
   return true;
 }
 
@@ -3613,7 +3612,6 @@ force_expr_to_var_cost (tree expr, bool speed)
       break;
 
     default:
-
       /* Just an arbitrary value, FIXME.  */
       return new_cost (target_spill_cost[speed], 0);
     }

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 6c3f988b991bfc826d573a8763394e34eab8e54a..34c526ecedf14327ae1527d8df159d168f565c02 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -8622,9 +8622,11 @@ simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
   else
     return false;
 
-  if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0, &must_be_nonzero0))
+  if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0,
+                                 &must_be_nonzero0))
     return false;
-  if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1, &must_be_nonzero1))
+  if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1,
+                                 &must_be_nonzero1))
     return false;
 
   switch (gimple_assign_rhs_code (stmt))
@@ -9181,7 +9183,6 @@ static bool
 simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
 {
   gimple stmt = gsi_stmt (*gsi);
-
   if (is_gimple_assign (stmt))
     {
       enum tree_code rhs_code = gimple_assign_rhs_code (stmt);

diff --git a/gcc/tree.c b/gcc/tree.c
index 43d6adae20b815fad77c95c4ef2b340cdcccaaee..e9b1b80b5ebec8d7045101242a11118d36bb27c9 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1780,8 +1780,7 @@ real_value_from_int_cst (const_tree type, const_tree i)
   memset (&d, 0, sizeof d);
 
   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
-                    wide_int (i),
-                    TYPE_SIGN (TREE_TYPE (i)));
+                    wide_int (i), TYPE_SIGN (TREE_TYPE (i)));
   return d;
 }
 
@@ -6708,7 +6707,7 @@ type_hash_eq (const void *va, const void *vb)
     case REAL_TYPE:
     case BOOLEAN_TYPE:
       if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type))
-         return false;
+       return false;
       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
               || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
                                      TYPE_MAX_VALUE (b->type)))

diff --git a/gcc/tree.h b/gcc/tree.h
index ec92f843a41f629fba672ab564bb74e0a78f22ea..1d8af651ed8c0696a01ea4e1429c2817af2772de 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -759,7 +759,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
 #define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
 
 /* Same as TYPE_UNSIGNED but converted to SIGNOP.  */
-#define TYPE_SIGN(NODE) ((signop)TYPE_UNSIGNED(NODE))
+#define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE))
 
 /* True if overflow wraps around for the given integral type.  That
    is, TYPE_MAX + 1 == TYPE_MIN.  */