From patchwork Fri Mar 9 16:23:35 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Iyer, Balaji V" X-Patchwork-Id: 145739 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 52910B6EF3 for ; Sat, 10 Mar 2012 03:24:29 +1100 (EST) Comment: DKIM? See http://www.dkim.org DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; d=gcc.gnu.org; s=default; x=1331915070; h=Comment: DomainKey-Signature:Received:Received:Received:Received:Received: Received:Received:From:To:Subject:Date:Message-ID:Content-Type: MIME-Version:Mailing-List:Precedence:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:Sender:Delivered-To; bh=ghk4bvS 3pIGsfJ2wOdXo9cZY8AU=; b=s1sMeYU7JsPc/VjvpQDuHZmU/bkPhv3lEt/GQRB 0VVVSF+thO02Nxx0gucYcmKByAz+P6SrbzlFINCccihnDDikTIPwdOAe3E3Qp0Yf 7mL4SdVR8PJ2ZnjzcDBzXUIadPWnu3LsIUcfvbY1hAOSdyqVli2oBTGA3HxOC7y5 RYCY= Comment: DomainKeys? See http://antispam.yahoo.com/domainkeys DomainKey-Signature: a=rsa-sha1; q=dns; c=nofws; s=default; d=gcc.gnu.org; h=Received:Received:X-SWARE-Spam-Status:X-Spam-Check-By:Received:Received:X-ExtLoop1:Received:Received:Received:From:To:Subject:Date:Message-ID:Content-Type:MIME-Version:Mailing-List:Precedence:List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help:Sender:Delivered-To; b=ibau06ZOdfnoGNarTfcMhJ1gEgHWTc14EQYLZK01VPEy8dJ3Co/75nTK5pKSta 7nybaB3UMBHB6S5zGOKapZFffoTQ5dAfPgkHg8YfRKFYZ4Zbn2Wpbc8gKWsNsGUD sGnVXpLGLQhd3/O0zL7bSAHqtFRntInN8aXGd2D8I8LjY=; Received: (qmail 14817 invoked by alias); 9 Mar 2012 16:24:04 -0000 Received: (qmail 14784 invoked by uid 22791); 9 Mar 2012 16:23:58 -0000 X-SWARE-Spam-Status: No, hits=-4.7 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mga03.intel.com (HELO mga03.intel.com) (143.182.124.21) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 09 Mar 2012 16:23:38 +0000 Received: from azsmga002.ch.intel.com ([10.2.17.35]) by azsmga101.ch.intel.com with ESMTP; 09 Mar 2012 08:23:37 -0800 X-ExtLoop1: 1 Received: from azsmsx601.amr.corp.intel.com ([10.2.121.193]) by AZSMGA002.ch.intel.com with ESMTP; 09 Mar 2012 08:23:37 -0800 Received: from fmsmsx107.amr.corp.intel.com (10.19.9.54) by azsmsx601.amr.corp.intel.com (10.2.121.193) with Microsoft SMTP Server (TLS) id 8.2.255.0; Fri, 9 Mar 2012 09:23:36 -0700 Received: from fmsmsx102.amr.corp.intel.com ([169.254.2.186]) by FMSMSX107.amr.corp.intel.com ([169.254.9.51]) with mapi id 14.01.0355.002; Fri, 9 Mar 2012 08:23:36 -0800 From: "Iyer, Balaji V" To: "gcc-patches@gcc.gnu.org" Subject: [PATCH][Cilkplus] elemental functions parsing patch Date: Fri, 9 Mar 2012 16:23:35 +0000 Message-ID: MIME-Version: 1.0 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 Hello Everyone, This patch is for the Cilkplus branch affecting mainly the C compiler. This patch will start the implementation of elemental functions in the branch. This patch will parse the elemental function attributes in the C compiler Thanking You, Yours Sincerely, Balaji V. Iyer. diff --git a/gcc/ChangeLog.cilk b/gcc/ChangeLog.cilk index ebabff6..1398870 100644 --- a/gcc/ChangeLog.cilk +++ b/gcc/ChangeLog.cilk @@ -1,3 +1,15 @@ +2012-03-09 Balaji V. Iyer + + * attribs.c (decl_attributes): Added a check for elemental function + attribute. + (is_elem_fn_attribute_p): New function. + * c-parser.c (c_parser_attributes): Added a check for vector attribute. + (c_parser_elem_fn_processor_clause): New function. + (c_parser_elem_fn_uniform_clause): Likewise. + (c_parser_elem_fn_linear_clause): Likewise. + (c_parser_elem_fn_vlength_clause): Likewise. + (c_parser_elem_fn_expr_list): Likewise. + 2012-02-15 Balaji V. Iyer * cilk.c (cilk_fix_stack_reg): New function. diff --git a/gcc/attribs.c b/gcc/attribs.c index 0e94fd2..2ececc4 100644 --- a/gcc/attribs.c +++ b/gcc/attribs.c @@ -228,6 +228,18 @@ lookup_attribute_spec (const_tree name) substring_hash (attr.str, attr.length)); } + +static bool +is_elem_fn_attribute_p (tree name) +{ + return is_attribute_p ("mask", name) + || is_attribute_p ("unmask", name) + || is_attribute_p ("vectorlength", name) + || is_attribute_p ("vector", name) + || is_attribute_p ("linear", name) + || is_attribute_p ("uniform", name); +} + /* Process the attributes listed in ATTRIBUTES and install them in *NODE, which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, it should be modified in place; if a TYPE, a copy should be created @@ -312,8 +324,9 @@ decl_attributes (tree *node, tree attributes, int flags) if (spec == NULL) { - warning (OPT_Wattributes, "%qE attribute directive ignored", - name); + if (!is_elem_fn_attribute_p (name)) + warning (OPT_Wattributes, "%qE attribute directive ignored", + name); continue; } else if (list_length (args) < spec->min_length diff --git a/gcc/c-parser.c b/gcc/c-parser.c index c67ea97..4f940e1 100644 --- a/gcc/c-parser.c +++ b/gcc/c-parser.c @@ -65,6 +65,7 @@ extern struct c_expr fix_array_notation_expr (location_t, enum tree_code, extern bool contains_array_notation_expr (tree); struct pragma_simd_values local_simd_values; + /* Initialization routine for this file. */ @@ -242,6 +243,8 @@ typedef struct GTY(()) c_parser { static GTY (()) c_parser *the_parser; +static VEC(tree,gc) *c_parser_elem_fn_expr_list (c_parser *parser); + /* Read in and lex a single token, storing it in *TOKEN. */ static void @@ -3635,7 +3638,12 @@ c_parser_attributes (c_parser *parser) attr_args = NULL_TREE; else { - expr_list = c_parser_expr_list (parser, false, true, NULL); + if (TREE_CODE (attr_name) == IDENTIFIER_NODE + && simple_cst_equal (attr_name, + get_identifier ("vector")) == 1) + expr_list = c_parser_elem_fn_expr_list (parser); + else + expr_list = c_parser_expr_list (parser, false, true, NULL); attr_args = build_tree_list_vec (expr_list); release_tree_vector (expr_list); } @@ -11870,4 +11878,421 @@ c_parser_array_notation (c_parser *parser, tree initial_index, tree array_value) return value_tree; } +static tree +c_parser_elem_fn_processor_clause (c_parser *parser) +{ + c_token *token; + tree proc_tree_list = NULL_TREE; + VEC(tree,gc) *proc_vec_list = NULL; + + token = c_parser_peek_token (parser); + if (!c_parser_next_token_is (parser, CPP_OPEN_PAREN)) + { + c_parser_error (parser, "expected %<)%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + else + c_parser_consume_token (parser); + + proc_vec_list = make_tree_vector (); + + if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + token = c_parser_peek_token (parser); + if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, get_identifier ("pentium_4")) == 1) + { + c_parser_consume_token (parser); + VEC_safe_push (tree, gc, proc_vec_list, + build_string (strlen ("pentium_4"), "pentium_4")); + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("pentium4_sse3")) == 1) + { + c_parser_consume_token (parser); + VEC_safe_push (tree, gc, proc_vec_list, + build_string (strlen ("pentium4_sse3"), + "pentium4_sse3")); + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("core2_duo_ssse3")) == 1) + { + c_parser_consume_token (parser); + VEC_safe_push (tree, gc, proc_vec_list, + build_string (strlen ("core2_duo_ssse3"), + "core2_duo_ssse3")); + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("core2_duo_sse_4_1")) == 1) + { + c_parser_consume_token (parser); + VEC_safe_push (tree, gc, proc_vec_list, + build_string (strlen ("core2_duo_sse_4_1"), + "core2_duo_sse_4_1")); + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("core_i7_sse4_2")) == 1) + { + c_parser_consume_token (parser); + VEC_safe_push (tree, gc, proc_vec_list, + build_string (strlen ("core_i7_sse4_2"), + "core_i7_sse4_2")); + } + else + { + sorry ("Processor type not supported"); + } + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + c_parser_consume_token (parser); + else + c_parser_error (parser, "expected %>)%>"); + } + else + c_parser_error (parser, "expected %>(%> and CPUID"); + + proc_tree_list = build_tree_list_vec (proc_vec_list); + release_tree_vector (proc_vec_list); + proc_tree_list = build_tree_list (get_identifier ("processor"), + proc_tree_list); + return proc_tree_list; +} + +static tree +c_parser_elem_fn_uniform_clause (c_parser *parser) +{ + c_token *token; + tree uniform_tree; + tree str_token = NULL_TREE; + VEC(tree,gc) *uniform_vec = NULL; + + if (!c_parser_next_token_is (parser, CPP_OPEN_PAREN)) + { + c_parser_error (parser, "expected %<)%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + else + c_parser_consume_token (parser); + + uniform_vec = make_tree_vector (); + while (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + token = c_parser_peek_token (parser); + if (token->value && token->type == CPP_NAME) + { + /* convert the variable to a string */ + str_token = build_string (strlen (IDENTIFIER_POINTER (token->value)), + IDENTIFIER_POINTER (token->value)); + VEC_safe_push (tree, gc, uniform_vec, str_token); + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is_not (parser, CPP_NAME)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, + "expected %<,%> or %<)%> after identifier"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else + { + c_parser_error (parser, "expected number or comma"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + c_parser_consume_token (parser); + uniform_tree = build_tree_list_vec (uniform_vec); + release_tree_vector (uniform_vec); + uniform_tree = build_tree_list (get_identifier ("uniform"), uniform_tree); + return uniform_tree; +} + +static tree +c_parser_elem_fn_linear_clause (c_parser *parser) +{ + c_token *token; + VEC(tree,gc) *linear_vec = NULL; + tree linear_tree = NULL_TREE; + tree var_str, step_size; + + if (!c_parser_next_token_is (parser, CPP_OPEN_PAREN)) + { + c_parser_error (parser, "expected %<)%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + else + c_parser_consume_token (parser); + linear_vec = make_tree_vector (); + // VEC_safe_push (tree, gc, linear_vec, get_identifier ("linear")); + + while (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + token = c_parser_peek_token (parser); + if (token->value && token->type == CPP_NAME) + { + var_str = build_string (strlen (IDENTIFIER_POINTER (token->value)), + IDENTIFIER_POINTER (token->value)); + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_COLON)) + { + c_parser_consume_token (parser); + token = c_parser_peek_token (parser); + if (token->value && token->type == CPP_NUMBER) + step_size = token->value; + else + { + c_parser_error (parser, "expected step-size"); + return NULL_TREE; + } + c_parser_consume_token (parser); + } + else + step_size = integer_one_node; + VEC_safe_push (tree, gc, linear_vec, var_str); + VEC_safe_push (tree, gc, linear_vec, step_size); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is_not (parser, CPP_NAME)) + { + c_parser_error (parser, + "expected variable after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, + "expected %<,%> or %<)%> after variable/step"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else + { + c_parser_error (parser, "expected variable name or comma"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + c_parser_consume_token (parser); /* consume the ')' */ + linear_tree = build_tree_list_vec (linear_vec); + release_tree_vector (linear_vec); + linear_tree = build_tree_list (get_identifier ("linear"), linear_tree); + return linear_tree; +} + +static tree +c_parser_elem_fn_vlength_clause (c_parser *parser) +{ + c_token *token; + VEC(tree,gc) *vlength_vec = NULL; + tree vlength_tree = NULL_TREE; + + if (!c_parser_next_token_is (parser, CPP_OPEN_PAREN)) + { + c_parser_error (parser, "expected %<)%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + else + c_parser_consume_token (parser); + + vlength_vec = make_tree_vector (); + // VEC_safe_push (tree, gc, vlength_vec, get_identifier ("vectorlength")); + while (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + token = c_parser_peek_token (parser); + if (token->value && token->type == CPP_NUMBER) + { + VEC_safe_push (tree, gc, vlength_vec, token->value); + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is_not (parser, CPP_NUMBER)) + { + c_parser_error (parser, "expected vectorlength after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, + "expected %<,%> or %<)%> after vectorlength"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + else + { + c_parser_error (parser, "expected number or comma"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return NULL_TREE; + } + } + c_parser_consume_token (parser); + vlength_tree = build_tree_list_vec (vlength_vec); + release_tree_vector (vlength_vec); + vlength_tree = build_tree_list (get_identifier ("vectorlength"), + vlength_tree); + return vlength_tree; +} + +static VEC(tree,gc) * +c_parser_elem_fn_expr_list (c_parser *parser) +{ + c_token *token; + VEC(tree,gc) *expr_list = NULL; + tree proc_list = NULL_TREE, mask_list = NULL_TREE, uniform_list = NULL_TREE; + tree vlength_list = NULL_TREE, linear_list = NULL_TREE; + + expr_list = make_tree_vector (); + + while (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + token = c_parser_peek_token (parser); + if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("processor")) == 1) + { + c_parser_consume_token (parser); + gcc_assert (proc_list == NULL_TREE); + proc_list = c_parser_elem_fn_processor_clause (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("mask")) == 1) + { + gcc_assert (mask_list == NULL_TREE); + mask_list = get_identifier ("mask"); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("unmask")) == 1) + { + c_parser_consume_token (parser); + gcc_assert (mask_list == NULL_TREE); + mask_list = get_identifier ("unmask"); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("vectorlength")) == 1) + { + c_parser_consume_token (parser); + gcc_assert (vlength_list == NULL_TREE); + vlength_list = c_parser_elem_fn_vlength_clause (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("uniform")) == 1) + { + c_parser_consume_token (parser); + gcc_assert (uniform_list == NULL_TREE); + uniform_list = c_parser_elem_fn_uniform_clause (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + else if (token->value && TREE_CODE (token->value) == IDENTIFIER_NODE + && simple_cst_equal (token->value, + get_identifier ("linear")) == 1) + { + c_parser_consume_token (parser); + gcc_assert (linear_list == NULL_TREE); + linear_list = c_parser_elem_fn_linear_clause (parser); + if (c_parser_next_token_is (parser, CPP_COMMA)) + { + c_parser_consume_token (parser); + if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) + { + c_parser_error (parser, "expected identifier after %<,%>"); + c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); + return expr_list; + } + } + } + } + + if (proc_list) + VEC_safe_push (tree, gc, expr_list, proc_list); + if (vlength_list) + VEC_safe_push (tree, gc, expr_list, vlength_list); + if (uniform_list) + VEC_safe_push (tree, gc, expr_list, uniform_list); + if (mask_list) + VEC_safe_push (tree, gc, expr_list, mask_list); + if (linear_list) + VEC_safe_push (tree, gc, expr_list, linear_list); + + return expr_list; +} + #include "gt-c-parser.h"