https://github.com/ojhunt created
https://github.com/llvm/llvm-project/pull/135469
These are a pair of builtins to support particularly weird edge case operations
while correctly handling the non-trivial implicit pointer authentication
schemas applied to polymorphic members.
>From 6e1d13805dabdbd1be58d4e3d095d322d798c3c8 Mon Sep 17 00:00:00 2001
From: Ahmed Bougacha <ah...@bougacha.org>
Date: Mon, 27 Sep 2021 08:00:00 -0700
Subject: [PATCH] [clang] Add builtin_get_vtable_pointer and
virtual_member_address
These are a pair of builtins to support particularly weird edge
case operations while correctly handling the non-trivial implicit
pointer authentication schemas applied to polymorphic members.
---
clang/docs/LanguageExtensions.rst | 33 ++
clang/include/clang/Basic/Builtins.td | 12 +
.../clang/Basic/DiagnosticSemaKinds.td | 15 +
clang/lib/CodeGen/CGBuiltin.cpp | 30 ++
clang/lib/Sema/SemaChecking.cpp | 90 ++++++
.../CodeGenCXX/builtin-get-vtable-pointer.cpp | 304 ++++++++++++++++++
.../builtin_virtual_member_address.cpp | 41 +++
.../SemaCXX/builtin-get-vtable-pointer.cpp | 123 +++++++
.../builtin_virtual_member_address.cpp | 57 ++++
9 files changed, 705 insertions(+)
create mode 100644 clang/test/CodeGenCXX/builtin-get-vtable-pointer.cpp
create mode 100644 clang/test/CodeGenCXX/builtin_virtual_member_address.cpp
create mode 100644 clang/test/SemaCXX/builtin-get-vtable-pointer.cpp
create mode 100644 clang/test/SemaCXX/builtin_virtual_member_address.cpp
diff --git a/clang/docs/LanguageExtensions.rst
b/clang/docs/LanguageExtensions.rst
index 3b8a9cac6587a..643dea3c6cbf7 100644
--- a/clang/docs/LanguageExtensions.rst
+++ b/clang/docs/LanguageExtensions.rst
@@ -3031,6 +3031,39 @@ following way:
Query for this feature with ``__has_builtin(__builtin_offsetof)``.
+``__builtin_get_vtable_pointer``
+--------------------------------
+
+``__builtin_get_vtable_pointer`` loads and authenticates the primary vtable
+pointer from an instance of a polymorphic C++ class.
+
+**Syntax**:
+
+.. code-block:: c++
+
+ __builtin_get_vtable_pointer(PolymorphicClass*)
+
+**Example of Use**:
+
+.. code-block:: c++
+
+ struct PolymorphicClass {
+ virtual ~PolymorphicClass();
+ };
+
+ PolymorphicClass anInstance;
+ const void* vtablePointer = __builtin_get_vtable_pointer(&anInstance);
+
+**Description**:
+
+The ``__builtin_get_vtable_pointer`` builtin loads the primary vtable
+pointer from a polymorphic C++ type. If the target platform authenticates
+vtable pointers, this builtin will perform the authentication and produce
+the underlying raw pointer. The object being queried must be polymorphic,
+and so must also be a complete type.
+
+Query for this feature with ``__has_builtin(__builtin_get_vtable_pointer)``.
+
``__builtin_call_with_static_chain``
------------------------------------
diff --git a/clang/include/clang/Basic/Builtins.td
b/clang/include/clang/Basic/Builtins.td
index 868e5b92acdc9..a55f411343c2d 100644
--- a/clang/include/clang/Basic/Builtins.td
+++ b/clang/include/clang/Basic/Builtins.td
@@ -970,6 +970,18 @@ def IsWithinLifetime : LangBuiltin<"CXX_LANG"> {
let Prototype = "bool(void*)";
}
+def GetVtablePointer : LangBuiltin<"CXX_LANG"> {
+ let Spellings = ["__builtin_get_vtable_pointer"];
+ let Attributes = [CustomTypeChecking, NoThrow, Const];
+ let Prototype = "void*(void*)";
+}
+
+def VirtualMemberAddress : Builtin {
+ let Spellings = ["__builtin_virtual_member_address"];
+ let Attributes = [CustomTypeChecking, NoThrow, Const];
+ let Prototype = "void*(void*,void*)";
+}
+
// GCC exception builtins
def EHReturn : Builtin {
let Spellings = ["__builtin_eh_return"];
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td
b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 180ca39bc07e9..8c534850696d9 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1013,6 +1013,13 @@ def err_ptrauth_indirect_goto_addrlabel_arithmetic :
Error<
"%select{subtraction|addition}0 of address-of-label expressions is not "
"supported with ptrauth indirect gotos">;
+def err_virtual_member_lhs_cxxrec : Error<
+ "first argument to __builtin_virtual_member_address must have C++ class
type">;
+def err_virtual_member_addrof : Error<
+ "second argument to __builtin_virtual_member_address must be the address of
a virtual C++ member function: for example '&Foo::func'">;
+def err_virtual_member_inherit : Error<
+ "first argument to __builtin_virtual_member_address must have a type
deriving from class where second argument was defined">;
+
/// main()
// static main() is not an error in C, just in C++.
def warn_static_main : Warning<"'main' should not be declared static">,
@@ -12547,6 +12554,14 @@ def err_bit_cast_non_trivially_copyable : Error<
def err_bit_cast_type_size_mismatch : Error<
"size of '__builtin_bit_cast' source type %0 does not match destination type
%1 (%2 vs %3 bytes)">;
+
+def err_get_vtable_pointer_incorrect_type : Error<
+ "__builtin_get_vtable_pointer requires an argument of%select{| polymorphic}0
class pointer type"
+ ", but %1 %select{was provided|has no virtual methods}0"
+>;
+def err_get_vtable_pointer_requires_complete_type : Error<
+ "__builtin_get_vtable_pointer requires an argument with a complete type, but
%0 is incomplete">;
+
// SYCL-specific diagnostics
def warn_sycl_kernel_num_of_template_params : Warning<
"'sycl_kernel' attribute only applies to a function template with at least"
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index fe55dfffc1cbe..316f5debf89d7 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -17,6 +17,7 @@
#include "CGDebugInfo.h"
#include "CGObjCRuntime.h"
#include "CGOpenCLRuntime.h"
+#include "CGPointerAuthInfo.h"
#include "CGRecordLayout.h"
#include "CGValue.h"
#include "CodeGenFunction.h"
@@ -5349,6 +5350,35 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl
GD, unsigned BuiltinID,
return RValue::get(Result);
}
+ case Builtin::BI__builtin_virtual_member_address: {
+ Address This = EmitLValue(E->getArg(0)).getAddress();
+ APValue ConstMemFun;
+ E->getArg(1)->isCXX11ConstantExpr(getContext(), &ConstMemFun, nullptr);
+ const CXXMethodDecl *CXXMethod =
+ cast<CXXMethodDecl>(ConstMemFun.getMemberPointerDecl());
+ const CGFunctionInfo &FInfo =
+ CGM.getTypes().arrangeCXXMethodDeclaration(CXXMethod);
+ llvm::FunctionType *Ty = CGM.getTypes().GetFunctionType(FInfo);
+ CGCallee VCallee = CGM.getCXXABI().getVirtualFunctionPointer(
+ *this, CXXMethod, This, Ty, E->getBeginLoc());
+ llvm::Value *Callee = VCallee.getFunctionPointer();
+ if (const CGPointerAuthInfo &Schema = VCallee.getPointerAuthInfo())
+ Callee = EmitPointerAuthAuth(Schema, Callee);
+ return RValue::get(Callee);
+ }
+
+ case Builtin::BI__builtin_get_vtable_pointer: {
+ auto target = E->getArg(0);
+ auto type = target->getType();
+ auto decl = type->getPointeeCXXRecordDecl();
+ assert(decl);
+ auto thisAddress = EmitPointerWithAlignment(target);
+ assert(thisAddress.isValid());
+ auto vtablePointer =
+ GetVTablePtr(thisAddress, Int8PtrTy, decl, VTableAuthMode::MustTrap);
+ return RValue::get(vtablePointer);
+ }
+
case Builtin::BI__exception_code:
case Builtin::BI_exception_code:
return RValue::get(EmitSEHExceptionCode());
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index bffd0dd461d3d..77b8b304f7f0a 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -1764,6 +1764,57 @@ static ExprResult PointerAuthAuthAndResign(Sema &S,
CallExpr *Call) {
return Call;
}
+static ExprResult VirtualMemberAddress(Sema &S, CallExpr *Call) {
+ if (S.checkArgCount(Call, 2))
+ return ExprError();
+
+ for (int i = 0; i < 2; ++i) {
+ auto ArgRValue = S.DefaultFunctionArrayLvalueConversion(Call->getArg(1));
+ if (ArgRValue.isInvalid())
+ return ExprError();
+
+ auto Arg = ArgRValue.get();
+ Call->setArg(1, Arg);
+ }
+
+ if (Call->getArg(0)->isTypeDependent() ||
Call->getArg(1)->isValueDependent())
+ return Call;
+
+ auto ThisArg = Call->getArg(0);
+ auto ThisTy = ThisArg->getType();
+ if (!ThisTy->getAsCXXRecordDecl()) {
+ S.Diag(ThisArg->getExprLoc(), diag::err_virtual_member_lhs_cxxrec);
+ return ExprError();
+ }
+
+ auto MemFunArg = Call->getArg(1);
+ APValue Result;
+ if (!MemFunArg->isCXX11ConstantExpr(S.getASTContext(), &Result, nullptr)) {
+ S.Diag(MemFunArg->getExprLoc(), diag::err_virtual_member_addrof);
+ return ExprError();
+ }
+
+ if (!Result.isMemberPointer() ||
+ !isa<CXXMethodDecl>(Result.getMemberPointerDecl())) {
+ S.Diag(MemFunArg->getExprLoc(), diag::err_virtual_member_addrof);
+ return ExprError();
+ }
+
+ auto CXXMethod = cast<CXXMethodDecl>(Result.getMemberPointerDecl());
+ if (!CXXMethod->isVirtual()) {
+ S.Diag(MemFunArg->getExprLoc(), diag::err_virtual_member_addrof);
+ return ExprError();
+ }
+
+ if (ThisTy->getAsCXXRecordDecl() != CXXMethod->getParent() &&
+ !S.IsDerivedFrom(Call->getBeginLoc(), ThisTy,
+ CXXMethod->getFunctionObjectParameterType())) {
+ S.Diag(ThisArg->getExprLoc(), diag::err_virtual_member_inherit);
+ return ExprError();
+ }
+ return Call;
+}
+
static ExprResult PointerAuthStringDiscriminator(Sema &S, CallExpr *Call) {
if (checkPointerAuthEnabled(S, Call))
return ExprError();
@@ -1782,6 +1833,39 @@ static ExprResult PointerAuthStringDiscriminator(Sema
&S, CallExpr *Call) {
return Call;
}
+static ExprResult GetVTablePointer(Sema &S, CallExpr *call) {
+ if (S.checkArgCount(call, 1))
+ return ExprError();
+ auto rvalue = S.DefaultFunctionArrayLvalueConversion(call->getArg(0));
+ if (rvalue.isInvalid())
+ return ExprError();
+ call->setArg(0, rvalue.get());
+ auto expression = call->getArg(0);
+ QualType expressionType = expression->getType();
+ const CXXRecordDecl *objectType = expressionType->getPointeeCXXRecordDecl();
+ if (!expressionType->isPointerType() || !objectType) {
+ S.Diag(expression->getBeginLoc(),
+ diag::err_get_vtable_pointer_incorrect_type)
+ << 0 << expressionType;
+ return ExprError();
+ }
+ if (S.RequireCompleteType(
+ expression->getBeginLoc(), expressionType->getPointeeType(),
+ diag::err_get_vtable_pointer_requires_complete_type)) {
+ return ExprError();
+ }
+
+ if (!objectType->isPolymorphic()) {
+ S.Diag(expression->getBeginLoc(),
+ diag::err_get_vtable_pointer_incorrect_type)
+ << 1 << objectType;
+ return ExprError();
+ }
+ QualType returnType = S.Context.getPointerType(S.Context.VoidTy.withConst());
+ call->setType(returnType);
+ return call;
+}
+
static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall) {
if (S.checkArgCount(TheCall, 1))
return ExprError();
@@ -2625,6 +2709,12 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl,
unsigned BuiltinID,
return PointerAuthAuthAndResign(*this, TheCall);
case Builtin::BI__builtin_ptrauth_string_discriminator:
return PointerAuthStringDiscriminator(*this, TheCall);
+
+ case Builtin::BI__builtin_get_vtable_pointer:
+ return GetVTablePointer(*this, TheCall);
+ case Builtin::BI__builtin_virtual_member_address:
+ return VirtualMemberAddress(*this, TheCall);
+
// OpenCL v2.0, s6.13.16 - Pipe functions
case Builtin::BIread_pipe:
case Builtin::BIwrite_pipe:
diff --git a/clang/test/CodeGenCXX/builtin-get-vtable-pointer.cpp
b/clang/test/CodeGenCXX/builtin-get-vtable-pointer.cpp
new file mode 100644
index 0000000000000..5577e01a09f6f
--- /dev/null
+++ b/clang/test/CodeGenCXX/builtin-get-vtable-pointer.cpp
@@ -0,0 +1,304 @@
+// RUN: %clang_cc1 %s -x c++ -std=c++11 -triple x86_64-apple-darwin10
-emit-llvm -O1 -disable-llvm-passes -no-enable-noundef-analysis -o - |
FileCheck --check-prefix=CHECK-NOAUTH %s
+// RUN: %clang_cc1 %s -x c++ -std=c++11 -triple arm64-apple-ios
-fptrauth-calls -fptrauth-vtable-pointer-type-discrimination -emit-llvm -O1
-disable-llvm-passes -no-enable-noundef-analysis -o - | FileCheck
--check-prefix=CHECK-TYPEAUTH %s
+// RUN: %clang_cc1 %s -x c++ -std=c++11 -triple arm64-apple-ios
-fptrauth-calls -fptrauth-vtable-pointer-address-discrimination -emit-llvm -O1
-disable-llvm-passes -no-enable-noundef-analysis -o - | FileCheck
--check-prefix=CHECK-ADDRESSAUTH %s
+// RUN: %clang_cc1 %s -x c++ -std=c++11 -triple arm64-apple-ios
-fptrauth-calls -fptrauth-vtable-pointer-type-discrimination
-fptrauth-vtable-pointer-address-discrimination -emit-llvm -O1
-disable-llvm-passes -no-enable-noundef-analysis -o - | FileCheck
--check-prefix=CHECK-BOTHAUTH %s
+// FIXME: Assume load should not require -fstrict-vtable-pointers
+
+namespace test1 {
+struct A {
+ A();
+ virtual void bar();
+};
+
+struct B : A {
+ B();
+ virtual void foo();
+};
+
+struct Z : A {};
+struct C : Z, B {
+ C();
+ virtual void wibble();
+};
+
+struct D : virtual A {
+};
+
+struct E : D, B {
+};
+
+const void *a(A *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test11aEPNS_1AE(ptr %o) #0 {
+ // CHECK-TYPEAUTH: define ptr @_ZN5test11aEPNS_1AE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer(o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %0 = load ptr, ptr %o.addr, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *b(B *o) {
+ // CHECK-TYPEAUTH: define ptr @_ZN5test11bEPNS_1BE(ptr %o) #0 {
+ // CHECK-NOAUTH: define ptr @_ZN5test11bEPNS_1BE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer(o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 %1, i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *b_as_A(B *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16b_as_AEPNS_1BE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((A *)o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 %1, i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *c(C *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test11cEPNS_1CE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer(o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 %1, i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *c_as_Z(C *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16c_as_ZEPNS_1CE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((Z *)o);
+ // CHECK-NOAUTH: %0 = load ptr, ptr %o.addr, align 8
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 %1, i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *c_as_B(C *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16c_as_BEPNS_1CE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((B *)o);
+ // CHECK-NOAUTH: %add.ptr = getelementptr inbounds i8, ptr %0, i64 8
+ // CHECK-NOAUTH: br label %cast.end
+ // CHECK-NOAUTH: %cast.result = phi ptr [ %add.ptr, %cast.notnull ], [ null,
%entry ]
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %cast.result = phi ptr [ %add.ptr, %cast.notnull ], [
null, %entry ]
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-TYPEAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %cast.result to i64
+ // CHECK-ADDRESSAUTH: %3 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %4 = call i64 @llvm.ptrauth.auth(i64 %3, i32 2, i64 %2)
+ // CHECK-ADDRESSAUTH: %5 = inttoptr i64 %4 to ptr
+ // CHECK-ADDRESSAUTH: %6 = load volatile i8, ptr %5, align 8
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 %2, i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *d(D *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test11dEPNS_1DE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer(o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: %1 = ptrtoint ptr %0 to i64
+ // CHECK-ADDRESSAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 %1)
+ // CHECK-ADDRESSAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-ADDRESSAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *d_as_A(D *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16d_as_AEPNS_1DE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((A *)o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-NOAUTH: %vbase.offset.ptr = getelementptr i8, ptr %vtable, i64 -32
+ // CHECK-NOAUTH: %vbase.offset = load i64, ptr %vbase.offset.ptr, align 8
+ // CHECK-NOAUTH: %add.ptr = getelementptr inbounds i8, ptr %0, i64
%vbase.offset
+ // CHECK-NOAUTH: %cast.result = phi ptr [ %add.ptr, %cast.notnull ], [ null,
%entry ]
+ // CHECK-NOAUTH: %vtable1 = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %vtable1 = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %5 = ptrtoint ptr %vtable1 to i64
+ // CHECK-TYPEAUTH: %6 = call i64 @llvm.ptrauth.auth(i64 %5, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %7 = inttoptr i64 %6 to ptr
+ // CHECK-TYPEAUTH: %8 = load volatile i8, ptr %7, align 8
+ // CHECK-ADDRESSAUTH: %6 = ptrtoint ptr %cast.result to i64
+ // CHECK-ADDRESSAUTH: %7 = ptrtoint ptr %vtable1 to i64
+ // CHECK-ADDRESSAUTH: %8 = call i64 @llvm.ptrauth.auth(i64 %7, i32 2, i64 %6)
+ // CHECK-ADDRESSAUTH: %9 = inttoptr i64 %8 to ptr
+ // CHECK-ADDRESSAUTH: %10 = load volatile i8, ptr %9, align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %cast.result to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable1 to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *e(E *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test11eEPNS_1EE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer(o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-ADDRESSAUTH: [[T2:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: [[T3:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T2]],
i32 2, i64 [[T1]])
+ // CHECK-ADDRESSAUTH: [[T4:%.*]] = inttoptr i64 [[T3]] to ptr
+ // CHECK-ADDRESSAUTH: [[T5:%.*]] = load volatile i8, ptr [[T4]], align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *e_as_B(E *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16e_as_BEPNS_1EE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((B *)o);
+ // CHECK-NOAUTH: %add.ptr = getelementptr inbounds i8, ptr %0, i64 8
+ // CHECK-NOAUTH: %cast.result = phi ptr [ %add.ptr, %cast.notnull ], [ null,
%entry ]
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %cast.result, align 8
+ // CHECK-TYPEAUTH: %2 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %3 = call i64 @llvm.ptrauth.auth(i64 %2, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %4 = inttoptr i64 %3 to ptr
+ // CHECK-TYPEAUTH: %5 = load volatile i8, ptr %4, align 8
+ // CHECK-ADDRESSAUTH: [[T1:%.*]] = ptrtoint ptr %cast.result to i64
+ // CHECK-ADDRESSAUTH: [[T2:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: [[T3:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T2]],
i32 2, i64 [[T1]])
+ // CHECK-ADDRESSAUTH: [[T4:%.*]] = inttoptr i64 [[T3]] to ptr
+ // CHECK-ADDRESSAUTH: [[T5:%.*]] = load volatile i8, ptr [[T4]], align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %cast.result to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+const void *e_as_D(E *o) {
+ // CHECK-NOAUTH: define ptr @_ZN5test16e_as_DEPNS_1EE(ptr %o) #0 {
+ return __builtin_get_vtable_pointer((D *)o);
+ // CHECK-NOAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %vtable = load ptr, ptr %0, align 8
+ // CHECK-TYPEAUTH: %1 = ptrtoint ptr %vtable to i64
+ // CHECK-TYPEAUTH: %2 = call i64 @llvm.ptrauth.auth(i64 %1, i32 2, i64 48388)
+ // CHECK-TYPEAUTH: %3 = inttoptr i64 %2 to ptr
+ // CHECK-TYPEAUTH: %4 = load volatile i8, ptr %3, align 8
+ // CHECK-ADDRESSAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-ADDRESSAUTH: [[T2:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-ADDRESSAUTH: [[T3:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T2]],
i32 2, i64 [[T1]])
+ // CHECK-ADDRESSAUTH: [[T4:%.*]] = inttoptr i64 [[T3]] to ptr
+ // CHECK-ADDRESSAUTH: [[T5:%.*]] = load volatile i8, ptr [[T4]], align 8
+ // CHECK-BOTHAUTH: [[T1:%.*]] = ptrtoint ptr %0 to i64
+ // CHECK-BOTHAUTH: [[T2:%.*]] = call i64 @llvm.ptrauth.blend(i64 [[T1]], i64
48388)
+ // CHECK-BOTHAUTH: [[T3:%.*]] = ptrtoint ptr %vtable to i64
+ // CHECK-BOTHAUTH: [[T4:%.*]] = call i64 @llvm.ptrauth.auth(i64 [[T3]], i32
2, i64 [[T2]])
+ // CHECK-BOTHAUTH: [[T5:%.*]] = inttoptr i64 [[T4]] to ptr
+ // CHECK-BOTHAUTH: [[T6:%.*]] = load volatile i8, ptr [[T5]], align 8
+}
+
+void test() {
+ A aInstance;
+ B bInstance;
+ C cInstance;
+ D dInstance;
+ E eInstance;
+ a(&aInstance);
+ a(&bInstance);
+ a((B *)&cInstance);
+ a(&dInstance);
+ a((D *)&eInstance);
+ a((B *)&eInstance);
+ b(&bInstance);
+ b(&cInstance);
+ b(&eInstance);
+ b_as_A(&bInstance);
+ c(&cInstance);
+ c_as_Z(&cInstance);
+ c_as_B(&cInstance);
+ d(&dInstance);
+ d(&eInstance);
+ d_as_A(&dInstance);
+ d_as_A(&eInstance);
+ e(&eInstance);
+ e_as_B(&eInstance);
+ e_as_D(&eInstance);
+}
+} // namespace test1
diff --git a/clang/test/CodeGenCXX/builtin_virtual_member_address.cpp
b/clang/test/CodeGenCXX/builtin_virtual_member_address.cpp
new file mode 100644
index 0000000000000..f16903948c0fd
--- /dev/null
+++ b/clang/test/CodeGenCXX/builtin_virtual_member_address.cpp
@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 -triple arm64e-apple-ios -fptrauth-calls -emit-llvm
-no-enable-noundef-analysis -o - %s | FileCheck %s --check-prefixes
CHECK,CHECK-AUTH
+// RUN: %clang_cc1 -triple arm64-apple-ios -emit-llvm
-no-enable-noundef-analysis -o - %s | FileCheck %s --check-prefixes
CHECK,CHECK-NOAUTH
+
+struct Base {
+ virtual void func1();
+ virtual void func2();
+ void nonvirt();
+};
+
+struct Derived : Base {
+ virtual void func1();
+};
+
+// CHECK-LABEL: define ptr @_Z6simpleR4Base(ptr {{.*}} %b)
+
+// CHECK-AUTH: [[BLOC:%.*]] = alloca ptr
+// CHECK-AUTH: store ptr %b, ptr [[BLOC]]
+// CHECK-AUTH: [[B:%.*]] = load ptr, ptr [[BLOC]]
+// CHECK-AUTH: [[VTABLE:%.*]] = load ptr, ptr [[B]]
+// CHECK-AUTH: [[VTABLE_AUTH_IN:%.*]] = ptrtoint ptr [[VTABLE]] to i64
+// CHECK-AUTH: [[VTABLE_AUTH_OUT:%.*]] = call i64 @llvm.ptrauth.auth(i64
[[VTABLE_AUTH_IN]], i32 2, i64 0)
+// CHECK-AUTH: [[VTABLE:%.*]] = inttoptr i64 [[VTABLE_AUTH_OUT]] to ptr
+// CHECK-AUTH: [[FUNC_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VTABLE]],
i64 1
+// CHECK-AUTH: [[FUNC:%.*]] = load ptr, ptr [[FUNC_ADDR]]
+// CHECK-AUTH: [[FUNC_ADDR_I64:%.*]] = ptrtoint ptr [[FUNC_ADDR]] to i64
+// CHECK-AUTH: [[DISC:%.*]] = call i64 @llvm.ptrauth.blend(i64
[[FUNC_ADDR_I64]], i64 25637)
+// CHECK-AUTH: [[FUNC_I64:%.*]] = ptrtoint ptr [[FUNC]] to i64
+// CHECK-AUTH: [[FUNC_AUTHED:%.*]] = call i64 @llvm.ptrauth.auth(i64
[[FUNC_I64]], i32 0, i64 [[DISC]])
+// CHECK-AUTH: [[FUNC:%.*]] = inttoptr i64 [[FUNC_AUTHED]] to ptr
+// CHECK-AUTH: ret ptr [[FUNC]]
+
+// CHECK-NOAUTH: [[BLOC:%.*]] = alloca ptr
+// CHECK-NOAUTH: store ptr %b, ptr [[BLOC]]
+// CHECK-NOAUTH: [[B:%.*]] = load ptr, ptr [[BLOC]]
+// CHECK-NOAUTH: [[VTABLE:%.*]] = load ptr, ptr [[B]]
+// CHECK-NOAUTH: [[FUNC_ADDR:%.*]] = getelementptr inbounds ptr, ptr
[[VTABLE]], i64 1
+// CHECK-NOAUTH: [[FUNC:%.*]] = load ptr, ptr [[FUNC_ADDR]]
+// CHECK-NOAUTH: ret ptr [[FUNC]]
+void *simple(Base &b) {
+ return __builtin_virtual_member_address(b, &Base::func2);
+}
diff --git a/clang/test/SemaCXX/builtin-get-vtable-pointer.cpp
b/clang/test/SemaCXX/builtin-get-vtable-pointer.cpp
new file mode 100644
index 0000000000000..273f9c3b4c667
--- /dev/null
+++ b/clang/test/SemaCXX/builtin-get-vtable-pointer.cpp
@@ -0,0 +1,123 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
+
+namespace basic {
+struct ForwardDeclaration; // expected-note{{forward declaration of
'basic::ForwardDeclaration'}}
+ // expected-note@-1{{forward declaration of
'basic::ForwardDeclaration'}}
+struct NonPolymorphic {};
+struct Polymorphic {
+ virtual ~Polymorphic();
+};
+
+template <typename T>
+struct Foo {
+ virtual ~Foo();
+};
+
+template <>
+struct Foo<int> {
+};
+
+template <typename T>
+struct Bar {
+ using SubType = typename T::SubType;
+ SubType *ty() const;
+};
+
+struct Thing1 {
+ using SubType = Thing1;
+};
+
+struct Thing2 {
+ using SubType = Thing2;
+ virtual ~Thing2();
+};
+
+struct Thing3 {
+ using SubType = int;
+};
+
+struct Thing4 {
+ using SubType = Polymorphic;
+};
+
+struct Thing5 {
+ using SubType = NonPolymorphic;
+};
+
+struct Thing6 {
+ using SubType = ForwardDeclaration;
+};
+
+template <typename T>
+const void *getThing(const Bar<T> *b = nullptr) {
+ return __builtin_get_vtable_pointer(b->ty()); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'SubType *' (aka 'int *') was provided}}
+ //
expected-error@-1{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'Thing1' has no virtual methods}}
+ //
expected-error@-2{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'NonPolymorphic' has no virtual methods}}
+ //
expected-error@-3{{__builtin_get_vtable_pointer requires an argument with a
complete type, but 'SubType' (aka 'basic::ForwardDeclaration') is incomplete}}
+}
+template <typename>
+struct IncompleteTemplate; // expected-note{{template is declared here}}
+template <typename>
+struct MonomorphicTemplate {
+};
+template <typename>
+struct PolymorphicTemplate {
+ virtual ~PolymorphicTemplate();
+};
+
+void test_function(int); // expected-note{{possible target for call}}
+ // expected-note@-1{{possible target for call}}
+void test_function(double); // expected-note{{possible target for call}}
+ // expected-note@-1{{possible target for call}}
+
+void getVTablePointer() {
+ ForwardDeclaration *fd = nullptr;
+ NonPolymorphic np;
+ Polymorphic p;
+ NonPolymorphic np_array[1];
+ Polymorphic p_array[1];
+ __builtin_get_vtable_pointer(0); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'int' was provided}}
+ __builtin_get_vtable_pointer(nullptr); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'std::nullptr_t' was provided}}
+ __builtin_get_vtable_pointer(0.5); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'double' was provided}}
+ __builtin_get_vtable_pointer(fd); //
expected-error{{__builtin_get_vtable_pointer requires an argument with a
complete type, but 'ForwardDeclaration' is incomplete}}
+ __builtin_get_vtable_pointer(np); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'NonPolymorphic' was provided}}
+ __builtin_get_vtable_pointer(&np); //
expected-error{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'NonPolymorphic' has no virtual methods}}
+ __builtin_get_vtable_pointer(p); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'Polymorphic' was provided}}
+ __builtin_get_vtable_pointer(&p); // expected-warning{{ignoring
return value of function declared with const attribute}}
+ __builtin_get_vtable_pointer(p_array); // expected-warning{{ignoring
return value of function declared with const attribute}}
+ __builtin_get_vtable_pointer(&p_array); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'Polymorphic (*)[1]' was provided}}
+ __builtin_get_vtable_pointer(np_array); //
expected-error{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'NonPolymorphic' has no virtual methods}}
+ __builtin_get_vtable_pointer(&np_array); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'NonPolymorphic (*)[1]' was provided}}
+ __builtin_get_vtable_pointer(test_function); // expected-error{{reference to
overloaded function could not be resolved; did you mean to call it?}}
+ // expected-error@-1{{reference
to overloaded function could not be resolved; did you mean to call it?}}
+ Foo<double> Food;
+ Foo<int> Fooi;
+ __builtin_get_vtable_pointer(Food); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'Foo<double>' was provided}}
+ (void)__builtin_get_vtable_pointer(&Food);
+ __builtin_get_vtable_pointer(Fooi); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'Foo<int>' was provided}}
+ __builtin_get_vtable_pointer(&Fooi); //
expected-error{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'Foo<int>' has no virtual methods}}
+
+ IncompleteTemplate<bool> *incomplete = nullptr;
+ (void)__builtin_get_vtable_pointer(incomplete); // expected-error{{implicit
instantiation of undefined template 'basic::IncompleteTemplate<bool>'}}
+ PolymorphicTemplate<bool> *ptb = nullptr;
+ MonomorphicTemplate<bool> *mtb = nullptr;
+ PolymorphicTemplate<int> pti;
+ MonomorphicTemplate<int> mti;
+ PolymorphicTemplate<float> ptf;
+ MonomorphicTemplate<float> mtf;
+ (void)__builtin_get_vtable_pointer(ptb);
+ __builtin_get_vtable_pointer(mtb); //
expected-error{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'MonomorphicTemplate<bool>' has no virtual
methods}}
+ __builtin_get_vtable_pointer(pti); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'PolymorphicTemplate<int>' was provided}}
+ __builtin_get_vtable_pointer(mti); //
expected-error{{__builtin_get_vtable_pointer requires an argument of class
pointer type, but 'MonomorphicTemplate<int>' was provided}}
+ (void)__builtin_get_vtable_pointer(&ptf);
+ __builtin_get_vtable_pointer(&mtf); //
expected-error{{__builtin_get_vtable_pointer requires an argument of
polymorphic class pointer type, but 'MonomorphicTemplate<float>' has no virtual
methods}}
+
+ getThing<Thing1>(); // expected-note{{in instantiation of function template
specialization 'basic::getThing<basic::Thing1>' requested here}}
+ getThing<Thing2>();
+ getThing<Thing3>(); // expected-note{{in instantiation of function template
specialization 'basic::getThing<basic::Thing3>' requested here}}
+ getThing<Thing4>();
+ getThing<Thing5>(); // expected-note{{in instantiation of function template
specialization 'basic::getThing<basic::Thing5>' requested here}}
+ getThing<Thing6>(); // expected-note{{in instantiation of function template
specialization 'basic::getThing<basic::Thing6>' requested here}}
+}
+
+} // namespace basic
diff --git a/clang/test/SemaCXX/builtin_virtual_member_address.cpp
b/clang/test/SemaCXX/builtin_virtual_member_address.cpp
new file mode 100644
index 0000000000000..a1834085ebb26
--- /dev/null
+++ b/clang/test/SemaCXX/builtin_virtual_member_address.cpp
@@ -0,0 +1,57 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct Base {
+ virtual void func1();
+ virtual void func2();
+
+ virtual void overloaded();
+ virtual void overloaded() const;
+
+ void nonvirt();
+};
+
+struct Derived : Base {
+ virtual void func1();
+};
+
+struct Unrelated {
+ virtual void func1();
+};
+
+void *simple(Base &b) {
+ return __builtin_virtual_member_address(b, &Base::func1);
+}
+
+void test(Base &b, Derived &d, Unrelated &u) {
+ __builtin_virtual_member_address(&b, &Base::func1); // expected-error
{{first argument to __builtin_virtual_member_address must have C++ class type}}
+ __builtin_virtual_member_address(42, &Base::func1); // expected-error
{{first argument to __builtin_virtual_member_address must have C++ class type}}
+ __builtin_virtual_member_address(u, &Base::func1); // expected-error {{first
argument to __builtin_virtual_member_address must have a type deriving from
class where second argument was defined}}
+
+ __builtin_virtual_member_address(b, &Derived::func1); // expected-error
{{first argument to __builtin_virtual_member_address must have a type deriving
from class where second argument was defined}}
+ __builtin_virtual_member_address(b, &Unrelated::func1); // expected-error
{{first argument to __builtin_virtual_member_address must have a type deriving
from class where second argument was defined}}
+
+ __builtin_virtual_member_address(b, 42); // expected-error {{second argument
to __builtin_virtual_member_address must be the address of a virtual C++ member
function: for example '&Foo::func'}}
+ __builtin_virtual_member_address(b, &Base::nonvirt); // expected-error
{{second argument to __builtin_virtual_member_address must be the address of a
virtual C++ member function: for example '&Foo::func'}}
+
+ (void)__builtin_virtual_member_address(d, &Base::overloaded); //
expected-error {{reference to overloaded function could not be resolved; did
you mean to call it?}} expected-error {{reference to overloaded function could
not be resolved; did you mean to call it?}}
+ (void)__builtin_virtual_member_address(d,(void (Base::*)() const)
&Base::overloaded);
+
+ (void)__builtin_virtual_member_address(d, &Base::func1);
+ (void)__builtin_virtual_member_address(Base(), &Base::func1);
+}
+
+template<typename T> void test(T &t, Base &b, Derived &d) {
+ (void)__builtin_virtual_member_address(t, &Base::func1);
+ (void)__builtin_virtual_member_address(t, &T::func1);
+ (void)__builtin_virtual_member_address(d, &T::func1);
+ (void)__builtin_virtual_member_address(t, &Unrelated::func1); //
expected-error {{first argument to __builtin_virtual_member_address must have a
type deriving from class where second argument was defined}} expected-error
{{first argument to __builtin_virtual_member_address must have a type deriving
from class where second argument was defined}}
+
+}
+
+void foo() {
+ Base b;
+ Derived d;
+
+ test<Base>(b, b, d); // expected-note {{in instantiation of function
template specialization 'test<Base>' requested here}}
+ test<Derived>(d, b, d); // expected-note {{in instantiation of function
template specialization 'test<Derived>' requested here}}
+}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
