diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp --- a/clang/lib/AST/ExprCXX.cpp +++ b/clang/lib/AST/ExprCXX.cpp @@ -765,29 +765,35 @@ /// struct C { }; /// /// C *f(B* b) { return dynamic_cast(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()) { - SrcType = SrcPTy->getPointeeType(); - DestType = DestType->castAs()->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(SrcType->castAs()->getDecl()); + if (SrcRD->isEffectivelyFinal()) { + assert(!SrcRD->isDerivedFrom(DestRD) && + "upcasts should not use CK_Dynamic"); + return true; + } - if (!SrcRD->hasAttr()) - return false; + if (DestRD->isEffectivelyFinal() && !DestRD->isDerivedFrom(SrcRD)) + return true; - const auto *DestRD = - cast(DestType->castAs()->getDecl()); - - return !DestRD->isDerivedFrom(SrcRD); + return false; } CXXReinterpretCastExpr * diff --git a/clang/lib/CodeGen/CGCXXABI.h b/clang/lib/CodeGen/CGCXXABI.h --- a/clang/lib/CodeGen/CGCXXABI.h +++ b/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, diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp --- a/clang/lib/CodeGen/CGClass.cpp +++ b/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; } diff --git a/clang/lib/CodeGen/CGExprCXX.cpp b/clang/lib/CodeGen/CGExprCXX.cpp --- a/clang/lib/CodeGen/CGExprCXX.cpp +++ b/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(); - - 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()) { SrcRecordTy = SrcTy->castAs()->getPointeeType(); DestRecordTy = DestPTy->getPointeeType(); } else { - isDynamicCastToVoid = false; SrcRecordTy = SrcTy; DestRecordTy = DestTy->castAs()->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; } diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/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, diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/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); diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/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(), {})); } diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp --- a/clang/lib/CodeGen/ItaniumCXXABI.cpp +++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -36,6 +36,8 @@ #include "llvm/IR/Value.h" #include "llvm/Support/ScopedPrinter.h" +#include + 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(ElementType->castAs()->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(SrcRecordTy->castAs()->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 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.CreateInBoundsGEP( + 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(SrcRecordTy->castAs()->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(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 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, diff --git a/clang/lib/CodeGen/MicrosoftCXXABI.cpp b/clang/lib/CodeGen/MicrosoftCXXABI.cpp --- a/clang/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/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(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( diff --git a/clang/test/CodeGenCXX/dynamic-cast-always-null.cpp b/clang/test/CodeGenCXX/dynamic-cast-always-null.cpp --- a/clang/test/CodeGenCXX/dynamic-cast-always-null.cpp +++ b/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(c); +} + +// CHECK: @_Z8nonnull2P1A +C *nonnull2(A* a) { + // CHECK: call {{.*}} @__dynamic_cast + return dynamic_cast(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(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(b); } +// CHECK: @_Z1gP1C +B *g(C* c) { + // CHECK-NOT: call {{.*}} @__dynamic_cast + // CHECK: ret ptr null + return dynamic_cast(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(c); +} + void dont_crash() { (void) dynamic_cast((A*)0); (void) dynamic_cast((B*)0); diff --git a/clang/test/CodeGenCXX/dynamic-cast-exact-disabled.cpp b/clang/test/CodeGenCXX/dynamic-cast-exact-disabled.cpp new file mode 100644 --- /dev/null +++ b/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(a); +} diff --git a/clang/test/CodeGenCXX/dynamic-cast-exact.cpp b/clang/test/CodeGenCXX/dynamic-cast-exact.cpp new file mode 100644 --- /dev/null +++ b/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(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 inbounds 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(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 inbounds 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(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(a); +}