From cadc5f347808151935a6306afe20055dee34d42e Mon Sep 17 00:00:00 2001 From: Jorge Gorbe Moya Date: Mon, 14 Oct 2019 23:25:25 +0000 Subject: [PATCH] Revert "Dead Virtual Function Elimination" This reverts commit 9f6a873268e1ad9855873d9d8007086c0d01cf4f. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@374844 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/CodeGenOptions.def | 4 - include/clang/Driver/Options.td | 7 -- lib/CodeGen/CGClass.cpp | 18 +-- lib/CodeGen/CGVTables.cpp | 35 +----- lib/CodeGen/CodeGenModule.h | 10 +- lib/CodeGen/ItaniumCXXABI.cpp | 105 ++++++------------ lib/Driver/ToolChains/Clang.cpp | 27 +---- lib/Frontend/CompilerInvocation.cpp | 2 - test/CodeGenCXX/vcall-visibility-metadata.cpp | 88 --------------- .../virtual-function-elimination.cpp | 75 ------------- test/Driver/virtual-function-elimination.cpp | 11 -- 11 files changed, 45 insertions(+), 337 deletions(-) delete mode 100644 test/CodeGenCXX/vcall-visibility-metadata.cpp delete mode 100644 test/CodeGenCXX/virtual-function-elimination.cpp delete mode 100644 test/Driver/virtual-function-elimination.cpp diff --git a/include/clang/Basic/CodeGenOptions.def b/include/clang/Basic/CodeGenOptions.def index d2266cc2d6..736f201a12 100644 --- a/include/clang/Basic/CodeGenOptions.def +++ b/include/clang/Basic/CodeGenOptions.def @@ -278,10 +278,6 @@ CODEGENOPT(EmitLLVMUseLists, 1, 0) ///< Control whether to serialize use-lists. CODEGENOPT(WholeProgramVTables, 1, 0) ///< Whether to apply whole-program /// vtable optimization. -CODEGENOPT(VirtualFunctionElimination, 1, 0) ///< Whether to apply the dead - /// virtual function elimination - /// optimization. - /// Whether to use public LTO visibility for entities in std and stdext /// namespaces. This is enabled by clang-cl's /MT and /MTd flags. CODEGENOPT(LTOVisibilityPublicStd, 1, 0) diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td index 22676b6787..71472b2366 100644 --- a/include/clang/Driver/Options.td +++ b/include/clang/Driver/Options.td @@ -1863,13 +1863,6 @@ def fforce_emit_vtables : Flag<["-"], "fforce-emit-vtables">, Group, HelpText<"Emits more virtual tables to improve devirtualization">; def fno_force_emit_vtables : Flag<["-"], "fno-force-emit-vtables">, Group, Flags<[CoreOption]>; - -def fvirtual_function_elimination : Flag<["-"], "fvirtual-function-elimination">, Group, - Flags<[CoreOption, CC1Option]>, - HelpText<"Enables dead virtual function elimination optimization. Requires -flto=full">; -def fno_virtual_function_elimination : Flag<["-"], "fno-virtual-function_elimination">, Group, - Flags<[CoreOption]>; - def fwrapv : Flag<["-"], "fwrapv">, Group, Flags<[CC1Option]>, HelpText<"Treat signed integer overflow as two's complement">; def fwritable_strings : Flag<["-"], "fwritable-strings">, Group, Flags<[CC1Option]>, diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp index 7cff6210c2..ab8588303d 100644 --- a/lib/CodeGen/CGClass.cpp +++ b/lib/CodeGen/CGClass.cpp @@ -2784,16 +2784,11 @@ void CodeGenFunction::EmitVTablePtrCheck(const CXXRecordDecl *RD, bool CodeGenFunction::ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD) { if (!CGM.getCodeGenOpts().WholeProgramVTables || + !SanOpts.has(SanitizerKind::CFIVCall) || + !CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIVCall) || !CGM.HasHiddenLTOVisibility(RD)) return false; - if (CGM.getCodeGenOpts().VirtualFunctionElimination) - return true; - - if (!SanOpts.has(SanitizerKind::CFIVCall) || - !CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIVCall)) - return false; - std::string TypeName = RD->getQualifiedNameAsString(); return !getContext().getSanitizerBlacklist().isBlacklistedType( SanitizerKind::CFIVCall, TypeName); @@ -2816,13 +2811,8 @@ llvm::Value *CodeGenFunction::EmitVTableTypeCheckedLoad( TypeId}); llvm::Value *CheckResult = Builder.CreateExtractValue(CheckedLoad, 1); - std::string TypeName = RD->getQualifiedNameAsString(); - if (SanOpts.has(SanitizerKind::CFIVCall) && - !getContext().getSanitizerBlacklist().isBlacklistedType( - SanitizerKind::CFIVCall, TypeName)) { - EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIVCall), - SanitizerHandler::CFICheckFail, {}, {}); - } + EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIVCall), + SanitizerHandler::CFICheckFail, nullptr, nullptr); return Builder.CreateBitCast( Builder.CreateExtractValue(CheckedLoad, 0), diff --git a/lib/CodeGen/CGVTables.cpp b/lib/CodeGen/CGVTables.cpp index f9f25e7e57..a74905fd70 100644 --- a/lib/CodeGen/CGVTables.cpp +++ b/lib/CodeGen/CGVTables.cpp @@ -808,7 +808,7 @@ CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD, assert(!VTable->isDeclaration() && "Shouldn't set properties on declaration"); CGM.setGVProperties(VTable, RD); - CGM.EmitVTableTypeMetadata(RD, VTable, *VTLayout.get()); + CGM.EmitVTableTypeMetadata(VTable, *VTLayout.get()); return VTable; } @@ -1039,32 +1039,7 @@ bool CodeGenModule::HasHiddenLTOVisibility(const CXXRecordDecl *RD) { return true; } -llvm::GlobalObject::VCallVisibility -CodeGenModule::GetVCallVisibilityLevel(const CXXRecordDecl *RD) { - LinkageInfo LV = RD->getLinkageAndVisibility(); - llvm::GlobalObject::VCallVisibility TypeVis; - if (!isExternallyVisible(LV.getLinkage())) - TypeVis = llvm::GlobalObject::VCallVisibilityTranslationUnit; - else if (HasHiddenLTOVisibility(RD)) - TypeVis = llvm::GlobalObject::VCallVisibilityLinkageUnit; - else - TypeVis = llvm::GlobalObject::VCallVisibilityPublic; - - for (auto B : RD->bases()) - if (B.getType()->getAsCXXRecordDecl()->isDynamicClass()) - TypeVis = std::min(TypeVis, - GetVCallVisibilityLevel(B.getType()->getAsCXXRecordDecl())); - - for (auto B : RD->vbases()) - if (B.getType()->getAsCXXRecordDecl()->isDynamicClass()) - TypeVis = std::min(TypeVis, - GetVCallVisibilityLevel(B.getType()->getAsCXXRecordDecl())); - - return TypeVis; -} - -void CodeGenModule::EmitVTableTypeMetadata(const CXXRecordDecl *RD, - llvm::GlobalVariable *VTable, +void CodeGenModule::EmitVTableTypeMetadata(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout) { if (!getCodeGenOpts().LTOUnit) return; @@ -1124,10 +1099,4 @@ void CodeGenModule::EmitVTableTypeMetadata(const CXXRecordDecl *RD, VTable->addTypeMetadata((PointerWidth * I).getQuantity(), MD); } } - - if (getCodeGenOpts().VirtualFunctionElimination) { - llvm::GlobalObject::VCallVisibility TypeVis = GetVCallVisibilityLevel(RD); - if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic) - VTable->addVCallVisibilityMetadata(TypeVis); - } } diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h index 73f81adae3..597b8d712c 100644 --- a/lib/CodeGen/CodeGenModule.h +++ b/lib/CodeGen/CodeGenModule.h @@ -1280,16 +1280,8 @@ public: /// optimization. bool HasHiddenLTOVisibility(const CXXRecordDecl *RD); - /// Returns the vcall visibility of the given type. This is the scope in which - /// a virtual function call could be made which ends up being dispatched to a - /// member function of this class. This scope can be wider than the visibility - /// of the class itself when the class has a more-visible dynamic base class. - llvm::GlobalObject::VCallVisibility - GetVCallVisibilityLevel(const CXXRecordDecl *RD); - /// Emit type metadata for the given vtable using the given layout. - void EmitVTableTypeMetadata(const CXXRecordDecl *RD, - llvm::GlobalVariable *VTable, + void EmitVTableTypeMetadata(llvm::GlobalVariable *VTable, const VTableLayout &VTLayout); /// Generate a cross-DSO type identifier for MD. diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp index 8f9b16470b..2945dec0bd 100644 --- a/lib/CodeGen/ItaniumCXXABI.cpp +++ b/lib/CodeGen/ItaniumCXXABI.cpp @@ -644,6 +644,8 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( VTableOffset = Builder.CreateTrunc(VTableOffset, CGF.Int32Ty); VTableOffset = Builder.CreateZExt(VTableOffset, CGM.PtrDiffTy); } + // Compute the address of the virtual function pointer. + llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset); // Check the address of the function pointer if CFI on member function // pointers is enabled. @@ -651,81 +653,44 @@ CGCallee ItaniumCXXABI::EmitLoadOfMemberFunctionPointer( llvm::Constant *CheckTypeDesc; bool ShouldEmitCFICheck = CGF.SanOpts.has(SanitizerKind::CFIMFCall) && CGM.HasHiddenLTOVisibility(RD); - bool ShouldEmitVFEInfo = CGM.getCodeGenOpts().VirtualFunctionElimination && - CGM.HasHiddenLTOVisibility(RD); - llvm::Value *VirtualFn = nullptr; - - { + if (ShouldEmitCFICheck) { CodeGenFunction::SanitizerScope SanScope(&CGF); - llvm::Value *TypeId = nullptr; - llvm::Value *CheckResult = nullptr; - - if (ShouldEmitCFICheck || ShouldEmitVFEInfo) { - // If doing CFI or VFE, we will need the metadata node to check against. - llvm::Metadata *MD = - CGM.CreateMetadataIdentifierForVirtualMemPtrType(QualType(MPT, 0)); - TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD); - } - llvm::Value *VFPAddr = Builder.CreateGEP(VTable, VTableOffset); - - if (ShouldEmitVFEInfo) { - // If doing VFE, load from the vtable with a type.checked.load intrinsic - // call. Note that we use the GEP to calculate the address to load from - // and pass 0 as the offset to the intrinsic. This is because every - // vtable slot of the correct type is marked with matching metadata, and - // we know that the load must be from one of these slots. - llvm::Value *CheckedLoad = Builder.CreateCall( - CGM.getIntrinsic(llvm::Intrinsic::type_checked_load), - {VFPAddr, llvm::ConstantInt::get(CGM.Int32Ty, 0), TypeId}); - CheckResult = Builder.CreateExtractValue(CheckedLoad, 1); - VirtualFn = Builder.CreateExtractValue(CheckedLoad, 0); - VirtualFn = Builder.CreateBitCast(VirtualFn, FTy->getPointerTo(), - "memptr.virtualfn"); - } else { - // When not doing VFE, emit a normal load, as it allows more - // optimisations than type.checked.load. - if (ShouldEmitCFICheck) { - CheckResult = Builder.CreateCall( - CGM.getIntrinsic(llvm::Intrinsic::type_test), - {Builder.CreateBitCast(VFPAddr, CGF.Int8PtrTy), TypeId}); - } - VFPAddr = - Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo()); - VirtualFn = Builder.CreateAlignedLoad(VFPAddr, CGF.getPointerAlign(), - "memptr.virtualfn"); - } - assert(VirtualFn && "Virtual fuction pointer not created!"); - assert((!ShouldEmitCFICheck || !ShouldEmitVFEInfo || CheckResult) && - "Check result required but not created!"); - - if (ShouldEmitCFICheck) { - // If doing CFI, emit the check. - CheckSourceLocation = CGF.EmitCheckSourceLocation(E->getBeginLoc()); - CheckTypeDesc = CGF.EmitCheckTypeDescriptor(QualType(MPT, 0)); - llvm::Constant *StaticData[] = { - llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall), - CheckSourceLocation, - CheckTypeDesc, - }; + CheckSourceLocation = CGF.EmitCheckSourceLocation(E->getBeginLoc()); + CheckTypeDesc = CGF.EmitCheckTypeDescriptor(QualType(MPT, 0)); + llvm::Constant *StaticData[] = { + llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall), + CheckSourceLocation, + CheckTypeDesc, + }; - if (CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIMFCall)) { - CGF.EmitTrapCheck(CheckResult); - } else { - llvm::Value *AllVtables = llvm::MetadataAsValue::get( - CGM.getLLVMContext(), - llvm::MDString::get(CGM.getLLVMContext(), "all-vtables")); - llvm::Value *ValidVtable = Builder.CreateCall( - CGM.getIntrinsic(llvm::Intrinsic::type_test), {VTable, AllVtables}); - CGF.EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIMFCall), - SanitizerHandler::CFICheckFail, StaticData, - {VTable, ValidVtable}); - } + llvm::Metadata *MD = + CGM.CreateMetadataIdentifierForVirtualMemPtrType(QualType(MPT, 0)); + llvm::Value *TypeId = llvm::MetadataAsValue::get(CGF.getLLVMContext(), MD); + + llvm::Value *TypeTest = Builder.CreateCall( + CGM.getIntrinsic(llvm::Intrinsic::type_test), {VFPAddr, TypeId}); - FnVirtual = Builder.GetInsertBlock(); + if (CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIMFCall)) { + CGF.EmitTrapCheck(TypeTest); + } else { + llvm::Value *AllVtables = llvm::MetadataAsValue::get( + CGM.getLLVMContext(), + llvm::MDString::get(CGM.getLLVMContext(), "all-vtables")); + llvm::Value *ValidVtable = Builder.CreateCall( + CGM.getIntrinsic(llvm::Intrinsic::type_test), {VTable, AllVtables}); + CGF.EmitCheck(std::make_pair(TypeTest, SanitizerKind::CFIMFCall), + SanitizerHandler::CFICheckFail, StaticData, + {VTable, ValidVtable}); } - } // End of sanitizer scope + FnVirtual = Builder.GetInsertBlock(); + } + + // Load the virtual function to call. + VFPAddr = Builder.CreateBitCast(VFPAddr, FTy->getPointerTo()->getPointerTo()); + llvm::Value *VirtualFn = Builder.CreateAlignedLoad( + VFPAddr, CGF.getPointerAlign(), "memptr.virtualfn"); CGF.EmitBranch(FnEnd); // In the non-virtual path, the function pointer is actually a @@ -1669,7 +1634,7 @@ void ItaniumCXXABI::emitVTableDefinitions(CodeGenVTables &CGVT, EmitFundamentalRTTIDescriptors(RD); if (!VTable->isDeclarationForLinker()) - CGM.EmitVTableTypeMetadata(RD, VTable, VTLayout); + CGM.EmitVTableTypeMetadata(VTable, VTLayout); } bool ItaniumCXXABI::isVirtualOffsetNeededForVTableField( diff --git a/lib/Driver/ToolChains/Clang.cpp b/lib/Driver/ToolChains/Clang.cpp index dfb3f33608..1ecc4d216d 100644 --- a/lib/Driver/ToolChains/Clang.cpp +++ b/lib/Driver/ToolChains/Clang.cpp @@ -5366,30 +5366,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back(Args.MakeArgString(TargetInfo.str())); } - bool VirtualFunctionElimination = - Args.hasFlag(options::OPT_fvirtual_function_elimination, - options::OPT_fno_virtual_function_elimination, false); - if (VirtualFunctionElimination) { - // VFE requires full LTO (currently, this might be relaxed to allow ThinLTO - // in the future). - if (D.getLTOMode() != LTOK_Full) - D.Diag(diag::err_drv_argument_only_allowed_with) - << "-fvirtual-function-elimination" - << "-flto=full"; - - CmdArgs.push_back("-fvirtual-function-elimination"); - } - - // VFE requires whole-program-vtables, and enables it by default. - bool WholeProgramVTables = Args.hasFlag( - options::OPT_fwhole_program_vtables, - options::OPT_fno_whole_program_vtables, VirtualFunctionElimination); - if (VirtualFunctionElimination && !WholeProgramVTables) { - D.Diag(diag::err_drv_argument_not_allowed_with) - << "-fno-whole-program-vtables" - << "-fvirtual-function-elimination"; - } - + bool WholeProgramVTables = + Args.hasFlag(options::OPT_fwhole_program_vtables, + options::OPT_fno_whole_program_vtables, false); if (WholeProgramVTables) { if (!D.isUsingLTO()) D.Diag(diag::err_drv_argument_only_allowed_with) diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp index 9d5987f07f..59e2301db2 100644 --- a/lib/Frontend/CompilerInvocation.cpp +++ b/lib/Frontend/CompilerInvocation.cpp @@ -758,8 +758,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Opts.CodeViewGHash = Args.hasArg(OPT_gcodeview_ghash); Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro); Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables); - Opts.VirtualFunctionElimination = - Args.hasArg(OPT_fvirtual_function_elimination); Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std); Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file); Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output); diff --git a/test/CodeGenCXX/vcall-visibility-metadata.cpp b/test/CodeGenCXX/vcall-visibility-metadata.cpp deleted file mode 100644 index 7cf4839567..0000000000 --- a/test/CodeGenCXX/vcall-visibility-metadata.cpp +++ /dev/null @@ -1,88 +0,0 @@ -// RUN: %clang_cc1 -flto -flto-unit -triple x86_64-unknown-linux -emit-llvm -fvirtual-function-elimination -fwhole-program-vtables -o - %s | FileCheck %s - - -// Anonymous namespace. -namespace { -// CHECK: @_ZTVN12_GLOBAL__N_11AE = {{.*}} !vcall_visibility [[VIS_TU:![0-9]+]] -struct A { - A() {} - virtual int f() { return 1; } -}; -} -void *construct_A() { - return new A(); -} - - -// Hidden visibility. -// CHECK: @_ZTV1B = {{.*}} !vcall_visibility [[VIS_DSO:![0-9]+]] -struct __attribute__((visibility("hidden"))) B { - B() {} - virtual int f() { return 1; } -}; -B *construct_B() { - return new B(); -} - - -// Default visibility. -// CHECK-NOT: @_ZTV1C = {{.*}} !vcall_visibility -struct __attribute__((visibility("default"))) C { - C() {} - virtual int f() { return 1; } -}; -C *construct_C() { - return new C(); -} - - -// Hidden visibility, public LTO visibility. -// CHECK-NOT: @_ZTV1D = {{.*}} !vcall_visibility -struct __attribute__((visibility("hidden"))) [[clang::lto_visibility_public]] D { - D() {} - virtual int f() { return 1; } -}; -D *construct_D() { - return new D(); -} - - -// Hidden visibility, but inherits from class with default visibility. -// CHECK-NOT: @_ZTV1E = {{.*}} !vcall_visibility -struct __attribute__((visibility("hidden"))) E : C { - E() {} - virtual int f() { return 1; } -}; -E *construct_E() { - return new E(); -} - - -// Anonymous namespace, but inherits from class with default visibility. -// CHECK-NOT: @_ZTVN12_GLOBAL__N_11FE = {{.*}} !vcall_visibility -namespace { -struct __attribute__((visibility("hidden"))) F : C { - F() {} - virtual int f() { return 1; } -}; -} -void *construct_F() { - return new F(); -} - - -// Anonymous namespace, but inherits from class with hidden visibility. -// CHECK: @_ZTVN12_GLOBAL__N_11GE = {{.*}} !vcall_visibility [[VIS_DSO:![0-9]+]] -namespace { -struct __attribute__((visibility("hidden"))) G : B { - G() {} - virtual int f() { return 1; } -}; -} -void *construct_G() { - return new G(); -} - - -// CHECK-DAG: [[VIS_DSO]] = !{i64 1} -// CHECK-DAG: [[VIS_TU]] = !{i64 2} diff --git a/test/CodeGenCXX/virtual-function-elimination.cpp b/test/CodeGenCXX/virtual-function-elimination.cpp deleted file mode 100644 index a89e6ebcee..0000000000 --- a/test/CodeGenCXX/virtual-function-elimination.cpp +++ /dev/null @@ -1,75 +0,0 @@ -// RUN: %clang_cc1 -triple x86_64-unknown-linux -flto -flto-unit -fvirtual-function-elimination -fwhole-program-vtables -emit-llvm -o - %s | FileCheck %s - - -struct __attribute__((visibility("default"))) A { - virtual void foo(); -}; - -void test_1(A *p) { - // A has default visibility, so no need for type.checked.load. -// CHECK-LABEL: define void @_Z6test_1P1A -// CHECK: [[FN_PTR_ADDR:%.+]] = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** {{%.+}}, i64 0 -// CHECK: [[FN_PTR:%.+]] = load void (%struct.A*)*, void (%struct.A*)** [[FN_PTR_ADDR]] -// CHECK: call void [[FN_PTR]]( - p->foo(); -} - - -struct __attribute__((visibility("hidden"))) [[clang::lto_visibility_public]] B { - virtual void foo(); -}; - -void test_2(B *p) { - // B has public LTO visibility, so no need for type.checked.load. -// CHECK-LABEL: define void @_Z6test_2P1B -// CHECK: [[FN_PTR_ADDR:%.+]] = getelementptr inbounds void (%struct.B*)*, void (%struct.B*)** {{%.+}}, i64 0 -// CHECK: [[FN_PTR:%.+]] = load void (%struct.B*)*, void (%struct.B*)** [[FN_PTR_ADDR]] -// CHECK: call void [[FN_PTR]]( - p->foo(); -} - - -struct __attribute__((visibility("hidden"))) C { - virtual void foo(); - virtual void bar(); -}; - -void test_3(C *p) { - // C has hidden visibility, so we generate type.checked.load to allow VFE. -// CHECK-LABEL: define void @_Z6test_3P1C -// CHECK: [[LOAD:%.+]] = call { i8*, i1 } @llvm.type.checked.load(i8* {{%.+}}, i32 0, metadata !"_ZTS1C") -// CHECK: [[FN_PTR_I8:%.+]] = extractvalue { i8*, i1 } [[LOAD]], 0 -// CHECK: [[FN_PTR:%.+]] = bitcast i8* [[FN_PTR_I8]] to void (%struct.C*)* -// CHECK: call void [[FN_PTR]]( - p->foo(); -} - -void test_4(C *p) { - // When using type.checked.load, we pass the vtable offset to the intrinsic, - // rather than adding it to the pointer with a GEP. -// CHECK-LABEL: define void @_Z6test_4P1C -// CHECK: [[LOAD:%.+]] = call { i8*, i1 } @llvm.type.checked.load(i8* {{%.+}}, i32 8, metadata !"_ZTS1C") -// CHECK: [[FN_PTR_I8:%.+]] = extractvalue { i8*, i1 } [[LOAD]], 0 -// CHECK: [[FN_PTR:%.+]] = bitcast i8* [[FN_PTR_I8]] to void (%struct.C*)* -// CHECK: call void [[FN_PTR]]( - p->bar(); -} - -void test_5(C *p, void (C::*q)(void)) { - // We also use type.checked.load for the virtual side of member function - // pointer calls. We use a GEP to calculate the address to load from and pass - // 0 as the offset to the intrinsic, because we know that the load must be - // from exactly the point marked by one of the function-type metadatas (in - // this case "_ZTSM1CFvvE.virtual"). If we passed the offset from the member - // function pointer to the intrinsic, this information would be lost. No - // codegen changes on the non-virtual side. -// CHECK-LABEL: define void @_Z6test_5P1CMS_FvvE( -// CHECK: [[FN_PTR_ADDR:%.+]] = getelementptr i8, i8* %vtable, i64 {{%.+}} -// CHECK: [[LOAD:%.+]] = call { i8*, i1 } @llvm.type.checked.load(i8* [[FN_PTR_ADDR]], i32 0, metadata !"_ZTSM1CFvvE.virtual") -// CHECK: [[FN_PTR_I8:%.+]] = extractvalue { i8*, i1 } [[LOAD]], 0 -// CHECK: [[FN_PTR:%.+]] = bitcast i8* [[FN_PTR_I8]] to void (%struct.C*)* - -// CHECK: [[PHI:%.+]] = phi void (%struct.C*)* {{.*}}[ [[FN_PTR]], {{.*}} ] -// CHECK: call void [[PHI]]( - (p->*q)(); -} diff --git a/test/Driver/virtual-function-elimination.cpp b/test/Driver/virtual-function-elimination.cpp deleted file mode 100644 index 3a026bbb43..0000000000 --- a/test/Driver/virtual-function-elimination.cpp +++ /dev/null @@ -1,11 +0,0 @@ -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -### %s 2>&1 | FileCheck --check-prefix=BAD-LTO %s -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -flto=thin -### %s 2>&1 | FileCheck --check-prefix=BAD-LTO %s -// BAD-LTO: invalid argument '-fvirtual-function-elimination' only allowed with '-flto=full' - -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -flto -### %s 2>&1 | FileCheck --check-prefix=GOOD %s -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -flto=full -### %s 2>&1 | FileCheck --check-prefix=GOOD %s -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -flto -fwhole-program-vtables -### %s 2>&1 | FileCheck --check-prefix=GOOD %s -// GOOD: "-fvirtual-function-elimination" "-fwhole-program-vtables" - -// RUN: %clang -target x86_64-unknown-linux -fvirtual-function-elimination -fno-whole-program-vtables -flto -### %s 2>&1 | FileCheck --check-prefix=NO-WHOLE-PROGRAM-VTABLES %s -// NO-WHOLE-PROGRAM-VTABLES: invalid argument '-fno-whole-program-vtables' not allowed with '-fvirtual-function-elimination' -- 2.40.0