[WPD/VFE] Always emit vcall_visibility metadata for -fwhole-program-vtables

[tejohnson]

Summary

First patch to support Safe Whole Program Devirtualization Enablement,
see RFC here: http://lists.llvm.org/pipermail/llvm-dev/2019-December/137543.html

Always emit !vcall_visibility metadata under -fwhole-program-vtables,
and not just for -fvirtual-function-elimination. The vcall visibility
metadata will (in a subsequent patch) be used to communicate to WPD
which vtables are safe to devirtualize, and we will optionally convert
the metadata to hidden visibility at link time. Subsequent follow on
patches will help enable this by adding vcall_visibility metadata to the
ThinLTO summaries, and always emit type test intrinsics under
-fwhole-program-vtables (and not just for vtables with hidden
visibility).

In order to do this safely with VFE, since for VFE all vtable loads must
be type checked loads which will no longer be the case, this patch adds
a new "Virtual Function Elim" module flag to communicate to GlobalDCE
whether to perform VFE using the vcall_visibility metadata.

One additional advantage of using the vcall_visibility metadata to drive
more WPD at LTO link time is that we can use the same mechanism to
enable more aggressive VFE at LTO link time as well. The link time
option proposed in the RFC will convert vcall_visibility metadata to
hidden (aka linkage unit visibility), which combined with
-fvirtual-function-elimination will allow it to be done more
aggressively at LTO link time under the same conditions.

[tejohnson]

llvm/lib/IR/Metadata.cpp

1506

The erasing of old metadata is needed to enable upgrading the visibility to hidden (linkage unit) in a subsequent patch. Made that change here as well as the associated rename of the method to try to contain the main vcall visibility metadata changes in a single patch.

[evgeny777]

Looks good at first sight. Do you have linker patch for me to try this out?

[tejohnson]

In D71907#1797218, @evgeny777 wrote:

Looks good at first sight. Do you have linker patch for me to try this out?

The linker changes are in D71913. This one should be a noop by itself (other than just getting the additional metadata). You need all three (this one, D71911 and D71913) to implement the RFC.

[tejohnson]

Rebase

[evgeny777]

clang/lib/CodeGen/ItaniumCXXABI.cpp

676 ↗

(On Diff #238561)

Why are we checking for hidden visibility here?

[tejohnson]

clang/lib/CodeGen/ItaniumCXXABI.cpp

676 ↗

(On Diff #238561)

This one is leftover from an earlier attempt at doing something more clever during GlobalOpt to decide whether we should be doing VFE or not, and I eventually abandoned that as it didn't work well, and went with the module flag here. You're right that we should be emitting the type test here under WholeProgramVtables, and not just with hidden visibility, but that belongs in D71913 (where I make the other change to insert type tests without hidden visibility). I've removed this change from this patch and am going to add it along with a test to that later patch.

[tejohnson]

Remove stale change that didn't belong here.

[evgeny777]

llvm/lib/Transforms/IPO/GlobalSplit.cpp

116

I think this needs a test. Removal of this code doesn't break anything

[tejohnson]

llvm/lib/Transforms/IPO/GlobalSplit.cpp

116

Adding some checking in a GlobalSplit test.

[tejohnson]

Test GlobalSplit handling of vcall_visibility metadata

[evgeny777]

LGTM

clang/lib/CodeGen/CGVTables.cpp

for (unsigned I = 0; I != Comps.size(); ++I) {
       llvm::Metadata *MD = CreateMetadataIdentifierForVirtualMemPtrType(
           Context.getMemberPointerType(
               Comps[I].getFunctionDecl()->getType(),
               Context.getRecordType(AP.first).getTypePtr()));
       VTable->addTypeMetadata((PointerWidth * I).getQuantity(), MD);
     }
   }
 
-  if (getCodeGenOpts().VirtualFunctionElimination) {
+  if (getCodeGenOpts().VirtualFunctionElimination ||
+      getCodeGenOpts().WholeProgramVTables) {
     llvm::GlobalObject::VCallVisibility TypeVis = GetVCallVisibilityLevel(RD);
     if (TypeVis != llvm::GlobalObject::VCallVisibilityPublic)
-      VTable->addVCallVisibilityMetadata(TypeVis);
+      VTable->setVCallVisibilityMetadata(TypeVis);
   }
 }

clang/lib/CodeGen/CodeGenModule.cpp

if (   Arch == llvm::Triple::arm
     getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
   }
 
   if (CodeGenOpts.SanitizeCfiCrossDso) {
     // Indicate that we want cross-DSO control flow integrity checks.
     getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
   }
 
+  if (CodeGenOpts.WholeProgramVTables) {
+    // Indicate whether VFE was enabled for this module, so that the
+    // vcall_visibility metadata added under whole program vtables is handled
+    // appropriately in the optimizer.
+    getModule().addModuleFlag(llvm::Module::Error, "Virtual Function Elim",
+                              CodeGenOpts.VirtualFunctionElimination);
+  }
+
   if (LangOpts.Sanitize.has(SanitizerKind::CFIICall)) {
     getModule().addModuleFlag(llvm::Module::Override,
                               "CFI Canonical Jump Tables",
                               CodeGenOpts.SanitizeCfiCanonicalJumpTables);
   }
 
   if (CodeGenOpts.CFProtectionReturn &&
       Target.checkCFProtectionReturnSupported(getDiags())) {

clang/test/CodeGenCXX/vcall-visibility-metadata.cpp

-// RUN: %clang_cc1 -flto -flto-unit -triple x86_64-unknown-linux -emit-llvm -fvirtual-function-elimination -fwhole-program-vtables -o - %s | FileCheck %s
+// RUN: %clang_cc1 -flto -flto-unit -triple x86_64-unknown-linux -emit-llvm -fvirtual-function-elimination -fwhole-program-vtables -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-VFE
+// RUN: %clang_cc1 -flto -flto-unit -triple x86_64-unknown-linux -emit-llvm -fwhole-program-vtables -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOVFE
 
 
 // Anonymous namespace.
 namespace {
 // CHECK: @_ZTVN12_GLOBAL__N_11AE = {{.*}} !vcall_visibility [[VIS_TU:![0-9]+]]
 struct A {
   A() {}
   virtual int f() { return 1; }
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}
+// CHECK-VFE-DAG: !{i32 1, !"Virtual Function Elim", i32 1}
+// CHECK-NOVFE-DAG: !{i32 1, !"Virtual Function Elim", i32 0}

llvm/include/llvm/IR/GlobalObject.h

public:
   ///
   /// \returns true if any metadata was removed.
   bool eraseMetadata(unsigned KindID);
 
   /// Copy metadata from Src, adjusting offsets by Offset.
   void copyMetadata(const GlobalObject *Src, unsigned Offset);
 
   void addTypeMetadata(unsigned Offset, Metadata *TypeID);
-  void addVCallVisibilityMetadata(VCallVisibility Visibility);
+  void setVCallVisibilityMetadata(VCallVisibility Visibility);
   VCallVisibility getVCallVisibility() const;
 
 protected:
   void copyAttributesFrom(const GlobalObject *Src);
 
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {

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::addVCallVisibilityMetadata(VCallVisibility Visibility) {
+void GlobalObject::setVCallVisibilityMetadata(VCallVisibility 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))}));
 }
 
 GlobalObject::VCallVisibility GlobalObject::getVCallVisibility() const {
   if (MDNode *MD = getMetadata(LLVMContext::MD_vcall_visibility)) {

llvm/lib/Transforms/IPO/GlobalDCE.cpp

for (auto U : TypeCheckedLoadFunc->users()) {
     }
   }
 }
 
 void GlobalDCEPass::AddVirtualFunctionDependencies(Module &M) {
   if (!ClEnableVFE)
     return;
 
+  // If the Virtual Function Elim module flag is present and set to zero, then
+  // the vcall_visibility metadata was inserted for another optimization (WPD)
+  // and we may not have type checked loads on all accesses to the vtable.
+  // Don't attempt VFE in that case.
+  auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
+      M.getModuleFlag("Virtual Function Elim"));
+  if (!Val || Val->getZExtValue() == 0)
+    return;
+
   ScanVTables(M);
 
   if (VFESafeVTables.empty())
     return;
 
   ScanTypeCheckedLoadIntrinsics(M);
 
   LLVM_DEBUG(

llvm/lib/Transforms/IPO/GlobalSplit.cpp

for (MDNode *Type : Types) {
         continue;
       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());
   }
 
   for (User *U : GV.users()) {
     auto *GEP = cast<GEPOperator>(U);
     unsigned I = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue();
     if (I >= SplitGlobals.size())
       continue;
 

llvm/test/Transforms/GlobalDCE/virtual-functions-base-call.ll

entry:
   %2 = extractvalue { i8*, i1 } %1, 0, !nosanitize !10
   %3 = bitcast i8* %2 to i32 (%struct.A*)*, !nosanitize !10
   %call = tail call i32 %3(%struct.A* %p)
   ret i32 %call
 }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata) #2
 
+!llvm.module.flags = !{!5}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFivE.virtual"}
 !2 = !{i64 2}
 !3 = !{i64 16, !"_ZTS1B"}
 !4 = !{i64 16, !"_ZTSM1BFivE.virtual"}
+!5 = !{i32 1, !"Virtual Function Elim", i32 1}
 !10 = !{}

llvm/test/Transforms/GlobalDCE/virtual-functions-base-pointer-call.ll

 memptr.end:                                       ; preds = %memptr.nonvirtual, %memptr.virtual
   %8 = phi i32 (%struct.A*, i32)* [ %memptr.virtualfn, %memptr.virtual ], [ %memptr.nonvirtualfn, %memptr.nonvirtual ]
   %call = tail call i32 %8(%struct.A* %this.adjusted, i32 42)
   ret i32 %call
 }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata)
 
+!llvm.module.flags = !{!7}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFiiE.virtual"}
 !2 = !{i64 24, !"_ZTSM1AFifE.virtual"}
 !3 = !{i64 2}
 !4 = !{i64 16, !"_ZTS1B"}
 !5 = !{i64 16, !"_ZTSM1BFiiE.virtual"}
 !6 = !{i64 24, !"_ZTSM1BFifE.virtual"}
+!7 = !{i32 1, !"Virtual Function Elim", i32 1}
 !12 = !{}

llvm/test/Transforms/GlobalDCE/virtual-functions-derived-call.ll

entry:
   %2 = extractvalue { i8*, i1 } %1, 0, !nosanitize !10
   %3 = bitcast i8* %2 to i32 (%struct.B*)*, !nosanitize !10
   %call = tail call i32 %3(%struct.B* %p)
   ret i32 %call
 }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata) #2
 
+!llvm.module.flags = !{!5}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFivE.virtual"}
 !2 = !{i64 2}
 !3 = !{i64 16, !"_ZTS1B"}
 !4 = !{i64 16, !"_ZTSM1BFivE.virtual"}
+!5 = !{i32 1, !"Virtual Function Elim", i32 1}
 !10 = !{}

llvm/test/Transforms/GlobalDCE/virtual-functions-derived-pointer-call.ll

 memptr.end:                                       ; preds = %memptr.nonvirtual, %memptr.virtual
   %8 = phi i32 (%struct.B*, i32)* [ %memptr.virtualfn, %memptr.virtual ], [ %memptr.nonvirtualfn, %memptr.nonvirtual ]
   %call = tail call i32 %8(%struct.B* %this.adjusted, i32 42)
   ret i32 %call
 }
 
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata)
 
+!llvm.module.flags = !{!7}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFiiE.virtual"}
 !2 = !{i64 24, !"_ZTSM1AFifE.virtual"}
 !3 = !{i64 2}
 !4 = !{i64 16, !"_ZTS1B"}
 !5 = !{i64 16, !"_ZTSM1BFiiE.virtual"}
 !6 = !{i64 24, !"_ZTSM1BFifE.virtual"}
+!7 = !{i32 1, !"Virtual Function Elim", i32 1}
 !12 = !{}

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

+; Tests that VFE is not performed when the Virtual Function Elim metadata set
+; to 0. This is the same as virtual-functions.ll otherwise.
 ; RUN: opt < %s -globaldce -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare dso_local noalias nonnull i8* @_Znwm(i64)
 declare { i8*, i1 } @llvm.type.checked.load(i8*, i32, metadata)
 
 ; %struct.A is a C++ struct with two virtual functions, A::foo and A::bar. The
 ; !vcall_visibility metadata is set on the vtable, so we know that all virtual
 ; calls through this vtable are visible and use the @llvm.type.checked.load
 ; intrinsic. Function test_A makes a call to A::foo, but there is no call to
 ; A::bar anywhere, so A::bar can be deleted, and its vtable slot replaced with
 ; null.
+; However, with the metadata set to 0 we should not perform this VFE.
 
 %struct.A = type { i32 (...)** }
 
-; The pointer to A::bar in the vtable can be removed, because it will never be
-; loaded. We replace it with null to keep the layout the same. Because it is at
-; the end of the vtable we could potentially shrink the vtable, but don't
-; currently do that.
-; CHECK: @_ZTV1A = internal unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* null, i8* bitcast (i32 (%struct.A*)* @_ZN1A3fooEv to i8*), i8* null] }
+; We should retain @_ZN1A3barEv in the vtable.
+; CHECK: @_ZTV1A = internal unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* null, i8* bitcast (i32 (%struct.A*)* @_ZN1A3fooEv to i8*), i8* bitcast (i32 (%struct.A*)* @_ZN1A3barEv to i8*)] }
 @_ZTV1A = internal unnamed_addr constant { [4 x i8*] } { [4 x i8*] [i8* null, i8* null, i8* bitcast (i32 (%struct.A*)* @_ZN1A3fooEv to i8*), i8* bitcast (i32 (%struct.A*)* @_ZN1A3barEv to i8*)] }, align 8, !type !0, !type !1, !type !2, !vcall_visibility !3
 
 ; A::foo is called, so must be retained.
 ; CHECK: define internal i32 @_ZN1A3fooEv(
 define internal i32 @_ZN1A3fooEv(%struct.A* nocapture readnone %this) {
 entry:
   ret i32 42
 }
 
-; A::bar is not used, so can be deleted.
-; CHECK-NOT: define internal i32 @_ZN1A3barEv(
+; A::bar is not used, so can be deleted with VFE, however, we should not be
+; performing that elimination here.
+; CHECK: define internal i32 @_ZN1A3barEv(
 define internal i32 @_ZN1A3barEv(%struct.A* nocapture readnone %this) {
 entry:
   ret i32 1337
 }
 
 define dso_local i32 @test_A() {
 entry:
   %call = tail call i8* @_Znwm(i64 8)
   %0 = bitcast i8* %call to %struct.A*
   %1 = bitcast i8* %call to i32 (...)***
   store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV1A, i64 0, inrange i32 0, i64 2) to i32 (...)**), i32 (...)*** %1, align 8
   %2 = tail call { i8*, i1 } @llvm.type.checked.load(i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV1A, i64 0, inrange i32 0, i64 2) to i8*), i32 0, metadata !"_ZTS1A"), !nosanitize !9
   %3 = extractvalue { i8*, i1 } %2, 0, !nosanitize !9
   %4 = bitcast i8* %3 to i32 (%struct.A*)*, !nosanitize !9
   %call1 = tail call i32 %4(%struct.A* nonnull %0)
   ret i32 %call1
 }
 
+!llvm.module.flags = !{!4}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFivE.virtual"}
 !2 = !{i64 24, !"_ZTSM1AFivE.virtual"}
 !3 = !{i64 2}
+!4 = !{i32 1, !"Virtual Function Elim", i32 0}
 !9 = !{}

llvm/test/Transforms/GlobalDCE/virtual-functions-visibility-post-lto.ll

entry:
   %call = tail call i8* @_Znwm(i64 8)
   %0 = bitcast i8* %call to %struct.C*
   tail call void @_ZN1CC2Ev(%struct.C* %0)
   ret i8* %call
 }
 
 declare dso_local noalias nonnull i8* @_Znwm(i64)
 
-!llvm.module.flags = !{!5}
+!llvm.module.flags = !{!5, !6}
 
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFvvE.virtual"}
 !2 = !{i64 0} ; public vcall visibility
 !3 = !{i64 1} ; linkage-unit vcall visibility
 !4 = !{i64 2} ; translation-unit vcall visibility
 !5 = !{i32 1, !"LTOPostLink", i32 1}
+!6 = !{i32 1, !"Virtual Function Elim", i32 1}

llvm/test/Transforms/GlobalDCE/virtual-functions-visibility-pre-lto.ll

entry:
   %call = tail call i8* @_Znwm(i64 8)
   %0 = bitcast i8* %call to %struct.C*
   tail call void @_ZN1CC2Ev(%struct.C* %0)
   ret i8* %call
 }
 
 declare dso_local noalias nonnull i8* @_Znwm(i64)
 
-!llvm.module.flags = !{}
+!llvm.module.flags = !{!5}
 
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFvvE.virtual"}
 !2 = !{i64 0} ; public vcall visibility
 !3 = !{i64 1} ; linkage-unit vcall visibility
 !4 = !{i64 2} ; translation-unit vcall visibility
+!5 = !{i32 1, !"Virtual Function Elim", i32 1}

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

entry:
   store i32 (...)** bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV1A, i64 0, inrange i32 0, i64 2) to i32 (...)**), i32 (...)*** %1, align 8
   %2 = tail call { i8*, i1 } @llvm.type.checked.load(i8* bitcast (i8** getelementptr inbounds ({ [4 x i8*] }, { [4 x i8*] }* @_ZTV1A, i64 0, inrange i32 0, i64 2) to i8*), i32 0, metadata !"_ZTS1A"), !nosanitize !9
   %3 = extractvalue { i8*, i1 } %2, 0, !nosanitize !9
   %4 = bitcast i8* %3 to i32 (%struct.A*)*, !nosanitize !9
   %call1 = tail call i32 %4(%struct.A* nonnull %0)
   ret i32 %call1
 }
 
+!llvm.module.flags = !{!4}
+
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFivE.virtual"}
 !2 = !{i64 24, !"_ZTSM1AFivE.virtual"}
 !3 = !{i64 2}
+!4 = !{i32 1, !"Virtual Function Elim", i32 1}
 !9 = !{}

llvm/test/Transforms/GlobalDCE/vtable-rtti.ll

entry:
   tail call void @_ZN1AC2Ev(%struct.A* %0)
   ret i8* %call
 }
 
 
 declare dso_local noalias nonnull i8* @_Znwm(i64)
 @_ZTVN10__cxxabiv117__class_type_infoE = external dso_local global i8*
 
-!llvm.module.flags = !{!3}
+!llvm.module.flags = !{!3, !4}
 
 !0 = !{i64 16, !"_ZTS1A"}
 !1 = !{i64 16, !"_ZTSM1AFvvE.virtual"}
 !2 = !{i64 2} ; translation-unit vcall visibility
 !3 = !{i32 1, !"LTOPostLink", i32 1}
+!4 = !{i32 1, !"Virtual Function Elim", i32 1}

llvm/test/Transforms/GlobalSplit/basic.ll

 ; RUN: opt -S -globalsplit %s | FileCheck %s
 ; RUN: opt -S -passes=globalsplit %s | FileCheck %s
 
 target datalayout = "e-p:64:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: @vtt = constant [3 x i8*] [i8* bitcast ([2 x i8* ()*]* @global.0 to i8*), i8* bitcast (i8* ()** getelementptr inbounds ([2 x i8* ()*], [2 x i8* ()*]* @global.0, i32 0, i32 1) to i8*), i8* bitcast ([1 x i8* ()*]* @global.1 to i8*)]
 @vtt = constant [3 x i8*] [
   i8* bitcast (i8* ()** getelementptr ({ [2 x i8* ()*], [1 x i8* ()*] }, { [2 x i8* ()*], [1 x i8* ()*] }* @global, i32 0, inrange i32 0, i32 0) to i8*),
   i8* bitcast (i8* ()** getelementptr ({ [2 x i8* ()*], [1 x i8* ()*] }, { [2 x i8* ()*], [1 x i8* ()*] }* @global, i32 0, inrange i32 0, i32 1) to i8*),
   i8* bitcast (i8* ()** getelementptr ({ [2 x i8* ()*], [1 x i8* ()*] }, { [2 x i8* ()*], [1 x i8* ()*] }* @global, i32 0, inrange i32 1, i32 0) to i8*)
 ]
 
 ; CHECK-NOT: @global =
-; CHECK: @global.0 = private constant [2 x i8* ()*] [i8* ()* @f1, i8* ()* @f2], !type [[T1:![0-9]+]], !type [[T2:![0-9]+]], !type [[T3:![0-9]+$]]
-; CHECK: @global.1 = private constant [1 x i8* ()*] [i8* ()* @f3], !type [[T4:![0-9]+]], !type [[T5:![0-9]+$]]
+; CHECK: @global.0 = private constant [2 x i8* ()*] [i8* ()* @f1, i8* ()* @f2], !type [[T1:![0-9]+]], !type [[T2:![0-9]+]], !type [[T3:![0-9]+]], !vcall_visibility [[VIS:![0-9]+$]]
+; CHECK: @global.1 = private constant [1 x i8* ()*] [i8* ()* @f3], !type [[T4:![0-9]+]], !type [[T5:![0-9]+]], !vcall_visibility [[VIS$]]
 ; CHECK-NOT: @global =
 @global = internal constant { [2 x i8* ()*], [1 x i8* ()*] } {
   [2 x i8* ()*] [i8* ()* @f1, i8* ()* @f2],
   [1 x i8* ()*] [i8* ()* @f3]
-}, !type !0, !type !1, !type !2, !type !3, !type !4
+}, !type !0, !type !1, !type !2, !type !3, !type !4, !vcall_visibility !5
 
 ; CHECK: define i8* @f1()
 define i8* @f1() {
   ; CHECK-NEXT: ret i8* bitcast ([2 x i8* ()*]* @global.0 to i8*)
   ret i8* bitcast (i8* ()** getelementptr ({ [2 x i8* ()*], [1 x i8* ()*] }, { [2 x i8* ()*], [1 x i8* ()*] }* @global, i32 0, inrange i32 0, i32 0) to i8*)
 }
 
 ; CHECK: define i8* @f2()
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: [[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}