[GlobalDCE][IR] Allow and support multiple !vcall_visibility ranges

clang/lib/CodeGen/CGVTables.cpp

for (auto AP : AddressPoints) {
     }
   }
 
   if (getCodeGenOpts().VirtualFunctionElimination ||
       getCodeGenOpts().WholeProgramVTables) {
     llvm::DenseSet<const CXXRecordDecl *> Visited;
     llvm::GlobalObject::VCallVisibility TypeVis =
         GetVCallVisibilityLevel(RD, Visited);
+
+    // Add a single range covering the whole global.
     if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
-      VTable->setVCallVisibilityMetadata(TypeVis);
+      VTable->setVCallVisibility(
+          {{TypeVis, 0, std::numeric_limits<uint64_t>::max()}});
   }
 }

clang/lib/CodeGen/MicrosoftCXXABI.cpp

if (!CGM.getCodeGenOpts().LTOUnit)
     return;
 
   // TODO: Should VirtualFunctionElimination also be supported here?
   // See similar handling in CodeGenModule::EmitVTableTypeMetadata.
   if (CGM.getCodeGenOpts().WholeProgramVTables) {
     llvm::DenseSet<const CXXRecordDecl *> Visited;
     llvm::GlobalObject::VCallVisibility TypeVis =
         CGM.GetVCallVisibilityLevel(RD, Visited);
+
+    // Add a single range covering the whole global
     if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
-      VTable->setVCallVisibilityMetadata(TypeVis);
+      VTable->setVCallVisibility(
+          {{TypeVis, 0, std::numeric_limits<uint64_t>::max()}});
   }
 
   // The location of the first virtual function pointer in the virtual table,
   // aka the "address point" on Itanium. This is at offset 0 if RTTI is
   // disabled, or sizeof(void*) if RTTI is enabled.
   CharUnits AddressPoint =
       getContext().getLangOpts().RTTIData
           ? getContext().toCharUnitsFromBits(

llvm/include/llvm/IR/GlobalObject.h

public:
   using Value::getMetadata;
   using Value::hasMetadata;
   using Value::setMetadata;
 
   /// Copy metadata from Src, adjusting offsets by Offset.
   void copyMetadata(const GlobalObject *Src, unsigned Offset);
 
   void addTypeMetadata(unsigned Offset, Metadata *TypeID);
-  void setVCallVisibilityMetadata(VCallVisibility Visibility);
-  VCallVisibility getVCallVisibility() const;
-  std::pair<uint64_t, uint64_t> getVTableOffsetRange() const;
+
+  struct VCallVisibilityEntry {
+    GlobalObject::VCallVisibility Visibility;
+    uint64_t RangeStart;
+    uint64_t RangeEnd;
+  };
+  using VCallVisibilityList = std::vector<VCallVisibilityEntry>;
+
+  void setVCallVisibility(VCallVisibilityList Visibility);
+  VCallVisibilityList getVCallVisibility() const;
 
   /// Returns true if the alignment of the value can be unilaterally
   /// increased.
   ///
   /// Note that for functions this is the alignment of the code, not the
   /// alignment of a function pointer.
   bool canIncreaseAlignment() const;
 

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

if (!Index.enableSplitLTOUnit()) {
     }
   }
 
   // Don't mark variables we won't be able to internalize as read/write-only.
   bool CanBeInternalized =
       !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
       !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();
   bool Constant = V.isConstant();
+
+  GlobalObject::VCallVisibilityList List = V.getVCallVisibility();
+  // Find the maximum visibility from all !vcall_visibility attachments.
+  GlobalObject::VCallVisibility TypeVis =
+      GlobalObject::VCallVisibilityTranslationUnit;
+  for (auto Entry : List) {
+    TypeVis = std::min(TypeVis, Entry.Visibility);
+  }
+  if (List.empty())
+    TypeVis = GlobalObject::VCallVisibilityPublic;
+
   GlobalVarSummary::GVarFlags VarFlags(CanBeInternalized,
                                        Constant ? false : CanBeInternalized,
-                                       Constant, V.getVCallVisibility());
+                                       Constant, TypeVis);
   auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
                                                          RefEdges.takeVector());
   if (NonRenamableLocal)
     CantBePromoted.insert(V.getGUID());
   if (HasBlockAddress)
     GVarSummary->setNotEligibleToImport();
   if (!VTableFuncs.empty())
     GVarSummary->setVTableFuncs(VTableFuncs);

llvm/lib/IR/Metadata.cpp

void GlobalObject::addTypeMetadata(unsigned Offset, Metadata *TypeID) {
   addMetadata(
       LLVMContext::MD_type,
       *MDTuple::get(getContext(),
                     {ConstantAsMetadata::get(ConstantInt::get(
                          Type::getInt64Ty(getContext()), Offset)),
                      TypeID}));
 }
 
-void GlobalObject::setVCallVisibilityMetadata(VCallVisibility Visibility) {
+void GlobalObject::setVCallVisibility(VCallVisibilityList Visibility) {
   // Remove any existing vcall visibility metadata first in case we are
   // updating.
   eraseMetadata(LLVMContext::MD_vcall_visibility);
-  addMetadata(LLVMContext::MD_vcall_visibility,
-              *MDNode::get(getContext(),
-                           {ConstantAsMetadata::get(ConstantInt::get(
-                               Type::getInt64Ty(getContext()), Visibility))}));
+  for (auto Entry : Visibility) {
+    addMetadata(
+        LLVMContext::MD_vcall_visibility,
+                     {
+                         ConstantAsMetadata::get(ConstantInt::get(
+                             Type::getInt64Ty(getContext()), Entry.Visibility)),
+                         ConstantAsMetadata::get(ConstantInt::get(
+                             Type::getInt64Ty(getContext()), Entry.RangeStart)),
+                         ConstantAsMetadata::get(ConstantInt::get(
+                             Type::getInt64Ty(getContext()), Entry.RangeEnd)),
+                     }));
+  }
 }
 
-GlobalObject::VCallVisibility GlobalObject::getVCallVisibility() const {
-  if (MDNode *MD = getMetadata(LLVMContext::MD_vcall_visibility)) {
+GlobalObject::VCallVisibilityList GlobalObject::getVCallVisibility() const {
+  VCallVisibilityList Result;
+
+  SmallVector<MDNode *, 2> MDs;
+  getMetadata(LLVMContext::MD_vcall_visibility, MDs);
+  for (MDNode *MD : MDs) {
     uint64_t Val = cast<ConstantInt>(
                        cast<ConstantAsMetadata>(MD->getOperand(0))->getValue())
                        ->getZExtValue();
     assert(Val <= 2 && "unknown vcall visibility!");
-    return (VCallVisibility)Val;
-  }
-  return VCallVisibility::VCallVisibilityPublic;
-}
 
-std::pair<uint64_t, uint64_t> GlobalObject::getVTableOffsetRange() const {
-  if (MDNode *MD = getMetadata(LLVMContext::MD_vcall_visibility)) {
+    uint64_t RangeStart = 0;
+    uint64_t RangeEnd = std::numeric_limits<uint64_t>::max();
     if (MD->getNumOperands() >= 3) {
-      uint64_t RangeStart =
-          cast<ConstantInt>(
+      RangeStart = cast<ConstantInt>(
                        cast<ConstantAsMetadata>(MD->getOperand(1))->getValue())
                        ->getZExtValue();
-      uint64_t RangeEnd =
-          cast<ConstantInt>(
+      RangeEnd = cast<ConstantInt>(
                      cast<ConstantAsMetadata>(MD->getOperand(2))->getValue())
                      ->getZExtValue();
-      return std::make_pair(RangeStart, RangeEnd);
     }
+
+    Result.push_back({VCallVisibility(Val), RangeStart, RangeEnd});
+  }
+
+  if (Result.empty()) {
+    Result.push_back({VCallVisibility::VCallVisibilityPublic, 0,
+                      std::numeric_limits<uint64_t>::max()});
   }
-  return std::make_pair(0, std::numeric_limits<uint64_t>::max());
+
+  return Result;
 }
 
 void Function::setSubprogram(DISubprogram *SP) {
   setMetadata(LLVMContext::MD_dbg, SP);
 }
 
 DISubprogram *Function::getSubprogram() const {
   return cast_or_null<DISubprogram>(getMetadata(LLVMContext::MD_dbg));

llvm/lib/IR/Verifier.cpp

if (MD->getNumOperands() == 3) {
       Assert(Op1Int.uge(0) && Op1Int.ult(std::numeric_limits<uint64_t>::max()),
              "bad !vcall_visibility attachment");
 
       Assert(isa<ConstantAsMetadata>(MD->getOperand(2)),
              "bad !vcall_visibility attachment");
       auto *Op2Val = cast<ConstantAsMetadata>(MD->getOperand(2))->getValue();
       Assert(isa<ConstantInt>(Op2Val), "bad !vcall_visibility attachment");
       auto Op2Int = cast<ConstantInt>(Op2Val)->getValue();
-      Assert(Op2Int.uge(0) && Op2Int.ult(std::numeric_limits<uint64_t>::max()),
+      Assert(Op2Int.uge(0) && Op2Int.ule(std::numeric_limits<uint64_t>::max()),
              "bad !vcall_visibility attachment");
 
       Assert(Op1Int.ule(Op2Int), "bad !vcall_visibility attachment");
     } else {
       Assert(MD->getNumOperands() == 1, "bad !vcall_visibility attachment");
     }
   }
 

llvm/lib/Transforms/IPO/GlobalDCE.cpp

if (Comdat *C = GV.getComdat()) {
     for (auto &&CM : make_range(ComdatMembers.equal_range(C))) {
       MarkLive(*CM.second, Updates); // Recursion depth is only two because only
                                      // globals in the same comdat are visited.
     }
   }
 }
 
 /// Recursively iterate over the (sub-)constants in the vtable and look for
-/// vptrs, if their offset is within [RangeStart..RangeEnd), add them to VFuncs.
+/// vptrs, if their offset is within ranges in List, add them to VFuncs.
 static void FindVirtualFunctionsInVTable(Module &M, Constant *C,
-                                         uint64_t RangeStart, uint64_t RangeEnd,
+                                         GlobalObject::VCallVisibilityList List,
                                          SmallPtrSet<GlobalValue *, 8> *VFuncs,
                                          uint64_t BaseOffset = 0) {
   if (auto *GV = dyn_cast<GlobalValue>(C)) {
     if (auto *F = dyn_cast<Function>(GV))
-      if (RangeStart <= BaseOffset && BaseOffset < RangeEnd)
+      for (auto Entry : List)
+        if (Entry.RangeStart <= BaseOffset && BaseOffset < Entry.RangeEnd)
           VFuncs->insert(F);
 
     // Do not recurse outside of the current global.
     return;
   }
 
   if (auto *S = dyn_cast<ConstantStruct>(C)) {
     StructType *STy = dyn_cast<StructType>(S->getType());
     const StructLayout *SL = M.getDataLayout().getStructLayout(STy);
     for (auto EI : llvm::enumerate(STy->elements())) {
       auto Offset = SL->getElementOffset(EI.index());
       unsigned Op = SL->getElementContainingOffset(Offset);
-      FindVirtualFunctionsInVTable(M, cast<Constant>(S->getOperand(Op)),
-                                   RangeStart, RangeEnd, VFuncs,
-                                   BaseOffset + Offset);
+      FindVirtualFunctionsInVTable(M, cast<Constant>(S->getOperand(Op)), List,
+                                   VFuncs, BaseOffset + Offset);
     }
   } else if (auto *A = dyn_cast<ConstantArray>(C)) {
     ArrayType *ATy = A->getType();
     auto EltSize = M.getDataLayout().getTypeAllocSize(ATy->getElementType());
     for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
-      FindVirtualFunctionsInVTable(M, cast<Constant>(A->getOperand(i)),
-                                   RangeStart, RangeEnd, VFuncs,
-                                   BaseOffset + EltSize * i);
+      FindVirtualFunctionsInVTable(M, cast<Constant>(A->getOperand(i)), List,
+                                   VFuncs, BaseOffset + EltSize * i);
     }
   } else {
     for (auto &Op : C->operands()) {
-      FindVirtualFunctionsInVTable(M, cast<Constant>(Op), RangeStart, RangeEnd,
-                                   VFuncs, BaseOffset);
+      FindVirtualFunctionsInVTable(M, cast<Constant>(Op), List, VFuncs,
+                                   BaseOffset);
     }
   }
 }
 
 void GlobalDCEPass::ScanVTables(Module &M) {
   SmallVector<MDNode *, 2> Types;
   LLVM_DEBUG(dbgs() << "Building type info -> vtable map\n");
 
for (MDNode *Type : Types) {
 
       TypeIdMap[TypeID].insert(std::make_pair(&GV, Offset));
     }
 
     // If the type corresponding to the vtable is private to this translation
     // unit, we know that we can see all virtual functions which might use it,
     // so VFE is safe.
     if (auto GO = dyn_cast<GlobalObject>(&GV)) {
-      GlobalObject::VCallVisibility TypeVis = GO->getVCallVisibility();
+      GlobalObject::VCallVisibilityList List = GO->getVCallVisibility();
+
+      // FIXME: For now, find the maximum visibility from all !vcall_visibility
+      // attachments, and conservatively treat all ranges with that visibility.
+      GlobalObject::VCallVisibility TypeVis =
+          GlobalObject::VCallVisibilityTranslationUnit;
+      for (auto Entry : List) {
+        TypeVis = std::min(TypeVis, Entry.Visibility);
+      }
+      if (List.empty())
+        TypeVis = GlobalObject::VCallVisibilityPublic;
+
       if (TypeVis == GlobalObject::VCallVisibilityTranslationUnit ||
           (LTOPostLink &&
            TypeVis == GlobalObject::VCallVisibilityLinkageUnit)) {
         LLVM_DEBUG(dbgs() << GV.getName() << " is safe for VFE\n");
 
-        // Find and record all the vfunctions that are within the offset range
-        // specified in the !vcall_visibility attribute.
-        auto Range = GO->getVTableOffsetRange();
+        // Find and record all the vfunctions that are within the offset ranges
+        // specified in the !vcall_visibility attributes.
         SmallPtrSet<GlobalValue *, 8> VFuncs;
-        FindVirtualFunctionsInVTable(M, GV.getInitializer(), std::get<0>(Range),
-                                     std::get<1>(Range), &VFuncs);
+        FindVirtualFunctionsInVTable(M, GV.getInitializer(), List, &VFuncs);
         VFESafeVTablesAndFns[&GV] = VFuncs;
       }
     }
   }
 }
 
 void GlobalDCEPass::ScanVTableLoad(Function *Caller, Metadata *TypeId,
                                    uint64_t CallOffset) {

llvm/lib/Transforms/IPO/GlobalSplit.cpp

for (MDNode *Type : Types) {
       SplitGV->addMetadata(
           LLVMContext::MD_type,
           *MDNode::get(GV.getContext(),
                        {ConstantAsMetadata::get(
                             ConstantInt::get(Int32Ty, ByteOffset - SplitBegin)),
                         Type->getOperand(1)}));
     }
 
-    if (GV.hasMetadata(LLVMContext::MD_vcall_visibility))
-      SplitGV->setVCallVisibilityMetadata(GV.getVCallVisibility());
+    if (GV.hasMetadata(LLVMContext::MD_vcall_visibility)) {
+      GlobalObject::VCallVisibilityList List = GV.getVCallVisibility();
+
+      // Find the maximum visibility from all !vcall_visibility
+      GlobalObject::VCallVisibility TypeVis =
+          GlobalObject::VCallVisibilityTranslationUnit;
+      for (auto Entry : List) {
+        TypeVis = std::min(TypeVis, Entry.Visibility);
+      }
+      if (List.empty())
+        TypeVis = GlobalObject::VCallVisibilityPublic;
+
+      SplitGV->setVCallVisibility(
+          {{TypeVis, 0, std::numeric_limits<uint64_t>::max()}});
+    }
   }
 
   for (User *U : GV.users()) {
     auto *GEP = cast<GEPOperator>(U);
     unsigned I = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue();
     if (I >= SplitGlobals.size())
       continue;
 

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

 /// If whole program visibility asserted, then upgrade all public vcall
 /// visibility metadata on vtable definitions to linkage unit visibility in
 /// Module IR (for regular or hybrid LTO).
 void updateVCallVisibilityInModule(
     Module &M, bool WholeProgramVisibilityEnabledInLTO,
     const DenseSet<GlobalValue::GUID> &DynamicExportSymbols) {
   if (!hasWholeProgramVisibility(WholeProgramVisibilityEnabledInLTO))
     return;
-  for (GlobalVariable &GV : M.globals())
+  for (GlobalVariable &GV : M.globals()) {
     // Add linkage unit visibility to any variable with type metadata, which are
     // the vtable definitions. We won't have an existing vcall_visibility
     // metadata on vtable definitions with public visibility.
-    if (GV.hasMetadata(LLVMContext::MD_type) &&
-        GV.getVCallVisibility() == GlobalObject::VCallVisibilityPublic &&
-        // Don't upgrade the visibility for symbols exported to the dynamic
-        // linker, as we have no information on their eventual use.
-        !DynamicExportSymbols.count(GV.getGUID()))
-      GV.setVCallVisibilityMetadata(GlobalObject::VCallVisibilityLinkageUnit);
+    GlobalObject::VCallVisibilityList List = GV.getVCallVisibility();
+    if (GV.hasMetadata(LLVMContext::MD_type) && !List.empty()) {
+      for (auto &Entry : List) {
+        if (Entry.Visibility == GlobalObject::VCallVisibilityPublic &&
+            !DynamicExportSymbols.count(GV.getGUID())) {
+          Entry.Visibility = GlobalObject::VCallVisibilityLinkageUnit;
+        }
+      }
+      GV.setVCallVisibility(List);
+    }
+  }
 }
 
 /// If whole program visibility asserted, then upgrade all public vcall
 /// visibility metadata on vtable definition summaries to linkage unit
 /// visibility in Module summary index (for ThinLTO).
 void updateVCallVisibilityInIndex(
     ModuleSummaryIndex &Index, bool WholeProgramVisibilityEnabledInLTO,
     const DenseSet<GlobalValue::GUID> &DynamicExportSymbols) {

 
 bool DevirtModule::tryFindVirtualCallTargets(
     std::vector<VirtualCallTarget> &TargetsForSlot,
     const std::set<TypeMemberInfo> &TypeMemberInfos, uint64_t ByteOffset) {
   for (const TypeMemberInfo &TM : TypeMemberInfos) {
     if (!TM.Bits->GV->isConstant())
       return false;
 
+    GlobalObject::VCallVisibilityList List = TM.Bits->GV->getVCallVisibility();
+    // Find the maximum visibility from all !vcall_visibility
+    GlobalObject::VCallVisibility TypeVis =
+        GlobalObject::VCallVisibilityTranslationUnit;
+    for (auto Entry : List) {
+      TypeVis = std::min(TypeVis, Entry.Visibility);
+    }
+    if (List.empty())
+      TypeVis = GlobalObject::VCallVisibilityPublic;
+
     // We cannot perform whole program devirtualization analysis on a vtable
     // with public LTO visibility.
-    if (TM.Bits->GV->getVCallVisibility() ==
-        GlobalObject::VCallVisibilityPublic)
+    if (TypeVis == GlobalObject::VCallVisibilityPublic)
       return false;
 
     Constant *Ptr = getPointerAtOffset(TM.Bits->GV->getInitializer(),
                                        TM.Offset + ByteOffset, M);
     if (!Ptr)
       return false;
 
     auto Fn = dyn_cast<Function>(Ptr->stripPointerCasts());

llvm/test/Transforms/GlobalDCE/virtual-functions-ranges.ll

 }, align 8, !type !{i64 0, !"vfunc1.type"}, !type !{i64 4, !"vfunc2.type"}, !vcall_visibility !{i64 2, i64 0, i64 8}
 
 ; CHECK:      @vtableD = internal unnamed_addr constant { i32, i32, i8* } {
 ; CHECK-SAME:   i32 trunc (i64 sub (i64 ptrtoint (void ()* @vfunc1_live              to i64), i64 ptrtoint ({ i32, i32, i8* }* @vtableD to i64)) to i32),
 ; CHECK-SAME:   i32 0,
 ; CHECK-SAME:   i8* bitcast (void ()* @regular_non_virtual_funcD to i8*)
 ; CHECK-SAME: }, align 8
 
+; A vtable that contains multiple ranges.
+@vtableE = internal unnamed_addr constant { [6 x i8*] } { [6 x i8*] [
+  i8* bitcast (void ()* @regular_non_virtual_funcE1 to i8*),
+  i8* bitcast (void ()* @vfunc1_live to i8*),
+  i8* bitcast (void ()* @vfunc2_dead to i8*),
+  i8* bitcast (void ()* @regular_non_virtual_funcE2 to i8*),
+  i8* bitcast (void ()* @vfunc3_live to i8*),
+  i8* bitcast (void ()* @vfunc4_dead to i8*)
+]}, align 8, !type !{i64 8, !"vfunc1.type"}, !type !{i64 16, !"vfunc2.type"}, !type !{i64 32, !"vfunc3.type"}, !type !{i64 40, !"vfunc4.type"},
+  !vcall_visibility !{i64 2, i64 8, i64 24}, !vcall_visibility !{i64 2, i64 32, i64 48}
+
+; CHECK:      @vtableE = internal unnamed_addr constant { [6 x i8*] } { [6 x i8*] [
+; CHECK-SAME:   i8* bitcast (void ()* @regular_non_virtual_funcE1 to i8*),
+; CHECK-SAME:   i8* bitcast (void ()* @vfunc1_live to i8*),
+; CHECK-SAME:   i8* null,
+; CHECK-SAME:   i8* bitcast (void ()* @regular_non_virtual_funcE2 to i8*),
+; CHECK-SAME:   i8* bitcast (void ()* @vfunc3_live to i8*),
+; CHECK-SAME:   i8* null
+; CHECK-SAME: ] }, align 8
+
 ; (1) vfunc1_live is referenced from @main, stays alive
 define internal void @vfunc1_live() {
   ; CHECK: define internal void @vfunc1_live(
   ret void
 }
 
 ; (2) vfunc2_dead is never referenced, gets removed and vtable slot is null'd
 define internal void @vfunc2_dead() {
   ; CHECK-NOT: define internal void @vfunc2_dead(
   ret void
 }
 
+define internal void @vfunc3_live() {
+  ; CHECK: define internal void @vfunc3_live(
+  ret void
+}
+
+define internal void @vfunc4_dead() {
+  ; CHECK-NOT: define internal void @vfunc4_dead(
+  ret void
+}
+
 ; (3) not using a range in !vcall_visibility, global gets removed
 define internal void @regular_non_virtual_funcA() {
   ; CHECK-NOT: define internal void @regular_non_virtual_funcA(
   ret void
 }
 
 ; (4) using a range in !vcall_visibility, pointer is outside of range, so should
 ; stay alive

 
 ; (6) using a range in !vcall_visibility, pointer is outside of range, so should
 ; stay alive
 define internal void @regular_non_virtual_funcD() {
   ; CHECK: define internal void @regular_non_virtual_funcD(
   ret void
 }
 
+define internal void @regular_non_virtual_funcE1() {
+  ; CHECK: define internal void @regular_non_virtual_funcE1(
+  ret void
+}
+
+define internal void @regular_non_virtual_funcE2() {
+  ; CHECK: define internal void @regular_non_virtual_funcE2(
+  ret void
+}
+
 define void @main() {
   %1 = ptrtoint { [3 x i8*] }* @vtableA to i64 ; to keep @vtableA alive
   %2 = ptrtoint { [3 x i8*] }* @vtableB to i64 ; to keep @vtableB alive
   %3 = ptrtoint { [3 x i8*] }* @vtableC to i64 ; to keep @vtableC alive
   %4 = ptrtoint { i32, i32, i8* }* @vtableD to i64 ; to keep @vtableD alive
-  %5 = tail call { i8*, i1 } @llvm.type.checked.load(i8* null, i32 0, metadata !"vfunc1.type")
+  %5 = ptrtoint { [6 x i8*] }* @vtableE to i64 ; to keep @vtableE alive
+  %6 = tail call { i8*, i1 } @llvm.type.checked.load(i8* null, i32 0, metadata !"vfunc1.type")
+  %7 = tail call { i8*, i1 } @llvm.type.checked.load(i8* null, i32 0, metadata !"vfunc3.type")
   ret void
 }
 
 !999 = !{i32 1, !"Virtual Function Elim", i32 1}
 !llvm.module.flags = !{!999}

llvm/test/Transforms/GlobalSplit/basic.ll

define void @foo() {
   ret void
 }
 
 declare i1 @llvm.type.test(i8*, metadata) nounwind readnone
 
 ; CHECK: [[T1]] = !{i32 0, !"foo"}
 ; CHECK: [[T2]] = !{i32 15, !"bar"}
 ; CHECK: [[T3]] = !{i32 16, !"a"}
-; CHECK: [[VIS]] = !{i64 2}
+; CHECK: [[VIS]] = !{i64 2, i64 0, i64 -1}
 ; CHECK: [[T4]] = !{i32 1, !"b"}
 ; CHECK: [[T5]] = !{i32 8, !"c"}
 !0 = !{i32 0, !"foo"}
 !1 = !{i32 15, !"bar"}
 !2 = !{i32 16, !"a"}
 !3 = !{i32 17, !"b"}
 !4 = !{i32 24, !"c"}
 !5 = !{i64 2}