================
@@ -0,0 +1,164 @@
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,c-local -x c %s
+// RUN: %clang_cc1 -fsyntax-only -verify=expected,cpp-local -pedantic -x c++
-std=c++11 %s
+
+void foo() {
+ int i;
+ int a[10], b[10];
+
+ [[clang::code_align(8)]]
+ for (i = 0; i < 10; ++i) { // this is OK
+ a[i] = b[i] = 0;
+ }
+ // expected-error@+1{{'code_align' attribute only applies to 'for', 'while',
and 'do' statements}}
+ [[clang::code_align(4)]]
+ i = 7;
+ for (i = 0; i < 10; ++i) {
+ a[i] = b[i] = 0;
+ }
+
+ // expected-error@+1{{'code_align' attribute cannot be applied to a
declaration}}
+ [[clang::code_align(12)]] int n[10];
+}
+
+void bar(int);
+// cpp-local-note@+1{{declared here}}
+void foo1(int A)
+{
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was 0}}
+ [[clang::code_align(0)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was -4}}
+ [[clang::code_align(-4)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // cpp-local-error@+2{{integral constant expression must have integral or
unscoped enumeration type, not 'double'}}
+ // c-local-error@+1{{integer constant expression must have integer type,
not 'double'}}
+ [[clang::code_align(64.0)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute takes one argument}}
+ [[clang::code_align()]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute takes one argument}}
+ [[clang::code_align(4,8)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // no diagnostic is expected
+ [[clang::code_align(32)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // cpp-local-error@+2{{integral constant expression must have integral or
unscoped enumeration type, not 'const char[4]'}}
+ // c-local-error@+1{{integer constant expression must have integer type, not
'char[4]'}}
+ [[clang::code_align("abc")]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ [[clang::code_align(64)]] // OK
+ [[clang::code_align(64)]] // OK
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ [[clang::code_align(8)]] // expected-note{{previous attribute is here}}
+ [[clang::code_align(64)]] // expected-error{{conflicting loop attribute
'code_align'}}
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was 7}}
+ [[clang::code_align(7)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was 5000}}
+ [[clang::code_align(5000)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // expected-warning@+2{{integer literal is too large to be represented in a
signed integer type, interpreting as unsigned}}
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was -9223372036854775808}}
+ [[clang::code_align(9223372036854775808)]]
+ for(int I=0; I<256; ++I) { bar(I); }
+
+ // expected-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was (__int128_t)1311768467294899680ULL << 64}}
+ [[clang::code_align((__int128_t)0x1234567890abcde0ULL << 64)]]
+ for(int I=0; I<256; ++I) { bar(I); }
+
+ // expected-error@+1 {{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was -922337203685477}}
+ [[clang::code_align(-922337203685477)]]
+ for(int I=0; I<256; ++I) { bar(I); }
+
+ // cpp-local-error@+3{{expression is not an integral constant expression}}
+ // cpp-local-note@+2{{left shift of negative value -1311768467294899680}}
+ // c-local-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was -(__int128_t)1311768467294899680ULL << 64}}
+ [[clang::code_align(-(__int128_t)0x1234567890abcde0ULL << 64)]]
+ for(int I=0; I<256; ++I) { bar(I); }
+
+ // cpp-local-error@+3{{expression is not an integral constant expression}}
+ // cpp-local-note@+2{{function parameter 'A' with unknown value cannot be
used in a constant expression}}
+ // c-local-error@+1{{expression is not an integer constant expression}}
+ [[clang::code_align(A)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+}
+
+void check_code_align_expression() {
+ int a[10];
+
+ // Test that checks expression is not a constant expression.
+ int foo2; // cpp-local-note {{declared here}}
+ // c-local-error@+3{{expression is not an integer constant expression}}
+ // cpp-local-error@+2{{expression is not an integral constant expression}}
+ // cpp-local-note@+1{{read of non-const variable 'foo2' is not allowed in a
constant expression}}
+ [[clang::code_align(foo2 + 1)]]
+ for (int i = 0; i != 10; ++i)
+ a[i] = 0;
+
+#if __cplusplus >= 201103L
+ // Test that checks expression is a constant expression.
+ constexpr int bars = 0;
+ [[clang::code_align(bars + 1)]]
+ for (int i = 0; i != 10; ++i)
+ a[i] = 0;
+#endif
+}
+
+#if __cplusplus >= 201103L
+template <int A, int B, int C, int D, int E>
+void code_align_dependent() {
+ [[clang::code_align(C)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ [[clang::code_align(A)]] // OK
+ [[clang::code_align(A)]] // OK
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ [[clang::code_align(A)]]
+ [[clang::code_align(E)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // cpp-local-error@+1{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was 23}}
+ [[clang::code_align(B)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+
+ // cpp-local-error@+2{{'code_align' attribute requires an integer argument
which is a constant power of two between 1 and 4096 inclusive; provided
argument was -10}}
+ // cpp-local-note@#neg-instantiation{{in instantiation of function template
specialization}}
+ [[clang::code_align(D)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+}
+
+template<int ITMPL>
+void bar3() {
+ [[clang::code_align(8)]]
+ [[clang::code_align(ITMPL)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+}
+
+template<int ITMPL1>
+void bar4() {
+ [[clang::code_align(ITMPL1)]]
+ [[clang::code_align(32)]]
+ for(int I=0; I<128; ++I) { bar(I); }
+}
+
+int main() {
+ code_align_dependent<8, 23, 32, -10, 64>(); // #neg-instantiation
+ bar3 <4>();
----------------
smanna12 wrote:
Yes, it is missing diagnostic!
https://github.com/llvm/llvm-project/pull/70762
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
