rsmith updated this revision to Diff 538281.
rsmith added a comment.
- Address review comments.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D154658/new/
https://reviews.llvm.org/D154658
Files:
clang/lib/AST/ExprCXX.cpp
clang/lib/CodeGen/CGCXXABI.h
clang/lib/CodeGen/CGClass.cpp
clang/lib/CodeGen/CGExprCXX.cpp
clang/lib/CodeGen/CodeGenFunction.h
clang/lib/CodeGen/CodeGenModule.cpp
clang/lib/CodeGen/CodeGenModule.h
clang/lib/CodeGen/ItaniumCXXABI.cpp
clang/lib/CodeGen/MicrosoftCXXABI.cpp
clang/test/CodeGenCXX/dynamic-cast-always-null.cpp
clang/test/CodeGenCXX/dynamic-cast-exact-disabled.cpp
clang/test/CodeGenCXX/dynamic-cast-exact.cpp
Index: clang/test/CodeGenCXX/dynamic-cast-exact.cpp
===================================================================
--- /dev/null
+++ clang/test/CodeGenCXX/dynamic-cast-exact.cpp
@@ -0,0 +1,78 @@
+// RUN: %clang_cc1 -I%S %s -triple x86_64-apple-darwin10 -emit-llvm -fcxx-exceptions -fexceptions -std=c++11 -o - | FileCheck %s --implicit-check-not='call {{.*}} @__dynamic_cast'
+struct Offset { virtual ~Offset(); };
+struct A { virtual ~A(); };
+struct B final : Offset, A { };
+
+struct C { virtual ~C(); int c; };
+struct D : A { int d; };
+struct E : A { int e; };
+struct F : virtual A { int f; };
+struct G : virtual A { int g; };
+struct H final : C, D, E, F, G { int h; };
+
+// CHECK-LABEL: @_Z7inexactP1A
+C *inexact(A *a) {
+ // CHECK: call {{.*}} @__dynamic_cast
+ return dynamic_cast<C*>(a);
+}
+
+// CHECK-LABEL: @_Z12exact_singleP1A
+B *exact_single(A *a) {
+ // CHECK: %[[PTR_NULL:.*]] = icmp eq ptr %[[PTR:.*]], null
+ // CHECK: br i1 %[[PTR_NULL]], label %[[LABEL_FAILED:.*]], label %[[LABEL_NOTNULL:.*]]
+
+ // CHECK: [[LABEL_NOTNULL]]:
+ // CHECK: %[[VPTR:.*]] = load ptr, ptr %[[PTR]]
+ // CHECK: %[[MATCH:.*]] = icmp eq ptr %[[VPTR]], getelementptr inbounds ({ [4 x ptr], [4 x ptr] }, ptr @_ZTV1B, i32 0, inrange i32 1, i32 2)
+ // CHECK: %[[RESULT:.*]] = getelementptr i8, ptr %[[PTR]], i64 -8
+ // CHECK: br i1 %[[MATCH]], label %[[LABEL_END:.*]], label %[[LABEL_FAILED]]
+
+ // CHECK: [[LABEL_FAILED]]:
+ // CHECK: br label %[[LABEL_END]]
+
+ // CHECK: [[LABEL_END]]:
+ // CHECK: phi ptr [ %[[RESULT]], %[[LABEL_NOTNULL]] ], [ null, %[[LABEL_FAILED]] ]
+ return dynamic_cast<B*>(a);
+}
+
+// CHECK-LABEL: @_Z9exact_refR1A
+B &exact_ref(A &a) {
+ // CHECK: %[[PTR_NULL:.*]] = icmp eq ptr %[[PTR:.*]], null
+ // CHECK: br i1 %[[PTR_NULL]], label %[[LABEL_FAILED:.*]], label %[[LABEL_NOTNULL:.*]]
+
+ // CHECK: [[LABEL_NOTNULL]]:
+ // CHECK: %[[VPTR:.*]] = load ptr, ptr %[[PTR]]
+ // CHECK: %[[MATCH:.*]] = icmp eq ptr %[[VPTR]], getelementptr inbounds ({ [4 x ptr], [4 x ptr] }, ptr @_ZTV1B, i32 0, inrange i32 1, i32 2)
+ // CHECK: %[[RESULT:.*]] = getelementptr i8, ptr %[[PTR]], i64 -8
+ // CHECK: br i1 %[[MATCH]], label %[[LABEL_END:.*]], label %[[LABEL_FAILED]]
+
+ // CHECK: [[LABEL_FAILED]]:
+ // CHECK: call {{.*}} @__cxa_bad_cast
+ // CHECK: unreachable
+
+ // CHECK: [[LABEL_END]]:
+ // CHECK: ret ptr %[[RESULT]]
+ return dynamic_cast<B&>(a);
+}
+
+// CHECK-LABEL: @_Z11exact_multiP1A
+H *exact_multi(A *a) {
+ // CHECK: %[[PTR_NULL:.*]] = icmp eq ptr %[[PTR:.*]], null
+ // CHECK: br i1 %[[PTR_NULL]], label %[[LABEL_FAILED:.*]], label %[[LABEL_NOTNULL:.*]]
+
+ // CHECK: [[LABEL_NOTNULL]]:
+ // CHECK: %[[VPTR:.*]] = load ptr, ptr %[[PTR]]
+ // CHECK: %[[OFFSET_TO_TOP_SLOT:.*]] = getelementptr inbounds i64, ptr %[[VPTR]], i64 -2
+ // CHECK: %[[OFFSET_TO_TOP:.*]] = load i64, ptr %[[OFFSET_TO_TOP_SLOT]]
+ // CHECK: %[[RESULT:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i64 %[[OFFSET_TO_TOP]]
+ // CHECK: %[[DERIVED_VPTR:.*]] = load ptr, ptr %[[RESULT]]
+ // CHECK: %[[MATCH:.*]] = icmp eq ptr %[[DERIVED_VPTR]], getelementptr inbounds ({ [5 x ptr], [4 x ptr], [4 x ptr], [6 x ptr], [6 x ptr] }, ptr @_ZTV1H, i32 0, inrange i32 0, i32 3)
+ // CHECK: br i1 %[[MATCH]], label %[[LABEL_END:.*]], label %[[LABEL_FAILED]]
+
+ // CHECK: [[LABEL_FAILED]]:
+ // CHECK: br label %[[LABEL_END]]
+
+ // CHECK: [[LABEL_END]]:
+ // CHECK: phi ptr [ %[[RESULT]], %[[LABEL_NOTNULL]] ], [ null, %[[LABEL_FAILED]] ]
+ return dynamic_cast<H*>(a);
+}
Index: clang/test/CodeGenCXX/dynamic-cast-exact-disabled.cpp
===================================================================
--- /dev/null
+++ clang/test/CodeGenCXX/dynamic-cast-exact-disabled.cpp
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -I%S %s -triple x86_64-apple-darwin10 -emit-llvm -std=c++11 -o - | FileCheck %s --check-prefixes=CHECK,EXACT
+// RUN: %clang_cc1 -I%S %s -triple x86_64-apple-darwin10 -fvisibility=hidden -emit-llvm -std=c++11 -o - | FileCheck %s --check-prefixes=CHECK,INEXACT
+// RUN: %clang_cc1 -I%S %s -triple x86_64-apple-darwin10 -fapple-kext -emit-llvm -std=c++11 -o - | FileCheck %s --check-prefixes=CHECK,INEXACT
+
+struct A { virtual ~A(); };
+struct B final : A { };
+
+// CHECK-LABEL: @_Z5exactP1A
+B *exact(A *a) {
+ // INEXACT: call {{.*}} @__dynamic_cast
+ // EXACT-NOT: call {{.*}} @__dynamic_cast
+ return dynamic_cast<B*>(a);
+}
Index: clang/test/CodeGenCXX/dynamic-cast-always-null.cpp
===================================================================
--- clang/test/CodeGenCXX/dynamic-cast-always-null.cpp
+++ clang/test/CodeGenCXX/dynamic-cast-always-null.cpp
@@ -3,21 +3,52 @@
struct B final : A { };
struct C { virtual ~C(); int c; };
+// CHECK: @_Z8nonnull1P1C
+A *nonnull1(C* c) {
+ // CHECK: call {{.*}} @__dynamic_cast
+ return dynamic_cast<A*>(c);
+}
+
+// CHECK: @_Z8nonnull2P1A
+C *nonnull2(A* a) {
+ // CHECK: call {{.*}} @__dynamic_cast
+ return dynamic_cast<C*>(a);
+}
+
// CHECK: @_Z1fP1B
C *f(B* b) {
- // CHECK-NOT: call ptr @__dynamic_cast
+ // CHECK-NOT: call {{.*}} @__dynamic_cast
// CHECK: ret ptr null
return dynamic_cast<C*>(b);
}
// CHECK: @_Z1fR1B
C &f(B& b) {
- // CHECK-NOT: call ptr @__dynamic_cast
+ // CHECK-NOT: call {{.*}} @__dynamic_cast
// CHECK: call void @__cxa_bad_cast() [[NR:#[0-9]+]]
- // CHECK: ret ptr undef
+ // CHECK: unreachable
+ //
+ // CHECK: ret ptr poison
return dynamic_cast<C&>(b);
}
+// CHECK: @_Z1gP1C
+B *g(C* c) {
+ // CHECK-NOT: call {{.*}} @__dynamic_cast
+ // CHECK: ret ptr null
+ return dynamic_cast<B*>(c);
+}
+
+// CHECK: @_Z1gR1C
+B &g(C& c) {
+ // CHECK-NOT: call {{.*}} @__dynamic_cast
+ // CHECK: call void @__cxa_bad_cast() [[NR:#[0-9]+]]
+ // CHECK: unreachable
+ //
+ // CHECK: ret ptr poison
+ return dynamic_cast<B&>(c);
+}
+
void dont_crash() {
(void) dynamic_cast<void*>((A*)0);
(void) dynamic_cast<void*>((B*)0);
Index: clang/lib/CodeGen/MicrosoftCXXABI.cpp
===================================================================
--- clang/lib/CodeGen/MicrosoftCXXABI.cpp
+++ clang/lib/CodeGen/MicrosoftCXXABI.cpp
@@ -152,6 +152,18 @@
bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
QualType SrcRecordTy) override;
+ bool shouldEmitExactDynamicCast(QualType DestRecordTy) override {
+ // TODO: Add support for exact dynamic_casts.
+ return false;
+ }
+ llvm::Value *EmitExactDynamicCast(CodeGenFunction &CGF, Address Value,
+ QualType SrcRecordTy, QualType DestTy,
+ QualType DestRecordTy,
+ llvm::BasicBlock *CastSuccess,
+ llvm::BasicBlock *CastFail) override {
+ llvm_unreachable("unsupported");
+ }
+
llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
QualType SrcRecordTy, QualType DestTy,
QualType DestRecordTy,
@@ -1935,8 +1947,7 @@
adjustThisArgumentForVirtualFunctionCall(CGF, GD, This, true);
auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
- llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty->getPointerTo(),
- MethodDecl->getParent());
+ llvm::Value *VTable = CGF.GetVTablePtr(VPtr, Ty->getPointerTo());
MicrosoftVTableContext &VFTContext = CGM.getMicrosoftVTableContext();
MethodVFTableLocation ML = VFTContext.getMethodVFTableLocation(GD);
@@ -2097,8 +2108,8 @@
// Load the vfptr and then callee from the vftable. The callee should have
// adjusted 'this' so that the vfptr is at offset zero.
llvm::Type *ThunkPtrTy = ThunkTy->getPointerTo();
- llvm::Value *VTable = CGF.GetVTablePtr(
- getThisAddress(CGF), ThunkPtrTy->getPointerTo(), MD->getParent());
+ llvm::Value *VTable =
+ CGF.GetVTablePtr(getThisAddress(CGF), ThunkPtrTy->getPointerTo());
llvm::Value *VFuncPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
ThunkPtrTy, VTable, ML.Index, "vfn");
@@ -4478,7 +4489,7 @@
const CXXRecordDecl *RD) {
std::tie(This, std::ignore, RD) =
performBaseAdjustment(CGF, This, QualType(RD->getTypeForDecl(), 0));
- return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
+ return {CGF.GetVTablePtr(This, CGM.Int8PtrTy), RD};
}
bool MicrosoftCXXABI::isPermittedToBeHomogeneousAggregate(
Index: clang/lib/CodeGen/ItaniumCXXABI.cpp
===================================================================
--- clang/lib/CodeGen/ItaniumCXXABI.cpp
+++ clang/lib/CodeGen/ItaniumCXXABI.cpp
@@ -36,6 +36,8 @@
#include "llvm/IR/Value.h"
#include "llvm/Support/ScopedPrinter.h"
+#include <optional>
+
using namespace clang;
using namespace CodeGen;
@@ -185,11 +187,55 @@
bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
QualType SrcRecordTy) override;
+ // Determine whether we know that all instances of type RecordTy will have
+ // the same vtable pointer values, that is distinct from all other vtable
+ // pointers. While this is required by the Itanium ABI, it doesn't happen in
+ // practice in some cases due to language extensions.
+ bool hasUniqueVTablePointer(QualType RecordTy) {
+ const CXXRecordDecl *RD = RecordTy->getAsCXXRecordDecl();
+
+ // Under -fapple-kext, multiple definitions of the same vtable may be
+ // emitted.
+ if (getContext().getLangOpts().AppleKext)
+ return false;
+
+ // If the type_info* would be null, the vtable might be merged with that of
+ // another type.
+ if (!CGM.GetAddrOfRTTIDescriptor(RecordTy))
+ return false;
+
+ // If there's only one definition of the vtable in the program, it has a
+ // unique address.
+ if (!llvm::GlobalValue::isWeakForLinker(CGM.getVTableLinkage(RD)))
+ return true;
+
+ // Even if there are multiple definitions of the vtable, they are required
+ // by the ABI to use the same symbol name, so should be merged at load
+ // time. However, if the class has hidden visibility, there can be
+ // different versions of the class in different modules, and the ABI
+ // library might treat them as being the same.
+ if (CGM.GetLLVMVisibility(RD->getVisibility()) !=
+ llvm::GlobalValue::DefaultVisibility)
+ return false;
+
+ return true;
+ }
+
+ bool shouldEmitExactDynamicCast(QualType DestRecordTy) override {
+ return hasUniqueVTablePointer(DestRecordTy);
+ }
+
llvm::Value *EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
QualType SrcRecordTy, QualType DestTy,
QualType DestRecordTy,
llvm::BasicBlock *CastEnd) override;
+ llvm::Value *EmitExactDynamicCast(CodeGenFunction &CGF, Address ThisAddr,
+ QualType SrcRecordTy, QualType DestTy,
+ QualType DestRecordTy,
+ llvm::BasicBlock *CastSuccess,
+ llvm::BasicBlock *CastFail) override;
+
llvm::Value *EmitDynamicCastToVoid(CodeGenFunction &CGF, Address Value,
QualType SrcRecordTy,
QualType DestTy) override;
@@ -633,7 +679,7 @@
CGF.CGM.getDynamicOffsetAlignment(ThisAddr.getAlignment(), RD,
CGF.getPointerAlign());
llvm::Value *VTable = CGF.GetVTablePtr(
- Address(This, ThisAddr.getElementType(), VTablePtrAlign), VTableTy, RD);
+ Address(This, ThisAddr.getElementType(), VTablePtrAlign), VTableTy);
// Apply the offset.
// On ARM64, to reserve extra space in virtual member function pointers,
@@ -1210,15 +1256,13 @@
// to pass to the deallocation function.
// Grab the vtable pointer as an intptr_t*.
- auto *ClassDecl =
- cast<CXXRecordDecl>(ElementType->castAs<RecordType>()->getDecl());
- llvm::Value *VTable =
- CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo(), ClassDecl);
+ llvm::Value *VTable = CGF.GetVTablePtr(Ptr, CGF.IntPtrTy->getPointerTo());
// Track back to entry -2 and pull out the offset there.
llvm::Value *OffsetPtr = CGF.Builder.CreateConstInBoundsGEP1_64(
CGF.IntPtrTy, VTable, -2, "complete-offset.ptr");
- llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(CGF.IntPtrTy, OffsetPtr, CGF.getPointerAlign());
+ llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(CGF.IntPtrTy, OffsetPtr,
+ CGF.getPointerAlign());
// Apply the offset.
llvm::Value *CompletePtr =
@@ -1415,10 +1459,8 @@
QualType SrcRecordTy,
Address ThisPtr,
llvm::Type *StdTypeInfoPtrTy) {
- auto *ClassDecl =
- cast<CXXRecordDecl>(SrcRecordTy->castAs<RecordType>()->getDecl());
llvm::Value *Value =
- CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo(), ClassDecl);
+ CGF.GetVTablePtr(ThisPtr, StdTypeInfoPtrTy->getPointerTo());
if (CGM.getItaniumVTableContext().isRelativeLayout()) {
// Load the type info.
@@ -1486,18 +1528,90 @@
return Value;
}
+llvm::Value *ItaniumCXXABI::EmitExactDynamicCast(
+ CodeGenFunction &CGF, Address ThisAddr, QualType SrcRecordTy,
+ QualType DestTy, QualType DestRecordTy, llvm::BasicBlock *CastSuccess,
+ llvm::BasicBlock *CastFail) {
+ ASTContext &Context = getContext();
+
+ // Find all the inheritance paths.
+ const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
+ const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
+ CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
+ /*DetectVirtual=*/false);
+ (void)DestDecl->isDerivedFrom(SrcDecl, Paths);
+
+ // Find an offset within `DestDecl` where a `SrcDecl` instance and its vptr
+ // might appear.
+ std::optional<CharUnits> Offset;
+ for (const CXXBasePath &Path : Paths) {
+ // dynamic_cast only finds public inheritance paths.
+ if (Path.Access != AS_public)
+ continue;
+
+ CharUnits PathOffset;
+ for (const CXXBasePathElement &PathElement : Path) {
+ // Find the offset along this inheritance step.
+ const CXXRecordDecl *Base =
+ PathElement.Base->getType()->getAsCXXRecordDecl();
+ if (PathElement.Base->isVirtual()) {
+ // For a virtual base class, we know that the derived class is exactly
+ // DestDecl, so we can use the vbase offset from its layout.
+ const ASTRecordLayout &L = Context.getASTRecordLayout(DestDecl);
+ PathOffset = L.getVBaseClassOffset(Base);
+ } else {
+ const ASTRecordLayout &L =
+ Context.getASTRecordLayout(PathElement.Class);
+ PathOffset += L.getBaseClassOffset(Base);
+ }
+ }
+
+ if (!Offset)
+ Offset = PathOffset;
+ else if (Offset != PathOffset) {
+ // Base appears in at least two different places. Find the most-derived
+ // object and see if it's a DestDecl. Note that the most-derived object
+ // must be at least as aligned as this base class subobject, and must
+ // have a vptr at offset 0.
+ ThisAddr =
+ Address(EmitDynamicCastToVoid(CGF, ThisAddr, SrcRecordTy, DestTy),
+ CGF.VoidPtrTy, ThisAddr.getAlignment());
+ SrcDecl = DestDecl;
+ Offset = CharUnits::Zero();
+ break;
+ }
+ }
+
+ if (!Offset) {
+ // If there are no public inheritance paths, the cast always fails.
+ CGF.EmitBranch(CastFail);
+ return llvm::PoisonValue::get(CGF.VoidPtrTy);
+ }
+
+ // Compare the vptr against the expected vptr for the destination type at
+ // this offset.
+ llvm::Value *VPtr = CGF.GetVTablePtr(ThisAddr, CGF.VoidPtrPtrTy);
+ llvm::Value *Success = CGF.Builder.CreateICmpEQ(
+ VPtr, getVTableAddressPoint(BaseSubobject(SrcDecl, *Offset), DestDecl));
+ llvm::Value *Result = ThisAddr.getPointer();
+ if (!Offset->isZero())
+ Result = CGF.Builder.CreateGEP(
+ CGF.CharTy, Result,
+ {llvm::ConstantInt::get(CGF.PtrDiffTy, -Offset->getQuantity())});
+ CGF.Builder.CreateCondBr(Success, CastSuccess, CastFail);
+ return Result;
+}
+
llvm::Value *ItaniumCXXABI::EmitDynamicCastToVoid(CodeGenFunction &CGF,
Address ThisAddr,
QualType SrcRecordTy,
QualType DestTy) {
llvm::Type *DestLTy = CGF.ConvertType(DestTy);
- auto *ClassDecl =
- cast<CXXRecordDecl>(SrcRecordTy->castAs<RecordType>()->getDecl());
llvm::Value *OffsetToTop;
if (CGM.getItaniumVTableContext().isRelativeLayout()) {
// Get the vtable pointer.
llvm::Value *VTable =
- CGF.GetVTablePtr(ThisAddr, CGM.Int32Ty->getPointerTo(), ClassDecl);
+ CGF.GetVTablePtr(ThisAddr, CGM.Int32Ty->getPointerTo());
// Get the offset-to-top from the vtable.
OffsetToTop =
@@ -1510,7 +1624,7 @@
// Get the vtable pointer.
llvm::Value *VTable =
- CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo(), ClassDecl);
+ CGF.GetVTablePtr(ThisAddr, PtrDiffLTy->getPointerTo());
// Get the offset-to-top from the vtable.
OffsetToTop =
@@ -1538,7 +1652,7 @@
Address This,
const CXXRecordDecl *ClassDecl,
const CXXRecordDecl *BaseClassDecl) {
- llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy, ClassDecl);
+ llvm::Value *VTablePtr = CGF.GetVTablePtr(This, CGM.Int8PtrTy);
CharUnits VBaseOffsetOffset =
CGM.getItaniumVTableContext().getVirtualBaseOffsetOffset(ClassDecl,
BaseClassDecl);
@@ -1924,8 +2038,7 @@
SourceLocation Loc) {
llvm::Type *TyPtr = Ty->getPointerTo();
auto *MethodDecl = cast<CXXMethodDecl>(GD.getDecl());
- llvm::Value *VTable = CGF.GetVTablePtr(
- This, TyPtr->getPointerTo(), MethodDecl->getParent());
+ llvm::Value *VTable = CGF.GetVTablePtr(This, TyPtr->getPointerTo());
uint64_t VTableIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(GD);
llvm::Value *VFunc;
@@ -4752,7 +4865,7 @@
std::pair<llvm::Value *, const CXXRecordDecl *>
ItaniumCXXABI::LoadVTablePtr(CodeGenFunction &CGF, Address This,
const CXXRecordDecl *RD) {
- return {CGF.GetVTablePtr(This, CGM.Int8PtrTy, RD), RD};
+ return {CGF.GetVTablePtr(This, CGM.Int8PtrTy), RD};
}
void WebAssemblyCXXABI::emitBeginCatch(CodeGenFunction &CGF,
Index: clang/lib/CodeGen/CodeGenModule.h
===================================================================
--- clang/lib/CodeGen/CodeGenModule.h
+++ clang/lib/CodeGen/CodeGenModule.h
@@ -826,8 +826,7 @@
TBAAAccessInfo TBAAInfo);
/// Adds !invariant.barrier !tag to instruction
- void DecorateInstructionWithInvariantGroup(llvm::Instruction *I,
- const CXXRecordDecl *RD);
+ void DecorateInstructionWithInvariantGroup(llvm::Instruction *I);
/// Emit the given number of characters as a value of type size_t.
llvm::ConstantInt *getSize(CharUnits numChars);
Index: clang/lib/CodeGen/CodeGenModule.cpp
===================================================================
--- clang/lib/CodeGen/CodeGenModule.cpp
+++ clang/lib/CodeGen/CodeGenModule.cpp
@@ -1106,7 +1106,7 @@
}
void CodeGenModule::DecorateInstructionWithInvariantGroup(
- llvm::Instruction *I, const CXXRecordDecl *RD) {
+ llvm::Instruction *I) {
I->setMetadata(llvm::LLVMContext::MD_invariant_group,
llvm::MDNode::get(getLLVMContext(), {}));
}
Index: clang/lib/CodeGen/CodeGenFunction.h
===================================================================
--- clang/lib/CodeGen/CodeGenFunction.h
+++ clang/lib/CodeGen/CodeGenFunction.h
@@ -2296,8 +2296,7 @@
/// GetVTablePtr - Return the Value of the vtable pointer member pointed
/// to by This.
- llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
- const CXXRecordDecl *VTableClass);
+ llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy);
enum CFITypeCheckKind {
CFITCK_VCall,
Index: clang/lib/CodeGen/CGExprCXX.cpp
===================================================================
--- clang/lib/CodeGen/CGExprCXX.cpp
+++ clang/lib/CodeGen/CGExprCXX.cpp
@@ -2230,8 +2230,8 @@
if (!CGF.CGM.getCXXABI().EmitBadCastCall(CGF))
return nullptr;
- CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
- return llvm::UndefValue::get(DestLTy);
+ CGF.Builder.ClearInsertionPoint();
+ return llvm::PoisonValue::get(DestLTy);
}
llvm::Value *CodeGenFunction::EmitDynamicCast(Address ThisAddr,
@@ -2244,17 +2244,16 @@
// C++ [expr.dynamic.cast]p7:
// If T is "pointer to cv void," then the result is a pointer to the most
// derived object pointed to by v.
- const PointerType *DestPTy = DestTy->getAs<PointerType>();
-
- bool isDynamicCastToVoid;
+ bool IsDynamicCastToVoid = DestTy->isVoidPointerType();
QualType SrcRecordTy;
QualType DestRecordTy;
- if (DestPTy) {
- isDynamicCastToVoid = DestPTy->getPointeeType()->isVoidType();
+ if (IsDynamicCastToVoid) {
+ SrcRecordTy = SrcTy->getPointeeType();
+ // No DestRecordTy.
+ } else if (const PointerType *DestPTy = DestTy->getAs<PointerType>()) {
SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
DestRecordTy = DestPTy->getPointeeType();
} else {
- isDynamicCastToVoid = false;
SrcRecordTy = SrcTy;
DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
}
@@ -2267,18 +2266,29 @@
EmitTypeCheck(TCK_DynamicOperation, DCE->getExprLoc(), ThisAddr.getPointer(),
SrcRecordTy);
- if (DCE->isAlwaysNull())
- if (llvm::Value *T = EmitDynamicCastToNull(*this, DestTy))
+ if (DCE->isAlwaysNull()) {
+ if (llvm::Value *T = EmitDynamicCastToNull(*this, DestTy)) {
+ // Expression emission is expected to retain a valid insertion point.
+ if (!Builder.GetInsertBlock())
+ EmitBlock(createBasicBlock("dynamic_cast.unreachable"));
return T;
+ }
+ }
assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
+ // If the destination is effectively final, the cast succeeds if and only
+ // if the dynamic type of the pointer is exactly the destination type.
+ bool IsExact = !IsDynamicCastToVoid &&
+ DestRecordTy->getAsCXXRecordDecl()->isEffectivelyFinal() &&
+ CGM.getCXXABI().shouldEmitExactDynamicCast(DestRecordTy);
+
// C++ [expr.dynamic.cast]p4:
// If the value of v is a null pointer value in the pointer case, the result
// is the null pointer value of type T.
bool ShouldNullCheckSrcValue =
- CGM.getCXXABI().shouldDynamicCastCallBeNullChecked(SrcTy->isPointerType(),
- SrcRecordTy);
+ IsExact || CGM.getCXXABI().shouldDynamicCastCallBeNullChecked(
+ SrcTy->isPointerType(), SrcRecordTy);
llvm::BasicBlock *CastNull = nullptr;
llvm::BasicBlock *CastNotNull = nullptr;
@@ -2294,30 +2304,39 @@
}
llvm::Value *Value;
- if (isDynamicCastToVoid) {
+ if (IsDynamicCastToVoid) {
Value = CGM.getCXXABI().EmitDynamicCastToVoid(*this, ThisAddr, SrcRecordTy,
DestTy);
+ } else if (IsExact) {
+ // If the destination type is effectively final, this pointer points to the
+ // right type if and only if its vptr has the right value.
+ Value = CGM.getCXXABI().EmitExactDynamicCast(
+ *this, ThisAddr, SrcRecordTy, DestTy, DestRecordTy, CastEnd, CastNull);
} else {
assert(DestRecordTy->isRecordType() &&
"destination type must be a record type!");
Value = CGM.getCXXABI().EmitDynamicCastCall(*this, ThisAddr, SrcRecordTy,
DestTy, DestRecordTy, CastEnd);
- CastNotNull = Builder.GetInsertBlock();
}
+ CastNotNull = Builder.GetInsertBlock();
+ llvm::Value *NullValue = nullptr;
if (ShouldNullCheckSrcValue) {
EmitBranch(CastEnd);
EmitBlock(CastNull);
+ NullValue = EmitDynamicCastToNull(*this, DestTy);
+ CastNull = Builder.GetInsertBlock();
+
EmitBranch(CastEnd);
}
EmitBlock(CastEnd);
- if (ShouldNullCheckSrcValue) {
+ if (CastNull) {
llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
PHI->addIncoming(Value, CastNotNull);
- PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
+ PHI->addIncoming(NullValue, CastNull);
Value = PHI;
}
Index: clang/lib/CodeGen/CGClass.cpp
===================================================================
--- clang/lib/CodeGen/CGClass.cpp
+++ clang/lib/CodeGen/CGClass.cpp
@@ -2375,8 +2375,7 @@
ApplyNonVirtualAndVirtualOffset(*this, This, NonVirtualOffset, nullptr,
Vptr.VTableClass, Vptr.NearestVBase);
- llvm::Value *VPtrValue =
- GetVTablePtr(This, VTableGlobal->getType(), Vptr.VTableClass);
+ llvm::Value *VPtrValue = GetVTablePtr(This, VTableGlobal->getType());
llvm::Value *Cmp =
Builder.CreateICmpEQ(VPtrValue, VTableGlobal, "cmp.vtables");
Builder.CreateAssumption(Cmp);
@@ -2594,7 +2593,7 @@
CGM.DecorateInstructionWithTBAA(Store, TBAAInfo);
if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
CGM.getCodeGenOpts().StrictVTablePointers)
- CGM.DecorateInstructionWithInvariantGroup(Store, Vptr.VTableClass);
+ CGM.DecorateInstructionWithInvariantGroup(Store);
}
CodeGenFunction::VPtrsVector
@@ -2680,9 +2679,7 @@
CGM.getCXXABI().initializeHiddenVirtualInheritanceMembers(*this, RD);
}
-llvm::Value *CodeGenFunction::GetVTablePtr(Address This,
- llvm::Type *VTableTy,
- const CXXRecordDecl *RD) {
+llvm::Value *CodeGenFunction::GetVTablePtr(Address This, llvm::Type *VTableTy) {
Address VTablePtrSrc = Builder.CreateElementBitCast(This, VTableTy);
llvm::Instruction *VTable = Builder.CreateLoad(VTablePtrSrc, "vtable");
TBAAAccessInfo TBAAInfo = CGM.getTBAAVTablePtrAccessInfo(VTableTy);
@@ -2690,7 +2687,7 @@
if (CGM.getCodeGenOpts().OptimizationLevel > 0 &&
CGM.getCodeGenOpts().StrictVTablePointers)
- CGM.DecorateInstructionWithInvariantGroup(VTable, RD);
+ CGM.DecorateInstructionWithInvariantGroup(VTable);
return VTable;
}
Index: clang/lib/CodeGen/CGCXXABI.h
===================================================================
--- clang/lib/CodeGen/CGCXXABI.h
+++ clang/lib/CodeGen/CGCXXABI.h
@@ -287,6 +287,7 @@
virtual bool shouldDynamicCastCallBeNullChecked(bool SrcIsPtr,
QualType SrcRecordTy) = 0;
+ virtual bool shouldEmitExactDynamicCast(QualType DestRecordTy) = 0;
virtual llvm::Value *
EmitDynamicCastCall(CodeGenFunction &CGF, Address Value,
@@ -298,6 +299,15 @@
QualType SrcRecordTy,
QualType DestTy) = 0;
+ /// Emit a dynamic_cast from SrcRecordTy to DestRecordTy. The cast fails if
+ /// the dynamic type of Value is not exactly DestRecordTy.
+ virtual llvm::Value *EmitExactDynamicCast(CodeGenFunction &CGF, Address Value,
+ QualType SrcRecordTy,
+ QualType DestTy,
+ QualType DestRecordTy,
+ llvm::BasicBlock *CastSuccess,
+ llvm::BasicBlock *CastFail) = 0;
+
virtual bool EmitBadCastCall(CodeGenFunction &CGF) = 0;
virtual llvm::Value *GetVirtualBaseClassOffset(CodeGenFunction &CGF,
Index: clang/lib/AST/ExprCXX.cpp
===================================================================
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -765,29 +765,35 @@
/// struct C { };
///
/// C *f(B* b) { return dynamic_cast<C*>(b); }
-bool CXXDynamicCastExpr::isAlwaysNull() const
-{
+bool CXXDynamicCastExpr::isAlwaysNull() const {
+ if (isValueDependent() || getCastKind() != CK_Dynamic)
+ return false;
+
QualType SrcType = getSubExpr()->getType();
QualType DestType = getType();
- if (const auto *SrcPTy = SrcType->getAs<PointerType>()) {
- SrcType = SrcPTy->getPointeeType();
- DestType = DestType->castAs<PointerType>()->getPointeeType();
+ if (DestType->isVoidPointerType())
+ return false;
+
+ if (DestType->isPointerType()) {
+ SrcType = SrcType->getPointeeType();
+ DestType = DestType->getPointeeType();
}
- if (DestType->isVoidType())
- return false;
+ const auto *SrcRD = SrcType->getAsCXXRecordDecl();
+ const auto *DestRD = DestType->getAsCXXRecordDecl();
+ assert(SrcRD && DestRD);
- const auto *SrcRD =
- cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
+ if (SrcRD->isEffectivelyFinal()) {
+ assert(!SrcRD->isDerivedFrom(DestRD) &&
+ "upcasts should not use CK_Dynamic");
+ return true;
+ }
- if (!SrcRD->hasAttr<FinalAttr>())
- return false;
+ if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD))
+ return true;
- const auto *DestRD =
- cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
-
- return !DestRD->isDerivedFrom(SrcRD);
+ return false;
}
CXXReinterpretCastExpr *
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
