From d11fdb45289eb406c5857ce6b1b8078f3047159c Mon Sep 17 00:00:00 2001 From: Richard Stallman Date: Fri, 6 Aug 1993 01:07:18 +0000 Subject: [PATCH] (output_init_element): Call digest_init before calling output_constant. (output_init_element): Call digest_init before calling output_constant. Always pass 0, 0 for last 2 args to digest_init. (build_binary_op): Warn about ordered comparison between pointers to complete and incomplete types. (digest_init): No error for a STRING_CST that already went through digest_init. (parser_build_binary_op): Generate a NON_LVALUE_EXPR, not NOP_EXPR, around a constant value. From-SVN: r5081 --- gcc/c-typeck.c | 54 +++++++++++++++++++++++++++++++------------------- 1 file changed, 34 insertions(+), 20 deletions(-) diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 9f2a8bc82ee..a08b72317e8 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -974,6 +974,21 @@ default_conversion (exp) register tree adr; tree restype = TREE_TYPE (type); tree ptrtype; + int constp = 0; + int volatilep = 0; + + if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' + || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd') + { + constp = TREE_READONLY (exp); + volatilep = TREE_THIS_VOLATILE (exp); + } + + if (TYPE_READONLY (type) || TYPE_VOLATILE (type) + || constp || volatilep) + restype = c_build_type_variant (restype, + TYPE_READONLY (type) || constp, + TYPE_VOLATILE (type) || volatilep); if (TREE_CODE (exp) == INDIRECT_REF) return convert (TYPE_POINTER_TO (restype), @@ -993,10 +1008,6 @@ default_conversion (exp) return error_mark_node; } - if (TYPE_READONLY (type) || TYPE_VOLATILE (type)) - restype = c_build_type_variant (restype, TYPE_READONLY (type), - TYPE_VOLATILE (type)); - ptrtype = build_pointer_type (restype); if (TREE_CODE (exp) == VAR_DECL) @@ -2230,10 +2241,11 @@ parser_build_binary_op (code, arg1, arg2) else { int flag = TREE_CONSTANT (result); - /* We use NOP_EXPR rather than NON_LVALUE_EXPR - so that convert_for_assignment won't strip it. - That way, we get warnings for things like p = (1 - 1). */ - result = build1 (NOP_EXPR, TREE_TYPE (result), result); + /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR + so that convert_for_assignment wouldn't strip it. + That way, we got warnings for things like p = (1 - 1). + But it turns out we should not get those warnings. */ + result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result); C_SET_EXP_ORIGINAL_CODE (result, code); TREE_CONSTANT (result) = flag; } @@ -2546,7 +2558,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) register tree tt0 = TREE_TYPE (type0); register tree tt1 = TREE_TYPE (type1); /* Anything compares with void *. void * compares with anything. - Otherwise, the targets must be the same. */ + Otherwise, the targets must be compatible + and both must be object or both incomplete. */ if (comp_target_types (type0, type1)) ; else if (TYPE_MAIN_VARIANT (tt0) == void_type_node) @@ -2619,6 +2632,9 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) { if (! comp_target_types (type0, type1)) pedwarn ("comparison of distinct pointer types lacks a cast"); + else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0) + != (TYPE_SIZE (TREE_TYPE (type1)) != 0)) + pedwarn ("comparison of complete and incomplete pointers"); else if (pedantic && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) pedwarn ("ANSI C forbids ordered comparisons of pointers to functions"); @@ -4855,6 +4871,9 @@ digest_init (type, init, require_constant, constructor_constant) { tree string = element ? element : inside_init; + if (TREE_TYPE (string) == type) + return string; + if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) != char_type_node) && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node)) @@ -5496,7 +5515,7 @@ pop_init_level (implicit) just pass out the element between them. */ constructor = p->replacement_value; /* If this is the top level thing within the initializer, - and it's for a variable, then since we already calle + and it's for a variable, then since we already called assemble_variable, we must output the value now. */ if (p->next == 0 && constructor_decl != 0 && constructor_incremental) @@ -5770,9 +5789,7 @@ output_init_element (value, type, field, pending) if (! duplicate) constructor_pending_elts = tree_cons (field, - digest_init (type, value, - require_constant_value, - require_constant_elements), + digest_init (type, value, 0, 0), constructor_pending_elts); } else if ((TREE_CODE (constructor_type) == RECORD_TYPE @@ -5782,9 +5799,7 @@ output_init_element (value, type, field, pending) if (!duplicate) constructor_pending_elts = tree_cons (field, - digest_init (type, value, - require_constant_value, - require_constant_elements), + digest_init (type, value, 0, 0), constructor_pending_elts); } else @@ -5798,9 +5813,7 @@ output_init_element (value, type, field, pending) constructor_elements = tree_cons ((TREE_CODE (constructor_type) != ARRAY_TYPE ? field : NULL), - digest_init (type, value, - require_constant_value, - require_constant_elements), + digest_init (type, value, 0, 0), constructor_elements); else { @@ -5820,7 +5833,8 @@ output_init_element (value, type, field, pending) assemble_zeros (next - here); } } - output_constant (value, int_size_in_bytes (type)); + output_constant (digest_init (type, value, 0, 0), + int_size_in_bytes (type)); /* For a record, keep track of end position of last field. */ if (TREE_CODE (constructor_type) == RECORD_TYPE) -- 2.30.2