[cfi] CFI-ICall for ThinLTO.

[eugenis]

Summary

Implement ControlFlowIntegrity for indirect function calls in ThinLTO.
Design follows the RFC in llvm-dev, see
https://groups.google.com/d/msg/llvm-dev/MgUlaphu4Qc/kywu0AqjAQAJ

[eugenis]

include/llvm/IR/ModuleSummaryIndexYAML.h

269

An alternative to this is rewriting SequenceTraits in terms of begin/end iterators.
The current interface does not work for std::set at all because it is index-based.

[pcc]

include/llvm/IR/ModuleSummaryIndex.h

38

Sort by name.

include/llvm/IR/ModuleSummaryIndexYAML.h

269

Yes, that's one possibility. But for now I'd suggest performing the vector/set conversions directly here, then relying on the built-in handling of std::vector which would avoid the need for the StringSetYaml class.

if (io.outputting()) {
  std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(), index.CfiFunctionDefs.end());
  io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);

  // same for CfiFunctionDecls
} else {
  std::vector<std::string> CfiFunctionDefs;
  io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
  index.CfiFunctionDefs = {CfiFunctionDefs.begin(), CfiFunctionDefs.end()};

  // same for CfiFunctionDecls
}

include/llvm/Support/YAMLTraits.h

662

This is only necessary because of StringSetYaml, right?

lib/Bitcode/Reader/BitcodeReader.cpp

5254

I'd do this with two record types, one for defs and the other for decls, but up to you.

lib/Bitcode/Writer/BitcodeWriter.cpp

3853

clang-format

lib/Transforms/IPO/LowerTypeTests.cpp

1444

Will this do the right thing if a (non-address-taken) function with local linkage has the same name as an unrelated function in another module with external linkage? I think you need to check that the function has external linkage before testing for set membership.

1481

I would declare a struct inline here instead of using a pair, to make this a little more self-documenting.

1498

I think this would be clearer as if (!V.first).

Could V.first be uninitialized at this point?

1504

Remove line.

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

35

Rebuilding the metadata in here doesn't seem very elegant. Maybe instead you could:

1. compute a SetVector<GlobalValue *> of which functions require jump table entries
2. pass that set into this function and use it to control whether to promote
3. once it returns, produce the metadata in the merged module by enumerating the set.

336

Can we declare an enum somewhere instead of using these magic numbers?

I would also rewrite with if/else.

[eugenis]

include/llvm/Support/YAMLTraits.h

662

Right. Still seems like the right thing to do. I've uploaded it as a separate NFC revision in D34116.

lib/Transforms/IPO/LowerTypeTests.cpp

1498

It's initialized to zero, which is what we want.

[eugenis]

lib/Transforms/IPO/LowerTypeTests.cpp

1498

I've rewrote this code in a more explicit way.

[pcc]

LGTM

lib/Transforms/IPO/CrossDSOCFI.cpp

98

Please add test coverage for this code.

lib/Transforms/IPO/LowerTypeTests.cpp

39

This should be the first include.

[pcc]

lib/Transforms/IPO/LowerTypeTests.cpp

1414

You could remove this function and use ModuleSummaryIndex::isGUIDLive now.

[eugenis]

lib/Transforms/IPO/LowerTypeTests.cpp

1414

I did not notice this before, but isGUIDLive thinks that all external functions are dead, because only definitions have value summaries.

[eugenis]

lib/Transforms/IPO/LowerTypeTests.cpp

1414

Fixed, PTAL

[eugenis]

One more fix: ignore !types in thinlto-exported declarations when the regular lto module has a definition.

[pcc]

Still LGTM

test/Transforms/LowerTypeTests/Inputs/use-typeid1-typeid2.yaml

4 ↗

(On Diff #102733)

Why did you change this to false?

Presumably the test still passes because WithGlobalValueDeadStripping is false?

[eugenis]

test/Transforms/LowerTypeTests/Inputs/use-typeid1-typeid2.yaml

4 ↗

(On Diff #102733)

Right. I'll change it back.

[eugenis]

r305533

include/llvm/Bitcode/BitcodeWriter.h

public:
     /// hash is written into ModHash. When GenerateHash is false, that value
     /// is used as the hash instead of computing from the generated bitcode.
     /// Can be used to produce the same module hash for a minimized bitcode
     /// used just for the thin link as in the regular full bitcode that will
     /// be used in the backend.
     void writeModule(const Module *M, bool ShouldPreserveUseListOrder = false,
                      const ModuleSummaryIndex *Index = nullptr,
                      bool GenerateHash = false, ModuleHash *ModHash = nullptr);
+
+    void writeIndex(
+        const ModuleSummaryIndex *Index,
+        const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex);
   };
 
   /// \brief Write the specified module to the specified raw output stream.
   ///
   /// For streams where it matters, the given stream should be in "binary"
   /// mode.
   ///
   /// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a

include/llvm/Bitcode/LLVMBitCodes.h

enum GlobalValueSummarySymtabCodes {
   // Identifies a virtual call made by this function using an
   // llvm.type.checked.load intrinsic with all constant integer arguments.
   // [typeid, offset, n x arg]
   FS_TYPE_CHECKED_LOAD_CONST_VCALL = 15,
   // Assigns a GUID to a value ID. This normally appears only in combined
   // summaries, but it can also appear in per-module summaries for PGO data.
   // [valueid, guid]
   FS_VALUE_GUID = 16,
+  // The list of functions with CFI jump tables. Names are pairs of (strtab
+  // offset, length). The first numdefs names are for definitions (i.e. local
+  // functions), the rest are external functions.
+  // [numdefs, numdefs x name, n x name]
+  FS_CFI_FUNCTIONS = 17,
 };
 
 enum MetadataCodes {
   METADATA_STRING_OLD = 1,     // MDSTRING:      [values]
   METADATA_VALUE = 2,          // VALUE:         [type num, value num]
   METADATA_NODE = 3,           // NODE:          [n x md num]
   METADATA_NAME = 4,           // STRING:        [values]
   METADATA_DISTINCT_NODE = 5,  // DISTINCT_NODE: [n x md num]

include/llvm/IR/ModuleSummaryIndex.h

 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
+#include <set>
 
 namespace llvm {
 
 namespace yaml {
 
 template <typename T> struct MappingTraits;
 
 } // end namespace yaml
private:
   /// GUIDs, it will be mapped to 0.
   std::map<GlobalValue::GUID, GlobalValue::GUID> OidGuidMap;
 
   /// Indicates that summary-based GlobalValue GC has run, and values with
   /// GVFlags::Live==false are really dead. Otherwise, all values must be
   /// considered live.
   bool WithGlobalValueDeadStripping = false;
 
+  std::set<std::string> CfiFunctionDefs;
+  std::set<std::string> CfiFunctionDecls;
+
   // YAML I/O support.
   friend yaml::MappingTraits<ModuleSummaryIndex>;
 
   GlobalValueSummaryMapTy::value_type *
   getOrInsertValuePtr(GlobalValue::GUID GUID) {
     return &*GlobalValueMap.emplace(GUID, GlobalValueSummaryInfo{}).first;
   }
 
public:
   }
 
   /// Return the GUID for \p OriginalId in the OidGuidMap.
   GlobalValue::GUID getGUIDFromOriginalID(GlobalValue::GUID OriginalID) const {
     const auto I = OidGuidMap.find(OriginalID);
     return I == OidGuidMap.end() ? 0 : I->second;
   }
 
+  std::set<std::string> &cfiFunctionDefs() { return CfiFunctionDefs; }
+  const std::set<std::string> &cfiFunctionDefs() const { return CfiFunctionDefs; }
+
+  std::set<std::string> &cfiFunctionDecls() { return CfiFunctionDecls; }
+  const std::set<std::string> &cfiFunctionDecls() const { return CfiFunctionDecls; }
+
   /// Add a global value summary for a value of the given name.
   void addGlobalValueSummary(StringRef ValueName,
                              std::unique_ptr<GlobalValueSummary> Summary) {
     addGlobalValueSummary(getOrInsertValueInfo(GlobalValue::getGUID(ValueName)),
                           std::move(Summary));
   }
 
   /// Add a global value summary for the given ValueInfo.

include/llvm/IR/ModuleSummaryIndexYAML.h

template <> struct MappingTraits<FunctionSummaryYaml> {
   }
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
 LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
 
 namespace llvm {
 namespace yaml {
 
+struct StringSetYaml {
+  std::vector<std::string> V;
+  StringSetYaml() {}
+  StringSetYaml(const std::set<std::string>& S) {
+    for (auto &Str : S)
+      V.push_back(Str);
+  }
+  void ToSet(std::set<std::string>& S) {
+    for (auto &Str : V)
+      S.insert(Str);
+  }
+};
+
+template<> struct SequenceTraits<StringSetYaml> {
+  static size_t size(IO &io, StringSetYaml &seq) {
+    return seq.V.size();
+  }
+  static std::string &element(IO &io, StringSetYaml &seq, size_t index) {
+    if (index >= seq.V.size())
+      seq.V.resize(index + 1);
+    return seq.V[index];
+  }
+};
+
 // FIXME: Add YAML mappings for the rest of the module summary.
 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");

 };
 
 template <> struct MappingTraits<ModuleSummaryIndex> {
   static void mapping(IO &io, ModuleSummaryIndex& index) {
     io.mapOptional("GlobalValueMap", index.GlobalValueMap);
     io.mapOptional("TypeIdMap", index.TypeIdMap);
     io.mapOptional("WithGlobalValueDeadStripping",
                    index.WithGlobalValueDeadStripping);
+
+    if (io.outputting()) {
+      StringSetYaml CfiFunctionDefs(index.CfiFunctionDefs);
+      io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
+
+      StringSetYaml CfiFunctionDecls(index.CfiFunctionDecls);
+      io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
+    } else {
+      StringSetYaml CfiFunctionDefs;
+      io.mapOptional("CfiFunctionDefs", CfiFunctionDefs);
+      CfiFunctionDefs.ToSet(index.CfiFunctionDefs);
+
+      StringSetYaml CfiFunctionDecls;
+      io.mapOptional("CfiFunctionDecls", CfiFunctionDecls);
+      CfiFunctionDecls.ToSet(index.CfiFunctionDecls);
+    }
   }
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
 #endif

include/llvm/Support/YAMLTraits.h

void mapOptional(const char *Key, T &Val, const T &Default) {
     EmptyContext Ctx;
     mapOptionalWithContext(Key, Val, Default, Ctx);
   }
 
   template <typename T, typename Context>
   typename std::enable_if<has_SequenceTraits<T>::value, void>::type
   mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
     // omit key/value instead of outputting empty sequence
-    if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
+    if (this->canElideEmptySequence() &&
+        SequenceTraits<T>::size(*this, Val) == 0)
       return;
     this->processKey(Key, Val, false, Ctx);
   }
 
   template <typename T, typename Context>
   void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
     this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
                                 Ctx);

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL: {
           {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
       break;
     }
     case bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL: {
       PendingTypeCheckedLoadConstVCalls.push_back(
           {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
       break;
     }
+    case bitc::FS_CFI_FUNCTIONS: {
+      std::set<std::string> &CfiFunctionDefs = TheIndex.cfiFunctionDefs();
+      std::set<std::string> &CfiFunctionDecls = TheIndex.cfiFunctionDecls();
+      unsigned NumDefs = Record[0];
+      for (unsigned I = 1, N = 0; I != Record.size(); I += 2, N++) {
+        StringRef Name{Strtab.data() + Record[I], Record[I+1]};
+        if (N < NumDefs)
+          CfiFunctionDefs.insert(Name);
+        else
+          CfiFunctionDecls.insert(Name);
+      }
+      break;
+    }
     }
   }
   llvm_unreachable("Exit infinite loop");
 }
 
 // Parse the  module string table block into the Index.
 // This populates the ModulePathStringTable map in the index.
 Error ModuleSummaryIndexBitcodeReader::parseModuleStringTable() {

lib/Bitcode/Writer/BitcodeWriter.cpp

 
 /// Abstract class to manage the bitcode writing, subclassed for each bitcode
 /// file type.
 class BitcodeWriterBase {
 protected:
   /// The stream created and owned by the client.
   BitstreamWriter &Stream;
 
+  StringTableBuilder &StrtabBuilder;
+
 public:
   /// Constructs a BitcodeWriterBase object that writes to the provided
   /// \p Stream.
-  BitcodeWriterBase(BitstreamWriter &Stream) : Stream(Stream) {}
+  BitcodeWriterBase(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder)
+      : Stream(Stream), StrtabBuilder(StrtabBuilder) {}
 
 protected:
   void writeBitcodeHeader();
   void writeModuleVersion();
 };
 
 void BitcodeWriterBase::writeModuleVersion() {
   // VERSION: [version#]
   Stream.EmitRecord(bitc::MODULE_CODE_VERSION, ArrayRef<uint64_t>{2});
 }
 
 /// Class to manage the bitcode writing for a module.
 class ModuleBitcodeWriter : public BitcodeWriterBase {
   /// Pointer to the buffer allocated by caller for bitcode writing.
   const SmallVectorImpl<char> &Buffer;
 
-  StringTableBuilder &StrtabBuilder;
-
   /// The Module to write to bitcode.
   const Module &M;
 
   /// Enumerates ids for all values in the module.
   ValueEnumerator VE;
 
   /// Optional per-module index to write for ThinLTO.
   const ModuleSummaryIndex *Index;

 public:
   /// Constructs a ModuleBitcodeWriter object for the given Module,
   /// writing to the provided \p Buffer.
   ModuleBitcodeWriter(const Module *M, SmallVectorImpl<char> &Buffer,
                       StringTableBuilder &StrtabBuilder,
                       BitstreamWriter &Stream, bool ShouldPreserveUseListOrder,
                       const ModuleSummaryIndex *Index, bool GenerateHash,
                       ModuleHash *ModHash = nullptr)
-      : BitcodeWriterBase(Stream), Buffer(Buffer), StrtabBuilder(StrtabBuilder),
-        M(*M), VE(*M, ShouldPreserveUseListOrder), Index(Index),
+      : BitcodeWriterBase(Stream, StrtabBuilder), Buffer(Buffer), M(*M),
+        VE(*M, ShouldPreserveUseListOrder), Index(Index),
         GenerateHash(GenerateHash), ModHash(ModHash),
         BitcodeStartBit(Stream.GetCurrentBitNo()) {
     // Assign ValueIds to any callee values in the index that came from
     // indirect call profiles and were recorded as a GUID not a Value*
     // (which would have been assigned an ID by the ValueEnumerator).
     // The starting ValueId is just after the number of values in the
     // ValueEnumerator, so that they can be emitted in the VST.
     GlobalValueId = VE.getValues().size();
class IndexBitcodeWriter : public BitcodeWriterBase {
 
   /// Tracks the last value id recorded in the GUIDToValueMap.
   unsigned GlobalValueId = 0;
 
 public:
   /// Constructs a IndexBitcodeWriter object for the given combined index,
   /// writing to the provided \p Buffer. When writing a subset of the index
   /// for a distributed backend, provide a \p ModuleToSummariesForIndex map.
-  IndexBitcodeWriter(BitstreamWriter &Stream, const ModuleSummaryIndex &Index,
+  IndexBitcodeWriter(BitstreamWriter &Stream, StringTableBuilder &StrtabBuilder,
+                     const ModuleSummaryIndex &Index,
                      const std::map<std::string, GVSummaryMapTy>
                          *ModuleToSummariesForIndex = nullptr)
-      : BitcodeWriterBase(Stream), Index(Index),
+      : BitcodeWriterBase(Stream, StrtabBuilder), Index(Index),
         ModuleToSummariesForIndex(ModuleToSummariesForIndex) {
     // Assign unique value ids to all summaries to be written, for use
     // in writing out the call graph edges. Save the mapping from GUID
     // to the new global value id to use when writing those edges, which
     // are currently saved in the index in terms of GUID.
     forEachSummary([&](GVInfo I) {
       GUIDToValueIdMap[I.first] = ++GlobalValueId;
     });
for (auto *AS : Aliases) {
     NameVals.push_back(AliaseeValueId);
 
     // Emit the finished record.
     Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);
     NameVals.clear();
     MaybeEmitOriginalName(*AS);
   }
 
+  const std::set<std::string> &CfiFunctionDefs = Index.cfiFunctionDefs();
+  const std::set<std::string> &CfiFunctionDecls = Index.cfiFunctionDecls();
+  if (!CfiFunctionDefs.empty() || !CfiFunctionDecls.empty()) {
+    NameVals.push_back(CfiFunctionDefs.size());
+    for (auto &S : CfiFunctionDefs) {
+      NameVals.push_back(StrtabBuilder.add(S));
+      NameVals.push_back(S.size());
+    }
+    for (auto &S : CfiFunctionDecls) {
+      NameVals.push_back(StrtabBuilder.add(S));
+      NameVals.push_back(S.size());
+    }
+    Stream.EmitRecord(bitc::FS_CFI_FUNCTIONS, NameVals);
+    NameVals.clear();
+  }
+
   Stream.ExitBlock();
 }
 
 /// Create the "IDENTIFICATION_BLOCK_ID" containing a single string with the
 /// current llvm version, and a record for the epoch number.
 static void writeIdentificationBlock(BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);
 
void BitcodeWriter::writeModule(const Module *M,
                                 const ModuleSummaryIndex *Index,
                                 bool GenerateHash, ModuleHash *ModHash) {
   ModuleBitcodeWriter ModuleWriter(M, Buffer, StrtabBuilder, *Stream,
                                    ShouldPreserveUseListOrder, Index,
                                    GenerateHash, ModHash);
   ModuleWriter.write();
 }
 
+void BitcodeWriter::writeIndex(
+    const ModuleSummaryIndex *Index,
+    const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
+  IndexBitcodeWriter IndexWriter(*Stream, StrtabBuilder, *Index, ModuleToSummariesForIndex);
+  IndexWriter.write();
+}
+
 /// WriteBitcodeToFile - Write the specified module to the specified output
 /// stream.
 void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out,
                               bool ShouldPreserveUseListOrder,
                               const ModuleSummaryIndex *Index,
                               bool GenerateHash, ModuleHash *ModHash) {
   SmallVector<char, 0> Buffer;
   Buffer.reserve(256*1024);

 // writing the combined index file for ThinLTO. When writing a subset of the
 // index for a distributed backend, provide a \p ModuleToSummariesForIndex map.
 void llvm::WriteIndexToFile(
     const ModuleSummaryIndex &Index, raw_ostream &Out,
     const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
   SmallVector<char, 0> Buffer;
   Buffer.reserve(256 * 1024);
 
-  BitstreamWriter Stream(Buffer);
-  writeBitcodeHeader(Stream);
-
-  IndexBitcodeWriter IndexWriter(Stream, Index, ModuleToSummariesForIndex);
-  IndexWriter.write();
+  BitcodeWriter Writer(Buffer);
+  Writer.writeIndex(&Index, ModuleToSummariesForIndex);
+  Writer.writeStrtab();
 
   Out.write((char *)&Buffer.front(), Buffer.size());
 }

lib/Transforms/IPO/CrossDSOCFI.cpp

for (MDNode *Type : Types) {
       // Sanity check. GO must not be a function declaration.
       assert(!isa<Function>(&GO) || !cast<Function>(&GO)->isDeclaration());
 
       if (ConstantInt *TypeId = extractNumericTypeId(Type))
         TypeIds.insert(TypeId->getZExtValue());
     }
   }
 
+  NamedMDNode *CfiFunctionsMD = M.getNamedMetadata("cfi.functions");
+  if (CfiFunctionsMD) {
+    for (auto Func : CfiFunctionsMD->operands()) {
+      assert(Func->getNumOperands() >= 2);
+      for (unsigned I = 2; I < Func->getNumOperands(); ++I)
+        if (ConstantInt *TypeId =
+                extractNumericTypeId(cast<MDNode>(Func->getOperand(I).get())))
+          TypeIds.insert(TypeId->getZExtValue());
+    }
+  }
+
   LLVMContext &Ctx = M.getContext();
   Constant *C = M.getOrInsertFunction(
       "__cfi_check", Type::getVoidTy(Ctx), Type::getInt64Ty(Ctx),
       Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx));
   Function *F = dyn_cast<Function>(C);
   // Take over the existing function. The frontend emits a weak stub so that the
   // linker knows about the symbol; this pass replaces the function body.
   F->deleteBody();

lib/Transforms/IPO/LowerTypeTests.cpp

 #include "llvm/IR/Operator.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TrailingObjects.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 using namespace lowertypetests;
 
 #define DEBUG_TYPE "lowertypetests"
 
 STATISTIC(ByteArraySizeBits, "Byte array size in bits");

 /// A POD-like structure that we use to store a global reference together with
 /// its metadata types. In this pass we frequently need to query the set of
 /// metadata types referenced by a global, which at the IR level is an expensive
 /// operation involving a map lookup; this data structure helps to reduce the
 /// number of times we need to do this lookup.
 class GlobalTypeMember final : TrailingObjects<GlobalTypeMember, MDNode *> {
   GlobalObject *GO;
   size_t NTypes;
+  // For functions: true if this is a definition (either in the merged module or
+  // in one of the thinlto modules).
+  bool IsDefinition;
+  // For functions: true if this function is either defined or used in a thinlto
+  // module and its jumptable entry needs to be exported to thinlto backends.
+  bool IsExported;
 
   friend TrailingObjects;
   size_t numTrailingObjects(OverloadToken<MDNode *>) const { return NTypes; }
 
 public:
   static GlobalTypeMember *create(BumpPtrAllocator &Alloc, GlobalObject *GO,
+                                  bool IsDefinition, bool IsExported,
                                   ArrayRef<MDNode *> Types) {
     auto *GTM = static_cast<GlobalTypeMember *>(Alloc.Allocate(
         totalSizeToAlloc<MDNode *>(Types.size()), alignof(GlobalTypeMember)));
     GTM->GO = GO;
     GTM->NTypes = Types.size();
+    GTM->IsDefinition = IsDefinition;
+    GTM->IsExported = IsExported;
     std::uninitialized_copy(Types.begin(), Types.end(),
                             GTM->getTrailingObjects<MDNode *>());
     return GTM;
   }
   GlobalObject *getGlobal() const {
     return GO;
   }
+  bool isDefinition() const {
+    return IsDefinition;
+  }
+  bool isExported() const {
+    return IsExported;
+  }
   ArrayRef<MDNode *> types() const {
     return makeArrayRef(getTrailingObjects<MDNode *>(), NTypes);
   }
 };
 
 class LowerTypeTestsModule {
   Module &M;
 
class LowerTypeTestsModule {
 
   std::vector<ByteArrayInfo> ByteArrayInfos;
 
   Function *WeakInitializerFn = nullptr;
 
   void exportTypeId(StringRef TypeId, const TypeIdLowering &TIL);
   TypeIdLowering importTypeId(StringRef TypeId);
   void importTypeTest(CallInst *CI);
+  void importFunction(Function *F, bool isDefinition);
 
   BitSetInfo
   buildBitSet(Metadata *TypeId,
               const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout);
   ByteArrayInfo *createByteArray(BitSetInfo &BSI);
   void allocateByteArrays();
   Value *createBitSetTest(IRBuilder<> &B, const TypeIdLowering &TIL,
                           Value *BitOffset);
report_fatal_error(
         "Second argument of llvm.type.test must be a metadata string");
 
   TypeIdLowering TIL = importTypeId(TypeIdStr->getString());
   Value *Lowered = lowerTypeTestCall(TypeIdStr, CI, TIL);
   CI->replaceAllUsesWith(Lowered);
   CI->eraseFromParent();
 }
 
+// ThinLTO backend: the function F has a jump table entry; update this module
+// accordingly. isDefinition describes the type of the jump table entry.
+void LowerTypeTestsModule::importFunction(Function *F, bool isDefinition) {
+  assert(F->getType()->getAddressSpace() == 0);
+
+  // Declaration of a local function - nothing to do.
+  if (F->isDeclarationForLinker() && isDefinition)
+    return;
+
+  GlobalValue::VisibilityTypes Visibility = F->getVisibility();
+  std::string Name = F->getName();
+  Function *FDecl;
+
+  if (F->isDeclarationForLinker() && !isDefinition) {
+    // Declaration of an external function.
+    FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
+                             Name + ".cfi_jt", &M);
+    FDecl->setVisibility(GlobalValue::HiddenVisibility);
+  } else {
+    // Definition.
+    assert(isDefinition);
+    F->setName(Name + ".cfi");
+    F->setLinkage(GlobalValue::ExternalLinkage);
+    F->setVisibility(GlobalValue::HiddenVisibility);
+    FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
+                             Name, &M);
+    FDecl->setVisibility(Visibility);
+  }
+
+  if (F->isWeakForLinker())
+    replaceWeakDeclarationWithJumpTablePtr(F, FDecl);
+  else
+    F->replaceAllUsesWith(FDecl);
+}
+
 void LowerTypeTestsModule::lowerTypeTestCalls(
     ArrayRef<Metadata *> TypeIds, Constant *CombinedGlobalAddr,
     const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout) {
   CombinedGlobalAddr = ConstantExpr::getBitCast(CombinedGlobalAddr, Int8PtrTy);
 
   // For each type identifier in this disjoint set...
   for (Metadata *TypeId : TypeIds) {
     // Build the bitset.
void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
   // mov h, %ecx
   // ret
   //
   // 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());
 
   // 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;
 
   Function *JumpTableFn =
       Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
                                          /* IsVarArg */ false),
                        GlobalValue::PrivateLinkage, ".cfi.jumptable", &M);
   ArrayType *JumpTableType =
       ArrayType::get(getJumpTableEntryType(), Functions.size());
   auto JumpTable =
       ConstantExpr::getPointerCast(JumpTableFn, JumpTableType->getPointerTo(0));
 
   lowerTypeTestCalls(TypeIds, JumpTable, GlobalLayout);
 
   // 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());
+    bool IsDefinition = Functions[I]->isDefinition();
 
     Constant *CombinedGlobalElemPtr = ConstantExpr::getBitCast(
         ConstantExpr::getInBoundsGetElementPtr(
             JumpTableType, JumpTable,
             ArrayRef<Constant *>{ConstantInt::get(IntPtrTy, 0),
                                  ConstantInt::get(IntPtrTy, I)}),
         F->getType());
-    if (F->isDeclarationForLinker()) {
+    if (Functions[I]->isExported()) {
+      if (IsDefinition) {
+        ExportSummary->cfiFunctionDefs().insert(F->getName());
+      } else {
+        GlobalAlias *JtAlias = GlobalAlias::create(
+            F->getValueType(), 0, GlobalValue::ExternalLinkage,
+            F->getName() + ".cfi_jt", CombinedGlobalElemPtr, &M);
+        JtAlias->setVisibility(GlobalValue::HiddenVisibility);
+        ExportSummary->cfiFunctionDecls().insert(F->getName());
+      }
+    }
+    if (!IsDefinition) {
       if (F->isWeakForLinker())
         replaceWeakDeclarationWithJumpTablePtr(F, CombinedGlobalElemPtr);
       else
         F->replaceAllUsesWith(CombinedGlobalElemPtr);
     } else {
       assert(F->getType()->getAddressSpace() == 0);
 
-      GlobalAlias *FAlias = GlobalAlias::create(F->getValueType(), 0,
-                                                F->getLinkage(), "",
-                                                CombinedGlobalElemPtr, &M);
+      GlobalAlias *FAlias = GlobalAlias::create(
+          F->getValueType(), 0, F->getLinkage(), "", CombinedGlobalElemPtr, &M);
       FAlias->setVisibility(F->getVisibility());
       FAlias->takeName(F);
       if (FAlias->hasName())
         F->setName(FAlias->getName() + ".cfi");
       F->replaceAllUsesWith(FAlias);
     }
     if (!F->isDeclarationForLinker())
       F->setLinkage(GlobalValue::InternalLinkage);
if (!ClWriteSummary.empty()) {
 
     yaml::Output Out(OS);
     Out << Summary;
   }
 
   return Changed;
 }
 
+static bool IsFunctionLive(StringRef Name, const ModuleSummaryIndex *Summary) {
+  auto GUID = GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name));
+  ValueInfo Info = Summary->getValueInfo(GUID);
+  if (!Info)
+    return true;
+  const auto &SummaryList = Info.getSummaryList();
+  if (SummaryList.empty())
+    return true;
+  return Summary->isGlobalValueLive(SummaryList[0].get());
+}
+
 bool LowerTypeTestsModule::lower() {
   Function *TypeTestFunc =
       M.getFunction(Intrinsic::getName(Intrinsic::type_test));
-  if ((!TypeTestFunc || TypeTestFunc->use_empty()) && !ExportSummary)
+  if ((!TypeTestFunc || TypeTestFunc->use_empty()) && !ExportSummary &&
+      !ImportSummary)
     return false;
 
   if (ImportSummary) {
+    if (TypeTestFunc) {
       for (auto UI = TypeTestFunc->use_begin(), UE = TypeTestFunc->use_end();
            UI != UE;) {
         auto *CI = cast<CallInst>((*UI++).getUser());
         importTypeTest(CI);
       }
+    }
+
+    SmallVector<Function *, 8> Defs;
+    SmallVector<Function *, 8> Decls;
+    for (auto &F : M) {
+      if (ImportSummary->cfiFunctionDefs().count(F.getName()))
+        Defs.push_back(&F);
+      else if (ImportSummary->cfiFunctionDecls().count(F.getName()))
+        Decls.push_back(&F);
+    }
+
+    for (auto F : Defs)
+      importFunction(F, /*isDefinition*/ true);
+    for (auto F : Decls)
+      importFunction(F, /*isDefinition*/ false);
+
     return true;
   }
 
   // Equivalence class set containing type identifiers and the globals that
   // reference them. This is used to partition the set of type identifiers in
   // the module into disjoint sets.
   typedef EquivalenceClasses<PointerUnion<GlobalTypeMember *, Metadata *>>
       GlobalClassesTy;
bool LowerTypeTestsModule::lower() {
   BumpPtrAllocator Alloc;
   struct TIInfo {
     unsigned Index;
     std::vector<GlobalTypeMember *> RefGlobals;
   };
   llvm::DenseMap<Metadata *, TIInfo> TypeIdInfo;
   unsigned I = 0;
   SmallVector<MDNode *, 2> Types;
+
+  DenseMap<StringRef, std::pair<bool, MDNode *>> ExportedFunctions;
+  if (ExportSummary) {
+    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 (!IsFunctionLive(FunctionName, ExportSummary)) {
+          continue;
+        }
+        unsigned Linkage = cast<ConstantAsMetadata>(FuncMD->getOperand(1))
+                               ->getValue()
+                               ->getUniqueInteger()
+                               .getZExtValue();
+        bool isDefinition = Linkage == 0;
+        auto &V = ExportedFunctions[FunctionName];
+        if (isDefinition >= V.first)
+          V = {isDefinition, FuncMD};
+      }
+
+      for (auto &P : ExportedFunctions) {
+        StringRef FunctionName = P.first;
+        // bool isDefinition = P.second.first;
+        MDNode *FuncMD = P.second.second;
+        unsigned Linkage = cast<ConstantAsMetadata>(FuncMD->getOperand(1))
+                               ->getValue()
+                               ->getUniqueInteger()
+                               .getZExtValue();
+
+        Function *F = M.getFunction(FunctionName);
+        if (!F)
+          F = Function::Create(
+              FunctionType::get(Type::getVoidTy(M.getContext()), false),
+              GlobalVariable::ExternalLinkage, FunctionName, &M);
+
+        if (Linkage == 2) // weak
+          F->setLinkage(GlobalValue::ExternalWeakLinkage);
+
+        SmallVector<MDNode *, 2> Types;
+        for (unsigned I = 2; I < FuncMD->getNumOperands(); ++I)
+          F->addMetadata(LLVMContext::MD_type,
+                         *cast<MDNode>(FuncMD->getOperand(I).get()));
+      }
+    }
+  }
+
   for (GlobalObject &GO : M.global_objects()) {
     if (isa<GlobalVariable>(GO) && GO.isDeclarationForLinker())
       continue;
 
     Types.clear();
     GO.getMetadata(LLVMContext::MD_type, Types);
     if (Types.empty())
       continue;
 
-    auto *GTM = GlobalTypeMember::create(Alloc, &GO, Types);
+    bool IsDefinition = !GO.isDeclarationForLinker();
+    bool IsExported = false;
+    if (isa<Function>(GO) && ExportedFunctions.count(GO.getName())) {
+      bool IsExportedDefinition = ExportedFunctions[GO.getName()].first;
+      IsDefinition |= IsExportedDefinition;
+      IsExported = true;
+    }
+
+    auto *GTM =
+        GlobalTypeMember::create(Alloc, &GO, IsDefinition, IsExported, Types);
     for (MDNode *Type : Types) {
       verifyTypeMDNode(&GO, Type);
       auto &Info = TypeIdInfo[cast<MDNode>(Type)->getOperand(1)];
       Info.Index = ++I;
       Info.RefGlobals.push_back(GTM);
     }
   }
 

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 using namespace llvm;
 
 namespace {
 
 // Promote each local-linkage entity defined by ExportM and used by ImportM by
 // changing visibility and appending the given ModuleId.
 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId) {
+  NamedMDNode *CfiFunctionsMD = ImportM.getNamedMetadata("cfi.functions");
+  DenseMap<StringRef, MDNode*> CfiFunctions;
+  if (CfiFunctionsMD)
+    for (auto MD : CfiFunctionsMD->operands())
+      CfiFunctions[cast<MDString>(MD->getOperand(0))->getString()] = MD;
+
   DenseMap<const Comdat *, Comdat *> RenamedComdats;
   for (auto &ExportGV : ExportM.global_values()) {
     if (!ExportGV.hasLocalLinkage())
       continue;
 
     auto Name = ExportGV.getName();
     GlobalValue *ImportGV = ImportM.getNamedValue(Name);
-    if (!ImportGV || ImportGV->use_empty())
+    bool HasMetadataRef = CfiFunctions.count(Name);
+    if ((!ImportGV || ImportGV->use_empty()) && !HasMetadataRef)
       continue;
 
     std::string NewName = (Name + ModuleId).str();
 
     if (const auto *C = ExportGV.getComdat())
       if (C->getName() == Name)
         RenamedComdats.try_emplace(C, ExportM.getOrInsertComdat(NewName));
 
     ExportGV.setName(NewName);
     ExportGV.setLinkage(GlobalValue::ExternalLinkage);
     ExportGV.setVisibility(GlobalValue::HiddenVisibility);
 
+    if (ImportGV) {
       ImportGV->setName(NewName);
       ImportGV->setVisibility(GlobalValue::HiddenVisibility);
     }
+    if (HasMetadataRef) {
+      MDNode *&ImportMD = CfiFunctions[Name];
+      SmallVector<Metadata *, 4> Ops;
+      Ops.push_back(MDString::get(ImportM.getContext(), NewName));
+      for (unsigned I = 1; I < ImportMD->getNumOperands(); ++I)
+        Ops.push_back(ImportMD->getOperand(I));
+      ImportMD = MDTuple::get(ImportM.getContext(), Ops);
+      // Don't bother updating CfiFunctions key.
+    }
+  }
 
   if (!RenamedComdats.empty())
     for (auto &GO : ExportM.global_objects())
       if (auto *C = GO.getComdat()) {
         auto Replacement = RenamedComdats.find(C);
         if (Replacement != RenamedComdats.end())
           GO.setComdat(Replacement->second);
       }
+
+  if(CfiFunctionsMD) {
+    CfiFunctionsMD->clearOperands();
+    for (auto I : CfiFunctions)
+      CfiFunctionsMD->addOperand(I.second);
+  }
 }
 
 // Promote all internal (i.e. distinct) type ids used by the module by replacing
 // them with external type ids formed using the module id.
 //
 // Note that this needs to be done before we clone the module because each clone
 // will receive its own set of distinct metadata nodes.
 void promoteTypeIds(Module &M, StringRef ModuleId) {
for (Function &F : *MergedM)
     if (!F.isDeclaration()) {
       // Reset the linkage of all functions eligible for virtual constant
       // propagation. The canonical definitions live in the thin LTO module so
       // that they can be imported.
       F.setLinkage(GlobalValue::AvailableExternallyLinkage);
       F.setComdat(nullptr);
     }
 
+
+  SmallVector<MDNode *, 8> CfiFunctions;
+  for (auto &F : M) {
+    if (!F.hasLocalLinkage() || F.hasAddressTaken()) {
+      SmallVector<MDNode *, 2> Types;
+      F.getMetadata(LLVMContext::MD_type, Types);
+      if (Types.empty())
+        continue;
+
+      auto &Ctx = MergedM->getContext();
+      SmallVector<Metadata *, 4> Elts;
+      Elts.push_back(MDString::get(Ctx, F.getName()));
+      unsigned Linkage =
+          F.isDeclarationForLinker() ? (F.isWeakForLinker() ? 2 : 1) : 0;
+      Elts.push_back(ConstantAsMetadata::get(
+          llvm::ConstantInt::get(Type::getInt8Ty(Ctx), Linkage)));
+      for (auto Type : Types)
+        Elts.push_back(Type);
+
+      MDNode *MDF = MDTuple::get(Ctx, Elts);
+      CfiFunctions.push_back(MDF);
+    }
+  }
+
+  if(!CfiFunctions.empty()) {
+    NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("cfi.functions");
+    for (auto MD : CfiFunctions)
+      NMD->addOperand(MD);
+  }
+
+
   // Remove all globals with type metadata, globals with comdats that live in
   // MergedM, and aliases pointing to such globals from the thin LTO module.
   filterModule(&M, [&](const GlobalValue *GV) {
     if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getBaseObject()))
       if (HasTypeMetadata(GVar))
         return false;
     if (const auto *C = GV->getComdat())
       if (MergedMComdats.count(C))

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: 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 void @foo() !type !0 {
+entry:
+  ret void
+}
+
+!llvm.module.flags = !{!1}
+
+!0 = !{i64 0, i64 1234}
+!1 = !{i32 4, !"Cross-DSO CFI", i32 1}
+
+; COMBINED:   <GLOBALVAL_SUMMARY_BLOCK
+; COMBINED:     <CFI_FUNCTIONS op0=1 op1=0 op2=3/>
+; COMBINED:   </GLOBALVAL_SUMMARY_BLOCK>
+
+; COMBINED:      <STRTAB_BLOCK
+; COMBINED-NEXT:   <BLOB abbrevid=4/> blob data = 'foo'
+; COMBINED-NEXT: </STRTAB_BLOCK>

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

+---
+TypeIdMap:
+  typeid1:
+    TTRes:
+      Kind:            AllOnes
+      SizeM1BitWidth:  7
+  typeid2:
+    TTRes:
+      Kind:            Single
+      SizeM1BitWidth:  0
+WithGlobalValueDeadStripping: false
+CfiFunctionDefs:
+  - local_a
+  - local_b
+  - does_not_exist
+CfiFunctionDecls:
+  - external
+  - external_weak
+...

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: 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
+}
+
+!cfi.functions = !{!0, !1, !3, !4, !5, !6}
+
+!0 = !{!"h", i8 0, !2}
+!1 = !{!"h", i8 1, !2}
+!2 = !{i64 0, !"typeid1"}
+!3 = !{!"f", i8 0, !2}
+!4 = !{!"external", i8 1, !2}
+!5 = !{!"external_weak", i8 2, !2}
+!6 = !{!"g", i8 0, !7}
+!7 = !{i64 0, !"typeid2"}
+
+
+; CHECK: @__typeid_typeid1_global_addr = hidden alias i8, bitcast (void ()* [[JT1:.*]] to i8*)
+; CHECK: @__typeid_typeid1_align = hidden alias i8, inttoptr (i8 3 to i8*)
+; CHECK: @__typeid_typeid1_size_m1 = hidden alias i8, inttoptr (i64 3 to i8*)
+
+; CHECK: @h                    = alias void (i8), bitcast (void ()* [[JT1]] to void (i8)*)
+; CHECK: @external.cfi_jt      = hidden alias void (), {{.*}}getelementptr {{.*}}void ()* [[JT1]]
+; CHECK: @f                    = alias void (), {{.*}}getelementptr {{.*}}void ()* [[JT1]]
+; CHECK: @external_weak.cfi_jt = hidden alias void (), {{.*}}getelementptr {{.*}}void ()* [[JT1]]
+
+; CHECK: @__typeid_typeid2_global_addr = hidden alias i8, bitcast (void ()* [[JT2:.*]] to i8*)
+
+; CHECK: @g                    = alias void (), void ()* [[JT2]]
+
+; CHECK: define internal void @h.cfi(i8 {{.*}}) !type !{{.*}}
+; CHECK: declare !type !{{.*}} void @external()
+; CHECK: declare !type !{{.*}} void @f.cfi()
+; CHECK: declare !type !{{.*}} void @external_weak()
+; CHECK: declare !type !{{.*}} void @g.cfi()
+
+
+; SUMMARY:      TypeIdMap:
+; SUMMARY-NEXT:   typeid1:
+; SUMMARY-NEXT:     TTRes:
+; SUMMARY-NEXT:       Kind:            AllOnes
+; SUMMARY-NEXT:       SizeM1BitWidth:  7
+; SUMMARY-NEXT:     WPDRes:
+; SUMMARY-NEXT:   typeid2:
+; SUMMARY-NEXT:     TTRes:
+; SUMMARY-NEXT:       Kind:            Single
+; SUMMARY-NEXT:       SizeM1BitWidth:  0
+; SUMMARY-NEXT:     WPDRes:
+
+; SUMMARY:      CfiFunctionDefs:
+; SUMMARY-NEXT:   - f
+; SUMMARY-NEXT:   - g
+; SUMMARY-NEXT:   - h
+; SUMMARY-NEXT: CfiFunctionDecls:
+; SUMMARY-NEXT:   - external
+; SUMMARY-NEXT:   - external_weak
+; SUMMARY-NEXT: ...

test/Transforms/LowerTypeTests/import-icall.ll

+; RUN: opt -S -lowertypetests -lowertypetests-summary-action=import -lowertypetests-read-summary=%S/Inputs/import-icall.yaml < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define i8 @local_a() {
+  call void @external()
+  call void @external_weak()
+  ret i8 1
+}
+
+define i8 @local_b() {
+  %x = call i8 @local_a()
+  ret i8 %x
+}
+
+
+declare void @external()
+declare extern_weak void @external_weak()
+
+; CHECK:      define hidden i8 @local_a.cfi() {
+; CHECK-NEXT:   call void @external.cfi_jt()
+; CHECK-NEXT:   call void select (i1 icmp ne (void ()* @external_weak, void ()* null), void ()* @external_weak.cfi_jt, void ()* null)()
+; CHECK-NEXT:   ret i8 1
+; CHECK-NEXT: }
+
+; CHECK:      define hidden i8 @local_b.cfi() {
+; CHECK-NEXT:   call i8 @local_a()
+
+; CHECK: declare void @external()
+; CHECK: declare extern_weak void @external_weak()
+; CHECK: declare i8 @local_a()
+; CHECK: declare i8 @local_b()
+; CHECK: declare hidden void @external.cfi_jt()
+; CHECK: declare hidden void @external_weak.cfi_jt()

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

default:
       STRINGIFY_CODE(FS, COMBINED_ORIGINAL_NAME)
       STRINGIFY_CODE(FS, VERSION)
       STRINGIFY_CODE(FS, TYPE_TESTS)
       STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_VCALLS)
       STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_VCALLS)
       STRINGIFY_CODE(FS, TYPE_TEST_ASSUME_CONST_VCALL)
       STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
       STRINGIFY_CODE(FS, VALUE_GUID)
+      STRINGIFY_CODE(FS, CFI_FUNCTIONS)
     }
   case bitc::METADATA_ATTACHMENT_ID:
     switch(CodeID) {
     default:return nullptr;
       STRINGIFY_CODE(METADATA, ATTACHMENT)
     }
   case bitc::METADATA_BLOCK_ID:
     switch(CodeID) {