[LowerTypeTests] Limit when icall jumptable entries are emitted

[vlad.tsyrklevich]

Summary

Currently LowerTypeTests emits jumptable entries for all live external
and address-taken functions; however, we could limit the number of
functions that we emit entries for significantly.

For Cross-DSO CFI, we continue to emit jumptable entries for all
exported definitions. In the non-Cross-DSO CFI case, we only need to
emit jumptable entries for live functions that are address-taken in live
functions. This ignores exported functions and functions that are only
address taken in dead functions. This change uses ThinLTO summary data
(now emitted for all modules during ThinLTO builds) to determine
address-taken and liveness info.

The logic for emitting jumptable entries is more conservative in the
regular LTO case because we don't have summary data in the case of
monolithic LTO builds; however, once summaries are emitted for all LTO
builds we can unify the Thin/monolithic LTO logic to only use summaries
to determine the liveness of address taking functions.

This change is a partial fix for PR37474. It reduces the build size for
nacl_helper by ~2-3%, the reduction is due to nacl_helper compiling in
lots of unused code and unused functions that are address taken in dead
functions no longer being being considered live due to emitted jumptable
references. The reduction for chromium is ~0.1-0.2%.

[pcc]

lib/Transforms/IPO/LowerTypeTests.cpp

1715

Wouldn't this apply not just to ExternalLinkage but to other non-local linkages?

1779

Use dyn_cast instead of isa to avoid needing the cast below.

1788

Same comment about ExternalLinkage.

test/Transforms/LowerTypeTests/function-ext.ll

10

With this change I don't think this test is testing what it is intended to test any more. Can you insert an artificial reference to foo?

[vlad.tsyrklevich]

• Address Peter's comments

[vlad.tsyrklevich]

lib/Transforms/IPO/LowerTypeTests.cpp

1715

You're right, I care that they're not exported, not that they're not external specifically.

test/Transforms/LowerTypeTests/function-ext.ll

10

If we address take @foo, then WASM32 @bar won't return false immediately. I've added tests that exercise both the addr-taken and non-addr-taken cases since WASM and X64 have similar behavior now.

[pcc]

LGTM

lib/Transforms/IPO/LowerTypeTests.cpp

1715

I might write this a little more straightforwardly as

if (GVS->isLive() && !GlobalValue::isLocalLinkage(GVS->linkage()))
  Exported = true;

include/llvm/IR/ModuleSummaryIndexYAML.h

static void mapping(IO &io, TypeIdSummary& summary) {
     io.mapOptional("TTRes", summary.TTRes);
     io.mapOptional("WPDRes", summary.WPDRes);
   }
 };
 
 struct FunctionSummaryYaml {
   unsigned Linkage;
   bool NotEligibleToImport, Live, IsLocal;
+  std::vector<uint64_t> Refs;
   std::vector<uint64_t> TypeTests;
   std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
       TypeCheckedLoadVCalls;
   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
       TypeCheckedLoadConstVCalls;
 };
 
 } // End yaml namespace

 namespace yaml {
 
 template <> struct MappingTraits<FunctionSummaryYaml> {
   static void mapping(IO &io, FunctionSummaryYaml& summary) {
     io.mapOptional("Linkage", summary.Linkage);
     io.mapOptional("NotEligibleToImport", summary.NotEligibleToImport);
     io.mapOptional("Live", summary.Live);
     io.mapOptional("Local", summary.IsLocal);
+    io.mapOptional("Refs", summary.Refs);
     io.mapOptional("TypeTests", summary.TypeTests);
     io.mapOptional("TypeTestAssumeVCalls", summary.TypeTestAssumeVCalls);
     io.mapOptional("TypeCheckedLoadVCalls", summary.TypeCheckedLoadVCalls);
     io.mapOptional("TypeTestAssumeConstVCalls",
                    summary.TypeTestAssumeConstVCalls);
     io.mapOptional("TypeCheckedLoadConstVCalls",
                    summary.TypeCheckedLoadConstVCalls);
   }
template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
     std::vector<FunctionSummaryYaml> FSums;
     io.mapRequired(Key.str().c_str(), FSums);
     uint64_t KeyInt;
     if (Key.getAsInteger(0, KeyInt)) {
       io.setError("key not an integer");
       return;
     }
-    auto P = V.emplace(KeyInt, /*IsAnalysis=*/false);
-    auto &Elem = (*P.first).second;
+    if (!V.count(KeyInt))
+      V.emplace(KeyInt, /*IsAnalysis=*/false);
+    auto &Elem = V.find(KeyInt)->second;
     for (auto &FSum : FSums) {
+      std::vector<ValueInfo> Refs;
+      for (auto &RefGUID : FSum.Refs) {
+        if (!V.count(RefGUID))
+          V.emplace(RefGUID, /*IsAnalysis=*/false);
+        Refs.push_back(ValueInfo(/*IsAnalysis=*/false, &*V.find(RefGUID)));
+      }
       Elem.SummaryList.push_back(llvm::make_unique<FunctionSummary>(
           GlobalValueSummary::GVFlags(
               static_cast<GlobalValue::LinkageTypes>(FSum.Linkage),
               FSum.NotEligibleToImport, FSum.Live, FSum.IsLocal),
-          0, FunctionSummary::FFlags{}, ArrayRef<ValueInfo>{},
+          0, FunctionSummary::FFlags{}, Refs,
           ArrayRef<FunctionSummary::EdgeTy>{}, std::move(FSum.TypeTests),
           std::move(FSum.TypeTestAssumeVCalls),
           std::move(FSum.TypeCheckedLoadVCalls),
           std::move(FSum.TypeTestAssumeConstVCalls),
           std::move(FSum.TypeCheckedLoadConstVCalls)));
     }
   }
   static void output(IO &io, GlobalValueSummaryMapTy &V) {
     for (auto &P : V) {
       std::vector<FunctionSummaryYaml> FSums;
       for (auto &Sum : P.second.SummaryList) {
-        if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get()))
+        if (auto *FSum = dyn_cast<FunctionSummary>(Sum.get())) {
+          std::vector<uint64_t> Refs;
+          for (auto &VI : FSum->refs())
+            Refs.push_back(VI.getGUID());
           FSums.push_back(FunctionSummaryYaml{
               FSum->flags().Linkage,
               static_cast<bool>(FSum->flags().NotEligibleToImport),
               static_cast<bool>(FSum->flags().Live),
-              static_cast<bool>(FSum->flags().DSOLocal), FSum->type_tests(),
-              FSum->type_test_assume_vcalls(), FSum->type_checked_load_vcalls(),
+              static_cast<bool>(FSum->flags().DSOLocal), Refs,
+              FSum->type_tests(), FSum->type_test_assume_vcalls(),
+              FSum->type_checked_load_vcalls(),
               FSum->type_test_assume_const_vcalls(),
               FSum->type_checked_load_const_vcalls()});
           }
+      }
       if (!FSums.empty())
         io.mapRequired(llvm::utostr(P.first).c_str(), FSums);
     }
   }
 };
 
 template <> struct MappingTraits<ModuleSummaryIndex> {
   static void mapping(IO &io, ModuleSummaryIndex& index) {

lib/Transforms/IPO/LowerTypeTests.cpp

bool LowerTypeTestsModule::lower() {
   struct TIInfo {
     unsigned UniqueId;
     std::vector<GlobalTypeMember *> RefGlobals;
   };
   DenseMap<Metadata *, TIInfo> TypeIdInfo;
   unsigned CurUniqueId = 0;
   SmallVector<MDNode *, 2> Types;
 
+  // Cross-DSO CFI emits jumptable entries for exported functions as well as
+  // address taken functions in case they are address taken in other modules.
+  const bool CrossDsoCfi = M.getModuleFlag("Cross-DSO CFI") != nullptr;
+
   struct ExportedFunctionInfo {
     CfiFunctionLinkage Linkage;
     MDNode *FuncMD; // {name, linkage, type[, type...]}
   };
   DenseMap<StringRef, ExportedFunctionInfo> ExportedFunctions;
   if (ExportSummary) {
+    // A set of all functions that are address taken by a live global object.
+    DenseSet<GlobalValue::GUID> AddressTaken;
+    for (auto &I : *ExportSummary)
+      for (auto &GVS : I.second.SummaryList)
+        if (GVS->isLive())
+          for (auto &Ref : GVS->refs())
+            AddressTaken.insert(Ref.getGUID());
+
     NamedMDNode *CfiFunctionsMD = M.getNamedMetadata("cfi.functions");
     if (CfiFunctionsMD) {
       for (auto FuncMD : CfiFunctionsMD->operands()) {
         assert(FuncMD->getNumOperands() >= 2);
         StringRef FunctionName =
             cast<MDString>(FuncMD->getOperand(0))->getString();
-        if (!ExportSummary->isGUIDLive(GlobalValue::getGUID(
-                GlobalValue::dropLLVMManglingEscape(FunctionName))))
-          continue;
         CfiFunctionLinkage Linkage = static_cast<CfiFunctionLinkage>(
             cast<ConstantAsMetadata>(FuncMD->getOperand(1))
                 ->getValue()
                 ->getUniqueInteger()
                 .getZExtValue());
+        const GlobalValue::GUID GUID = GlobalValue::getGUID(
+                GlobalValue::dropLLVMManglingEscape(FunctionName));
+        // Do not emit jumptable entries for functions that are not-live and
+        // have no live references (and are not external with cross-DSO CFI.)
+        if (!ExportSummary->isGUIDLive(GUID))
+          continue;
+        if (!AddressTaken.count(GUID)) {
+          if (!CrossDsoCfi || Linkage != CFL_Definition)
+            continue;
+
+          bool External = false;
+          if (auto VI = ExportSummary->getValueInfo(GUID))
+            for (auto &GVS : VI.getSummaryList())
+              if (GVS->isLive())
+                External |= GVS->linkage() == GlobalValue::ExternalLinkage;
+
+          if (!External)
+            continue;
+        }
         auto P = ExportedFunctions.insert({FunctionName, {Linkage, FuncMD}});
         if (!P.second && P.first->second.Linkage != CFL_Definition)
           P.first->second = {Linkage, FuncMD};
       }
 
       for (const auto &P : ExportedFunctions) {
         StringRef FunctionName = P.first;
         CfiFunctionLinkage Linkage = P.second.Linkage;
for (GlobalObject &GO : M.global_objects()) {
     if (isa<GlobalVariable>(GO) && GO.isDeclarationForLinker())
       continue;
 
     Types.clear();
     GO.getMetadata(LLVMContext::MD_type, Types);
 
     bool IsDefinition = !GO.isDeclarationForLinker();
     bool IsExported = false;
-    if (isa<Function>(GO) && ExportedFunctions.count(GO.getName())) {
+    if (isa<Function>(GO)) {
+      if (ExportedFunctions.count(GO.getName())) {
         IsDefinition |= ExportedFunctions[GO.getName()].Linkage == CFL_Definition;
         IsExported = true;
+      // TODO: The logic here checks only that the function is address taken,
+      // not that the address takers are live. This can be updated to check
+      // their liveness and emit fewer jumptable entries once monolithic LTO
+      // builds also emit summaries.
+      } else if (!cast<Function>(GO).hasAddressTaken()) {
+        if (!CrossDsoCfi || !IsDefinition || !GO.hasExternalLinkage())
+          continue;
+      }
     }
 
     auto *GTM =
         GlobalTypeMember::create(Alloc, &GO, IsDefinition, IsExported, Types);
     GlobalTypeMembers[&GO] = GTM;
     for (MDNode *Type : Types) {
       verifyTypeMDNode(&GO, Type);
       auto &Info = TypeIdInfo[Type->getOperand(1)];

test/LTO/Resolution/X86/export-jumptable.ll

define void @f1() !type !0 {
   ret void
 }
 
 ; CHECK: define internal void @f2()
 define void @f2() !type !1 {
   ret void
 }
 
-define i1 @_start(i8* %p) {
-  %1 = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
-  call void @f1()
-  call void @f2()
-  ret i1 %1
+define i1 @_start(i1 %i) {
+  %1 = select i1 %i, void ()* @f1, void ()* @f2
+  %2 = bitcast void ()* %1 to i8*
+  %3 = call i1 @llvm.type.test(i8* %2, metadata !"typeid1")
+  ret i1 %3
 }
 
 declare i1 @llvm.type.test(i8*, metadata)
 
 !0 = !{i64 0, !"typeid1"}
 !1 = !{i64 0, !"typeid2"}

test/ThinLTO/X86/cfi-icall.ll

 ; RUN: opt -thinlto-bc %s -o %t1.bc
 ; RUN: llvm-lto2 run  -thinlto-distributed-indexes %t1.bc -o %t.out -save-temps \
 ; RUN:   -r %t1.bc,foo,plx \
-; RUN:   -r %t1.bc,bar,x
+; RUN:   -r %t1.bc,bar,x \
+; RUN:   -r %t1.bc,addrtaken,px
 ; RUN: llvm-bcanalyzer -dump %t.out.index.bc | FileCheck %s --check-prefix=COMBINED
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i1 @foo(i8* %p) !type !0 {
 entry:
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ret i1 %x
 }
 
-declare !type !0 void @bar()
+declare !type !0 i1 @bar(i8*)
+
+; Functions must be address taken to have jump table entries emitted
+define void @addrtaken(i1 %i) {
+  %1 = select i1 %i, i1(i8*)* @foo, i1(i8*)* @bar
+  ret void
+}
 
 declare i1 @llvm.type.test(i8* %ptr, metadata %type) nounwind readnone
 
 !0 = !{i64 0, !"typeid1"}
 
 ; COMBINED:   <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED:     <CFI_FUNCTION_DEFS op0=0 op1=3/>
 ; COMBINED:     <CFI_FUNCTION_DECLS op0=3 op1=3/>
 ; COMBINED:     <TYPE_ID op0=6 op1=7 op2=4 op3=7 op4=0 op5=0 op6=0 op7=0/>
 ; COMBINED:   </GLOBALVAL_SUMMARY_BLOCK>
 
 ; COMBINED:      <STRTAB_BLOCK
 ; COMBINED-NEXT:   <BLOB abbrevid=4/> blob data = 'foobartypeid1'
 ; COMBINED-NEXT: </STRTAB_BLOCK>

test/Transforms/LowerTypeTests/Inputs/export-icall.yaml

+---
+GlobalValueMap:
+  42:
+    - Live: true
+      # guid("f"), guid("f2"), guid("f3"), guid("g"), guid("h"), guid("external"), guid("external_weak")
+      Refs: [14740650423002898831, 8471399308421654326, 4197650231481825559, 13146401226427987378, 8124147457056772133, 5224464028922159466, 5227079976482001346]
+      TypeTests: [14276520915468743435, 15427464259790519041] # guid("typeid1"), guid("typeid2")
+  14740650423002898831: # guid("f")
+    - Linkage: 0 # external
+      Live: true
+  8471399308421654326: # guid("f2")
+    - Linkage: 0 # external
+      Live: true
+  4197650231481825559: # guid("f3")
+    - Linkage: 0 # external
+      Live: true
+  13146401226427987378: # guid("g")
+    - Linkage: 0 # external
+      Live: true
+  8124147457056772133: # guid("h")
+    - Linkage: 0 # external
+      Live: true
+  5224464028922159466: # guid("external")
+    - Linkage: 0 # external
+      Live: true
+  5227079976482001346: # guid("external_weak")
+    - Linkage: 9 # extern_weak
+      Live: true
+...

test/Transforms/LowerTypeTests/Inputs/exported-funcs.yaml

+---
+GlobalValueMap:
+  42:
+    - Live: true
+      Refs: [16594175687743574550, 2415377257478301385] # guid("external_addrtaken"), guid("external_addrtaken2")
+      TypeTests: [14276520915468743435, 15427464259790519041] # guid("typeid1"), guid("typeid2")
+  5224464028922159466: # guid("external")
+    - Linkage: 0 # external
+      Live: true
+  16430208882958242304: # guid("external2")
+    - Linkage: 0 # external
+      Live: true
+  16594175687743574550: # guid("external_addrtaken")
+    - Linkage: 0 # external
+      Live: true
+  2415377257478301385: # guid("external_addrtaken2")
+    - Linkage: 0 # external
+      Live: true
+  15859245615183425489: # guid("internal")
+    - Linkage: 7 # internal
+      Live: true
+...

test/Transforms/LowerTypeTests/export-alias.ll

-; RUN: opt -S %s -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/use-typeid1-typeid2.yaml | FileCheck %s
+; RUN: opt -S %s -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/exported-funcs.yaml | FileCheck %s
 ;
-; CHECK: @alias1 = weak alias void (), void ()* @f
-; CHECK: @alias2 = hidden alias void (), void ()* @f
-; CHECK: declare !type !1 void @alias3()
+; CHECK: @alias1 = weak alias void (), void ()* @external_addrtaken
+; CHECK: @alias2 = hidden alias void (), void ()* @external_addrtaken
 ; CHECK-NOT: @alias3 = alias
+; CHECK-NOT: @not_present
 
 target triple = "x86_64-unknown-linux"
 
 !cfi.functions = !{!0, !2, !3}
 !aliases = !{!4, !5, !6}
 
-!0 = !{!"f", i8 0, !1}
+!0 = !{!"external_addrtaken", i8 0, !1}
 !1 = !{i64 0, !"typeid1"}
 !2 = !{!"alias1", i8 1, !1}
 ; alias2 not included here, this could happen if the only reference to alias2
 ; is in a module compiled without cfi-icall
 !3 = !{!"alias3", i8 1, !1}
-!4 = !{!"alias1", !"f", i8 0, i8 1}
-!5 = !{!"alias2", !"f", i8 1, i8 0}
+!4 = !{!"alias1", !"external_addrtaken", i8 0, i8 1}
+!5 = !{!"alias2", !"external_addrtaken", i8 1, i8 0}
 !6 = !{!"alias3", !"not_present", i8 0, i8 0}

test/Transforms/LowerTypeTests/export-cross-dso-cfi.ll

+; Test that external functions have jumptable entries emitted even if they are
+; not address-taken when Cross-DSO CFI is used, but not otherwise.
+
+; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/exported-funcs.yaml < %s | FileCheck --check-prefixes=CHECK,CROSSDSO %s
+; RUN: cat %s | grep -v "llvm.module.flags" | opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/exported-funcs.yaml | FileCheck --check-prefixes=CHECK,NORMAL %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+;;; Defined in the ThinLTO portion of the build (e.g. the summary)
+; CROSSDSO: declare !type !1 !type !2 void @external.cfi()
+; NORMAL: declare !type !1 !type !2 void @external()
+declare !type !1 !type !2 void @external()
+
+; Don't emit jumptable entries for external declarations/non-external definitions
+; CHECK-NOT: @external2
+; CHECK-NOT: @internal
+
+;;; Defined in the regular LTO portion of the build
+; CROSSDSO: define internal void @regularlto_external.cfi()
+; NORMAL: define void @regularlto_external()
+define void @regularlto_external() !type !1 !type !2 {
+  ret void
+}
+
+; CHECK: define internal void @regularlto_internal()
+define internal void @regularlto_internal() !type !1 !type !2 {
+  ret void
+}
+
+!cfi.functions = !{!0, !3, !4}
+!llvm.module.flags = !{!5}
+
+!0 = !{!"external", i8 0, !1, !2}
+!1 = !{i64 0, !"typeid1"}
+!2 = !{i64 0, i64 1234}
+!3 = !{!"external2", i8 1, !1, !2}
+!4 = !{!"internal", i8 0, !1, !2}
+!5 = !{i32 4, !"Cross-DSO CFI", i32 1}

test/Transforms/LowerTypeTests/export-icall.ll

-; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/use-typeid1-typeid2.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
+; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/export-icall.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
 ; RUN: FileCheck --check-prefix=SUMMARY %s < %t
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @h(i8 %x) !type !2 {
   ret void
 }

test/Transforms/LowerTypeTests/export-symver.ll

-; RUN: opt -S %s -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/use-typeid1-typeid2.yaml | FileCheck %s
+; RUN: opt -S %s -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/exported-funcs.yaml | FileCheck %s
 ;
-; CHECK: module asm ".symver exported_and_symver, alias1"
-; CHECK-NOT: .symver exported
-; CHECK-NOT: .symver symver
+; CHECK: module asm ".symver external_addrtaken, alias1"
+; CHECK-NOT: .symver external_addrtaken2
+; CHECK-NOT: .symver not_exported
 
 target triple = "x86_64-unknown-linux"
 
 !cfi.functions = !{!0, !1}
 !symvers = !{!3, !4}
 
-!0 = !{!"exported_and_symver", i8 2, !2}
-!1 = !{!"exported", i8 2, !2}
+!0 = !{!"external_addrtaken", i8 0, !2}
+!1 = !{!"external_addrtaken2", i8 0, !2}
 !2 = !{i64 0, !"typeid1"}
-!3 = !{!"exported_and_symver", !"alias1"}
-!4 = !{!"symver", !"alias2"}
+!3 = !{!"external_addrtaken", !"alias1"}
+!4 = !{!"not_exported", !"alias2"}

test/Transforms/LowerTypeTests/function-arm-thumb.ll

 define void @g2() "target-features"="-thumb-mode" !type !1 {
   ret void
 }
 
 define void @h2() "target-features"="-thumb-mode" !type !1 {
   ret void
 }
 
+declare void @takeaddr(void()*, void()*, void()*, void()*, void()*)
+define void @addrtaken() {
+  call void @takeaddr(void()* @f1, void()* @g1, void()* @f2, void()* @g2, void()* @h2)
+  ret void
+}
+
 !0 = !{i32 0, !"typeid1"}
 !1 = !{i32 0, !"typeid2"}
 
 ; CHECK: define private void {{.*}} #[[AT:.*]] align 4 {
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:  call void asm sideeffect "b.w $0\0Ab.w $1\0A", "s,s"(void ()* @f1.cfi, void ()* @g1.cfi)
 ; CHECK-NEXT:  unreachable
 ; CHECK-NEXT: }

test/Transforms/LowerTypeTests/function-ext.ll

 ; RUN: opt -S -lowertypetests -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck --check-prefix=X64 %s
 ; RUN: opt -S -lowertypetests -mtriple=wasm32-unknown-unknown < %s | FileCheck --check-prefix=WASM32 %s
 
 ; Tests that we correctly handle external references, including the case where
 ; all functions in a bitset are external references.
 
 ; WASM32: private constant [0 x i8] zeroinitializer
 
 ; WASM32: declare !type !{{[0-9]+}} void @foo()
 declare !type !0 void @foo()
 
 define i1 @bar(i8* %ptr) {
-  ; X64: icmp eq i64 {{.*}}, ptrtoint (void ()* @[[JT:.*]] to i64)
+  ; X64: ret i1 false
   ; WASM32: ret i1 false
   %p = call i1 @llvm.type.test(i8* %ptr, metadata !"void")
   ret i1 %p
 }
 
 declare i1 @llvm.type.test(i8* %ptr, metadata %bitset) nounwind readnone
 
 !0 = !{i64 0, !"void"}
 ; WASM-NOT: !{i64 0}
 ; WASM-NOT: !{i64 1}
-
-; X64: define private void @[[JT]]() #{{.*}} align {{.*}} {
-; X64:   call void asm sideeffect "jmp ${0:c}@plt\0Aint3\0Aint3\0Aint3\0A", "s"(void ()* @foo)

test/Transforms/LowerTypeTests/pr37625.ll

-; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/use-typeid1-typeid2.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
+; RUN: opt -S -lowertypetests -lowertypetests-summary-action=export -lowertypetests-read-summary=%S/Inputs/exported-funcs.yaml -lowertypetests-write-summary=%t < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-declare !type !2 extern_weak void @h(i8)
+declare !type !2 extern_weak void @external_addrtaken(i8)
 
 !cfi.functions = !{!0, !1}
 
-!0 = !{!"h", i8 2, !2}
-!1 = !{!"h", i8 0, !2}
+!0 = !{!"external_addrtaken", i8 2, !2}
+!1 = !{!"external_addrtaken", i8 0, !2}
 !2 = !{i64 0, !"typeid1"}
 
-; CHECK-DAG: @h = alias void (i8), bitcast
+; CHECK-DAG: @external_addrtaken = alias void (i8), bitcast