From 6cb72a7d5cae9ca6f616e9784055d029bfe0d67a Mon Sep 17 00:00:00 2001 From: Richard Stallman Date: Wed, 15 Jul 1992 18:35:30 +0000 Subject: [PATCH] (self_promoting_args_p, self_promoting_type_p): (signed_type, unsigned_type, default_conversion, check_format): (build_binary_op, c_expand_start_case): Use TYPE_MAIN_VARIANT when comparing against specific non-void types. From-SVN: r1591 --- gcc/c-typeck.c | 55 ++++++++++++++++++++++++++------------------------ 1 file changed, 29 insertions(+), 26 deletions(-) diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index a0264ebdb46..c4246215c70 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -153,13 +153,11 @@ qualify_type (type, like) /* Return the common type of two types. We assume that comptypes has already been done and returned 1; - if that isn't so, this may crash. + if that isn't so, this may crash. In particular, we assume that qualifiers + match. This is the type for the result of most arithmetic operations - if the operands have the given two types. - - We do not deal with enumeral types here because they have already been - converted to integer types. */ + if the operands have the given two types. */ tree common_type (t1, t2) @@ -603,7 +601,7 @@ self_promoting_args_p (parms) if (TREE_CHAIN (t) == 0 && type != void_type_node) return 0; - if (type == float_type_node) + if (TYPE_MAIN_VARIANT (type) == float_type_node) return 0; if (type @@ -620,7 +618,7 @@ static int self_promoting_type_p (type) tree type; { - if (type == float_type_node) + if (TYPE_MAIN_VARIANT (type) == float_type_node) return 0; if (TREE_CODE (type) == INTEGER_TYPE @@ -636,15 +634,16 @@ tree unsigned_type (type) tree type; { - if (type == signed_char_type_node || type == char_type_node) + tree type1 = TYPE_MAIN_VARIANT (type); + if (type1 == signed_char_type_node || type1 == char_type_node) return unsigned_char_type_node; - if (type == integer_type_node) + if (type1 == integer_type_node) return unsigned_type_node; - if (type == short_integer_type_node) + if (type1 == short_integer_type_node) return short_unsigned_type_node; - if (type == long_integer_type_node) + if (type1 == long_integer_type_node) return long_unsigned_type_node; - if (type == long_long_integer_type_node) + if (type1 == long_long_integer_type_node) return long_long_unsigned_type_node; return type; } @@ -655,15 +654,16 @@ tree signed_type (type) tree type; { - if (type == unsigned_char_type_node || type == char_type_node) + tree type1 = TYPE_MAIN_VARIANT (type); + if (type1 == unsigned_char_type_node || type1 == char_type_node) return signed_char_type_node; - if (type == unsigned_type_node) + if (type1 == unsigned_type_node) return integer_type_node; - if (type == short_unsigned_type_node) + if (type1 == short_unsigned_type_node) return short_integer_type_node; - if (type == long_unsigned_type_node) + if (type1 == long_unsigned_type_node) return long_integer_type_node; - if (type == long_long_unsigned_type_node) + if (type1 == long_long_unsigned_type_node) return long_long_integer_type_node; return type; } @@ -917,7 +917,7 @@ default_conversion (exp) return convert (unsigned_type_node, exp); return convert (integer_type_node, exp); } - if (flag_traditional && type == float_type_node) + if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node) return convert (double_type_node, exp); if (code == VOID_TYPE) { @@ -1537,7 +1537,8 @@ check_format (info, params) It will work on most machines, because size_t and int have the same mode. But might as well warn anyway, since it will fail on other machines. */ - if (TREE_TYPE (cur_param) != integer_type_node) + if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) + != integer_type_node) { sprintf (message, "field width is not type int (arg %d)", @@ -1580,7 +1581,8 @@ check_format (info, params) cur_param = TREE_VALUE (params); params = TREE_CHAIN (params); ++arg_num; - if (TREE_TYPE (cur_param) != integer_type_node) + if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) + != integer_type_node) { sprintf (message, "field width is not type int (arg %d)", @@ -1723,7 +1725,7 @@ check_format (info, params) /* Check the type of the "real" argument, if there's a type we want. */ if (i == fci->pointer_count && wanted_type != 0 - && wanted_type != cur_type + && wanted_type != TYPE_MAIN_VARIANT (cur_type) /* If we want `void *', allow any pointer type. (Anything else would already have got a warning.) */ && ! (wanted_type == void_type_node @@ -2363,7 +2365,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) regardless of size of value being shifted. */ if (! flag_traditional) { - if (TREE_TYPE (op1) != integer_type_node) + if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) op1 = convert (integer_type_node, op1); /* Avoid converting op1 to result_type later. */ converted = 1; @@ -2387,7 +2389,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) regardless of size of value being shifted. */ if (! flag_traditional) { - if (TREE_TYPE (op1) != integer_type_node) + if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) op1 = convert (integer_type_node, op1); /* Avoid converting op1 to result_type later. */ converted = 1; @@ -2412,7 +2414,7 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) regardless of size of value being shifted. */ if (! flag_traditional) { - if (TREE_TYPE (op1) != integer_type_node) + if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) op1 = convert (integer_type_node, op1); /* Avoid converting op1 to result_type later. */ converted = 1; @@ -5312,10 +5314,11 @@ c_expand_start_case (exp) else { tree index; + type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); if (warn_traditional - && (TREE_TYPE (exp) == long_integer_type_node - || TREE_TYPE (exp) == long_unsigned_type_node)) + && (type == long_integer_type_node + || type == long_unsigned_type_node)) pedwarn ("`long' switch expression not converted to `int' in ANSI C"); exp = default_conversion (exp); -- 2.30.2