From patchwork Tue Oct 4 23:13:18 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Artem Shinkarov X-Patchwork-Id: 117711 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id C71991007D1 for ; Wed, 5 Oct 2011 10:13:56 +1100 (EST) Received: (qmail 597 invoked by alias); 4 Oct 2011 23:13:55 -0000 Received: (qmail 589 invoked by uid 22791); 4 Oct 2011 23:13:53 -0000 X-SWARE-Spam-Status: No, hits=-2.1 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW X-Spam-Check-By: sourceware.org Received: from mail-vx0-f175.google.com (HELO mail-vx0-f175.google.com) (209.85.220.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 04 Oct 2011 23:13:38 +0000 Received: by vcbfl17 with SMTP id fl17so1033770vcb.20 for ; Tue, 04 Oct 2011 16:13:38 -0700 (PDT) Received: by 10.220.140.146 with SMTP id i18mr522660vcu.75.1317770018062; Tue, 04 Oct 2011 16:13:38 -0700 (PDT) MIME-Version: 1.0 Received: by 10.220.150.13 with HTTP; Tue, 4 Oct 2011 16:13:18 -0700 (PDT) In-Reply-To: References: From: Artem Shinkarov Date: Wed, 5 Oct 2011 00:13:18 +0100 Message-ID: Subject: Re: Fix pr50607 bconstp-3.c failure To: "Joseph S. Myers" Cc: GCC Patches X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org On Tue, Oct 4, 2011 at 11:51 PM, Joseph S. Myers wrote: > On Tue, 4 Oct 2011, Artem Shinkarov wrote: > >> Hi >> >> Here is the patch tho fix bconstp-3.c failure in the bug 50607. The >> failure was cause because the new parser routine did not consider >> original_tree_code of the expression. >> >> The patch is bootstrapped on x86-unknown-linux-gnu and is being tested. > > Please repost the patch for review without the unrelated whitespace > changes. > > -- > Joseph S. Myers > joseph@codesourcery.com > Sure. The new version is in the attachment. Thanks, Artem. diff -up '-F^(define' gcc-bootstrap/gcc//c-parser.c gcc-new/gcc//c-parser.c --- gcc-bootstrap/gcc//c-parser.c 2011-10-05 00:09:59.067560839 +0100 +++ gcc-new/gcc//c-parser.c 2011-10-05 00:08:23.454756162 +0100 @@ -5993,16 +5993,16 @@ c_parser_alignof_expression (c_parser *p for the middle-end nodes like COMPLEX_EXPR, VEC_SHUFFLE_EXPR and others. The name of the builtin is passed using BNAME parameter. Function returns true if there were no errors while parsing and - stores the arguments in EXPR_LIST. List of original types can be - obtained by passing non NULL value to ORIG_TYPES. */ + stores the arguments in CEXPR_LIST. */ static bool c_parser_get_builtin_args (c_parser *parser, const char *bname, - VEC(tree,gc) **expr_list, - VEC(tree,gc) **orig_types) + VEC(c_expr_t,gc) **ret_cexpr_list) { location_t loc = c_parser_peek_token (parser)->location; - *expr_list = NULL; + VEC (c_expr_t,gc) *cexpr_list; + c_expr_t expr; + *ret_cexpr_list = NULL; if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN)) { error_at (loc, "cannot take address of %qs", bname); @@ -6017,14 +6017,20 @@ c_parser_get_builtin_args (c_parser *par return true; } - if (orig_types) - *expr_list = c_parser_expr_list (parser, false, false, orig_types); - else - *expr_list = c_parser_expr_list (parser, false, false, NULL); + expr = c_parser_expr_no_commas (parser, NULL); + cexpr_list = VEC_alloc (c_expr_t, gc, 1); + C_EXPR_APPEND (cexpr_list, expr); + while (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + expr = c_parser_expr_no_commas (parser, NULL); + C_EXPR_APPEND (cexpr_list, expr); + } if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) return false; + *ret_cexpr_list = cexpr_list; return true; } @@ -6378,20 +6384,20 @@ c_parser_postfix_expression (c_parser *p break; case RID_CHOOSE_EXPR: { - VEC(tree,gc) *expr_list; - VEC(tree,gc) *orig_types; - tree e1value, e2value, e3value, c; + VEC (c_expr_t, gc) *cexpr_list; + c_expr_t *e1_p, *e2_p, *e3_p; + tree c; c_parser_consume_token (parser); if (!c_parser_get_builtin_args (parser, "__builtin_choose_expr", - &expr_list, &orig_types)) + &cexpr_list)) { expr.value = error_mark_node; break; } - if (VEC_length (tree, expr_list) != 3) + if (VEC_length (c_expr_t, cexpr_list) != 3) { error_at (loc, "wrong number of arguments to " "%<__builtin_choose_expr%>"); @@ -6399,31 +6405,20 @@ c_parser_postfix_expression (c_parser *p break; } - e1value = VEC_index (tree, expr_list, 0); - e2value = VEC_index (tree, expr_list, 1); - e3value = VEC_index (tree, expr_list, 2); - - c = e1value; - mark_exp_read (e2value); - mark_exp_read (e3value); + e1_p = VEC_index (c_expr_t, cexpr_list, 0); + e2_p = VEC_index (c_expr_t, cexpr_list, 1); + e3_p = VEC_index (c_expr_t, cexpr_list, 2); + + c = e1_p->value; + mark_exp_read (e2_p->value); + mark_exp_read (e3_p->value); if (TREE_CODE (c) != INTEGER_CST || !INTEGRAL_TYPE_P (TREE_TYPE (c))) error_at (loc, "first argument to %<__builtin_choose_expr%> not" " a constant"); constant_expression_warning (c); - - if (integer_zerop (c)) - { - expr.value = e3value; - expr.original_type = VEC_index (tree, orig_types, 2); - } - else - { - expr.value = e2value; - expr.original_type = VEC_index (tree, orig_types, 1); - } - + expr = integer_zerop (c) ? *e3_p : *e2_p; break; } case RID_TYPES_COMPATIBLE_P: @@ -6465,19 +6460,19 @@ c_parser_postfix_expression (c_parser *p break; case RID_BUILTIN_COMPLEX: { - VEC(tree,gc) *expr_list; - tree e1value, e2value; + VEC(c_expr_t, gc) *cexpr_list; + c_expr_t *e1_p, *e2_p; c_parser_consume_token (parser); if (!c_parser_get_builtin_args (parser, "__builtin_complex", - &expr_list, NULL)) + &cexpr_list)) { expr.value = error_mark_node; break; } - if (VEC_length (tree, expr_list) != 2) + if (VEC_length (c_expr_t, cexpr_list) != 2) { error_at (loc, "wrong number of arguments to " "%<__builtin_complex%>"); @@ -6485,29 +6480,29 @@ c_parser_postfix_expression (c_parser *p break; } - e1value = VEC_index (tree, expr_list, 0); - e2value = VEC_index (tree, expr_list, 1); + e1_p = VEC_index (c_expr_t, cexpr_list, 0); + e2_p = VEC_index (c_expr_t, cexpr_list, 1); - mark_exp_read (e1value); - if (TREE_CODE (e1value) == EXCESS_PRECISION_EXPR) - e1value = convert (TREE_TYPE (e1value), - TREE_OPERAND (e1value, 0)); - mark_exp_read (e2value); - if (TREE_CODE (e2value) == EXCESS_PRECISION_EXPR) - e2value = convert (TREE_TYPE (e2value), - TREE_OPERAND (e2value, 0)); - if (!SCALAR_FLOAT_TYPE_P (TREE_TYPE (e1value)) - || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e1value)) - || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (e2value)) - || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e2value))) + mark_exp_read (e1_p->value); + if (TREE_CODE (e1_p->value) == EXCESS_PRECISION_EXPR) + e1_p->value = convert (TREE_TYPE (e1_p->value), + TREE_OPERAND (e1_p->value, 0)); + mark_exp_read (e2_p->value); + if (TREE_CODE (e2_p->value) == EXCESS_PRECISION_EXPR) + e2_p->value = convert (TREE_TYPE (e2_p->value), + TREE_OPERAND (e2_p->value, 0)); + if (!SCALAR_FLOAT_TYPE_P (TREE_TYPE (e1_p->value)) + || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e1_p->value)) + || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (e2_p->value)) + || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e2_p->value))) { error_at (loc, "%<__builtin_complex%> operand " "not of real binary floating-point type"); expr.value = error_mark_node; break; } - if (TYPE_MAIN_VARIANT (TREE_TYPE (e1value)) - != TYPE_MAIN_VARIANT (TREE_TYPE (e2value))) + if (TYPE_MAIN_VARIANT (TREE_TYPE (e1_p->value)) + != TYPE_MAIN_VARIANT (TREE_TYPE (e2_p->value))) { error_at (loc, "%<__builtin_complex%> operands of different types"); @@ -6518,34 +6513,37 @@ c_parser_postfix_expression (c_parser *p pedwarn (loc, OPT_pedantic, "ISO C90 does not support complex types"); expr.value = build2 (COMPLEX_EXPR, - build_complex_type (TYPE_MAIN_VARIANT - (TREE_TYPE (e1value))), - e1value, e2value); + build_complex_type + (TYPE_MAIN_VARIANT + (TREE_TYPE (e1_p->value))), + e1_p->value, e2_p->value); break; } case RID_BUILTIN_SHUFFLE: { - VEC(tree,gc) *expr_list; + VEC(c_expr_t,gc) *cexpr_list; c_parser_consume_token (parser); if (!c_parser_get_builtin_args (parser, "__builtin_shuffle", - &expr_list, NULL)) + &cexpr_list)) { expr.value = error_mark_node; break; } - if (VEC_length (tree, expr_list) == 2) - expr.value = c_build_vec_shuffle_expr - (loc, VEC_index (tree, expr_list, 0), - NULL_TREE, - VEC_index (tree, expr_list, 1)); - else if (VEC_length (tree, expr_list) == 3) - expr.value = c_build_vec_shuffle_expr - (loc, VEC_index (tree, expr_list, 0), - VEC_index (tree, expr_list, 1), - VEC_index (tree, expr_list, 2)); + if (VEC_length (c_expr_t, cexpr_list) == 2) + expr.value = + c_build_vec_shuffle_expr + (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, + NULL_TREE, VEC_index (c_expr_t, cexpr_list, 1)->value); + + else if (VEC_length (c_expr_t, cexpr_list) == 3) + expr.value = + c_build_vec_shuffle_expr + (loc, VEC_index (c_expr_t, cexpr_list, 0)->value, + VEC_index (c_expr_t, cexpr_list, 1)->value, + VEC_index (c_expr_t, cexpr_list, 2)->value); else { error_at (loc, "wrong number of arguments to " diff -up '-F^(define' gcc-bootstrap/gcc//c-tree.h gcc-new/gcc//c-tree.h --- gcc-bootstrap/gcc//c-tree.h 2011-10-05 00:10:06.419468926 +0100 +++ gcc-new/gcc//c-tree.h 2011-10-05 00:08:23.475755901 +0100 @@ -130,6 +130,22 @@ struct c_expr tree original_type; }; +/* Type alias for struct c_expr. This allows to use the structure + inside the VEC types. */ +typedef struct c_expr c_expr_t; + +/* A varray of c_expr_t. */ +DEF_VEC_O (c_expr_t); +DEF_VEC_ALLOC_O (c_expr_t, gc); +DEF_VEC_ALLOC_O (c_expr_t, heap); + +/* Append a new c_expr_t element to V. */ +#define C_EXPR_APPEND(V, ELEM) \ + do { \ + c_expr_t *__elem_p = VEC_safe_push (c_expr_t, gc, V, NULL); \ + *__elem_p = (ELEM); \ + } while (0) + /* A kind of type specifier. Note that this information is currently only used to distinguish tag definitions, tag references and typeof uses. */