================
@@ -0,0 +1,86 @@
+// RUN: %clang_cc1 -triple arm64-apple-ios -fsyntax-only -verify
-fptrauth-intrinsics %s
+// RUN: %clang_cc1 -triple aarch64-linux-gnu -fsyntax-only -verify
-fptrauth-intrinsics %s
+
+#if __has_feature(ptrauth_qualifier)
+#warning __ptrauth qualifier enabled!
+// expected-warning@-1 {{__ptrauth qualifier enabled!}}
+#endif
+
+#if __aarch64__
+#define VALID_CODE_KEY 0
+#define VALID_DATA_KEY 2
+#define INVALID_KEY 200
+#else
+#error Provide these constants if you port this test
+#endif
+
+int * __ptrauth(VALID_DATA_KEY) valid0;
+
+typedef int *intp;
+
+int nonConstantGlobal = 5;
+
+__ptrauth int invalid0; // expected-error{{expected '('}}
+__ptrauth() int invalid1; // expected-error{{expected expression}}
+__ptrauth(INVALID_KEY) int invalid2; // expected-error{{200 does not identify
a valid pointer authentication key for the current target}}
+__ptrauth(VALID_DATA_KEY) int invalid3; // expected-error {{'__ptrauth'
qualifier only applies to pointer types; 'int' is invalid}}
+__ptrauth(VALID_DATA_KEY) int *invalid4; // expected-error {{'__ptrauth'
qualifier only applies to pointer types; 'int' is invalid}}
+int * (__ptrauth(VALID_DATA_KEY) invalid5); // expected-error{{expected
identifier or '('}} expected-error{{expected ')'}} expected-note {{to match
this '('}}
+int *__ptrauth(VALID_DATA_KEY) __ptrauth(VALID_DATA_KEY) invalid6; //
expected-error{{type 'int *__ptrauth(2,0,0)' is already __ptrauth-qualified}}
+int * __ptrauth(VALID_DATA_KEY, 2) invalid7; // expected-error {{invalid
address discrimination flag '2'; '__ptrauth' requires '0' or '1'}}
+int * __ptrauth(VALID_DATA_KEY, -1) invalid8; // expected-error {{invalid
address discrimination flag '-1'; '__ptrauth' requires '0' or '1'}}
+int * __ptrauth(VALID_DATA_KEY, 1, -1) invalid9; // expected-error {{invalid
extra discriminator flag '-1'; '__ptrauth' requires a value between '0' and
'65535'}}
+int * __ptrauth(VALID_DATA_KEY, 1, 100000) invalid10; // expected-error
{{invalid extra discriminator flag '100000'; '__ptrauth' requires a value
between '0' and '65535'}}
+int * __ptrauth(VALID_DATA_KEY, 1, nonConstantGlobal) invalid12; //
expected-error {{argument to '__ptrauth' must be an integer constant
expression}}
+int * __ptrauth(VALID_DATA_KEY, nonConstantGlobal, 1000) invalid13; //
expected-error {{argument to '__ptrauth' must be an integer constant
expression}}
+int * __ptrauth(nonConstantGlobal, 1, 1000) invalid14; //
expected-error{{expression is not an integer constant expression}}
+int * __ptrauth(VALID_DATA_KEY, 1, 1000, 12) invalid15; //
expected-error{{qualifier must take between 1 and 3 arguments}}
+
+int * __ptrauth(VALID_DATA_KEY) valid0;
+int * __ptrauth(VALID_DATA_KEY) *valid1;
+__ptrauth(VALID_DATA_KEY) intp valid2;
+__ptrauth(VALID_DATA_KEY) intp *valid3;
+intp __ptrauth(VALID_DATA_KEY) valid4;
+intp __ptrauth(VALID_DATA_KEY) *valid5;
+int * __ptrauth(VALID_DATA_KEY, 0) valid6;
+int * __ptrauth(VALID_DATA_KEY, 1) valid7;
+int * __ptrauth(VALID_DATA_KEY, (_Bool) 1) valid8;
+int * __ptrauth(VALID_DATA_KEY, 1, 0) valid9;
+int * __ptrauth(VALID_DATA_KEY, 1, 65535) valid10;
+
+extern intp redeclaration0; // expected-note {{previous declaration}}
+extern intp __ptrauth(VALID_DATA_KEY) redeclaration0; //
expected-error{{redeclaration of 'redeclaration0' with a different type:
'__ptrauth(2,0,0) intp' (aka 'int *__ptrauth(2,0,0)') vs 'intp' (aka 'int *')}}
+
+extern intp redeclaration1; // expected-note {{previous declaration}}
+extern intp __ptrauth(VALID_DATA_KEY) redeclaration1; //
expected-error{{redeclaration of 'redeclaration1' with a different type:
'__ptrauth(2,0,0) intp' (aka 'int *__ptrauth(2,0,0)') vs 'intp' (aka 'int *')}}
+
+intp __ptrauth(VALID_DATA_KEY) redeclaration2; // expected-note {{previous
definition}}
+intp redeclaration2 = 0; // expected-error{{redefinition
of 'redeclaration2' with a different type: 'intp' (aka 'int *') vs
'__ptrauth(2,0,0) intp' (aka 'int *__ptrauth(2,0,0)')}}
+
+intp __ptrauth(VALID_DATA_KEY) redeclaration3; // expected-note {{previous
definition}}
+intp redeclaration3 = 0; // expected-error{{redefinition
of 'redeclaration3' with a different type: 'intp' (aka 'int *') vs
'__ptrauth(2,0,0) intp' (aka 'int *__ptrauth(2,0,0)')}}
+
+void illegal0(intp __ptrauth(VALID_DATA_KEY)); // expected-error {{parameter
type may not be qualified with '__ptrauth'; type is '__ptrauth(2,0,0) intp'
(aka 'int *__ptrauth(2,0,0)')}}
+intp __ptrauth(VALID_DATA_KEY) illegal1(void); // expected-error {{return type
may not be qualified with '__ptrauth'; type is '__ptrauth(2,0,0) intp' (aka
'int *__ptrauth(2,0,0)')}}
+
+void test_code(intp p) {
+ p = (intp __ptrauth(VALID_DATA_KEY)) 0; // expected-error {{cannot cast to
'__ptrauth'-qualified type '__ptrauth(2,0,0) intp' (aka 'int
*__ptrauth(2,0,0)')}}
+
+ __ptrauth(VALID_DATA_KEY) intp pSpecial = p;
+ pSpecial = p;
+ intp pNormal = pSpecial;
+ pNormal = pSpecial;
+
+ intp __ptrauth(VALID_DATA_KEY) *ppSpecial0 = &pSpecial;
+ intp __ptrauth(VALID_DATA_KEY) *ppSpecial1 = &pNormal; // expected-error
{{initializing '__ptrauth(2,0,0) intp *' (aka 'int *__ptrauth(2,0,0) *') with
an expression of type 'intp *' (aka 'int **') changes pointer authentication of
pointee type}}
+ intp *ppNormal0 = &pSpecial; // expected-error {{initializing 'intp *' (aka
'int **') with an expression of type '__ptrauth(2,0,0) intp *' (aka 'int
*__ptrauth(2,0,0) *') changes pointer authentication of pointee type}}
+ intp *ppNormal1 = &pNormal;
+
+ intp *pp5 = (p ? &pSpecial : &pNormal); // expected-error {{'__ptrauth'
qualification mismatch ('__ptrauth(2,0,0) intp *' (aka 'int *__ptrauth(2,0,0)
*') and 'intp *' (aka 'int **'))}}
+}
+
+void test_array(void) {
----------------
AaronBallman wrote:
Sorry for missing your questions twice now. :-/ I was thinking tests along the
lines:
```
int * __ptrauth(VALID_DATA_KEY) valid0;
// Test that we see the qualifier on the pointer type.
static_assert(_Generic(typeof(valid0), int * __ptrauth(VALID_DATA_KEY) : 1, int
* : 0, default : 0));
// Test that the key is part of the qualifier in terms of type identity.
static_assert(_Generic(typeof(valid0), int * __ptrauth(<some other key>) : 0,
default : 1));
// Test that the qualifier can be stripped explicitly.
static_assert(_Generic(typeof_unqual(valid0), int * __ptrauth(VALID_DATA_KEY) :
0, int * : 1, default : 0));
// Test that rvalue conversion strips the qualifier.
static_assert(_Generic(valid0, int * __ptrauth(VALID_DATA_KEY) : 0, int * : 1,
default : 0));
// Test overloadable behavior.
__attribute__((overloadable)) void overload_test(int *ptr);
__attribute__((overloadable)) void overload_test(int *
__ptrauth(VALID_DATA_KEY));
// Note: also add a codegen test which calls the overloaded function one with
an int * and another with a qualified int * to ensure the calls resolve to the
correct function.
// Test array behavior.
int * __ptrauth(VALID_DATA_KEY) array[10];
static_assert(_Generic(array, int * __ptrauth(VALID_DATA_KEY) : 1, default :
0)); // Decay keeps the qualifier?
int (* __ptrauth(VALID_DATA_KEY) array)[10]; // Fine because it's on a pointer
to arrays?
static_assert(_Generic(*array, int * : 1, default : 0)); // No qualifier to
keep in this case of decay, right?
// Arrays in function parameter lists are just secret pointers, so C has this
funky construct to slap
// a qualifier onto the array itself.
void func(int array[__ptrauth(VALID_DATA_KEY 10]) { // This works?
static_assert(_Generic(typeof(array), int * __ptrauth(VALID_DATA_KEY) : 1,
default : 0));
}
```
I don't know what I was thinking in terms of VLAs; I think the array tests will
capture what I was after.
https://github.com/llvm/llvm-project/pull/100830
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
