Make aliases explicit in the module summary

[mehdi_amini]

Summary

To be able to work accurately on the reference graph when taking decision
about internalizing, promoting, renaming, etc. We need to have the alias
information explicit.

This needs a bit of cleanup and a few more test, but you may have some early comments on the general way of representing this.

[mehdi_amini]

Added a test

[mehdi_amini]

Teresa, FYI this is rebased on your changes in D18763

[tejohnson]

include/llvm/Bitcode/LLVMBitCodes.h

215

COMBINED_ALIAS

lib/Bitcode/Reader/BitcodeReader.cpp

5857

Note somewhere that it is expected that all alias records should follow all of the other summary records?

Also, I think this will be an issue for anonymous functions since won't get a summary for them (see comment below in bitcode writer)

lib/Bitcode/Writer/BitcodeWriter.cpp

2928

Comment is wrong now. With this change we will no longer get a summary emitted for anonymous functions.

2964

Do this renaming in a different NFC commit?

3120

The name seems off - this is an offset not an ID.

3132

continue is unnecessary

lib/Transforms/IPO/FunctionImport.cpp

90

Anonymous function may not have summary, see earlier comment

347

Lost this comment, I think it was useful.

test/Bitcode/thinlto-function-summary.ll

10

This is a case where aliasee is an anonymous function and doesn't have a summary. I would expect the reading side to hit some of the asserts I called out earlier.

[mehdi_amini]

lib/Bitcode/Writer/BitcodeWriter.cpp

2928

Indeed. Can we just "rename" anonymous functions in the compile-phase of the ThinLTO pipeline?
Then we would just guarantee to not have any anonymous function.

2964

Will do.

3120

Yes, I started with an ID before realizing I needed an offset, will rename.

lib/Transforms/IPO/FunctionImport.cpp

347

Indeed, will restore!

[mehdi_amini]

Address comments. Assuming a separate patch will introduce renaming for anonymous functions.

[tejohnson]

lib/Bitcode/Reader/BitcodeReader.cpp

5840

Maybe "Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as they expect all aliasee summaries to be available." Similar for the COMBINED_ALIAS

lib/Bitcode/Writer/BitcodeWriter.cpp

2928

I guess? Don't know what expectations there are for anonymous functions, but that would certainly make life easier.

2932

Won't this cause assert for anonymous function in thinlto-function-summary.ll test?

[mehdi_amini]

Address comment. Accept nameless functions but don't write an entry in the summary for alias to them.

[tejohnson]

lib/Bitcode/Reader/BitcodeReader.cpp

5925

s/FS_PERMODULE/FS_COMBINED/

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

Saw that you sent a patch to rename them on which this is dependent (will review that tomorrow morn). Assuming that goes in first, perhaps this should stay an assert? Ditto for the continue you added below to the alias loop.

[mehdi_amini]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

That's why I put the assert originally. But then I wasn't sure anymore: should we forbid llvm-as -module-summary test.ll when it contains an alias to an anonymous function?
The current implementation will accept it, but the alias will just not be present in the summary.

2932

Yes, until we name them :)

[tejohnson]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

Looked at the anon function renaming pass - ok I see the issue is that it is a pass that it won't kick in for llvm-as. I think that should be fixed - similar to the way with D18763 I am computing the Index in llvm-as by invoking the builder directly, I think that the renaming in your new pass should be structured so that it is done in a separate class that can be invoked either from the pass or out of pass. I don't think we want to get a different index when there are anonymous functions that come directly from source through the pass manager vs from LLVM assembly via llvm-as.

And then this can be turned back into an assert to catch anything unexpected.

[mehdi_amini]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

I already made it a utility (there is a free function in a public header), because my original plan was to do exactly what you mention above. However I was not super comfortable making llvm-as depends on the Transformations library, or modifying the IR itself...

[tejohnson]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

Ah, see that now about the utility function.

I think it should be moved out of Transforms into some place more accessible.

IMO changing the IR in llvm-as for this purpose is acceptable, but not sure what the general philosophy is.

[mehdi_amini]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

I'll wait for Duncan's opinion on this (he's OOO right now).

We would break round-tripping through llvm-as | llvm-dis when summary is enabled.

[tejohnson]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

What does it mean to break round-tripping? Is it required that the output be identical to the input? Because once I add serialization of the index, that will be a difference.

[mehdi_amini]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

I just meant that the IR is changed here.
I'm not totally opposed to it, but I'd rather have someone else giving an opinion before doing it.

[tejohnson]

lib/Bitcode/Writer/BitcodeWriter.cpp

2943

I think this loop should be removed? Doesn't the new FS_ALIAS support apply to references as well?

[mehdi_amini]

Remove obsolete loop pointed by Teresa

[mehdi_amini]

Error when a nameless function is encountered during summary writing, this is possible after D19032 (move from llvm-as to opt)

[tejohnson]

lib/Bitcode/Writer/BitcodeWriter.cpp

2929

Maybe "should have been renamed by anonymous function renaming pass"?

test/Bitcode/thinlto-function-summary.ll

1

Needs merge. But I think there is still an issue here, as opt will also need to be invoked with the -name-anon-functions to avoid the new assert. Which makes me wonder - should the -module-summary option to opt force enable -name-anon-functions? Or if not, at least warn if that wasn't specified?

[mehdi_amini]

Rebase, fix some tests that require the name-anon-function pass

[mehdi_amini]

Improve a little bit one test

[mehdi_amini]

Rebase

[mehdi_amini]

Anything else here?

[tejohnson]

Thanks! One unaddressed nit noted below, and a suggestion for future patch.

lib/Bitcode/Reader/BitcodeReader.cpp

5925

This one still needs a fix.

test/Bitcode/thinlto-function-summary.ll

1

Not for this patch, but I still think it would be useful to make opt either force enable -name-anon-functions when -module-summary is supplied, or at least warn if it wasn't.

[mehdi_amini]

r266517

include/llvm/Bitcode/LLVMBitCodes.h

enum GlobalValueSummarySymtabCodes {
   //            n x (valueid, callsitecount)]
   FS_COMBINED = 4,
   // COMBINED_PROFILE: [modid, linkage, instcount, numrefs,
   //                    numrefs x valueid,
   //                    n x (valueid, callsitecount, profilecount)]
   FS_COMBINED_PROFILE = 5,
   // COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid]
   FS_COMBINED_GLOBALVAR_INIT_REFS = 6,
+  // ALIAS: [valueid, linkage, valueid]
+  FS_ALIAS = 7,
+  // ALIAS: [modid, linkage, offset]
+  FS_COMBINED_ALIAS = 8,
 };
 
 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

 /// \brief Function and variable summary information to aid decisions and
 /// implementation of importing.
 ///
 /// This is a separate class from GlobalValueInfo to enable lazy reading of this
 /// summary information from the combined index file during imporing.
 class GlobalValueSummary {
 public:
   /// \brief Sububclass discriminator (for dyn_cast<> et al.)
-  enum SummaryKind { FunctionKind, GlobalVarKind };
+  enum SummaryKind { AliasKind, FunctionKind, GlobalVarKind };
 
 private:
   /// Kind of summary for use in dyn_cast<> et al.
   SummaryKind Kind;
 
   /// \brief Path of module IR containing value's definition, used to locate
   /// module during importing.
   ///
for (auto &RI : RefEdges)
       addRefEdge(RI);
   }
 
   /// Return the list of values referenced by this global value definition.
   std::vector<ValueInfo> &refs() { return RefEdgeList; }
   const std::vector<ValueInfo> &refs() const { return RefEdgeList; }
 };
 
+/// \brief Alias summary information.
+class AliasSummary : public GlobalValueSummary {
+  GlobalValueSummary *AliaseeSummary;
+
+public:
+  /// Summary constructors.
+  AliasSummary(GlobalValue::LinkageTypes Linkage)
+      : GlobalValueSummary(AliasKind, Linkage) {}
+
+  /// Check if this is an alias summary.
+  static bool classof(const GlobalValueSummary *GVS) {
+    return GVS->getSummaryKind() == AliasKind;
+  }
+
+  void setAliasee(GlobalValueSummary *Aliasee) { AliaseeSummary = Aliasee; }
+
+  const GlobalValueSummary &getAliasee() const {
+    return const_cast<AliasSummary *>(this)->getAliasee();
+  }
+
+  GlobalValueSummary &getAliasee() {
+    assert(AliaseeSummary && "Unexpected missing aliasee summary");
+    return *AliaseeSummary;
+  }
+};
+
 /// \brief Function summary information to aid decisions and implementation of
 /// importing.
 class FunctionSummary : public GlobalValueSummary {
 public:
   /// <CalleeValueInfo, CalleeInfo> call edge pair.
   typedef std::pair<ValueInfo, CalleeInfo> EdgeTy;
 
 private:

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FS_PERMODULE_PROFILE: {
                              CalleeInfo(CallsiteCount, ProfileCount));
       }
       GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
       auto *Info = TheIndex->getGlobalValueInfo(GUID);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       break;
     }
+    // FS_ALIAS: [valueid, linkage, valueid]
+    case bitc::FS_ALIAS: {
+      unsigned ValueID = Record[0];
+      uint64_t RawLinkage = Record[1];
+      unsigned AliaseeID = Record[2];
+      std::unique_ptr<AliasSummary> AS =
+          llvm::make_unique<AliasSummary>(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.
+      AS->setModulePath(
+          TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
+
+      GlobalValue::GUID AliaseeGUID = getGUIDFromValueId(AliaseeID);
+      auto *AliaseeInfo = TheIndex->getGlobalValueInfo(AliaseeGUID);
+      if (!AliaseeInfo->summary())
+        return error("Alias expects aliasee summary to be parsed");
+      AS->setAliasee(AliaseeInfo->summary());
+
+      GlobalValue::GUID GUID = getGUIDFromValueId(ValueID);
+      auto *Info = TheIndex->getGlobalValueInfo(GUID);
+      assert(!Info->summary() && "Expected a single summary per VST entry");
+      Info->setSummary(std::move(AS));
+      break;
+    }
     // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid]
     case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
       unsigned ValueID = Record[0];
       uint64_t RawLinkage = Record[1];
       std::unique_ptr<GlobalVarSummary> FS =
           llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
case bitc::FS_COMBINED_PROFILE: {
                              CalleeInfo(CallsiteCount, ProfileCount));
       }
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       Combined = true;
       break;
     }
+    // FS_COMBINED_ALIAS: [modid, linkage, offset]
+    case bitc::FS_COMBINED_ALIAS: {
+      uint64_t ModuleId = Record[0];
+      uint64_t RawLinkage = Record[1];
+      uint64_t AliaseeSummaryOffset = Record[2];
+      std::unique_ptr<AliasSummary> AS =
+          llvm::make_unique<AliasSummary>(getDecodedLinkage(RawLinkage));
+      AS->setModulePath(ModuleIdMap[ModuleId]);
+
+      auto *AliaseeInfo = getInfoFromSummaryOffset(AliaseeSummaryOffset);
+      if (!AliaseeInfo->summary())
+        return error("Alias expects aliasee summary to be parsed");
+      AS->setAliasee(AliaseeInfo->summary());
+
+      auto *Info = getInfoFromSummaryOffset(CurRecordBit);
+      assert(!Info->summary() && "Expected a single summary per VST entry");
+      Info->setSummary(std::move(AS));
+      Combined = true;
+      break;
+    }
     // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid]
     case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {
       uint64_t ModuleId = Record[0];
       uint64_t RawLinkage = Record[1];
       std::unique_ptr<GlobalVarSummary> FS =
           llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
       FS->setModulePath(ModuleIdMap[ModuleId]);
       for (unsigned I = 2, E = Record.size(); I != E; ++I) {

lib/Bitcode/Writer/BitcodeWriter.cpp

static void WritePerModuleGlobalValueSummary(const Module *M,
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));  // valueids
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv);
 
+  // Abbrev for FS_ALIAS.
+  Abbv = new BitCodeAbbrev();
+  Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
+  unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv);
+
   SmallVector<uint64_t, 64> NameVals;
   // Iterate over the list of functions instead of the Index to
   // ensure the ordering is stable.
   for (const Function &F : *M) {
     if (F.isDeclaration())
       continue;
     // Skip anonymous functions. We will emit a function summary for
     // any aliases below.
     if (!F.hasName())
       continue;
 
     auto *Info = Index.getGlobalValueInfo(F);
     WritePerModuleFunctionSummaryRecord(
         NameVals, Info,
         VE.getValueID(M->getValueSymbolTable().lookup(F.getName())), VE,
         FSCallsAbbrev, FSCallsProfileAbbrev, Stream, F);
   }
 
-  for (const GlobalAlias &A : M->aliases()) {
-    if (!A.getBaseObject())
-      continue;
-    const Function *F = dyn_cast<Function>(A.getBaseObject());
-    if (!F || F->isDeclaration())
-      continue;
-
-    auto *Info = Index.getGlobalValueInfo(A);
-    WritePerModuleFunctionSummaryRecord(
-        NameVals, Info,
-        VE.getValueID(M->getValueSymbolTable().lookup(A.getName())), VE,
-        FSCallsAbbrev, FSCallsProfileAbbrev, Stream, *F);
-  }
-
   // Capture references from GlobalVariable initializers, which are outside
   // of a function scope.
   for (const GlobalVariable &G : M->globals())
     WriteModuleLevelReferences(G, Index, VE, NameVals, FSModRefsAbbrev, Stream);
   for (const GlobalAlias &A : M->aliases())
     if (auto *GV = dyn_cast<GlobalVariable>(A.getBaseObject()))
       WriteModuleLevelReferences(*GV, Index, VE, NameVals, FSModRefsAbbrev,
                                  Stream);
 
+  for (const GlobalAlias &A : M->aliases()) {
+    auto *Aliasee = A.getBaseObject();
+    auto AliasId = VE.getValueID(&A);
+    auto AliaseeId = VE.getValueID(Aliasee);
+    NameVals.push_back(AliasId);
+    NameVals.push_back(getEncodedLinkage(A.getLinkage()));
+    NameVals.push_back(AliaseeId);
+    Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);
+    NameVals.clear();
+  }
+
   Stream.ExitBlock();
 }
 
 /// Emit the combined summary section into the combined index file.
 static void WriteCombinedGlobalValueSummary(
-    const ModuleSummaryIndex &I, BitstreamWriter &Stream,
+    const ModuleSummaryIndex &Index, BitstreamWriter &Stream,
     std::map<GlobalValue::GUID, unsigned> &GUIDToValueIdMap,
     unsigned GlobalValueId) {
   Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
 
   // Abbrev for FS_COMBINED.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
static void WriteCombinedGlobalValueSummary(
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));    // valueids
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv);
 
+  // Abbrev for FS_COMBINED_ALIAS.
+  Abbv = new BitCodeAbbrev();
+  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
+  unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv);
+
+  // The aliases are emitted as a post-pass, and will point to the summary
+  // offset id of the aliasee. For this purpose we need to be able to get back
+  // from the summary to the offset
+  SmallVector<GlobalValueInfo *, 64> Aliases;
+  DenseMap<const GlobalValueSummary *, uint64_t> SummaryToOffsetMap;
+
   SmallVector<uint64_t, 64> NameVals;
-  for (const auto &FII : I) {
+  for (const auto &FII : Index) {
     for (auto &FI : FII.second) {
       GlobalValueSummary *S = FI->summary();
       assert(S);
+      if (isa<AliasSummary>(S)) {
+        // Will process aliases as a post-pass because the reader wants all
+        // global to be loaded first.
+        Aliases.push_back(FI.get());
+        continue;
+      }
 
       if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {
-        NameVals.push_back(I.getModuleId(VS->modulePath()));
+        NameVals.push_back(Index.getModuleId(VS->modulePath()));
         NameVals.push_back(getEncodedLinkage(VS->linkage()));
         for (auto &RI : VS->refs()) {
           const auto &VMI = GUIDToValueIdMap.find(RI.getId());
           unsigned RefId;
           // If this GUID doesn't have an entry, assign one.
           if (VMI == GUIDToValueIdMap.end()) {
             GUIDToValueIdMap[RI.getId()] = ++GlobalValueId;
             RefId = GlobalValueId;
           } else {
             RefId = VMI->second;
           }
           NameVals.push_back(RefId);
         }
 
         // 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());
+        // Store temporarily the offset in the map for a possible alias.
+        SummaryToOffsetMap[S] = FI->bitcodeIndex();
 
         // Emit the finished record.
         Stream.EmitRecord(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS, NameVals,
                           FSModRefsAbbrev);
         NameVals.clear();
         continue;
       }
 
       auto *FS = cast<FunctionSummary>(S);
-      NameVals.push_back(I.getModuleId(FS->modulePath()));
+      NameVals.push_back(Index.getModuleId(FS->modulePath()));
       NameVals.push_back(getEncodedLinkage(FS->linkage()));
       NameVals.push_back(FS->instCount());
       NameVals.push_back(FS->refs().size());
 
       for (auto &RI : FS->refs()) {
         const auto &VMI = GUIDToValueIdMap.find(RI.getId());
         unsigned RefId;
         // If this GUID doesn't have an entry, assign one.
for (auto &FI : FII.second) {
         if (HasProfileData)
           NameVals.push_back(EI.second.ProfileCount);
       }
 
       // 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());
+      // Store temporarily the offset in the map for a possible alias.
+      SummaryToOffsetMap[S] = FI->bitcodeIndex();
 
       unsigned FSAbbrev =
           (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
       unsigned Code =
           (HasProfileData ? bitc::FS_COMBINED_PROFILE : bitc::FS_COMBINED);
 
       // Emit the finished record.
       Stream.EmitRecord(Code, NameVals, FSAbbrev);
       NameVals.clear();
     }
   }
 
+  for (auto GVI : Aliases) {
+    AliasSummary *AS = cast<AliasSummary>(GVI->summary());
+    NameVals.push_back(Index.getModuleId(AS->modulePath()));
+    NameVals.push_back(getEncodedLinkage(AS->linkage()));
+    auto AliaseeID = SummaryToOffsetMap[&AS->getAliasee()];
+    assert(AliaseeID);
+    NameVals.push_back(AliaseeID);
+
+    // 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.
+    GVI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth());
+
+    // Emit the finished record.
+    Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);
+    NameVals.clear();
+    continue;
+  }
+
   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(const Module *M, BitstreamWriter &Stream) {
   Stream.EnterSubblock(bitc::IDENTIFICATION_BLOCK_ID, 5);
 

lib/Transforms/IPO/FunctionImport.cpp

 ///
 /// FIXME: select "best" instead of first that fits. But what is "best"?
 /// - The smallest: more likely to be inlined.
 /// - The one with the least outgoing edges (already well optimized).
 /// - One from a module already being imported from in order to reduce the
 ///   number of source modules parsed/linked.
 /// - One that has PGO data attached.
 /// - [insert you fancy metric here]
-static const FunctionSummary *
+static const GlobalValueSummary *
 selectCallee(const GlobalValueInfoList &CalleeInfoList, unsigned Threshold) {
   auto It = llvm::find_if(
       CalleeInfoList, [&](const std::unique_ptr<GlobalValueInfo> &GlobInfo) {
         assert(GlobInfo->summary() &&
                "We should not have a Global Info without summary");
-        auto *Summary = cast<FunctionSummary>(GlobInfo->summary());
+        auto *GVSummary = GlobInfo->summary();
+        if (auto *AS = dyn_cast<AliasSummary>(GVSummary))
+          GVSummary = &AS->getAliasee();
+        auto *Summary = cast<FunctionSummary>(GVSummary);
 
         if (GlobalValue::isWeakAnyLinkage(Summary->linkage()))
           return false;
 
         if (Summary->instCount() > Threshold)
           return false;
 
         return true;
       });
   if (It == CalleeInfoList.end())
     return nullptr;
 
-  return cast<FunctionSummary>((*It)->summary());
+  return cast<GlobalValueSummary>((*It)->summary());
 }
 
 /// Return the summary for the function \p GUID that fits the \p Threshold, or
 /// null if there's no match.
-static const FunctionSummary *selectCallee(GlobalValue::GUID GUID,
+static const GlobalValueSummary *selectCallee(GlobalValue::GUID GUID,
                                               unsigned Threshold,
                                               const ModuleSummaryIndex &Index) {
   auto CalleeInfoList = Index.findGlobalValueInfoList(GUID);
   if (CalleeInfoList == Index.end()) {
     return nullptr; // This function does not have a summary
   }
   return selectCallee(CalleeInfoList->second, Threshold);
 }
 
 /// Return true if the global \p GUID is exported by module \p ExportModulePath.
if (DefinedFunctions.count(GUID)) {
       continue;
     }
 
     auto *CalleeSummary = selectCallee(GUID, Threshold, Index);
     if (!CalleeSummary) {
       DEBUG(dbgs() << "ignored! No qualifying callee with summary found.\n");
       continue;
     }
-    assert(CalleeSummary->instCount() <= Threshold &&
+    // "Resolve" the summary, traversing alias,
+    const FunctionSummary *ResolvedCalleeSummary;
+    if (isa<AliasSummary>(CalleeSummary))
+      ResolvedCalleeSummary = cast<FunctionSummary>(
+          &cast<AliasSummary>(CalleeSummary)->getAliasee());
+    else
+      ResolvedCalleeSummary = cast<FunctionSummary>(CalleeSummary);
+
+    assert(ResolvedCalleeSummary->instCount() <= Threshold &&
            "selectCallee() didn't honor the threshold");
 
     auto &ProcessedThreshold =
-        ImportsForModule[CalleeSummary->modulePath()][GUID];
+        ImportsForModule[ResolvedCalleeSummary->modulePath()][GUID];
     /// Since the traversal of the call graph is DFS, we can revisit a function
     /// a second time with a higher threshold. In this case, it is added back to
     /// the worklist with the new threshold.
     if (ProcessedThreshold && ProcessedThreshold > Threshold) {
       DEBUG(dbgs() << "ignored! Target was already seen with Threshold "
                    << ProcessedThreshold << "\n");
       continue;
     }
     // Mark this function as imported in this module, with the current Threshold
     ProcessedThreshold = Threshold;
 
     // Make exports in the source module.
-    auto ExportModulePath = CalleeSummary->modulePath();
+    auto ExportModulePath = ResolvedCalleeSummary->modulePath();
     auto ExportList = ExportLists[ExportModulePath];
     ExportList.insert(GUID);
     // Mark all functions and globals referenced by this function as exported to
     // the outside if they are defined in the same source module.
-    for (auto &Edge : CalleeSummary->calls()) {
+    for (auto &Edge : ResolvedCalleeSummary->calls()) {
       auto CalleeGUID = Edge.first.getId();
       if (isGlobalExported(Index, ExportModulePath, CalleeGUID))
         ExportList.insert(CalleeGUID);
     }
-    for (auto &Ref : CalleeSummary->refs()) {
+    for (auto &Ref : ResolvedCalleeSummary->refs()) {
       auto GUID = Ref.getId();
       if (isGlobalExported(Index, ExportModulePath, GUID))
         ExportList.insert(GUID);
     }
 
     // Insert the newly imported function to the worklist.
-    Worklist.push_back(std::make_pair(CalleeSummary, Threshold));
+    Worklist.push_back(std::make_pair(ResolvedCalleeSummary, Threshold));
   }
 }
 
 /// Given the list of globals defined in a module, compute the list of imports
 /// as well as the list of "exports", i.e. the list of symbols referenced from
 /// another module (that may require promotion).
 static void ComputeImportForModule(
     StringRef ModulePath,
for (auto &GV : SrcModule->aliases()) {
       auto GUID = GV.getGUID();
       auto Import = ImportGUIDs.count(GUID);
       DEBUG(dbgs() << (Import ? "Is" : "Not") << " importing " << GUID << " "
                    << GV.getName() << " from " << SrcModule->getSourceFileName()
                    << "\n");
       if (Import) {
         // Alias can't point to "available_externally". However when we import
         // linkOnceODR the linkage does not change. So we import the alias
         // and aliasee only in this case.
         const GlobalObject *GO = GV.getBaseObject();
         if (!GO->hasLinkOnceODRLinkage())
           continue;
         GV.materialize();
         GlobalsToImport.insert(&GV);
         GlobalsToImport.insert(GO);
       }
     }

test/Bitcode/thinlto-function-summary.ll

 ; RUN: llvm-as -module-summary < %s | llvm-bcanalyzer -dump | FileCheck %s -check-prefix=BC
 ; Check for summary block/records.
 
 ; Check the value ids in the summary entries against the
 ; same in the ValueSumbolTable, to ensure the ordering is stable.
 ; Also check the linkage field on the summary entries.
 ; BC: <GLOBALVAL_SUMMARY_BLOCK
 ; BC-NEXT: <PERMODULE {{.*}} op0=1 op1=0
 ; BC-NEXT: <PERMODULE {{.*}} op0=2 op1=0
-; BC-NEXT: <PERMODULE {{.*}} op0=4 op1=3
+; BC-NEXT: <ALIAS {{.*}} op0=4 op1=0 op2=3
 ; BC-NEXT: </GLOBALVAL_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 -module-summary < %s | llvm-dis | FileCheck %s
 ; Check that this round-trips correctly.

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

case bitc::GLOBALVAL_SUMMARY_BLOCK_ID:
     default:
       return nullptr;
       STRINGIFY_CODE(FS, PERMODULE)
       STRINGIFY_CODE(FS, PERMODULE_PROFILE)
       STRINGIFY_CODE(FS, PERMODULE_GLOBALVAR_INIT_REFS)
       STRINGIFY_CODE(FS, COMBINED)
       STRINGIFY_CODE(FS, COMBINED_PROFILE)
       STRINGIFY_CODE(FS, COMBINED_GLOBALVAR_INIT_REFS)
+      STRINGIFY_CODE(FS, ALIAS)
+      STRINGIFY_CODE(FS, COMBINED_ALIAS)
     }
   case bitc::METADATA_ATTACHMENT_ID:
     switch(CodeID) {
     default:return nullptr;
       STRINGIFY_CODE(METADATA, ATTACHMENT)
     }
   case bitc::METADATA_BLOCK_ID:
     switch(CodeID) {