[cfi] Emit jump tables as a function-level inline asm

[eugenis]

Summary

Use a dummy private function with inline asm calls instead of module level asm blocks for CFI jumptables.

The main advantage is that now jumptable codegen can be affected by the function attributes (like target_cpu on ARM). Module level asm gets the default subtarget based on the target triple, which is often not good enough.

This change also uses asm constraints/arguments to reference jumptable targets and aliases directly. We no longer do asm name mangling in an IR pass.

[eugenis]

Fix asm for non-ex86 targets.
${0:c} is x86-specific. Other targets emit a function label w/o "$" with simple $0 substitution (x86 emits $label in that case).

[eugenis]

Replaced asm aliases with IR aliases based on the function that holds the jumptable inline asm.

[pcc]

Thanks, this certainly seems nicer than the previous approach and should map quite cleanly into whichever IR-level representation we ultimately end up using for this. Just a few minor comments, then LGTM.

lib/Transforms/IPO/LowerTypeTests.cpp

264

I think you can remove this field now. Same for the include above.

699

Please update this comment.

844

Is this a string attribute? I thought it was an enum (llvm::Attribute::Naked). Perhaps this is just getting things right by chance (i.e. the backend figures out that it does not need a prologue).

[eugenis]

lib/Transforms/IPO/LowerTypeTests.cpp

844

Yes, you are right. There is no prologue on any of the supported targets. Even on win32.
Strangely enough, win32 target is not very fond of inline assembly in a naked function (see https://llvm.org/bugs/show_bug.cgi?id=28641#c3).

Adding llvm::Attribute::Naked on all non-windows targets.

If a prologue is added at some point, our runtime tests will surely catch it, so I think we are good.

lib/Transforms/IPO/LowerTypeTests.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TrailingObjects.h"
class LowerTypeTestsModule {
   // Indirect function call index assignment counter for WebAssembly
   uint64_t IndirectIndex = 1;
 
   // Mapping from type identifiers to the call sites that test them.
   DenseMap<Metadata *, std::vector<CallInst *>> TypeTestCallSites;
 
   std::vector<ByteArrayInfo> ByteArrayInfos;
 
   Mangler Mang;
   Function *WeakInitializerFn = nullptr;
+  Function *DummyJumpTableFn = nullptr;
 
   BitSetInfo
   buildBitSet(Metadata *TypeId,
               const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout);
   ByteArrayInfo *createByteArray(BitSetInfo &BSI);
   void allocateByteArrays();
   Value *createBitSetTest(IRBuilder<> &B, BitSetInfo &BSI, ByteArrayInfo *&BAI,
                           Value *BitOffset);
   void lowerTypeTestCalls(
       ArrayRef<Metadata *> TypeIds, Constant *CombinedGlobalAddr,
       const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout);
   Value *
   lowerBitSetCall(CallInst *CI, BitSetInfo &BSI, ByteArrayInfo *&BAI,
                   Constant *CombinedGlobal,
                   const DenseMap<GlobalObject *, uint64_t> &GlobalLayout);
   void buildBitSetsFromGlobalVariables(ArrayRef<Metadata *> TypeIds,
                                        ArrayRef<GlobalTypeMember *> Globals);
   unsigned getJumpTableEntrySize();
   Type *getJumpTableEntryType();
-  void createJumpTableEntry(raw_ostream &OS, Function *Dest, unsigned Distance);
-  void createJumpTableAlias(raw_ostream &OS, Function *Dest,
+  void createJumpTableEntry(raw_ostream &AsmOS, raw_ostream &ConstraintOS,
+                            SmallVectorImpl<Value *> &AsmArgs, Function *Dest);
+  void createJumpTableAlias(raw_ostream &AsmOS, raw_ostream &ConstraintOS,
+                            SmallVectorImpl<Value *> &AsmArgs, Function *Dest,
                             GlobalVariable *JumpTable, unsigned Distance);
   void verifyTypeMDNode(GlobalObject *GO, MDNode *Type);
   void buildBitSetsFromFunctions(ArrayRef<Metadata *> TypeIds,
                                  ArrayRef<GlobalTypeMember *> Functions);
   void buildBitSetsFromFunctionsNative(ArrayRef<Metadata *> TypeIds,
                                     ArrayRef<GlobalTypeMember *> Functions);
   void buildBitSetsFromFunctionsWASM(ArrayRef<Metadata *> TypeIds,
                                      ArrayRef<GlobalTypeMember *> Functions);
   void buildBitSetsFromDisjointSet(ArrayRef<Metadata *> TypeIds,
                                    ArrayRef<GlobalTypeMember *> Globals);
 
   void replaceWeakDeclarationWithJumpTablePtr(Function *F, Constant *JT);
   void moveInitializerToModuleConstructor(GlobalVariable *GV);
   void findGlobalVariableUsersOf(Constant *C,
                                  SmallSetVector<GlobalVariable *, 8> &Out);
 
+  void createJumpTableFn();
 public:
   LowerTypeTestsModule(Module &M);
   bool lower();
 };
 
 struct LowerTypeTests : public ModulePass {
   static char ID;
   LowerTypeTests() : ModulePass(ID) {
switch (Arch) {
     case Triple::thumb:
     case Triple::aarch64:
       return kARMJumpTableEntrySize;
     default:
       report_fatal_error("Unsupported architecture for jump tables");
   }
 }
 
-static bool isValidAsmUnquotedName(StringRef Name) {
-  if (Name.empty())
-    return false;
-
-  for (char C : Name) {
-    if (!((C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z') ||
-          (C >= '0' && C <= '9') || C == '_' || C == '$' || C == '.' ||
-          C == '@'))
-      return false;
-  }
-
-  return true;
-}
-
 // Create a constant representing a jump table entry for the target. This
 // consists of an instruction sequence containing a relative branch to Dest. The
 // constant will be laid out at address Src+(Len*Distance) where Len is the
 // target-specific jump table entry size.
-void LowerTypeTestsModule::createJumpTableEntry(raw_ostream &OS, Function *Dest,
-                                                unsigned Distance) {
-  // FIXME: replace IR Mangler with TargetLoweringObjectFile interface.
-  // A private instance of Mangler we use here can not deal with unnamed
-  // symbols, as it may create colliding labels. Thankfully(?), the use of
-  // inline asm requires us to give names to all affected functions anyway.
-  assert(Dest->hasName() && "jumptable targets can not be anonymous");
-  SmallString<16> Name;
-  Mang.getNameWithPrefix(Name, Dest, /* CannotUsePrivateLabel */ false);
-
-  if (!isValidAsmUnquotedName(Name)) {
-    // We are going to emit a function call as textual asm. Escaped strings
-    // in such expressions are not well supported.
-    report_fatal_error(
-        "CFI-ICall does not allow special characters in a function name.");
-  }
+void LowerTypeTestsModule::createJumpTableEntry(
+    raw_ostream &AsmOS, raw_ostream &ConstraintOS,
+    SmallVectorImpl<Value *> &AsmArgs, Function *Dest) {
+  unsigned ArgIndex = AsmArgs.size();
 
   if (Arch == Triple::x86 || Arch == Triple::x86_64) {
-    OS << "jmp " << Name << "@plt\n";
-    OS << "int3\nint3\nint3\n";
+    AsmOS << "jmp ${" << ArgIndex << ":c}@plt\n";
+    AsmOS << "int3\nint3\nint3\n";
   } else if (Arch == Triple::arm || Arch == Triple::aarch64) {
-    OS << "b " << Name << "\n";
+    AsmOS << "b ${" << ArgIndex << ":c}\n";
   } else if (Arch == Triple::thumb) {
-    OS << "b.w " << Name << "\n";
+    AsmOS << "b.w ${" << ArgIndex << ":c}\n";
   } else {
     report_fatal_error("Unsupported architecture for jump tables");
   }
-}
 
-void LowerTypeTestsModule::createJumpTableAlias(raw_ostream &OS, Function *Dest,
-                                                GlobalVariable *JumpTable,
-                                                unsigned Distance) {
-  assert(Dest->hasName() && "jumptable targets can not be anonymous");
-  SmallString<16> Name;
-  Mang.getNameWithPrefix(Name, Dest, /* CannotUsePrivateLabel */ false);
-
-  if (!isValidAsmUnquotedName(Name)) {
-    // We are going to emit a function alias as textual asm. Escaped strings
-    // in such expressions are not well supported.
-    report_fatal_error(
-        "CFI-ICall does not allow special characters in a function name.");
-  }
+  ConstraintOS << (ArgIndex > 0 ? ",s" : "s");
+  AsmArgs.push_back(Dest);
 
+void LowerTypeTestsModule::createJumpTableAlias(
+    raw_ostream &AsmOS, raw_ostream &ConstraintOS,
+    SmallVectorImpl<Value *> &AsmArgs, Function *Dest,
+    GlobalVariable *JumpTable, unsigned Distance) {
+  unsigned ArgIndex = AsmArgs.size();
+
   if (Dest->isWeakForLinker())
-    OS << ".weak " << Name << "\n";
+    AsmOS << ".weak ${" << ArgIndex << ":c}\n";
   else if (!Dest->hasLocalLinkage())
-    OS << ".globl " << Name << "\n";
-  OS << ".type " << Name << ", function\n";
+    AsmOS << ".globl ${" << ArgIndex << ":c}\n";
+  AsmOS << ".type ${" << ArgIndex << ":c}, function\n";
   if (Arch == Triple::thumb) {
-    OS << ".thumb_set " << Name << ", " << JumpTable->getName() << " + "
-       << (getJumpTableEntrySize() * Distance) << "\n";
+    AsmOS << ".thumb_set ${" << ArgIndex << ":c}, " << JumpTable->getName()
+          << " + " << (getJumpTableEntrySize() * Distance) << "\n";
   } else {
-    OS << Name << " = " << JumpTable->getName() << " + "
+    AsmOS << "${" << ArgIndex << ":c} = " << JumpTable->getName() << " + "
           << (getJumpTableEntrySize() * Distance) << "\n";
   }
-  OS << ".size " << Name << ", " << getJumpTableEntrySize() << "\n";
+  AsmOS << ".size ${" << ArgIndex << ":c}, " << getJumpTableEntrySize() << "\n";
+
+  ConstraintOS << (ArgIndex > 0 ? ",s" : "s");
+  AsmArgs.push_back(Dest);
 }
 
 Type *LowerTypeTestsModule::getJumpTableEntryType() {
   return ArrayType::get(Int8Ty, getJumpTableEntrySize());
 }
 
 /// Given a disjoint set of type identifiers and functions, build the bit sets
 /// and lower the llvm.type.test calls, architecture dependently.
void LowerTypeTestsModule::replaceWeakDeclarationWithJumpTablePtr(
   Constant *Target = ConstantExpr::getSelect(
       ConstantExpr::getICmp(CmpInst::ICMP_NE, F,
                             Constant::getNullValue(F->getType())),
       JT, Constant::getNullValue(F->getType()));
   PlaceholderFn->replaceAllUsesWith(Target);
   PlaceholderFn->eraseFromParent();
 }
 
+void LowerTypeTestsModule::createJumpTableFn() {
+  // DummyJumpTableFn needs a name to be added to llvm.used.
+  DummyJumpTableFn =
+      Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
+                                         /* IsVarArg */ false),
+                       GlobalValue::PrivateLinkage, "__cfi_jumptables", &M);
+
+  // Try to emit the jump table at the end of the text segment.
+  // Jump table must come after __cfi_check in the cross-dso mode.
+  // FIXME: this magic section name seems to do the trick.
+  DummyJumpTableFn->setSection(ObjectFormat == Triple::MachO
+                                   ? "__TEXT,__text,regular,pure_instructions"
+                                   : ".text.cfi");
+  BasicBlock *BB =
+      BasicBlock::Create(M.getContext(), "entry", DummyJumpTableFn);
+  IRBuilder<> IRB(BB);
+  IRB.CreateUnreachable();
+  appendToUsed(M, DummyJumpTableFn);
+}
+
 /// Given a disjoint set of type identifiers and functions, build a jump table
 /// for the functions, build the bit sets and lower the llvm.type.test calls.
 void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
     ArrayRef<Metadata *> TypeIds, ArrayRef<GlobalTypeMember *> Functions) {
   // Unlike the global bitset builder, the function bitset builder cannot
   // re-arrange functions in a particular order and base its calculations on the
   // layout of the functions' entry points, as we have no idea how large a
   // particular function will end up being (the size could even depend on what
   // this pass does!) Instead, we build a jump table, which is a block of code
void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
   // Because the addresses of f, g, h are evenly spaced at a power of 2, in the
   // normal case the check can be carried out using the same kind of simple
   // arithmetic that we normally use for globals.
 
   // FIXME: find a better way to represent the jumptable in the IR.
 
   assert(!Functions.empty());
 
+  // Create DummyJumpTableFn if necessary.
+  if (DummyJumpTableFn == nullptr) {
+    createJumpTableFn();
+  }
+
   // Build a simple layout based on the regular layout of jump tables.
   DenseMap<GlobalTypeMember *, uint64_t> GlobalLayout;
   unsigned EntrySize = getJumpTableEntrySize();
   for (unsigned I = 0; I != Functions.size(); ++I)
     GlobalLayout[Functions[I]] = I * EntrySize;
 
   // Create a constant to hold the jump table.
   ArrayType *JumpTableType =
       ArrayType::get(getJumpTableEntryType(), Functions.size());
   auto JumpTable =
       new GlobalVariable(M, JumpTableType,
                          /*isConstant=*/true, GlobalValue::ExternalLinkage,
                          nullptr, ".cfi.jumptable");
   JumpTable->setVisibility(GlobalValue::HiddenVisibility);
   lowerTypeTestCalls(TypeIds, JumpTable, GlobalLayout);
 
-  std::string AsmStr;
-  raw_string_ostream AsmOS(AsmStr);
+  std::string AsmStr, ConstraintStr;
+  raw_string_ostream AsmOS(AsmStr), ConstraintOS(ConstraintStr);
+  SmallVector<Value *, 16> AsmArgs;
+  AsmArgs.reserve(Functions.size() * 2);
 
   // Build aliases pointing to offsets into the jump table, and replace
   // references to the original functions with references to the aliases.
   for (unsigned I = 0; I != Functions.size(); ++I) {
     Function *F = cast<Function>(Functions[I]->getGlobal());
 
     // Need a name for the asm label. Normally, unnamed functions get temporary
     // asm labels in TargetLoweringObjectFile but we don't have access to that
     // here.
     if (!F->hasName())
       F->setName("unnamed");
     if (LinkerSubsectionsViaSymbols || F->isDeclarationForLinker()) {
       Constant *CombinedGlobalElemPtr = ConstantExpr::getBitCast(
           ConstantExpr::getGetElementPtr(
               JumpTableType, JumpTable,
               ArrayRef<Constant *>{ConstantInt::get(IntPtrTy, 0),
                                    ConstantInt::get(IntPtrTy, I)}),
           F->getType());
 
       if (F->isWeakForLinker()) {
-        AsmOS << ".weak " << F->getName() << "\n";
+        unsigned ArgIndex = AsmArgs.size();
+        AsmOS << ".weak ${" << ArgIndex << ":c}\n";
+        ConstraintOS << (ArgIndex > 0 ? ",s" : "s");
+        AsmArgs.push_back(F);
         replaceWeakDeclarationWithJumpTablePtr(F, CombinedGlobalElemPtr);
       } else {
         F->replaceAllUsesWith(CombinedGlobalElemPtr);
       }
     } else {
       assert(F->getType()->getAddressSpace() == 0);
 
-      createJumpTableAlias(AsmOS, F, JumpTable, I);
-
       Function *DeclAlias =
           Function::Create(cast<FunctionType>(F->getValueType()),
                            GlobalValue::ExternalLinkage, "", &M);
       // Since the alias (DeclAlias) is actually a declaration, it can not have
       // internal linkage. Compensate for that by giving it hidden visibility.
       // With this we end up with a GOT relocation against a local symbol.
       DeclAlias->setVisibility(F->hasLocalLinkage()
                                    ? GlobalValue::HiddenVisibility
                                    : F->getVisibility());
       DeclAlias->takeName(F);
+      createJumpTableAlias(AsmOS, ConstraintOS, AsmArgs, DeclAlias, JumpTable,
+                           I);
+
       // Unnamed functions can not be added to llvm.used.
       F->setName(DeclAlias->getName() + ".cfi");
       F->replaceAllUsesWith(DeclAlias);
     }
     if (!F->isDeclarationForLinker())
       F->setLinkage(GlobalValue::InternalLinkage);
   }
 
-  // Try to emit the jump table at the end of the text segment.
-  // Jump table must come after __cfi_check in the cross-dso mode.
-  // FIXME: this magic section name seems to do the trick.
-  AsmOS << ".section " << (ObjectFormat == Triple::MachO
-                               ? "__TEXT,__text,regular,pure_instructions"
-                               : ".text.cfi, \"ax\", %progbits")
-        << "\n";
   // Align the whole table by entry size.
   AsmOS << ".balign " << EntrySize << "\n";
   if (Arch == Triple::thumb)
     AsmOS << ".thumb_func\n";
   AsmOS << JumpTable->getName() << ":\n";
+
   for (unsigned I = 0; I != Functions.size(); ++I)
-    createJumpTableEntry(AsmOS, cast<Function>(Functions[I]->getGlobal()), I);
+    createJumpTableEntry(AsmOS, ConstraintOS, AsmArgs,
+                         cast<Function>(Functions[I]->getGlobal()));
 
-  M.appendModuleInlineAsm(AsmOS.str());
+  // Add the new table as a inline asm call in DummyJumpTableFn.
+  IRBuilder<> IRB(DummyJumpTableFn->getEntryBlock().getTerminator());
+  SmallVector<Type *, 16> ArgTypes;
+  ArgTypes.reserve(AsmArgs.size());
+  for (const auto &Arg : AsmArgs)
+    ArgTypes.push_back(Arg->getType());
+  InlineAsm *JumpTableAsm =
+      InlineAsm::get(FunctionType::get(IRB.getVoidTy(), ArgTypes, false),
+                     AsmOS.str(), ConstraintOS.str(),
+                     /*hasSideEffects=*/true);
 
-  SmallVector<GlobalValue *, 16> Used;
-  Used.reserve(Functions.size());
-  for (auto *F : Functions)
-    Used.push_back(F->getGlobal());
-  appendToUsed(M, Used);
+  IRB.CreateCall(JumpTableAsm, AsmArgs);
 }
 
 /// Assign a dummy layout using an incrementing counter, tag each function
 /// with its index represented as metadata, and lower each type test to an
 /// integer range comparison. During generation of the indirect function call
 /// table in the backend, it will assign the given indexes.
 /// Note: Dynamic linking is not supported, as the WebAssembly ABI has not yet
 /// been finalized.

test/Transforms/LowerTypeTests/function-disjoint.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 bitsets with disjoint call target sets.
 
 target datalayout = "e-p:64:64"
 
-; X64:      module asm "f = .cfi.jumptable + 0"
-
-; X64:      module asm ".cfi.jumptable:"
-; X64-NEXT: module asm "jmp f.cfi@plt"
-; X64-NEXT: module asm "int3"
-; X64-NEXT: module asm "int3"
-; X64-NEXT: module asm "int3"
-
-; X64:      module asm "g = .cfi.jumptable.1 + 0"
-
-; X64:      module asm ".cfi.jumptable.1:"
-; X64-NEXT: module asm "jmp g.cfi@plt"
-; X64-NEXT: module asm "int3"
-; X64-NEXT: module asm "int3"
-; X64-NEXT: module asm "int3"
-
-
 ; X64: @.cfi.jumptable = external hidden constant [1 x [8 x i8]]
 ; X64: @.cfi.jumptable.1 = external hidden constant [1 x [8 x i8]]
 
 ; WASM32: private constant [0 x i8] zeroinitializer
 @0 = private unnamed_addr constant [2 x void ()*] [void ()* @f, void ()* @g], align 16
 
 ; X64: define internal void @f.cfi()
 ; WASM32: define void @f() !type !{{[0-9]+}} !wasm.index ![[I0:[0-9]+]]
define i1 @foo(i8* %p) {
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ; X64: icmp eq i64 {{.*}}, ptrtoint ([1 x [8 x i8]]* @.cfi.jumptable.1 to i64)
   ; WASM32: icmp eq i64 {{.*}}, 2
   %y = call i1 @llvm.type.test(i8* %p, metadata !"typeid2")
   %z = add i1 %x, %y
   ret i1 %z
 }
 
+; X64: define private void @__cfi_jumptables()
+; X64: call void asm sideeffect "
+; X64-SAME: ${0:c} = .cfi.jumptable + 0
+; X64-SAME: .cfi.jumptable:
+; X64-SAME: jmp ${1:c}@plt
+; X64-SAME: "s,s"(void ()* @f, void ()* @f.cfi)
+
+; X64: call void asm sideeffect "
+; X64-SAME: ${0:c} = .cfi.jumptable.1 + 0
+; X64-SAME: .cfi.jumptable.1:
+; X64-SAME: jmp ${1:c}@plt
+; X64-SAME: "s,s"(void ()* @g, void ()* @g.cfi)
+
 ; X64: declare void @f()
 ; X64: declare void @g()
 
 ; WASM32: ![[I0]] = !{i64 1}
 ; WASM32: ![[I1]] = !{i64 2}
 No newline at end of file

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.
 
-; X64:      module asm ".cfi.jumptable:"
-; X64-NEXT: module asm "jmp foo@plt"
-; X64-NOT:  module asm "jmp {{.*}}@plt"
-
 ; X64: @.cfi.jumptable = external hidden constant [1 x [8 x i8]]
 ; 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 ([1 x [8 x i8]]* @.cfi.jumptable to i64)
   ; WASM32: sub i64 {{.*}}, 0
   ; WASM32: icmp ult i64 {{.*}}, 1
   %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 @__cfi_jumptables()
+; X64: jmp ${0:c}@plt
+; X64-NOT: jmp {{.*}}@plt
+; X64-SAME: "s"(void ()* @foo)

test/Transforms/LowerTypeTests/function-weak.ll

 ; RUN: opt -S -lowertypetests -mtriple=i686-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: opt -S -lowertypetests -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: opt -S -lowertypetests -mtriple=arm-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: opt -S -lowertypetests -mtriple=aarch64-unknown-linux-gnu < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-; CHECK: module asm ".weak f"
-
 ; CHECK: @x = global void ()* null, align 8
 @x = global void ()* @f, align 8
 
 ; CHECK: @x2 = global void ()* null, align 8
 @x2 = global void ()* @f, align 8
 
 ; CHECK: @x3 = internal global void ()* null, align 8
 @x3 = internal constant void ()* @f, align 8

 
 declare i1 @llvm.type.test(i8* %ptr, metadata %bitset) nounwind readnone
 
 define i1 @foo(i8* %p) {
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ret i1 %x
 }
 
+; CHECK: define private void @__cfi_jumptables()
+; CHECK: .weak ${0:c}
+; CHECK-SAME: "s,s"(void ()* @f,
+
 ; CHECK: define internal void @__cfi_global_var_init() section ".text.startup" {
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: store { void ()*, void ()*, i32 } { void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null), void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null), i32 42 }, { void ()*, void ()*, i32 }* @s, align 8
 ; CHECK-NEXT: store void ()* bitcast (i8* getelementptr (i8, i8* bitcast (void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null) to i8*), i64 42) to void ()*), void ()** @x4, align 8
 ; CHECK-NEXT: store void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null), void ()** @x3, align 8
 ; CHECK-NEXT: store void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null), void ()** @x2, align 8
 ; CHECK-NEXT: store void ()* select (i1 icmp ne (void ()* @f, void ()* null), void ()* bitcast ({{.*}}@.cfi.jumptable to void ()*), void ()* null), void ()** @x, align 8
 ; CHECK-NEXT: ret void
 ; CHECK-NEXT: }
 
-
 !0 = !{i32 0, !"typeid1"}

test/Transforms/LowerTypeTests/function.ll

 ; RUN: opt -S -lowertypetests -mtriple=i686-unknown-linux-gnu < %s | FileCheck --check-prefixes=X86,NATIVE %s
 ; RUN: opt -S -lowertypetests -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck --check-prefixes=X86,NATIVE %s
 ; RUN: opt -S -lowertypetests -mtriple=arm-unknown-linux-gnu < %s | FileCheck --check-prefixes=ARM,NATIVE %s
 ; RUN: opt -S -lowertypetests -mtriple=thumb-unknown-linux-gnu < %s | FileCheck --check-prefixes=THUMB,NATIVE %s
 ; RUN: opt -S -lowertypetests -mtriple=aarch64-unknown-linux-gnu < %s | FileCheck --check-prefixes=ARM,NATIVE %s
 ; RUN: opt -S -lowertypetests -mtriple=wasm32-unknown-unknown < %s | FileCheck --check-prefix=WASM32 %s
 
 ; Tests that we correctly handle bitsets containing 2 or more functions.
 
 target datalayout = "e-p:64:64"
 
-; X86:      module asm ".globl f"
-; X86-NEXT: module asm ".type f, function"
-; X86-NEXT: module asm "f = .cfi.jumptable + 0"
-; X86-NEXT: module asm ".size f, 8"
-; X86-NEXT: module asm ".type g, function"
-; X86-NEXT: module asm "g = .cfi.jumptable + 8"
-; X86-NEXT: module asm ".size g, 8"
-; X86-NEXT: module asm ".section .text.cfi, \22ax\22, %progbits"
-; X86-NEXT: module asm ".balign 8"
-; X86-NEXT: module asm ".cfi.jumptable:"
-; X86-NEXT: module asm "jmp f.cfi@plt"
-; X86-NEXT: module asm "int3"
-; X86-NEXT: module asm "int3"
-; X86-NEXT: module asm "int3"
-; X86-NEXT: module asm "jmp g.cfi@plt"
-; X86-NEXT: module asm "int3"
-; X86-NEXT: module asm "int3"
-; X86-NEXT: module asm "int3"
-
-; ARM:      module asm ".globl f"
-; ARM-NEXT: module asm ".type f, function"
-; ARM-NEXT: module asm "f = .cfi.jumptable + 0"
-; ARM-NEXT: module asm ".size f, 4"
-; ARM-NEXT: module asm ".type g, function"
-; ARM-NEXT: module asm "g = .cfi.jumptable + 4"
-; ARM-NEXT: module asm ".size g, 4"
-; ARM-NEXT: module asm ".section .text.cfi, \22ax\22, %progbits"
-; ARM-NEXT: module asm ".balign 4"
-; ARM-NEXT: module asm ".cfi.jumptable:"
-; ARM-NEXT: module asm "b f.cfi"
-; ARM-NEXT: module asm "b g.cfi"
-
-; THUMB:      module asm ".globl f"
-; THUMB-NEXT: module asm ".type f, function"
-; THUMB-NEXT: module asm ".thumb_set f, .cfi.jumptable + 0"
-; THUMB-NEXT: module asm ".size f, 4"
-; THUMB-NEXT: module asm ".type g, function"
-; THUMB-NEXT: module asm ".thumb_set g, .cfi.jumptable + 4"
-; THUMB-NEXT: module asm ".size g, 4"
-; THUMB-NEXT: module asm ".section .text.cfi, \22ax\22, %progbits"
-; THUMB-NEXT: module asm ".balign 4"
-; THUMB-NEXT: module asm ".thumb_func"
-; THUMB-NEXT: module asm ".cfi.jumptable:"
-; THUMB-NEXT: module asm "b.w f.cfi"
-; THUMB-NEXT: module asm "b.w g.cfi"
-
+; NATIVE: @llvm.used = appending global [1 x i8*] [i8* bitcast (void ()* @__cfi_jumptables to i8*)], section "llvm.metadata"
 
 ; X86: @.cfi.jumptable = external hidden constant [2 x [8 x i8]]
 ; ARM: @.cfi.jumptable = external hidden constant [2 x [4 x i8]]
 ; THUMB: @.cfi.jumptable = external hidden constant [2 x [4 x i8]]
 
 ; WASM32: private constant [0 x i8] zeroinitializer
 @0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16
 
-; NATIVE: @llvm.used = appending global [2 x i8*] [i8* bitcast (void ()* @f.cfi to i8*), i8* bitcast (void ()* @g.cfi to i8*)], section "llvm.metadata"
-
 ; NATIVE: define internal void @f.cfi()
 ; WASM32: define void @f() !type !{{[0-9]+}} !wasm.index ![[I0:[0-9]+]]
 define void @f() !type !0 {
   ret void
 }
 
 ; NATIVE: define internal void @g.cfi()
 ; WASM32: define internal void @g() !type !{{[0-9]+}} !wasm.index ![[I1:[0-9]+]]
define i1 @foo(i8* %p) {
   ; X86: sub i64 {{.*}}, ptrtoint ([2 x [8 x i8]]* @.cfi.jumptable to i64)
   ; ARM: sub i64 {{.*}}, ptrtoint ([2 x [4 x i8]]* @.cfi.jumptable to i64)
   ; WASM32: sub i64 {{.*}}, 1
   ; WASM32: icmp ult i64 {{.*}}, 2
   %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1")
   ret i1 %x
 }
 
+; NATIVE: define private void @__cfi_jumptables()
+
+; X86:      .globl ${0:c}
+; X86-SAME: .type ${0:c}, function
+; X86-SAME: ${0:c} = .cfi.jumptable + 0
+; X86-SAME: .size ${0:c}, 8
+; X86-SAME: .type ${1:c}, function
+; X86-SAME: ${1:c} = .cfi.jumptable + 8
+; X86-SAME: .size ${1:c}, 8
+; X86-SAME: .balign 8
+; X86-SAME: .cfi.jumptable:
+; X86-SAME: jmp ${2:c}@plt
+; X86-SAME: int3
+; X86-SAME: int3
+; X86-SAME: int3
+; X86-SAME: jmp ${3:c}@plt
+; X86-SAME: int3
+; X86-SAME: int3
+; X86-SAME: int3
+
+; ARM:      .globl ${0:c}
+; ARM-SAME: .type ${0:c}, function
+; ARM-SAME: ${0:c} = .cfi.jumptable + 0
+; ARM-SAME: .size ${0:c}, 4
+; ARM-SAME: .type ${1:c}, function
+; ARM-SAME: ${1:c} = .cfi.jumptable + 4
+; ARM-SAME: .size ${1:c}, 4
+; ARM-SAME: .balign 4
+; ARM-SAME: .cfi.jumptable:
+; ARM-SAME: b ${2:c}
+; ARM-SAME: b ${3:c}
+
+; THUMB:      .globl ${0:c}
+; THUMB-SAME: .type ${0:c}, function
+; THUMB-SAME: .thumb_set ${0:c}, .cfi.jumptable + 0
+; THUMB-SAME: .size ${0:c}, 4
+; THUMB-SAME: .type ${1:c}, function
+; THUMB-SAME: .thumb_set ${1:c}, .cfi.jumptable + 4
+; THUMB-SAME: .size ${1:c}, 4
+; THUMB-SAME: .balign 4
+; THUMB-SAME: .thumb_func
+; THUMB-SAME: .cfi.jumptable:
+; THUMB-SAME: b.w ${2:c}
+; THUMB-SAME: b.w ${3:c}
+
+; NATIVE-SAME: "s,s,s,s"(void ()* @f, void ()* @g, void ()* @f.cfi, void ()* @g.cfi)
+
 ; NATIVE: declare void @f()
 ; NATIVE: declare hidden void @g()
 
 ; WASM32: ![[I0]] = !{i64 1}
 ; WASM32: ![[I1]] = !{i64 2}

test/Transforms/LowerTypeTests/section.ll

 ; Test that functions with "section" attribute are accepted, and jumptables are
 ; emitted in ".text".
 
 ; RUN: opt -S -lowertypetests < %s | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
-; CHECK:      module asm ".section .text.cfi,
-; CHECK:      module asm ".cfi.jumptable:"
-; CHECK-NEXT: module asm "jmp f.cfi@plt"
-
 ; CHECK: define internal void @f.cfi() section "xxx"
 
 define void @f() section "xxx" !type !0 {
 entry:
   ret void
 }
 
 define i1 @g() {
 entry:
   %0 = call i1 @llvm.type.test(i8* bitcast (void ()* @f to i8*), metadata !"_ZTSFvE")
   ret i1 %0
 }
 
+; CHECK: define private void @__cfi_jumptables() section ".text.cfi" {
+
 declare i1 @llvm.type.test(i8*, metadata) nounwind readnone
 
 !0 = !{i64 0, !"_ZTSFvE"}