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 <[email protected]>
* decl2.c (cp_check_const_attributes): New.
(cplus_decl_attributes): Call cp_check_const_attributes.
gcc/testsuite/
2011-03-10 Rodrigo Rivas Costa <[email protected]>
* g++.dg/cpp0x/constexpr-attribute.C: New.
commit fbd79f3f22242a865d57fd106b4d8202a5e60241
Author: Rodrigo Rivas Costa <[email protected]>
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<typename T>
+constexpr int fooT() { return __alignof__(T); }
+
+template<int N>
+constexpr int fooN() { return N; }
+
+//Now the attributes
+
+//with normal variables,
+int a __attribute__((aligned(foo())));
+int b __attribute__((aligned(fooT<int>())));
+int c __attribute__((aligned(fooN<__alignof__(int)>())));
+
+//with variables inside a template,
+template <typename T>
+void fun()
+{
+ T a __attribute__((aligned(foo())));
+ T b __attribute__((aligned(fooT<T>())));
+ T c __attribute__((aligned(fooN<__alignof__(T)>())));
+ T d __attribute__((aligned(fooT<int>())));
+ T e __attribute__((aligned(fooN<__alignof__(int)>())));
+}
+
+//instantiate it,
+void bar()
+{
+ fun<int>();
+}
+
+//with classes
+struct __attribute__((aligned(foo()))) S0
+{
+ char dummy;
+};
+S0 s0;
+
+struct __attribute__((aligned(fooT<int>()))) S1
+{
+ char dummy;
+};
+S1 s1;
+
+//and class templates
+template <typename T>
+struct __attribute__((aligned(foo()))) S2
+{
+ char dummy;
+};
+
+S2<int> s2;
+
+template <typename T>
+struct __attribute__((aligned(fooT<T>()))) S3
+{
+ char dummy;
+};
+S3<int> s3;
