From patchwork Thu Mar 10 18:24:00 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rodrigo Rivas X-Patchwork-Id: 86330 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 58F3D1007D3 for ; Fri, 11 Mar 2011 05:24:15 +1100 (EST) Received: (qmail 19433 invoked by alias); 10 Mar 2011 18:24:10 -0000 Received: (qmail 19411 invoked by uid 22791); 10 Mar 2011 18:24:07 -0000 X-SWARE-Spam-Status: No, hits=-2.2 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, T_TO_NO_BRKTS_FREEMAIL X-Spam-Check-By: sourceware.org Received: from mail-pv0-f175.google.com (HELO mail-pv0-f175.google.com) (74.125.83.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 10 Mar 2011 18:24:02 +0000 Received: by pvc30 with SMTP id 30so540548pvc.20 for ; Thu, 10 Mar 2011 10:24:00 -0800 (PST) MIME-Version: 1.0 Received: by 10.142.134.16 with SMTP id h16mr6688231wfd.248.1299781440657; Thu, 10 Mar 2011 10:24:00 -0800 (PST) Received: by 10.142.251.20 with HTTP; Thu, 10 Mar 2011 10:24:00 -0800 (PST) Date: Thu, 10 Mar 2011 19:24:00 +0100 Message-ID: Subject: [C++0x patch] constexpr in attribute argument From: Rodrigo Rivas To: gcc-patches@gcc.gnu.org Cc: Jason Merrill 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 Hi! Checking the new constexpr support in the C++0x frontend, I've notices that there is one place where a plain constant is accepted but a constexpr is not. Probably you have guessed (from the subject line above), it is in an attribute argument, e.g: constexpr int foo() { return 4; } int __attribute__((aligned(4))) a; //ok int __attribute__((aligned(foo()))) b; //error: requested alignment is not a constant IMHO, this code is correct. The attached patch solves this issue cleanly, I think. In the included testsuite I've used only the attribute ((aligned)), but I don't think that should matter too much. Regards --- Rodrigo Changelog: gcc/cp/ 2011-03-10 Rodrigo Rivas Costa * decl2.c (cp_check_const_attributes): New. (cplus_decl_attributes): Call cp_check_const_attributes. gcc/testsuite/ 2011-03-10 Rodrigo Rivas Costa * g++.dg/cpp0x/constexpr-attribute.C: New. commit fbd79f3f22242a865d57fd106b4d8202a5e60241 Author: Rodrigo Rivas Costa Date: Thu Mar 10 15:57:47 2011 +0100 constexpr attribute diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index eb5d4f5..8a2c2e3 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -1264,6 +1264,25 @@ cp_reconstruct_complex_type (tree type, tree bottom) return cp_build_qualified_type (outer, cp_type_quals (type)); } +/* Replaces any constexpr expression that may be into the attributes + arguments with their reduced value. */ + +static void +cp_check_const_attributes (tree attributes) +{ + tree attr; + for (attr = attributes; attr; attr = TREE_CHAIN (attr)) + { + tree arg; + for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg)) + { + tree expr = TREE_VALUE (arg); + if (EXPR_P (expr)) + TREE_VALUE (arg) = maybe_constant_value (expr); + } + } +} + /* Like decl_attributes, but handle C++ complexity. */ void @@ -1284,6 +1303,8 @@ cplus_decl_attributes (tree *decl, tree attributes, int flags) return; } + cp_check_const_attributes(attributes); + if (TREE_CODE (*decl) == TEMPLATE_DECL) decl = &DECL_TEMPLATE_RESULT (*decl); diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-attribute.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-attribute.C new file mode 100644 index 0000000..58b3793 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-attribute.C @@ -0,0 +1,63 @@ +// { dg-options -std=c++0x } + +//A few constexpr's +constexpr int foo() { return __alignof__(int); } + +template +constexpr int fooT() { return __alignof__(T); } + +template +constexpr int fooN() { return N; } + +//Now the attributes + +//with normal variables, +int a __attribute__((aligned(foo()))); +int b __attribute__((aligned(fooT()))); +int c __attribute__((aligned(fooN<__alignof__(int)>()))); + +//with variables inside a template, +template +void fun() +{ + T a __attribute__((aligned(foo()))); + T b __attribute__((aligned(fooT()))); + T c __attribute__((aligned(fooN<__alignof__(T)>()))); + T d __attribute__((aligned(fooT()))); + T e __attribute__((aligned(fooN<__alignof__(int)>()))); +} + +//instantiate it, +void bar() +{ + fun(); +} + +//with classes +struct __attribute__((aligned(foo()))) S0 +{ + char dummy; +}; +S0 s0; + +struct __attribute__((aligned(fooT()))) S1 +{ + char dummy; +}; +S1 s1; + +//and class templates +template +struct __attribute__((aligned(foo()))) S2 +{ + char dummy; +}; + +S2 s2; + +template +struct __attribute__((aligned(fooT()))) S3 +{ + char dummy; +}; +S3 s3;