diff options
Diffstat (limited to 'gcc/fold-const.c')
| -rw-r--r-- | gcc/fold-const.c | 34 |
1 files changed, 17 insertions, 17 deletions
diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 6a606ea..5ffaf10 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -1354,7 +1354,7 @@ split_tree (in, code, conp, litp, negate_p) *conp = 0; *litp = 0; - /* Strip any conversions that don't change the machine mode or signedness. */ + /* Strip any conversions that don't change the machine mode or signedness. */ STRIP_SIGN_NOPS (in); if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST) @@ -1385,7 +1385,7 @@ split_tree (in, code, conp, litp, negate_p) *conp = op1, neg_conp_p = neg1_p, op1 = 0; /* If we haven't dealt with either operand, this is not a case we can - decompose. Otherwise, VAR is either of the ones remaining, if any. */ + decompose. Otherwise, VAR is either of the ones remaining, if any. */ if (op0 != 0 && op1 != 0) var = in; else if (op0 != 0) @@ -1546,7 +1546,7 @@ int_const_binop (code, arg1, arg2, notrunc, forsize) break; } - /* ... fall through ... */ + /* ... fall through ... */ case ROUND_DIV_EXPR: if (int2h == 0 && int2l == 1) @@ -1579,7 +1579,7 @@ int_const_binop (code, arg1, arg2, notrunc, forsize) break; } - /* ... fall through ... */ + /* ... fall through ... */ case ROUND_MOD_EXPR: overflow = div_and_round_double (code, uns, @@ -1745,11 +1745,11 @@ const_binop (code, arg1, arg2, notrunc) args.code = code; if (do_float_handler (const_binop_1, (PTR) &args)) - /* Receive output from const_binop_1. */ + /* Receive output from const_binop_1. */ t = args.t; else { - /* We got an exception from const_binop_1. */ + /* We got an exception from const_binop_1. */ t = copy_node (arg1); overflow = 1; } @@ -1980,9 +1980,9 @@ size_diffop (arg0, arg1) /* This structure is used to communicate arguments to fold_convert_1. */ struct fc_args { - tree arg1; /* Input: value to convert. */ - tree type; /* Input: type to convert value to. */ - tree t; /* Ouput: result of conversion. */ + tree arg1; /* Input: value to convert. */ + tree type; /* Input: type to convert value to. */ + tree t; /* Ouput: result of conversion. */ }; /* Function to convert floating-point constants, protected by floating @@ -2383,7 +2383,7 @@ operand_equal_p (arg0, arg1, only_const) case 'r': /* If either of the pointer (or reference) expressions we are dereferencing - contain a side effect, these cannot be equal. */ + contain a side effect, these cannot be equal. */ if (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)) return 0; @@ -3265,7 +3265,7 @@ range_binop (code, type, arg0, upper0_p, arg1, upper1_p) the same. But, this is computer arithmetic, where numbers are finite. We can therefore make the transformation of any unbounded range with the value Z, Z being greater than any representable number. This permits - us to treat unbounded ranges as equal. */ + us to treat unbounded ranges as equal. */ sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1); sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1); switch (code) @@ -4552,7 +4552,7 @@ extract_muldiv (t, c, code, wide_type) /* The last case is if we are a multiply. In that case, we can apply the distributive law to commute the multiply and addition - if the multiplication of the constants doesn't overflow. */ + if the multiplication of the constants doesn't overflow. */ if (code == MULT_EXPR) return fold (build (tcode, ctype, fold (build (code, ctype, convert (ctype, op0), @@ -4570,7 +4570,7 @@ extract_muldiv (t, c, code, wide_type) && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0))) return omit_one_operand (type, integer_zero_node, op0); - /* ... fall through ... */ + /* ... fall through ... */ case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR: case ROUND_DIV_EXPR: case EXACT_DIV_EXPR: @@ -5564,7 +5564,7 @@ fold (expr) associate each group together, the constants with literals, then the result with variables. This increases the chances of literals being recombined later and of generating relocatable - expressions for the sum of a constant and literal. */ + expressions for the sum of a constant and literal. */ var0 = split_tree (arg0, code, &con0, &lit0, 0); var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR); @@ -5854,7 +5854,7 @@ fold (expr) && 0 != (tem = const_binop (code, build_real (type, dconst1), arg1, 0))) return fold (build (MULT_EXPR, type, arg0, tem)); - /* Find the reciprocal if optimizing and the result is exact. */ + /* Find the reciprocal if optimizing and the result is exact. */ else if (optimize) { REAL_VALUE_TYPE r; @@ -6045,7 +6045,7 @@ fold (expr) truth and/or operations and the transformation will still be valid. Also note that we only care about order for the ANDIF and ORIF operators. If B contains side effects, this - might change the truth-value of A. */ + might change the truth-value of A. */ if (TREE_CODE (arg0) == TREE_CODE (arg1) && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR || TREE_CODE (arg0) == TRUTH_ORIF_EXPR @@ -7342,7 +7342,7 @@ multiple_of_p (type, top, bottom) < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0))))) return 0; - /* .. fall through ... */ + /* .. fall through ... */ case SAVE_EXPR: return multiple_of_p (type, TREE_OPERAND (top, 0), bottom); |