[ThinLTO] Include linkage type in function summary

[tejohnson]

Summary

Adds the linkage type to both the per-module and combined function
summaries, which subsumes the current islocal bit. This will eventually
be used to optimized linkage types based on global summary-based
analysis.

[mehdi_amini]

LGTM.

include/llvm/Bitcode/LLVMBitCodes.h

enum { BITCODE_CURRENT_EPOCH = 0 };
   // The module path symbol table only has one code (MST_CODE_ENTRY).
   enum ModulePathSymtabCodes {
     MST_CODE_ENTRY   = 1,  // MST_ENTRY: [modid, namechar x N]
   };
 
   // The function summary section uses different codes in the per-module
   // and combined index cases.
   enum FunctionSummarySymtabCodes {
-    FS_CODE_PERMODULE_ENTRY = 1,  // FS_ENTRY: [valueid, islocal, instcount]
-    FS_CODE_COMBINED_ENTRY  = 2,  // FS_ENTRY: [modid, instcount]
+    FS_CODE_PERMODULE_ENTRY = 1,  // FS_ENTRY: [valueid, linkage, instcount]
+    FS_CODE_COMBINED_ENTRY  = 2,  // FS_ENTRY: [modid, linkage, instcount]
   };
 
   enum MetadataCodes {
     METADATA_STRING        = 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/FunctionInfo.h

private:
   /// importing this function.
   ///
   /// This is only used during parsing of the combined function index, or when
   /// parsing the per-module index for creation of the combined function index,
   /// not during writing of the per-module index which doesn't contain a
   /// module path string table.
   StringRef ModulePath;
 
-  /// \brief Used to flag functions that have local linkage types and need to
+  /// \brief The linkage type of the associated function.
+  ///
+  /// One use is to flag functions that have local linkage types and need to
   /// have module identifier appended before placing into the combined
   /// index, to disambiguate from other functions with the same name.
-  ///
-  /// This is only used in the per-module function index, as it is consumed
-  /// while creating the combined index.
-  bool IsLocalFunction;
+  /// In the future this will be used to update and optimize linkage
+  /// types based on global summary-based analysis.
+  GlobalValue::LinkageTypes FunctionLinkage;
 
   // The rest of the information is used to help decide whether importing
   // is likely to be profitable.
   // Other information will be added as the importing is tuned, such
   // as hotness (when profile available), and other function characteristics.
 
   /// Number of instructions (ignoring debug instructions, e.g.) computed
   /// during the initial compile step when the function index is first built.
   unsigned InstCount;
 
 public:
   /// Construct a summary object from summary data expected for all
   /// summary records.
   FunctionSummary(unsigned NumInsts) : InstCount(NumInsts) {}
 
   /// Set the path to the module containing this function, for use in
   /// the combined index.
   void setModulePath(StringRef ModPath) { ModulePath = ModPath; }
 
   /// Get the path to the module containing this function.
   StringRef modulePath() const { return ModulePath; }
 
-  /// Record whether this is a local function in the per-module index.
-  void setLocalFunction(bool IsLocal) { IsLocalFunction = IsLocal; }
+  /// Record linkage type.
+  void setFunctionLinkage(GlobalValue::LinkageTypes Linkage) {
+    FunctionLinkage = Linkage;
+  }
 
-  /// Check whether this was a local function, for use in creating
-  /// the combined index.
-  bool isLocalFunction() const { return IsLocalFunction; }
+  /// Return linkage type recorded for this function.
+  GlobalValue::LinkageTypes getFunctionLinkage() const {
+    return FunctionLinkage;
+  }
 
   /// Get the instruction count recorded for this function.
   unsigned instCount() const { return InstCount; }
 };
 
 /// \brief Class to hold pointer to function summary and information required
 /// for parsing it.
 ///

lib/Bitcode/Reader/BitcodeReader.cpp

while (1) {
     // via the bitcode offset of the summary records (which were saved
     // in the combined index VST entries). The records also contain
     // information used for ThinLTO renaming and importing.
     Record.clear();
     uint64_t CurRecordBit = Stream.GetCurrentBitNo();
     switch (Stream.readRecord(Entry.ID, Record)) {
     default: // Default behavior: ignore.
       break;
-    // FS_PERMODULE_ENTRY: [valueid, islocal, instcount]
+    // FS_PERMODULE_ENTRY: [valueid, linkage, instcount]
     case bitc::FS_CODE_PERMODULE_ENTRY: {
       unsigned ValueID = Record[0];
-      bool IsLocal = Record[1];
+      uint64_t RawLinkage = Record[1];
       unsigned InstCount = Record[2];
       std::unique_ptr<FunctionSummary> FS =
           llvm::make_unique<FunctionSummary>(InstCount);
-      FS->setLocalFunction(IsLocal);
+      FS->setFunctionLinkage(getDecodedLinkage(RawLinkage));
       // The module path string ref set in the summary must be owned by the
       // index's module string table. Since we don't have a module path
       // string table section in the per-module index, we create a single
       // module path string table entry with an empty (0) ID to take
       // ownership.
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0));
       SummaryMap[ValueID] = std::move(FS);
     }
-    // FS_COMBINED_ENTRY: [modid, instcount]
+    // FS_COMBINED_ENTRY: [modid, linkage, instcount]
     case bitc::FS_CODE_COMBINED_ENTRY: {
       uint64_t ModuleId = Record[0];
-      unsigned InstCount = Record[1];
+      uint64_t RawLinkage = Record[1];
+      unsigned InstCount = Record[2];
       std::unique_ptr<FunctionSummary> FS =
           llvm::make_unique<FunctionSummary>(InstCount);
+      FS->setFunctionLinkage(getDecodedLinkage(RawLinkage));
       FS->setModulePath(ModuleIdMap[ModuleId]);
       SummaryMap[CurRecordBit] = std::move(FS);
     }
     }
   }
   llvm_unreachable("Exit infinite loop");
 }
 

lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
     TypeVals.clear();
   }
 
   Stream.ExitBlock();
 }
 
-static unsigned getEncodedLinkage(const GlobalValue &GV) {
-  switch (GV.getLinkage()) {
+static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
+  switch (Linkage) {
   case GlobalValue::ExternalLinkage:
     return 0;
   case GlobalValue::WeakAnyLinkage:
     return 16;
   case GlobalValue::AppendingLinkage:
     return 2;
   case GlobalValue::InternalLinkage:
     return 3;
static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
   case GlobalValue::LinkOnceODRLinkage:
     return 19;
   case GlobalValue::AvailableExternallyLinkage:
     return 12;
   }
   llvm_unreachable("Invalid linkage");
 }
 
+static unsigned getEncodedLinkage(const GlobalValue &GV) {
+  return getEncodedLinkage(GV.getLinkage());
+}
+
 static unsigned getEncodedVisibility(const GlobalValue &GV) {
   switch (GV.getVisibility()) {
   case GlobalValue::DefaultVisibility:   return 0;
   case GlobalValue::HiddenVisibility:    return 1;
   case GlobalValue::ProtectedVisibility: return 2;
   }
   llvm_unreachable("Invalid visibility");
 }

 /// to hold the provided summary information.
 static void SaveFunctionInfo(
     const Function &F,
     DenseMap<const Function *, std::unique_ptr<FunctionInfo>> &FunctionIndex,
     unsigned NumInsts, uint64_t BitcodeIndex, bool EmitFunctionSummary) {
   std::unique_ptr<FunctionSummary> FuncSummary;
   if (EmitFunctionSummary) {
     FuncSummary = llvm::make_unique<FunctionSummary>(NumInsts);
-    FuncSummary->setLocalFunction(F.hasLocalLinkage());
+    FuncSummary->setFunctionLinkage(F.getLinkage());
   }
   FunctionIndex[&F] =
       llvm::make_unique<FunctionInfo>(BitcodeIndex, std::move(FuncSummary));
 }
 
 /// Emit a function body to the module stream.
 static void WriteFunction(
     const Function &F, ValueEnumerator &VE, BitstreamWriter &Stream,

 }
 
 // Helper to emit a single function summary record.
 static void WritePerModuleFunctionSummaryRecord(
     SmallVector<unsigned, 64> &NameVals, FunctionSummary *FS, unsigned ValueID,
     unsigned FSAbbrev, BitstreamWriter &Stream) {
   assert(FS);
   NameVals.push_back(ValueID);
-  NameVals.push_back(FS->isLocalFunction());
+  NameVals.push_back(getEncodedLinkage(FS->getFunctionLinkage()));
   NameVals.push_back(FS->instCount());
 
   // Emit the finished record.
   Stream.EmitRecord(bitc::FS_CODE_PERMODULE_ENTRY, NameVals, FSAbbrev);
   NameVals.clear();
 }
 
 /// Emit the per-module function summary section alongside the rest of
 /// the module's bitcode.
 static void WritePerModuleFunctionSummary(
     DenseMap<const Function *, std::unique_ptr<FunctionInfo>> &FunctionIndex,
     const Module *M, const ValueEnumerator &VE, BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::FUNCTION_SUMMARY_BLOCK_ID, 3);
 
   // Abbrev for FS_CODE_PERMODULE_ENTRY.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_PERMODULE_ENTRY));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // islocal
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<unsigned, 64> NameVals;
   // Iterate over the list of functions instead of the FunctionIndex map to
   // ensure the ordering is stable.
   for (const Function &F : *M) {
     if (F.isDeclaration())

 static void WriteCombinedFunctionSummary(const FunctionInfoIndex &I,
                                          BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::FUNCTION_SUMMARY_BLOCK_ID, 3);
 
   // Abbrev for FS_CODE_COMBINED_ENTRY.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_CODE_COMBINED_ENTRY));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // instcount
   unsigned FSAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<unsigned, 64> NameVals;
   for (const auto &FII : I) {
     for (auto &FI : FII.getValue()) {
       FunctionSummary *FS = FI->functionSummary();
       assert(FS);
 
       NameVals.push_back(I.getModuleId(FS->modulePath()));
+      NameVals.push_back(getEncodedLinkage(FS->getFunctionLinkage()));
       NameVals.push_back(FS->instCount());
 
       // Record the starting offset of this summary entry for use
       // in the VST entry. Add the current code size since the
       // reader will invoke readRecord after the abbrev id read.
       FI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth());
 
       // Emit the finished record.

lib/IR/FunctionInfo.cpp

else
              "Each module in the combined map should have a unique ID");
 
     // Note the module path string ref was copied above and is still owned by
     // the original per-module index. Reset it to the new module path
     // string reference owned by the combined index.
     Info->functionSummary()->setModulePath(ModPath);
 
     // If it is a local function, rename it.
-    if (Info->functionSummary()->isLocalFunction()) {
+    if (GlobalValue::isLocalLinkage(
+            Info->functionSummary()->getFunctionLinkage())) {
       // Any local functions are virtually renamed when being added to the
       // combined index map, to disambiguate from other functions with
       // the same name. The symbol table created for the combined index
       // file should contain the renamed symbols.
       FuncName =
           FunctionInfoIndex::getGlobalNameForLocal(FuncName, NextModuleId);
     }
 
     // Add new function info to existing list. There may be duplicates when
     // combining FunctionMap entries, due to COMDAT functions. Any local
     // functions were virtually renamed above.
     addFunctionInfo(FuncName, std::move(Info));
   }
 }

test/Bitcode/thinlto-function-summary.ll

 ; RUN: llvm-as -function-summary < %s | llvm-bcanalyzer -dump | FileCheck %s -check-prefix=BC
 ; Check for function summary block/records.
 
 ; Check the value ids in the function summary entries against the
 ; same in the ValueSumbolTable, to ensure the ordering is stable.
-; Also check the islocal flag on the summary entries.
+; Also check the linkage field on the summary entries.
 ; BC: <FUNCTION_SUMMARY_BLOCK
 ; BC-NEXT: <PERMODULE_ENTRY {{.*}} op0=1 op1=0
 ; BC-NEXT: <PERMODULE_ENTRY {{.*}} op0=2 op1=0
-; BC-NEXT: <PERMODULE_ENTRY {{.*}} op0=4 op1=1
+; BC-NEXT: <PERMODULE_ENTRY {{.*}} op0=4 op1=3
 ; BC-NEXT: </FUNCTION_SUMMARY_BLOCK
 ; BC-NEXT: <VALUE_SYMTAB
 ; BC-NEXT: <FNENTRY {{.*}} op0=1 {{.*}}> record string = 'foo'
 ; BC-NEXT: <FNENTRY {{.*}} op0=2 {{.*}}> record string = 'bar'
 ; BC-NEXT: <FNENTRY {{.*}} op0=4 {{.*}}> record string = 'f'
 
 ; RUN: llvm-as -function-summary < %s | llvm-dis | FileCheck %s
 ; Check that this round-trips correctly.

test/Bitcode/thinlto-summary-linkage-types.ll

+; Check the linkage types in both the per-module and combined summaries.
+; RUN: llvm-as -function-summary %s -o %t.o
+; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
+; RUN: llvm-lto -thinlto -o %t2 %t.o
+; RUN: llvm-bcanalyzer -dump %t2.thinlto.bc | FileCheck %s --check-prefix=COMBINED
+
+define private void @private()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=9
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=9
+{
+  ret void
+}
+
+define internal void @internal()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=3
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=3
+{
+  ret void
+}
+
+define available_externally void @available_externally()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=12
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=12
+{
+  ret void
+}
+
+define linkonce void @linkonce()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=18
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=18
+{
+  ret void
+}
+
+define weak void @weak()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=16
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=16
+{
+  ret void
+}
+
+define linkonce_odr void @linkonce_odr()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=19
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=19
+{
+  ret void
+}
+
+define weak_odr void @weak_odr()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=17
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=17
+{
+  ret void
+}
+
+define external void @external()
+; CHECK: <PERMODULE_ENTRY {{.*}} op1=0
+; COMBINED-DAG: <COMBINED_ENTRY {{.*}} op1=0
+{
+  ret void
+}