[ThinLto] Fix Ifunc symbol usage

[yota9]

Summary

This patch fixes undefined reference problem when using ifunc symbols with
thinLTO.

The bug link: https://bugs.llvm.org/show_bug.cgi?id=46488#
This patch adds ifunc symbol to the global value summary. The ifunc
summary contains link to its resolver.

The llvm-dis results of the bug example:

Before patch:
^1 = gv: (name: "called", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0)))) ; guid = 9741048783615374159
^2 = gv: (name: "resolver", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0), refs: (^1)))) ; guid = 18291748799076262136

After patch:
^1 = gv: (name: "foo", summaries: (ifunc: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), resolver: ^3))) ; guid = 6699318081062747564
^2 = gv: (name: "called", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0)))) ; guid = 9741048783615374159
^3 = gv: (name: "resolver", summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 0), refs: (^2)))) ; guid = 18291748799076262136

Vladislav
Advanced Software Technology Lab, Huawei

[tejohnson]

Yikes, I guess ifunc weren't used very extensively before if we have been dropping them on the floor with thinlto all this time!

There are some uses of alias summaries other places (e.g. in ModuleSummaryIndex.cpp for exporting to a dot file, computing the cache key in LTO.cpp) that you'll want to adjust as well. There's some other uses of AliasSummary that may need similar handling as well that I'm not sure about offhand. E.g. see the uses of AliasSummary in LTO.cpp where we decide whether we can adjust the linkage to AvailableExternally. Also see my comments on the def of GlobalValueSummary::getBaseObject and one of its uses in FunctionImport.cpp since it is not being handled there. If we do decide to try to import ifuncs and resolvers, you'll need to think about how this should work when we do the importing. For aliases, we import the aliasee as a copy (see replaceAliasWithAliasee in FunctionImport.cpp). I'm not familiar enough with ifunc to know how it should be handled when importing.

Also, since most of the handling here for ifunc summary is essentially an exact duplicate of the equivalent alias summary handling, I'm wondering if we can just generalize the AliasSummary to be a more general GlobalIndirectionSummary? Perhaps we could distinguish between the two types as needed with different SummaryKind?

Before changing the patch significantly though, I think it would be good to decide how these should be handled for other types of ThinLTO optimizations as mentioned above (e.g. importing and weak symbol resolution). I'm fine with treating them conservatively (e.g. not importing), but right now as noted above I think we might get runtime failures when these are seen during importing analysis.

llvm/include/llvm/IR/ModuleSummaryIndex.h

376–377

Should be same for ifunc kind

528–529

Should this (and the method below) return the resolver for IfuncSummary? See my comment in FunctionImport.cpp in one of the callsites for what I think will happen currently.

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

350

"aliasee or resolver"?

351

Missing space between first 2 words.

llvm/lib/Transforms/IPO/FunctionImport.cpp

214

With the current patch this will fail if the callee is an IfuncSummary, since getBaseObject on the GlobalValueSummary only handles alias summaries.

[yota9]

Fixed rev 1 comments

[yota9]

Dear tejohnson !
Thank you for you comments!
I've also added the same conditions for the LTO.cpp, but I'm not sure about symbol linkage resolution in LTO.cpp, since I'm not extremely familiar with LLVM internal linkage types, hope you can help me to investigate this.
Thank you!
Vladislav
Advanced Software Technology Lab, Huawei

llvm/include/llvm/IR/ModuleSummaryIndex.h

376–377

Thank you!

528–529

Seems to be you're right, thank you!

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

351

Thank you!

[yota9]

gentle ping :)
Dear @tejohnson maybe you can help/suggest something about this patch? Yes, theoretically it is not a big deal to combine both ifunc & alias cases, but I'm not sure if this won't give any problems in the future.. Thank you!

[tejohnson]

Sorry for the delayed review!

Looking at the code here, all of the handling for ifuncs is essentially now combined with or a duplicate of the equivalent handling for alias summary, I'm more convinced that the summary hierarchy should be changed to mirror the symbol hierarchy. i.e. a GlobalIndirectSummary with derived AliasSummary and IfuncSummary. Then the vast majority of the code modified here could be simply generalized to a single handling of GlobalIndirectSummary and its getBaseObject. BTW, there is still some missing handling for importing, see specifics further below.

However - before you try this I would recommend creating a more robust set of tests. The only test added here now simply tests the serialization/deserialization of the new summary to bitcode and llvm assembly. Tests are needed that actually invoke the thin link, e.g. via either llvm-lto or llvm-lto2, see tests in llvm/test/ThinLTO/X86/ for examples. The alias_import.ll and alias_resolution.ll tests there are good to model new ifunc tests on.

One of the tests should check the case where one module references an external symbol defined as an ifunc in the other module, to test the handling where we try to import it. AFAICT, the code in FunctionImport.cpp in computeImportForFunction with the comment '"Resolve" the summary', which gets the base object, will attempt to import an ifunc resolver. However, the handling in the backend where we actually do the importing (see importFunctions in the same file) will completely ignore any ifunc that we decided to import. We should either (conservatively for now) prevent importing of ifunc during the thin link (computeImportForFunction), or handle ifunc appropriately in importFunctions (not sure what the appropriate handling is - for alias we import as a copy of the aliasee, does that even make sense for ifunc? If not, probably the conservative handling is best).

llvm/lib/IR/Verifier.cpp

383 ↗

(On Diff #279766)

The changes in this file seem unrelated to ThinLTO. Can you split into another patch (with test)?

[yota9]

Create GlobalIndirectValueSummary class
Add ifunc_import test
Skip ifuncs import

[yota9]

Dear @tejohnson!
Sorry for the late answer, the task is not prioritized and I don't have much time to finish it :)
Still I've added GlobalIndirectSummary class as you've requested and decided not to import ifuncs for now, since it should be handled another way then aliases (still AFAIU there is not so much sense in it, maybe only if the resolver unconditionally returns only one function, but in other way unlike aliases ifunc is a relocation that should be processed at runtime).
It seems to be ifunc_import test is not needed, but still added it, maybe it will be useful if somebody will import ifuncs in the future..
Thank you so much for your patch review!

llvm/lib/IR/Verifier.cpp

383 ↗

(On Diff #279766)

I see, no problems :)

[yota9]

Gentle ping.
Dear @tejohnson if there are some issues that I accidentally missed or not fully understood please let me know about them :)
Thank you for your understanding!

[tejohnson]

Thanks for doing this and sorry for the slow reply! Some comments and suggested fixes below.

llvm/include/llvm/IR/ModuleSummaryIndex.h

471–473

Changing Aliasee to Summary here and below is a little confusing, since it is ambiguous what summary you are talking about (the current one, the indirect symbol?). Suggest changing Summary here and in below interfaces to IndirectSymbol. It's a little longer but captures the meaning better (and is equivalent to similar interface naming on the GlobalIndirectSymbol itself).

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

351

s/an alias summary/an indirect value summary/

llvm/lib/AsmParser/LLParser.cpp

8748

Needs equivalent handling for the new IfuncSummary. To test this handling, add an ifunc summary case to llvm/test/Assembler/thinlto-summary.ll. Actually, add two cases, equivalent to the following two alias cases:

; Make this one an alias with a forward reference to aliasee.
^5 = gv: (guid: 4, summaries: (alias: (module: ^0, flags: (linkage: private, notEligibleToImport: 0, live: 0, dsoLocal: 1), aliasee: ^14)))

and

; Alias summary with backwards reference to aliasee.
^18 = gv: (guid: 17, summaries: (alias: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 0, dsoLocal: 1), aliasee: ^14)))

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

464

Could this just be merged into the above alias handling by casting to GlobalIndirectSymbol?

4196

I don't see the associated post-pass for the Ifuncs. See where the Aliases vector is walked down around line 4251.

llvm/lib/IR/Globals.cpp

169

Could this just be merged into the above alias handling by casting to GlobalIndirectSymbol?

llvm/lib/IR/ModuleSummaryIndex.cpp

628–629

Cast to GlobalIndirectSymbolSummary so this covers both cases?

llvm/lib/Transforms/IPO/FunctionImport.cpp

556

This is an expensive hash table lookup (related to the below FIXME), which is why we only want to do this when necessary (currently under debug compiler for the debug message below). Suggestion later on why you don't need this.

575

We already have a representative summary in GVSummary.second. However, I don't think you even want to skip ifuncs here. This is just deciding what to import for any functions defined in the current module. What you really want to do is to skip trying to import the ifunc base object on any references made to an ifunc in the function. To do that, you'll want to modify within selectCallee, which is called by computeImportForFunction for everything it calls. Specifically, the code which is around line 215:

auto *Summary = cast<FunctionSummary>(GVSummary->getBaseObject());

You will want to check before calling getBaseObject() if GVSummary is an IfuncSummary and return false from the lambda function so that we don't try to import the ifunc resolver.

After looking at your tests, I'm surprised the new ifunc_import test is working. I.e. this loop should see function main(), which isn't an ifunc, add it, and then compute imports based on all of its calls, which include all of the ifuncs. Ah - I see what is going on, you are checking that the ifuncs themselves are still declarations. But we would import the base object, which is the resolver. That test should probably check whether we are importing the resolver functions or not.

Actually, it shouldn't really be a problem to import them, since we haven't imported the defs of the ifuncs that resolve to them, they should get thrown away since there won't be any references to them after importing. However, it's just wasteful work that can be avoided by the change I suggest above.

llvm/test/Bitcode/thinlto-ifunc.ll

5

You don't need to redo the opt invocation, they are identical. Just use %t.o in the below llvm-dis.

[guy-david]

Hey, requesting a pair of changes changes after I ran into alias-to-ifunc issues.

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

793–794

This should happen before the alias summary loop in case of an alias to an ifunc scenario.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

4036–4050

Same as before, this should go before the alias summary loop so the bitcode reader would have all the necessary information to parse the alias.

[yota9]

@tejohnson Thank you for you comments and sorry for so long answer! Looking forward to your review!
@guy-david Thank you, fixed!

[guy-david]

It appears that this one is not fixed yet.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

4036

This loop should happen before emitting the FS_ALIAS records (which is just above it).

[yota9]

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

4036

Thank you!

[yota9]

Hello @guy-david @tejohnson ! I've rebased the patch to the current version of llvm and seems to be all the comments are fixed. All the test are passed (the linux failure seems has nothing to do with this patch).

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum GlobalValueSummarySymtabCodes {
   //                                        numrefs, numrefs x valueid,
   //                                        n x (valueid, offset)]
   FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS = 23,
   // The total number of basic blocks in the module.
   FS_BLOCK_COUNT = 24,
   // Range information for accessed offsets for every argument.
   // [n x (paramno, range, numcalls, numcalls x (callee_guid, paramno, range))]
   FS_PARAM_ACCESS = 25,
+  // IFUNC: [valueid, flags, valueid]
+  FS_IFUNC = 26,
+  // COMBINED_IFUNC: [valueid, modid, flags, valueid]
+  FS_COMBINED_IFUNC = 27,
 };
 
 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]

llvm/include/llvm/IR/ModuleSummaryIndex.h

template <> struct DenseMapInfo<ValueInfo> {
   static unsigned getHashValue(ValueInfo I) { return (uintptr_t)I.getRef(); }
 };
 
 /// Function and variable summary information to aid decisions and
 /// implementation of importing.
 class GlobalValueSummary {
 public:
   /// Sububclass discriminator (for dyn_cast<> et al.)
-  enum SummaryKind : unsigned { AliasKind, FunctionKind, GlobalVarKind };
+  enum SummaryKind : unsigned {
+    AliasKind,
+    IfuncKind,
+    FunctionKind,
+    GlobalVarKind
+  };
 
   /// Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
   struct GVFlags {
     /// The linkage type of the associated global value.
     ///
     /// One use is to flag values that have local linkage types and need to
     /// have module identifier appended before placing into the combined
     /// index, to disambiguate from other values with the same name.
private:
   /// List of values referenced by this global value's definition
   /// (either by the initializer of a global variable, or referenced
   /// from within a function). This does not include functions called, which
   /// are listed in the derived FunctionSummary object.
   std::vector<ValueInfo> RefEdgeList;
 
 protected:
   GlobalValueSummary(SummaryKind K, GVFlags Flags, std::vector<ValueInfo> Refs)
       : Kind(K), Flags(Flags), RefEdgeList(std::move(Refs)) {
-    assert((K != AliasKind || Refs.empty()) &&
-           "Expect no references for AliasSummary");
+
+    assert(((K != AliasKind && K != IfuncKind) || (Refs.empty())) &&
+           "Expect no references for Alias and Ifunc summary");
   }
 
 public:
   virtual ~GlobalValueSummary() = default;
 
   /// Returns the hash of the original name, it is identical to the GUID for
   /// externally visible symbols, but not for local ones.
   GlobalValue::GUID getOriginalName() const { return OriginalName; }
public:
   }
 
   /// Flag that this global value cannot be imported.
   void setNotEligibleToImport() { Flags.NotEligibleToImport = true; }
 
   /// Return the list of values referenced by this global value definition.
   ArrayRef<ValueInfo> refs() const { return RefEdgeList; }
 
-  /// If this is an alias summary, returns the summary of the aliased object (a
-  /// global variable or function), otherwise returns itself.
+  /// If this is an global indirect value summary, returns the summary of the
+  /// indirect object (a global variable or function), otherwise returns itself.
   GlobalValueSummary *getBaseObject();
   const GlobalValueSummary *getBaseObject() const;
 
   friend class ModuleSummaryIndex;
 };
 
-/// Alias summary information.
-class AliasSummary : public GlobalValueSummary {
-  ValueInfo AliaseeValueInfo;
-
-  /// This is the Aliasee in the same module as alias (could get from VI, trades
-  /// memory for time). Note that this pointer may be null (and the value info
-  /// empty) when we have a distributed index where the alias is being imported
-  /// (as a copy of the aliasee), but the aliasee is not.
-  GlobalValueSummary *AliaseeSummary;
+class GlobalIndirectValueSummary : public GlobalValueSummary {
+  ValueInfo IndirectValueInfo;
+  /// This is the Aliasee in the same module as alias or Resolver in the same
+  /// module as ifunc (could get from VI, trades memory for time). Note that
+  /// this pointer may be null (and the value info empty) when we have a
+  /// distributed index where the alias is being imported (as a copy of the
+  /// aliasee), but the aliasee is not.
+  GlobalValueSummary *IndirectValueSummary;
 
 public:
-  AliasSummary(GVFlags Flags)
-      : GlobalValueSummary(AliasKind, Flags, ArrayRef<ValueInfo>{}),
-        AliaseeSummary(nullptr) {}
+  GlobalIndirectValueSummary(enum SummaryKind kind, GVFlags Flags)
+      : GlobalValueSummary(kind, Flags, ArrayRef<ValueInfo>{}),
+        IndirectValueSummary(nullptr) {}
 
-  /// Check if this is an alias summary.
   static bool classof(const GlobalValueSummary *GVS) {
-    return GVS->getSummaryKind() == AliasKind;
+    auto kind = GVS->getSummaryKind();
+    return kind == AliasKind || kind == IfuncKind;
   }
 
-  void setAliasee(ValueInfo &AliaseeVI, GlobalValueSummary *Aliasee) {
-    AliaseeValueInfo = AliaseeVI;
-    AliaseeSummary = Aliasee;
+  void setIndirectSymbol(ValueInfo &ValueInfo, GlobalValueSummary *Summary) {
+    IndirectValueInfo = ValueInfo;
+    IndirectValueSummary = Summary;
   }
 
-  bool hasAliasee() const {
-    assert(!!AliaseeSummary == (AliaseeValueInfo &&
-                                !AliaseeValueInfo.getSummaryList().empty()) &&
-           "Expect to have both aliasee summary and summary list or neither");
-    return !!AliaseeSummary;
+  bool hasIndirectSymbol() const {
+    assert(!!IndirectValueSummary ==
+               (IndirectValueInfo &&
+                !IndirectValueInfo.getSummaryList().empty()) &&
+           "Expect to have both value summary and summary list or neither");
+    return !!IndirectValueSummary;
   }
 
-  const GlobalValueSummary &getAliasee() const {
-    assert(AliaseeSummary && "Unexpected missing aliasee summary");
-    return *AliaseeSummary;
+  const GlobalValueSummary &getIndirectSymbol() const {
+    assert(IndirectValueSummary && "Unexpected missing resolver summary");
+    return *IndirectValueSummary;
   }
 
-  GlobalValueSummary &getAliasee() {
+  GlobalValueSummary &getIndirectSymbol() {
     return const_cast<GlobalValueSummary &>(
-                         static_cast<const AliasSummary *>(this)->getAliasee());
+        static_cast<const GlobalIndirectValueSummary *>(this)
+            ->getIndirectSymbol());
+  }
+
+  ValueInfo getIndirectSymbolVI() const {
+    assert(IndirectValueInfo && "Unexpected missing indirect value info");
+    return IndirectValueInfo;
+  }
+
+  GlobalValue::GUID getIndirectSymbolGUID() const {
+    assert(IndirectValueInfo && "Unexpected missing indirect value info");
+    return IndirectValueInfo.getGUID();
+  }
+};
+
+/// Alias summary information.
+class AliasSummary : public GlobalIndirectValueSummary {
+public:
+  AliasSummary(GVFlags Flags) : GlobalIndirectValueSummary(AliasKind, Flags) {}
+
+  /// Check if this is an alias summary.
+  static bool classof(const GlobalValueSummary *GVS) {
+    return GVS->getSummaryKind() == AliasKind;
   }
-  ValueInfo getAliaseeVI() const {
-    assert(AliaseeValueInfo && "Unexpected missing aliasee");
-    return AliaseeValueInfo;
-  }
-  GlobalValue::GUID getAliaseeGUID() const {
-    assert(AliaseeValueInfo && "Unexpected missing aliasee");
-    return AliaseeValueInfo.getGUID();
+};
+
+/// Ifunc summary information.
+class IfuncSummary : public GlobalIndirectValueSummary {
+public:
+  IfuncSummary(GVFlags Flags) : GlobalIndirectValueSummary(IfuncKind, Flags) {}
+
+  /// Check if this is an ifunc summary.
+  static bool classof(const GlobalValueSummary *GVS) {
+    return GVS->getSummaryKind() == IfuncKind;
   }
 };
 
 const inline GlobalValueSummary *GlobalValueSummary::getBaseObject() const {
-  if (auto *AS = dyn_cast<AliasSummary>(this))
-    return &AS->getAliasee();
+  if (auto *GIV = dyn_cast<GlobalIndirectValueSummary>(this))
+    return &GIV->getIndirectSymbol();
   return this;
 }
 
 inline GlobalValueSummary *GlobalValueSummary::getBaseObject() {
-  if (auto *AS = dyn_cast<AliasSummary>(this))
-    return &AS->getAliasee();
+  if (auto *GIV = dyn_cast<GlobalIndirectValueSummary>(this))
+    return &GIV->getIndirectSymbol();
   return this;
 }
 
 /// Function summary information to aid decisions and implementation of
 /// importing.
 class FunctionSummary : public GlobalValueSummary {
 public:
   /// <CalleeValueInfo, CalleeInfo> call edge pair.
ModuleSummaryIndex(bool HaveGVs, bool EnableSplitLTOUnit = false)
       : HaveGVs(HaveGVs), EnableSplitLTOUnit(EnableSplitLTOUnit), Saver(Alloc),
         BlockCount(0) {}
 
   // Current version for the module summary in bitcode files.
   // The BitcodeSummaryVersion should be bumped whenever we introduce changes
   // in the way some record are interpreted, like flags for instance.
   // Note that incrementing this may require changes in both BitcodeReader.cpp
   // and BitcodeWriter.cpp.
-  static constexpr uint64_t BitcodeSummaryVersion = 9;
+  static constexpr uint64_t BitcodeSummaryVersion = 10;
 
   // Regular LTO module name for ASM writer
   static constexpr const char *getRegularLTOModuleName() {
     return "[Regular LTO]";
   }
 
   bool haveGVs() const { return HaveGVs; }
 

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

for (const Instruction &I : BB) {
 
       auto *CalledValue = CB->getCalledOperand();
       auto *CalledFunction = CB->getCalledFunction();
       if (CalledValue && !CalledFunction) {
         CalledValue = CalledValue->stripPointerCasts();
         // Stripping pointer casts can reveal a called function.
         CalledFunction = dyn_cast<Function>(CalledValue);
       }
-      // Check if this is an alias to a function. If so, get the
-      // called aliasee for the checks below.
-      if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
+      // Check if this is an alias to a function or ifunc.
+      // If so, get the called aliasee or resolver for the checks below.
+      if (auto *GIS = dyn_cast<GlobalIndirectSymbol>(CalledValue)) {
         assert(!CalledFunction && "Expected null called function in callsite for alias");
-        CalledFunction = dyn_cast<Function>(GA->getBaseObject());
+        CalledFunction = dyn_cast<Function>(GIS->getBaseObject());
       }
+
       // Check if this is a direct call to a known function or a known
       // intrinsic, or an indirect call with profile data.
       if (CalledFunction) {
         if (CI && CalledFunction->isIntrinsic()) {
           addIntrinsicToSummary(
               CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
               TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
           continue;
         }
         // We should have named any anonymous globals
         assert(CalledFunction->hasName());
         auto ScaledCount = PSI->getProfileCount(*CB, BFI);
         auto Hotness = ScaledCount ? getHotness(ScaledCount.getValue(), PSI)
                                    : CalleeInfo::HotnessType::Unknown;
         if (ForceSummaryEdgesCold != FunctionSummary::FSHT_None)
           Hotness = CalleeInfo::HotnessType::Cold;
 
-        // Use the original CalledValue, in case it was an alias. We want
-        // to record the call edge to the alias in that case. Eventually
-        // an alias summary will be created to associate the alias and
-        // aliasee.
+        // Use the original CalledValue, in case it was an alias or ifunc.
+        // We want to record the call edge to the aliasee or resolver in that
+        // case. Eventually an indirect value summary will be created to
+        // associate the alias and aliasee or ifunc and its resolver.
         auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(
             cast<GlobalValue>(CalledValue))];
         ValueInfo.updateHotness(Hotness);
         // Add the relative block frequency to CalleeInfo if there is no profile
         // information.
         if (BFI != nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
           uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();
           uint64_t EntryFreq = BFI->getEntryFreq();
static void computeVariableSummary(ModuleSummaryIndex &Index,
   if (HasBlockAddress)
     GVarSummary->setNotEligibleToImport();
   if (!VTableFuncs.empty())
     GVarSummary->setVTableFuncs(VTableFuncs);
   Index.addGlobalValueSummary(V, std::move(GVarSummary));
 }
 
 static void
-computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A,
+computeGlobalIndirectSummary(ModuleSummaryIndex &Index,
+                             GlobalValueSummary::SummaryKind Kind,
+                             const GlobalIndirectSymbol &GIS,
                              DenseSet<GlobalValue::GUID> &CantBePromoted) {
-  bool NonRenamableLocal = isNonRenamableLocal(A);
+  bool NonRenamableLocal = isNonRenamableLocal(GIS);
   GlobalValueSummary::GVFlags Flags(
-      A.getLinkage(), A.getVisibility(), NonRenamableLocal,
-      /* Live = */ false, A.isDSOLocal(),
-      A.hasLinkOnceODRLinkage() && A.hasGlobalUnnamedAddr());
-  auto AS = std::make_unique<AliasSummary>(Flags);
-  auto *Aliasee = A.getBaseObject();
-  auto AliaseeVI = Index.getValueInfo(Aliasee->getGUID());
-  assert(AliaseeVI && "Alias expects aliasee summary to be available");
-  assert(AliaseeVI.getSummaryList().size() == 1 &&
-         "Expected a single entry per aliasee in per-module index");
-  AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
+      GIS.getLinkage(), GIS.getVisibility(), NonRenamableLocal,
+      /* Live = */ false, GIS.isDSOLocal(),
+      GIS.hasLinkOnceODRLinkage() && GIS.hasGlobalUnnamedAddr());
+
+  auto GIV = std::make_unique<GlobalIndirectValueSummary>(Kind, Flags);
+  auto *IndirectSymbol = GIS.getBaseObject();
+  auto IndirectSymbolVI = Index.getValueInfo(IndirectSymbol->getGUID());
+  assert(IndirectSymbolVI &&
+         "GlobalIndirectValue expects indirect summary to be available");
+  assert(IndirectSymbolVI.getSummaryList().size() == 1 &&
+         "Expected a single entry per indirect symbol in per-module index");
+  GIV->setIndirectSymbol(IndirectSymbolVI,
+                         IndirectSymbolVI.getSummaryList()[0].get());
   if (NonRenamableLocal)
-    CantBePromoted.insert(A.getGUID());
-  Index.addGlobalValueSummary(A, std::move(AS));
+    CantBePromoted.insert(GIS.getGUID());
+  Index.addGlobalValueSummary(GIS, std::move(GIV));
 }
 
 // Set LiveRoot flag on entries matching the given value name.
 static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name) {
   if (ValueInfo VI = Index.getValueInfo(GlobalValue::getGUID(Name)))
     for (auto &Summary : VI.getSummaryList())
       Summary->setLive(true);
 }
ModuleSummaryIndex llvm::buildModuleSummaryIndex(
   // index.
   SmallVector<MDNode *, 2> Types;
   for (const GlobalVariable &G : M.globals()) {
     if (G.isDeclaration())
       continue;
     computeVariableSummary(Index, G, CantBePromoted, M, Types);
   }
 
-  // Compute summaries for all aliases defined in module, and save in the
-  // index.
+  // Compute summaries for all aliases and ifuncs defined in module,
+  // and save in the index.
+  for (const GlobalIFunc &I : M.ifuncs())
+    computeGlobalIndirectSummary(Index, GlobalValueSummary::IfuncKind, I,
+                                 CantBePromoted);
+
   for (const GlobalAlias &A : M.aliases())
-    computeAliasSummary(Index, A, CantBePromoted);
+    computeGlobalIndirectSummary(Index, GlobalValueSummary::AliasKind, A,
+                                 CantBePromoted);
 
   for (auto *V : LocalsUsed) {
     auto *Summary = Index.getGlobalValueSummary(*V);
     assert(Summary && "Missing summary for global value");
     Summary->setNotEligibleToImport();
   }
 
   // The linker doesn't know about these LLVM produced values, so we need
   // to flag them as live in the index to ensure index-based dead value
   // analysis treats them as live roots of the analysis.
   setLiveRoot(Index, "llvm.used");

llvm/lib/Analysis/StackSafetyAnalysis.cpp

FunctionSummary *findCalleeFunctionSummary(ValueInfo VI, StringRef ModuleId) {
   if (!VI)
     return nullptr;
   auto SummaryList = VI.getSummaryList();
   GlobalValueSummary* S = nullptr;
   for (const auto& GVS : SummaryList) {
     if (!GVS->isLive())
       continue;
     if (const AliasSummary *AS = dyn_cast<AliasSummary>(GVS.get()))
-      if (!AS->hasAliasee())
+      if (!AS->hasIndirectSymbol())
         continue;
     if (!isa<FunctionSummary>(GVS->getBaseObject()))
       continue;
     if (GlobalValue::isLocalLinkage(GVS->linkage())) {
       if (GVS->modulePath() == ModuleId) {
         S = GVS.get();
         break;
       }
for (const auto& GVS : SummaryList) {
     }
   };
   while (S) {
     if (!S->isLive() || !S->isDSOLocal())
       return nullptr;
     if (FunctionSummary *FS = dyn_cast<FunctionSummary>(S))
       return FS;
     AliasSummary *AS = dyn_cast<AliasSummary>(S);
-    if (!AS || !AS->hasAliasee())
+    if (!AS || !AS->hasIndirectSymbol())
       return nullptr;
     S = AS->getBaseObject();
     if (S == AS)
       return nullptr;
   }
   return nullptr;
 }
 

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(unknown);
   KEYWORD(hot);
   KEYWORD(critical);
   KEYWORD(relbf);
   KEYWORD(variable);
   KEYWORD(vTableFuncs);
   KEYWORD(virtFunc);
   KEYWORD(aliasee);
+  KEYWORD(resolver);
   KEYWORD(refs);
   KEYWORD(typeIdInfo);
   KEYWORD(typeTests);
   KEYWORD(typeTestAssumeVCalls);
   KEYWORD(typeCheckedLoadVCalls);
   KEYWORD(typeTestAssumeConstVCalls);
   KEYWORD(typeCheckedLoadConstVCalls);
   KEYWORD(vFuncId);

llvm/lib/AsmParser/LLParser.h

private:
     std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
     std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
 
     // Summary global value reference information.
     std::map<unsigned, std::vector<std::pair<ValueInfo *, LocTy>>>
         ForwardRefValueInfos;
     std::map<unsigned, std::vector<std::pair<AliasSummary *, LocTy>>>
         ForwardRefAliasees;
+    std::map<unsigned, std::vector<std::pair<IfuncSummary *, LocTy>>>
+        ForwardRefResolvers;
     std::vector<ValueInfo> NumberedValueInfos;
 
     // Summary type id reference information.
     std::map<unsigned, std::vector<std::pair<GlobalValue::GUID *, LocTy>>>
         ForwardRefTypeIds;
 
     // Map of module ID to path.
     std::map<unsigned, StringRef> ModuleIdMap;
private:
     bool parseModuleReference(StringRef &ModulePath);
     bool parseGVReference(ValueInfo &VI, unsigned &GVId);
     bool parseSummaryIndexFlags();
     bool parseBlockCount();
     bool parseGVEntry(unsigned ID);
     bool parseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     bool parseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     bool parseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
+    bool parseIfuncSummary(std::string Name, GlobalValue::GUID, unsigned ID);
     bool parseGVFlags(GlobalValueSummary::GVFlags &GVFlags);
     bool parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags);
     bool parseOptionalFFlags(FunctionSummary::FFlags &FFlags);
     bool parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls);
     bool parseHotness(CalleeInfo::HotnessType &Hotness);
     bool parseOptionalTypeIdInfo(FunctionSummary::TypeIdInfo &TypeIdInfo);
     bool parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests);
     bool parseVFuncIdList(lltok::Kind Kind,

llvm/lib/AsmParser/LLParser.cpp

return error(ForwardRefValueInfos.begin()->second.front().second,
                  "use of undefined summary '^" +
                      Twine(ForwardRefValueInfos.begin()->first) + "'");
 
   if (!ForwardRefAliasees.empty())
     return error(ForwardRefAliasees.begin()->second.front().second,
                  "use of undefined summary '^" +
                      Twine(ForwardRefAliasees.begin()->first) + "'");
 
+  if (!ForwardRefResolvers.empty())
+    return error(ForwardRefResolvers.begin()->second.front().second,
+                 "use of undefined summary '^" +
+                     Twine(ForwardRefResolvers.begin()->first) + "'");
+
   if (!ForwardRefTypeIds.empty())
     return error(ForwardRefTypeIds.begin()->second.front().second,
                  "use of undefined type id summary '^" +
                      Twine(ForwardRefTypeIds.begin()->first) + "'");
 
   return false;
 }
 
if (FwdRefVIs != ForwardRefValueInfos.end()) {
     }
     ForwardRefValueInfos.erase(FwdRefVIs);
   }
 
   // Resolve forward references from aliases
   auto FwdRefAliasees = ForwardRefAliasees.find(ID);
   if (FwdRefAliasees != ForwardRefAliasees.end()) {
     for (auto AliaseeRef : FwdRefAliasees->second) {
-      assert(!AliaseeRef.first->hasAliasee() &&
+      assert(!AliaseeRef.first->hasIndirectSymbol() &&
              "Forward referencing alias already has aliasee");
       assert(Summary && "Aliasee must be a definition");
-      AliaseeRef.first->setAliasee(VI, Summary.get());
+      AliaseeRef.first->setIndirectSymbol(VI, Summary.get());
     }
     ForwardRefAliasees.erase(FwdRefAliasees);
   }
 
+  // Resolve forward references from ifuncs
+  auto FwdRefResolvers = ForwardRefResolvers.find(ID);
+  if (FwdRefResolvers != ForwardRefResolvers.end()) {
+    for (auto ResolverRef : FwdRefResolvers->second) {
+      assert(!ResolverRef.first->hasIndirectSymbol() &&
+             "Forward referencing ifunc already has resolver");
+      assert(Summary && "Resolver must be a definition");
+      ResolverRef.first->setIndirectSymbol(VI, Summary.get());
+    }
+    ForwardRefResolvers.erase(FwdRefResolvers);
+  }
+
   // Add the summary if one was provided.
   if (Summary)
     Index->addGlobalValueSummary(VI, std::move(Summary));
 
   // Save the associated ValueInfo for use in later references by ID.
   if (ID == NumberedValueInfos.size())
     NumberedValueInfos.push_back(VI);
   else {
do {
     case lltok::kw_variable:
       if (parseVariableSummary(Name, GUID, ID))
         return true;
       break;
     case lltok::kw_alias:
       if (parseAliasSummary(Name, GUID, ID))
         return true;
       break;
+    case lltok::kw_ifunc:
+      if (parseIfuncSummary(Name, GUID, ID))
+        return true;
+      break;
     default:
       return error(Lex.getLoc(), "expected summary type");
     }
   } while (EatIfPresent(lltok::comma));
 
   if (parseToken(lltok::rparen, "expected ')' here") ||
       parseToken(lltok::rparen, "expected ')' here"))
     return true;
bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
   GS->setVTableFuncs(std::move(VTableFuncs));
 
   addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
                         ID, std::move(GS));
 
   return false;
 }
 
 /// AliasSummary
 ///   ::= 'alias' ':' '(' 'module' ':' ModuleReference ',' GVFlags ','
 ///         'aliasee' ':' GVReference ')'
 bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
                                  unsigned ID) {
   assert(Lex.getKind() == lltok::kw_alias);
   LocTy Loc = Lex.getLoc();
   Lex.Lex();
 
bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
   AS->setModulePath(ModulePath);
 
   // Record forward reference if the aliasee is not parsed yet.
   if (AliaseeVI.getRef() == FwdVIRef) {
     ForwardRefAliasees[GVId].emplace_back(AS.get(), Loc);
   } else {
     auto Summary = Index->findSummaryInModule(AliaseeVI, ModulePath);
     assert(Summary && "Aliasee must be a definition");
-    AS->setAliasee(AliaseeVI, Summary);
+    AS->setIndirectSymbol(AliaseeVI, Summary);
   }
 
   addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
                         ID, std::move(AS));
 
   return false;
 }
 
+/// IfuncSummary
+///   ::= 'ifunc' ':' '(' 'module' ':' ModuleReference ',' GVFlags ','
+///         'resolver' ':' GVReference ')'
+bool LLParser::parseIfuncSummary(std::string Name, GlobalValue::GUID GUID,
+                                 unsigned ID) {
+  assert(Lex.getKind() == lltok::kw_ifunc);
+  LocTy Loc = Lex.getLoc();
+  Lex.Lex();
+
+  StringRef ModulePath;
+  GlobalValueSummary::GVFlags GVFlags = GlobalValueSummary::GVFlags(
+      GlobalValue::ExternalLinkage, GlobalValue::DefaultVisibility,
+      /*NotEligibleToImport=*/false,
+      /*Live=*/false, /*IsLocal=*/false, /*CanAutoHide=*/false);
+  if (parseToken(lltok::colon, "expected ':' here") ||
+      parseToken(lltok::lparen, "expected '(' here") ||
+      parseModuleReference(ModulePath) ||
+      parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
+      parseToken(lltok::comma, "expected ',' here") ||
+      parseToken(lltok::kw_resolver, "expected 'resolver' here") ||
+      parseToken(lltok::colon, "expected ':' here"))
+    return true;
+
+  ValueInfo ResolverVI;
+  unsigned GVId;
+  if (parseGVReference(ResolverVI, GVId))
+    return true;
+
+  if (parseToken(lltok::rparen, "expected ')' here"))
+    return true;
+
+  auto IF = std::make_unique<IfuncSummary>(GVFlags);
+
+  IF->setModulePath(ModulePath);
+
+  // Record forward reference if the resolver is not parsed yet.
+  if (ResolverVI.getRef() == FwdVIRef) {
+    ForwardRefResolvers[GVId].emplace_back(IF.get(), Loc);
+  } else {
+    auto Summary = Index->findSummaryInModule(ResolverVI, ModulePath);
+    assert(Summary && "Resolver must be a definition");
+    IF->setIndirectSymbol(ResolverVI, Summary);
+  }
+
+  addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
+                        ID, std::move(IF));
+
+  return false;
+}
+
 /// Flag
 ///   ::= [0|1]
 bool LLParser::parseFlag(unsigned &Val) {
   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
     return tokError("expected integer");
   Val = (unsigned)Lex.getAPSIntVal().getBoolValue();
   Lex.Lex();
   return false;

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_unknown,
   kw_hot,
   kw_critical,
   kw_relbf,
   kw_variable,
   kw_vTableFuncs,
   kw_virtFunc,
   kw_aliasee,
+  kw_resolver,
   kw_refs,
   kw_typeIdInfo,
   kw_typeTests,
   kw_typeTestAssumeVCalls,
   kw_typeCheckedLoadVCalls,
   kw_typeTestAssumeConstVCalls,
   kw_typeCheckedLoadConstVCalls,
   kw_vFuncId,

llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp

default:
       STRINGIFY_CODE(MODULE_CODE, FUNCTION)
       STRINGIFY_CODE(MODULE_CODE, ALIAS)
       STRINGIFY_CODE(MODULE_CODE, GCNAME)
       STRINGIFY_CODE(MODULE_CODE, COMDAT)
       STRINGIFY_CODE(MODULE_CODE, VSTOFFSET)
       STRINGIFY_CODE(MODULE_CODE, METADATA_VALUES_UNUSED)
       STRINGIFY_CODE(MODULE_CODE, SOURCE_FILENAME)
       STRINGIFY_CODE(MODULE_CODE, HASH)
+      STRINGIFY_CODE(MODULE_CODE, IFUNC)
     }
   case bitc::IDENTIFICATION_BLOCK_ID:
     switch (CodeID) {
     default:
       return None;
       STRINGIFY_CODE(IDENTIFICATION_CODE, STRING)
       STRINGIFY_CODE(IDENTIFICATION_CODE, EPOCH)
     }
default:
       STRINGIFY_CODE(FS, TYPE_CHECKED_LOAD_CONST_VCALL)
       STRINGIFY_CODE(FS, VALUE_GUID)
       STRINGIFY_CODE(FS, CFI_FUNCTION_DEFS)
       STRINGIFY_CODE(FS, CFI_FUNCTION_DECLS)
       STRINGIFY_CODE(FS, TYPE_ID)
       STRINGIFY_CODE(FS, TYPE_ID_METADATA)
       STRINGIFY_CODE(FS, BLOCK_COUNT)
       STRINGIFY_CODE(FS, PARAM_ACCESS)
+      STRINGIFY_CODE(FS, IFUNC)
     }
   case bitc::METADATA_ATTACHMENT_ID:
     switch (CodeID) {
     default:
       return None;
       STRINGIFY_CODE(METADATA, ATTACHMENT)
     }
   case bitc::METADATA_BLOCK_ID:

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case BitstreamEntry::Record: {
         case bitc::MODULE_CODE_VSTOFFSET:
           if (Record.empty())
             return error("Invalid record");
           // Note that we subtract 1 here because the offset is relative to one
           // word before the start of the identification or module block, which
           // was historically always the start of the regular bitcode header.
           VSTOffset = Record[0] - 1;
           break;
-        // v1 GLOBALVAR: [pointer type, isconst,     initid,       linkage, ...]
-        // v1 FUNCTION:  [type,         callingconv, isproto,      linkage, ...]
-        // v1 ALIAS:     [alias type,   addrspace,   aliasee val#, linkage, ...]
+        // v1 GLOBALVAR: [pointer type, isconst,     initid,        linkage, ...]
+        // v1 FUNCTION:  [type,         callingconv, isproto,       linkage, ...]
+        // v1 IFUNC:     [ifunc type,   addrspace,   resolver val#, linkage, ...]
+        // v1 ALIAS:     [alias type,   addrspace,   aliasee val#,  linkage, ...]
         // v2: [strtab offset, strtab size, v1]
         case bitc::MODULE_CODE_GLOBALVAR:
         case bitc::MODULE_CODE_FUNCTION:
+        case bitc::MODULE_CODE_IFUNC:
         case bitc::MODULE_CODE_ALIAS: {
           StringRef Name;
           ArrayRef<uint64_t> GVRecord;
           std::tie(Name, GVRecord) = readNameFromStrtab(Record);
           if (GVRecord.size() <= 3)
             return error("Invalid record");
           uint64_t RawLinkage = GVRecord[3];
           GlobalValue::LinkageTypes Linkage = getDecodedLinkage(RawLinkage);
           if (!UseStrtab) {
             ValueIdToLinkageMap[ValueId++] = Linkage;
             break;
           }
 
           setValueGUID(ValueId++, Name, Linkage, SourceFileName);
           break;
         }
         }
       }
       continue;
     }
   }
 }
 
 std::vector<ValueInfo>
 ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) {
   std::vector<ValueInfo> Ret;
   Ret.reserve(Record.size());
   for (uint64_t RefValueId : Record)
     Ret.push_back(getValueInfoFromValueId(RefValueId).first);
case bitc::FS_ALIAS: {
       // module path string table entry with an empty (0) ID to take
       // ownership.
       AS->setModulePath(getThisModule()->first());
 
       auto AliaseeVI = getValueInfoFromValueId(AliaseeID).first;
       auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, ModulePath);
       if (!AliaseeInModule)
         return error("Alias expects aliasee summary to be parsed");
-      AS->setAliasee(AliaseeVI, AliaseeInModule);
+      AS->setIndirectSymbol(AliaseeVI, AliaseeInModule);
 
       auto GUID = getValueInfoFromValueId(ValueID);
       AS->setOriginalName(GUID.second);
       TheIndex.addGlobalValueSummary(GUID.first, std::move(AS));
       break;
     }
+    // FS_IFUNC: [valueid, flags, valueid]
+    // Ifuncs must be emitted (and parsed) after all FS_PERMODULE entries, as
+    // they expect all resolver summaries to be available.
+    case bitc::FS_IFUNC: {
+      unsigned ValueID = Record[0];
+      uint64_t RawFlags = Record[1];
+      unsigned ResolverID = Record[2];
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      auto IF = std::make_unique<IfuncSummary>(Flags);
+      // 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.
+      IF->setModulePath(getThisModule()->first());
+
+      auto ResolverVI = getValueInfoFromValueId(ResolverID).first;
+      auto ResolverInModule =
+          TheIndex.findSummaryInModule(ResolverVI, ModulePath);
+      if (!ResolverInModule)
+        return error("Ifunc expects resolver summary to be parsed");
+      IF->setIndirectSymbol(ResolverVI, ResolverInModule);
+
+      auto GUID = getValueInfoFromValueId(ValueID);
+      IF->setOriginalName(GUID.second);
+      TheIndex.addGlobalValueSummary(GUID.first, std::move(IF));
+      break;
+    }
+
     // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, varflags, n x valueid]
     case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
       unsigned ValueID = Record[0];
       uint64_t RawFlags = Record[1];
       unsigned RefArrayStart = 2;
       GlobalVarSummary::GVarFlags GVF(/* ReadOnly */ false,
                                       /* WriteOnly */ false,
                                       /* Constant */ false,
                                       GlobalObject::VCallVisibilityPublic);
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       if (Version >= 5) {
         GVF = getDecodedGVarFlags(Record[2]);
         RefArrayStart = 3;
       }
       std::vector<ValueInfo> Refs =
           makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
       auto FS =
           std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
       FS->setModulePath(getThisModule()->first());
       auto GUID = getValueInfoFromValueId(ValueID);
       FS->setOriginalName(GUID.second);
       TheIndex.addGlobalValueSummary(GUID.first, std::move(FS));
       break;
     }
     // FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS: [valueid, flags, varflags,
case bitc::FS_COMBINED_ALIAS: {
       unsigned AliaseeValueId = Record[3];
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       auto AS = std::make_unique<AliasSummary>(Flags);
       LastSeenSummary = AS.get();
       AS->setModulePath(ModuleIdMap[ModuleId]);
 
       auto AliaseeVI = getValueInfoFromValueId(AliaseeValueId).first;
       auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, AS->modulePath());
-      AS->setAliasee(AliaseeVI, AliaseeInModule);
+      AS->setIndirectSymbol(AliaseeVI, AliaseeInModule);
 
       ValueInfo VI = getValueInfoFromValueId(ValueID).first;
       LastSeenGUID = VI.getGUID();
       TheIndex.addGlobalValueSummary(VI, std::move(AS));
       break;
     }
+    // FS_COMBINED_IFUNC: [valueid, modid, flags, valueid]
+    // Ifuncs must be emitted (and parsed) after all FS_COMBINED entries, as
+    // they expect all resolver summaries to be available.
+    case bitc::FS_COMBINED_IFUNC: {
+      unsigned ValueID = Record[0];
+      uint64_t ModuleId = Record[1];
+      uint64_t RawFlags = Record[2];
+      unsigned ResolverValueId = Record[3];
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      auto IF = std::make_unique<IfuncSummary>(Flags);
+      LastSeenSummary = IF.get();
+      IF->setModulePath(ModuleIdMap[ModuleId]);
+
+      auto ResolverVI = getValueInfoFromValueId(ResolverValueId).first;
+      auto ResolverInModule =
+          TheIndex.findSummaryInModule(ResolverVI, IF->modulePath());
+      IF->setIndirectSymbol(ResolverVI, ResolverInModule);
+
+      ValueInfo VI = getValueInfoFromValueId(ValueID).first;
+      LastSeenGUID = VI.getGUID();
+      TheIndex.addGlobalValueSummary(VI, std::move(IF));
+      break;
+    }
     // FS_COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
     case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {
       unsigned ValueID = Record[0];
       uint64_t ModuleId = Record[1];
       uint64_t RawFlags = Record[2];
       unsigned RefArrayStart = 3;
       GlobalVarSummary::GVarFlags GVF(/* ReadOnly */ false,
                                       /* WriteOnly */ false,
                                       /* Constant */ false,
                                       GlobalObject::VCallVisibilityPublic);
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       if (Version >= 5) {
         GVF = getDecodedGVarFlags(Record[3]);
         RefArrayStart = 4;
       }
       std::vector<ValueInfo> Refs =
           makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
       auto FS =
           std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));
       LastSeenSummary = FS.get();
       FS->setModulePath(ModuleIdMap[ModuleId]);
       ValueInfo VI = getValueInfoFromValueId(ValueID).first;
       LastSeenGUID = VI.getGUID();
       TheIndex.addGlobalValueSummary(VI, std::move(FS));
       break;
     }
     // FS_COMBINED_ORIGINAL_NAME: [original_name]
     case bitc::FS_COMBINED_ORIGINAL_NAME: {

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

public:
   /// bitcode. This hides the details of whether they are being pulled from the
   /// entire index or just those in a provided ModuleToSummariesForIndex map.
   template<typename Functor>
   void forEachSummary(Functor Callback) {
     if (ModuleToSummariesForIndex) {
       for (auto &M : *ModuleToSummariesForIndex)
         for (auto &Summary : M.second) {
           Callback(Summary, false);
-          // Ensure aliasee is handled, e.g. for assigning a valueId,
+          // Ensure aliasee and ifunc resolver are handled,
+          // e.g. for assigning a valueId,
           // even if we are not importing the aliasee directly (the
           // imported alias will contain a copy of aliasee).
-          if (auto *AS = dyn_cast<AliasSummary>(Summary.getSecond()))
-            Callback({AS->getAliaseeGUID(), &AS->getAliasee()}, true);
+          if (auto *GIV =
+                  dyn_cast<GlobalIndirectValueSummary>(Summary.getSecond()))
+            Callback({GIV->getIndirectSymbolGUID(), &GIV->getIndirectSymbol()},
+                     true);
         }
     } else {
       for (auto &Summaries : Index)
         for (auto &Summary : Summaries.second.SummaryList)
           Callback({Summaries.first, Summary.get()}, false);
     }
   }
 
void ModuleBitcodeWriterBase::writePerModuleGlobalValueSummary() {
   // Abbrev for FS_ALIAS.
   Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
   unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
 
+  // Abbrev for FS_IFUNC.
+  Abbv = std::make_shared<BitCodeAbbrev>();
+  Abbv->Add(BitCodeAbbrevOp(bitc::FS_IFUNC));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
+  unsigned FSIfuncAbbrev = Stream.EmitAbbrev(std::move(Abbv));
+
   // Abbrev for FS_TYPE_ID_METADATA
   Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_TYPE_ID_METADATA));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid strtab index
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // typeid length
   // n x (valueid , offset)
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
for (const GlobalAlias &A : M.aliases()) {
     auto *Summary = Index->getGlobalValueSummary(A);
     AliasSummary *AS = cast<AliasSummary>(Summary);
     NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
     NameVals.push_back(AliaseeId);
     Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);
     NameVals.clear();
   }
 
+  for (const GlobalIFunc &I : M.ifuncs()) {
+    auto *Resolver = I.getBaseObject();
+    auto IfuncId = VE.getValueID(&I);
+    auto ResolverId = VE.getValueID(Resolver);
+
+    auto *Summary = Index->getGlobalValueSummary(I);
+    IfuncSummary *IF = cast<IfuncSummary>(Summary);
+
+    NameVals.push_back(IfuncId);
+    NameVals.push_back(getEncodedGVSummaryFlags(IF->flags()));
+    NameVals.push_back(ResolverId);
+    Stream.EmitRecord(bitc::FS_IFUNC, NameVals, FSIfuncAbbrev);
+    NameVals.clear();
+  }
   for (auto &S : Index->typeIdCompatibleVtableMap()) {
     writeTypeIdCompatibleVtableSummaryRecord(NameVals, StrtabBuilder, S.first,
                                              S.second, VE);
     Stream.EmitRecord(bitc::FS_TYPE_ID_METADATA, NameVals,
                       TypeIdCompatibleVtableAbbrev);
     NameVals.clear();
   }
 
   Stream.EmitRecord(bitc::FS_BLOCK_COUNT,
                     ArrayRef<uint64_t>{Index->getBlockCount()});
 
   Stream.ExitBlock();
 }
 
 /// Emit the combined summary section into the combined index file.
 void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
-  Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
+  Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 4);
   Stream.EmitRecord(
       bitc::FS_VERSION,
       ArrayRef<uint64_t>{ModuleSummaryIndex::BitcodeSummaryVersion});
 
   // Write the index flags.
   Stream.EmitRecord(bitc::FS_FLAGS, ArrayRef<uint64_t>{Index.getFlags()});
 
   for (const auto &GVI : valueIds()) {
void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   // Abbrev for FS_COMBINED_ALIAS.
   Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
   unsigned FSAliasAbbrev = Stream.EmitAbbrev(std::move(Abbv));
+  // Abbrev for FS_COMBINED_IFUNC.
+  Abbv = std::make_shared<BitCodeAbbrev>();
+  Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_IFUNC));
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // modid
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
+  unsigned FSIfuncAbbrev = Stream.EmitAbbrev(std::move(Abbv));
 
   // The aliases are emitted as a post-pass, and will point to the value
   // id of the aliasee. Save them in a vector for post-processing.
   SmallVector<AliasSummary *, 64> Aliases;
 
-  // Save the value id for each summary for alias emission.
+  // The ifuncs are emitted as a post-pass, and will point to the value
+  // id of the resolver. Save them in a vector for post-processing.
+  SmallVector<IfuncSummary *, 64> Ifuncs;
+
+  // Save the value id for each summary for alias and ifunc emission.
   DenseMap<const GlobalValueSummary *, unsigned> SummaryToValueIdMap;
 
   SmallVector<uint64_t, 64> NameVals;
 
   // Set that will be populated during call to writeFunctionTypeMetadataRecords
   // with the type ids referenced by this index file.
   std::set<GlobalValue::GUID> ReferencedTypeIds;
 
   // For local linkage, we also emit the original name separately
   // immediately after the record.
   auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {
     if (!GlobalValue::isLocalLinkage(S.linkage()))
       return;
     NameVals.push_back(S.getOriginalName());
     Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);
     NameVals.clear();
   };
 
   std::set<GlobalValue::GUID> DefOrUseGUIDs;
-  forEachSummary([&](GVInfo I, bool IsAliasee) {
+  forEachSummary([&](GVInfo I, bool IsAliaseeOrIRes) {
     GlobalValueSummary *S = I.second;
     assert(S);
     DefOrUseGUIDs.insert(I.first);
     for (const ValueInfo &VI : S->refs())
       DefOrUseGUIDs.insert(VI.getGUID());
 
     auto ValueId = getValueId(I.first);
     assert(ValueId);
     SummaryToValueIdMap[S] = *ValueId;
 
-    // If this is invoked for an aliasee, we want to record the above
-    // mapping, but then not emit a summary entry (if the aliasee is
-    // to be imported, we will invoke this separately with IsAliasee=false).
-    if (IsAliasee)
+    // If this is invoked for an aliasee or ifunc resolver, we want to record
+    // the above mapping, but then not emit a summary entry (if the aliasee is
+    // to be imported, we will invoke this separately with
+    // IsAliaseeOrIRes=false).
+    if (IsAliaseeOrIRes)
       return;
 
     if (auto *AS = dyn_cast<AliasSummary>(S)) {
       // Will process aliases as a post-pass because the reader wants all
       // global to be loaded first.
       Aliases.push_back(AS);
       return;
     }
 
+    if (auto *IF = dyn_cast<IfuncSummary>(S)) {
+      // Will process ifuncs as a post-pass because the reader wants all
+      // global to be loaded first.
+      Ifuncs.push_back(IF);
+      return;
+    }
+
     if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {
       NameVals.push_back(*ValueId);
       NameVals.push_back(Index.getModuleId(VS->modulePath()));
       NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
       NameVals.push_back(getEncodedGVarFlags(VS->varflags()));
       for (auto &RI : VS->refs()) {
         auto RefValueId = getValueId(RI.getGUID());
         if (!RefValueId)
void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   });
 
   for (auto *AS : Aliases) {
     auto AliasValueId = SummaryToValueIdMap[AS];
     assert(AliasValueId);
     NameVals.push_back(AliasValueId);
     NameVals.push_back(Index.getModuleId(AS->modulePath()));
     NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
-    auto AliaseeValueId = SummaryToValueIdMap[&AS->getAliasee()];
+    auto AliaseeValueId = SummaryToValueIdMap[&AS->getIndirectSymbol()];
     assert(AliaseeValueId);
     NameVals.push_back(AliaseeValueId);
 
     // Emit the finished record.
     Stream.EmitRecord(bitc::FS_COMBINED_ALIAS, NameVals, FSAliasAbbrev);
     NameVals.clear();
     MaybeEmitOriginalName(*AS);
 
-    if (auto *FS = dyn_cast<FunctionSummary>(&AS->getAliasee()))
+    if (auto *FS = dyn_cast<FunctionSummary>(&AS->getIndirectSymbol()))
       getReferencedTypeIds(FS, ReferencedTypeIds);
   }
+  for (auto *IF : Ifuncs) {
+    auto IfuncValueId = SummaryToValueIdMap[IF];
+    assert(IfuncValueId);
+    NameVals.push_back(IfuncValueId);
+    NameVals.push_back(Index.getModuleId(IF->modulePath()));
+    NameVals.push_back(getEncodedGVSummaryFlags(IF->flags()));
+    auto ResolverValueId = SummaryToValueIdMap[&IF->getIndirectSymbol()];
+    assert(ResolverValueId);
+    NameVals.push_back(ResolverValueId);
 
+    // Emit the finished record.
+    Stream.EmitRecord(bitc::FS_COMBINED_IFUNC, NameVals, FSIfuncAbbrev);
+    NameVals.clear();
+    MaybeEmitOriginalName(*IF);
+
+    auto *FS = dyn_cast<FunctionSummary>(&IF->getIndirectSymbol());
+    assert(FS);
+    getReferencedTypeIds(FS, ReferencedTypeIds);
+  }
   if (!Index.cfiFunctionDefs().empty()) {
     for (auto &S : Index.cfiFunctionDefs()) {
       if (DefOrUseGUIDs.count(
               GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(S)))) {
         NameVals.push_back(StrtabBuilder.add(S));
         NameVals.push_back(S.size());
       }
     }

llvm/lib/IR/AsmWriter.cpp

public:
 
   void printUseListOrder(const UseListOrder &Order);
   void printUseLists(const Function *F);
 
   void printModuleSummaryIndex();
   void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
   void printSummary(const GlobalValueSummary &Summary);
   void printAliasSummary(const AliasSummary *AS);
+  void printIfuncSummary(const IfuncSummary *IF);
   void printGlobalVarSummary(const GlobalVarSummary *GS);
   void printFunctionSummary(const FunctionSummary *FS);
   void printTypeIdSummary(const TypeIdSummary &TIS);
   void printTypeIdCompatibleVtableSummary(const TypeIdCompatibleVtableInfo &TI);
   void printTypeTestResolution(const TypeTestResolution &TTRes);
   void printArgs(const std::vector<uint64_t> &Args);
   void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
   void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
   }
   Out << ")";
 }
 
 static const char *getSummaryKindName(GlobalValueSummary::SummaryKind SK) {
   switch (SK) {
   case GlobalValueSummary::AliasKind:
     return "alias";
+  case GlobalValueSummary::IfuncKind:
+    return "ifunc";
   case GlobalValueSummary::FunctionKind:
     return "function";
   case GlobalValueSummary::GlobalVarKind:
     return "variable";
   }
   llvm_unreachable("invalid summary kind");
 }
 
 void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
   Out << ", aliasee: ";
   // The indexes emitted for distributed backends may not include the
   // aliasee summary (only if it is being imported directly). Handle
   // that case by just emitting "null" as the aliasee.
-  if (AS->hasAliasee())
-    Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
+  if (AS->hasIndirectSymbol())
+    Out << "^"
+        << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getIndirectSymbol()]);
+  else
+    Out << "null";
+}
+
+void AssemblyWriter::printIfuncSummary(const IfuncSummary *IF) {
+  Out << ", resolver: ";
+  // The indexes emitted for distributed backends may not include the
+  // resolver summary (only if it is being imported directly). Handle
+  // that case by just emitting "null" as the resolver.
+  if (IF->hasIndirectSymbol())
+    Out << "^"
+        << Machine.getGUIDSlot(SummaryToGUIDMap[&IF->getIndirectSymbol()]);
   else
     Out << "null";
 }
 
 void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
   auto VTableFuncs = GS->vTableFuncs();
   Out << ", varFlags: (readonly: " << GS->VarFlags.MaybeReadOnly << ", "
       << "writeonly: " << GS->VarFlags.MaybeWriteOnly << ", "
void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
   Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
   Out << ", live: " << GVFlags.Live;
   Out << ", dsoLocal: " << GVFlags.DSOLocal;
   Out << ", canAutoHide: " << GVFlags.CanAutoHide;
   Out << ")";
 
   if (Summary.getSummaryKind() == GlobalValueSummary::AliasKind)
     printAliasSummary(cast<AliasSummary>(&Summary));
+  else if (Summary.getSummaryKind() == GlobalValueSummary::IfuncKind)
+    printIfuncSummary(cast<IfuncSummary>(&Summary));
   else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
     printFunctionSummary(cast<FunctionSummary>(&Summary));
   else
     printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));
 
   auto RefList = Summary.refs();
   if (!RefList.empty()) {
     Out << ", refs: (";

llvm/lib/IR/Globals.cpp

 
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 using namespace llvm;
 

 }
 
 std::string GlobalValue::getGlobalIdentifier() const {
   return getGlobalIdentifier(getName(), getLinkage(),
                              getParent()->getSourceFileName());
 }
 
 StringRef GlobalValue::getSection() const {
-  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
+  if (auto *GIS = dyn_cast<GlobalIndirectSymbol>(this)) {
     // In general we cannot compute this at the IR level, but we try.
-    if (const GlobalObject *GO = GA->getBaseObject())
+    if (const GlobalObject *GO = GIS->getBaseObject())
       return GO->getSection();
     return "";
   }
   return cast<GlobalObject>(this)->getSection();
 }
 
 const Comdat *GlobalValue::getComdat() const {
   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // In general we cannot compute this at the IR level, but we try.
     if (const GlobalObject *GO = GA->getBaseObject())
       return const_cast<GlobalObject *>(GO)->getComdat();

llvm/lib/IR/ModuleSummaryIndex.cpp

static std::string getNodeVisualName(GlobalValue::GUID Id) {
   return std::string("@") + std::to_string(Id);
 }
 
 static std::string getNodeVisualName(const ValueInfo &VI) {
   return VI.name().empty() ? getNodeVisualName(VI.getGUID()) : VI.name().str();
 }
 
 static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS) {
-  if (isa<AliasSummary>(GVS))
+  if (isa<GlobalIndirectValueSummary>(GVS))
     return getNodeVisualName(VI);
 
   std::string Attrs = getSummaryAttributes(GVS);
   std::string Label =
       getNodeVisualName(VI) + "|" + linkageToString(GVS->linkage());
   if (!Attrs.empty())
     Label += std::string(" (") + Attrs + ")";
   Label += "}";
for (auto &ModIt : ModuleToDefinedGVS) {
     }
     OS << "    // Edges:\n";
 
     for (auto &SummaryIt : GVSMap) {
       auto *GVS = SummaryIt.second;
       for (auto &R : GVS->refs())
         Draw(SummaryIt.first, R.getGUID(),
              R.isWriteOnly() ? -1 : (R.isReadOnly() ? -2 : -3));
 
-      if (auto *AS = dyn_cast_or_null<AliasSummary>(SummaryIt.second)) {
-        Draw(SummaryIt.first, AS->getAliaseeGUID(), -4);
+      if (auto *GIV =
+              dyn_cast_or_null<GlobalIndirectValueSummary>(SummaryIt.second)) {
+        Draw(SummaryIt.first, GIV->getIndirectSymbolGUID(), -4);
         continue;
       }
 
       if (auto *FS = dyn_cast_or_null<FunctionSummary>(SummaryIt.second))
         for (auto &CGEdge : FS->calls())
           Draw(SummaryIt.first, CGEdge.first.getGUID(),
                static_cast<int>(CGEdge.second.Hotness));
     }

llvm/lib/LTO/LTO.cpp

#endif
   }
 
   // Imported functions may introduce new uses of type identifier resolutions,
   // so we need to collect their used resolutions as well.
   for (auto &ImpM : ImportList)
     for (auto &ImpF : ImpM.second) {
       GlobalValueSummary *S = Index.findSummaryInModule(ImpF, ImpM.first());
       AddUsedThings(S);
-      // If this is an alias, we also care about any types/etc. that the aliasee
-      // may reference.
-      if (auto *AS = dyn_cast_or_null<AliasSummary>(S))
-        AddUsedThings(AS->getBaseObject());
+      // If this is an alias/ifunc, we also care about any types/etc.
+      // that the aliasee/resolver may reference.
+      if (auto *GIV = dyn_cast_or_null<GlobalIndirectValueSummary>(S))
+        AddUsedThings(GIV->getBaseObject());
     }
 
   auto AddTypeIdSummary = [&](StringRef TId, const TypeIdSummary &S) {
     AddString(TId);
 
     AddUnsigned(S.TTRes.TheKind);
     AddUnsigned(S.TTRes.SizeM1BitWidth);
 
if (!Conf.SampleProfile.empty()) {
     }
   }
 
   Key = toHex(Hasher.result());
 }
 
 static void thinLTOResolvePrevailingGUID(
     const Config &C, ValueInfo VI,
-    DenseSet<GlobalValueSummary *> &GlobalInvolvedWithAlias,
+    DenseSet<GlobalValueSummary *> &GlobalInvolvedWithIndirectValue,
     function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
         isPrevailing,
     function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
         recordNewLinkage,
     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
   GlobalValue::VisibilityTypes Visibility =
       C.VisibilityScheme == Config::ELF ? VI.getELFVisibility()
                                         : GlobalValue::DefaultVisibility;
if (isPrevailing(VI.getGUID(), S.get())) {
         // summary), and in that case we cannot hide it as it isn't possible to
         // check all copies.
         S->setCanAutoHide(VI.canAutoHide() &&
                           !GUIDPreservedSymbols.count(VI.getGUID()));
       }
       if (C.VisibilityScheme == Config::FromPrevailing)
         Visibility = S->getVisibility();
     }
-    // Alias and aliasee can't be turned into available_externally.
-    else if (!isa<AliasSummary>(S.get()) &&
-             !GlobalInvolvedWithAlias.count(S.get()))
+    // Alias and aliasee or ifunc and resolver can't be turned into
+    // available_externally.
+    else if (!isa<GlobalIndirectValueSummary>(S.get()) &&
+             !GlobalInvolvedWithIndirectValue.count(S.get()))
       S->setLinkage(GlobalValue::AvailableExternallyLinkage);
 
     // For ELF, set visibility to the computed visibility from summaries. We
     // don't track visibility from declarations so this may be more relaxed than
     // the most constraining one.
     if (C.VisibilityScheme == Config::ELF)
       S->setVisibility(Visibility);
 
void llvm::thinLTOResolvePrevailingInIndex(
     function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
         isPrevailing,
     function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
         recordNewLinkage,
     const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols) {
   // We won't optimize the globals that are referenced by an alias for now
   // Ideally we should turn the alias into a global and duplicate the definition
   // when needed.
-  DenseSet<GlobalValueSummary *> GlobalInvolvedWithAlias;
+  DenseSet<GlobalValueSummary *> GlobalInvolvedWithIndirectValue;
   for (auto &I : Index)
     for (auto &S : I.second.SummaryList)
-      if (auto AS = dyn_cast<AliasSummary>(S.get()))
-        GlobalInvolvedWithAlias.insert(&AS->getAliasee());
+      if (auto GIV = dyn_cast<GlobalIndirectValueSummary>(S.get()))
+        GlobalInvolvedWithIndirectValue.insert(&GIV->getIndirectSymbol());
 
   for (auto &I : Index)
     thinLTOResolvePrevailingGUID(C, Index.getValueInfo(I),
-                                 GlobalInvolvedWithAlias, isPrevailing,
+                                 GlobalInvolvedWithIndirectValue, isPrevailing,
                                  recordNewLinkage, GUIDPreservedSymbols);
 }
 
 static bool isWeakObjectWithRWAccess(GlobalValueSummary *GVS) {
   if (auto *VarSummary = dyn_cast<GlobalVarSummary>(GVS->getBaseObject()))
     return !VarSummary->maybeReadOnly() && !VarSummary->maybeWriteOnly() &&
            (VarSummary->linkage() == GlobalValue::WeakODRLinkage ||
             VarSummary->linkage() == GlobalValue::LinkOnceODRLinkage);

llvm/lib/Transforms/IPO/FunctionImport.cpp

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/IR/AutoUpgrade.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
+#include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"
auto It = llvm::find_if(
           return false;
         }
         if (GlobalValue::isInterposableLinkage(GVSummary->linkage())) {
           Reason = FunctionImporter::ImportFailureReason::InterposableLinkage;
           // There is no point in importing these, we can't inline them
           return false;
         }
 
+        if (GVSummary->getSummaryKind() == GlobalValueSummary::IfuncKind) {
+          return false;
+        }
+
         auto *Summary = cast<FunctionSummary>(GVSummary->getBaseObject());
 
         // If this is a local function, make sure we import the copy
         // in the caller's module. The only time a local function can
         // share an entry in the index is if there is a local with the same name
         // in another module that had the same source file name (in a different
         // directory), where each was compiled in their own directory so there
         // was not distinguishing path.
         // However, do the import from another module if there is only one
static void ComputeImportForModule(
   // Worklist contains the list of function imported in this module, for which
   // we will analyse the callees and may import further down the callgraph.
   SmallVector<EdgeInfo, 128> Worklist;
   FunctionImporter::ImportThresholdsTy ImportThresholds;
 
   // Populate the worklist with the import for the functions in the current
   // module
   for (auto &GVSummary : DefinedGVSummaries) {
 #ifndef NDEBUG
     // FIXME: Change the GVSummaryMapTy to hold ValueInfo instead of GUID
     // so this map look up (and possibly others) can be avoided.
     auto VI = Index.getValueInfo(GVSummary.first);
 #endif
     if (!Index.isGlobalValueLive(GVSummary.second)) {
       LLVM_DEBUG(dbgs() << "Ignores Dead GUID: " << VI << "\n");
       continue;
     }
     auto *FuncSummary =
         dyn_cast<FunctionSummary>(GVSummary.second->getBaseObject());
     if (!FuncSummary)
       // Skip import for global variables
       continue;
     LLVM_DEBUG(dbgs() << "Initialize import for " << VI << "\n");
     computeImportForFunction(*FuncSummary, Index, ImportInstrLimit,
                              DefinedGVSummaries, Worklist, ImportList,
                              ExportLists, ImportThresholds);
   }
 
   // Process the newly imported functions and add callees to the worklist.
   while (!Worklist.empty()) {
     auto GVInfo = Worklist.pop_back_val();
for (auto &S : Entry.second.SummaryList)
         LLVM_DEBUG(dbgs() << "Live root: " << VI << "\n");
         Worklist.push_back(VI);
         ++LiveSymbols;
         break;
       }
   }
 
   // Make value live and add it to the worklist if it was not live before.
-  auto visit = [&](ValueInfo VI, bool IsAliasee) {
+  auto visit = [&](ValueInfo VI, bool IsAliaseeOrResolver) {
     // FIXME: If we knew which edges were created for indirect call profiles,
     // we could skip them here. Any that are live should be reached via
     // other edges, e.g. reference edges. Otherwise, using a profile collected
     // on a slightly different binary might provoke preserving, importing
     // and ultimately promoting calls to functions not linked into this
     // binary, which increases the binary size unnecessarily. Note that
     // if this code changes, the importer needs to change so that edges
     // to functions marked dead are skipped.
if (isPrevailing(VI.getGUID()) == PrevailingType::No) {
         if (S->linkage() == GlobalValue::AvailableExternallyLinkage ||
             S->linkage() == GlobalValue::WeakODRLinkage ||
             S->linkage() == GlobalValue::LinkOnceODRLinkage)
           KeepAliveLinkage = true;
         else if (GlobalValue::isInterposableLinkage(S->linkage()))
           Interposable = true;
       }
 
-      if (!IsAliasee) {
+      if (!IsAliaseeOrResolver) {
         if (!KeepAliveLinkage)
           return;
 
         if (Interposable)
           report_fatal_error(
               "Interposable and available_externally/linkonce_odr/weak_odr "
               "symbol");
       }
     }
 
     for (auto &S : VI.getSummaryList())
       S->setLive(true);
     ++LiveSymbols;
     Worklist.push_back(VI);
   };
 
   while (!Worklist.empty()) {
     auto VI = Worklist.pop_back_val();
     for (auto &Summary : VI.getSummaryList()) {
-      if (auto *AS = dyn_cast<AliasSummary>(Summary.get())) {
-        // If this is an alias, visit the aliasee VI to ensure that all copies
-        // are marked live and it is added to the worklist for further
-        // processing of its references.
-        visit(AS->getAliaseeVI(), true);
+      if (auto *GIV = dyn_cast<GlobalIndirectValueSummary>(Summary.get())) {
+        // If this is an alias or ifunc, visit the aliasee / resolver VI to
+        // ensure that all copies are marked live and it is added to the
+        // worklist for further processing of its references.
+        visit(GIV->getIndirectSymbolVI(), true);
         continue;
       }
+
       for (auto Ref : Summary->refs())
         visit(Ref, false);
       if (auto *FS = dyn_cast<FunctionSummary>(Summary.get()))
         for (auto Call : FS->calls())
           visit(Call.first, false);
     }
   }
   Index.setWithGlobalValueDeadStripping();

llvm/test/Assembler/thinlto-summary.ll

 ^15 = gv: (guid: 14, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 1, dsoLocal: 0), insts: 1, funcFlags: (noInline: 1))))
 ^16 = gv: (guid: 15, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 1, funcFlags: (readNone: 1, noRecurse: 1, alwaysInline: 1))))
 ; This one also tests backwards reference in calls.
 ^17 = gv: (guid: 16, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 1, funcFlags: (readOnly: 1, returnDoesNotAlias: 1), calls: ((callee: ^15)))))
 
 ; Alias summary with backwards reference to aliasee.
 ^18 = gv: (guid: 17, summaries: (alias: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1), aliasee: ^14)))
 
+; Test Ifunc summaries with forward reference to resolver:
+^19 = gv: (guid: 18, summaries: (ifunc: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1), resolver: ^20)))
+^20 = gv: (guid: 19, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1), insts: 1, refs: (^21))))
+^21 = gv: (guid: 20, summaries: (function: (module: ^0, flags: (linkage: internal, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1), insts: 1)))
+; Test Ifunc summaries with backwards reference to resolver:
+^22 = gv: (guid: 21, summaries: (ifunc: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1), resolver: ^20)))
+
 ; Test all types of TypeIdInfo on function summaries.
-^19 = gv: (guid: 18, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 4, typeIdInfo: (typeTests: (^24, ^26)))))
-^20 = gv: (guid: 19, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 8, typeIdInfo: (typeTestAssumeVCalls: (vFuncId: (^27, offset: 16))))))
-^21 = gv: (guid: 20, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 5, typeIdInfo: (typeCheckedLoadVCalls: (vFuncId: (^25, offset: 16))))))
-^22 = gv: (guid: 21, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 15, typeIdInfo: (typeTestAssumeConstVCalls: ((vFuncId: (^27, offset: 16), args: (42)), (vFuncId: (^27, offset: 24)))))))
-^23 = gv: (guid: 22, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 5, typeIdInfo: (typeCheckedLoadConstVCalls: ((vFuncId: (^28, offset: 16), args: (42)))))))
+^23 = gv: (guid: 22, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 4, typeIdInfo: (typeTests: (^28, ^30)))))
+^24 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 8, typeIdInfo: (typeTestAssumeVCalls: (vFuncId: (^31, offset: 16))))))
+^25 = gv: (guid: 24, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 5, typeIdInfo: (typeCheckedLoadVCalls: (vFuncId: (^29, offset: 16))))))
+^26 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 15, typeIdInfo: (typeTestAssumeConstVCalls: ((vFuncId: (^31, offset: 16), args: (42)), (vFuncId: (^31, offset: 24)))))))
+^27 = gv: (guid: 26, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0), insts: 5, typeIdInfo: (typeCheckedLoadConstVCalls: ((vFuncId: (^32, offset: 16), args: (42)))))))
 
 ; Test TypeId summaries:
-
-^24 = typeid: (name: "_ZTS1C", summary: (typeTestRes: (kind: single, sizeM1BitWidth: 0)))
+^28 = typeid: (name: "_ZTS1C", summary: (typeTestRes: (kind: single, sizeM1BitWidth: 0)))
 ; Test TypeId with other optional fields (alignLog2/sizeM1/bitMask/inlineBits)
-^25 = typeid: (name: "_ZTS1B", summary: (typeTestRes: (kind: inline, sizeM1BitWidth: 0, alignLog2: 1, sizeM1: 2, bitMask: 3, inlineBits: 4)))
+^29 = typeid: (name: "_ZTS1B", summary: (typeTestRes: (kind: inline, sizeM1BitWidth: 0, alignLog2: 1, sizeM1: 2, bitMask: 3, inlineBits: 4)))
 ; Test the AllOnes resolution, and all kinds of WholeProgramDevirtResolution
 ; types, including all optional resolution by argument kinds.
-^26 = typeid: (name: "_ZTS1A", summary: (typeTestRes: (kind: allOnes, sizeM1BitWidth: 7), wpdResolutions: ((offset: 0, wpdRes: (kind: branchFunnel)), (offset: 8, wpdRes: (kind: singleImpl, singleImplName: "_ZN1A1nEi")), (offset: 16, wpdRes: (kind: indir, resByArg: (args: (1, 2), byArg: (kind: indir, byte: 2, bit: 3), args: (3), byArg: (kind: uniformRetVal, info: 1), args: (4), byArg: (kind: uniqueRetVal, info: 1), args: (5), byArg: (kind: virtualConstProp)))))))
+^30 = typeid: (name: "_ZTS1A", summary: (typeTestRes: (kind: allOnes, sizeM1BitWidth: 7), wpdResolutions: ((offset: 0, wpdRes: (kind: branchFunnel)), (offset: 8, wpdRes: (kind: singleImpl, singleImplName: "_ZN1A1nEi")), (offset: 16, wpdRes: (kind: indir, resByArg: (args: (1, 2), byArg: (kind: indir, byte: 2, bit: 3), args: (3), byArg: (kind: uniformRetVal, info: 1), args: (4), byArg: (kind: uniqueRetVal, info: 1), args: (5), byArg: (kind: virtualConstProp)))))))
 ; Test the other kinds of type test resoultions
-^27 = typeid: (name: "_ZTS1D", summary: (typeTestRes: (kind: byteArray, sizeM1BitWidth: 0)))
-^28 = typeid: (name: "_ZTS1E", summary: (typeTestRes: (kind: unsat, sizeM1BitWidth: 0)))
-^29 = flags: 8
-^30 = blockcount: 1888
+^31 = typeid: (name: "_ZTS1D", summary: (typeTestRes: (kind: byteArray, sizeM1BitWidth: 0)))
+^32 = typeid: (name: "_ZTS1E", summary: (typeTestRes: (kind: unsat, sizeM1BitWidth: 0)))
+^33 = flags: 8
+^34 = blockcount: 1888
 
 ; Make sure we get back from llvm-dis essentially what we put in via llvm-as.
 ; CHECK: ^0 = module: (path: "thinlto-summary1.o", hash: (1369602428, 2747878711, 259090915, 2507395659, 1141468049))
 ; CHECK: ^1 = module: (path: "thinlto-summary2.o", hash: (2998369023, 4283347029, 1195487472, 2757298015, 1852134156))
 ; CHECK: ^2 = gv: (guid: 1, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 10, calls: ((callee: ^15, hotness: hot), (callee: ^17, hotness: cold), (callee: ^16, hotness: none)), refs: (^11, readonly ^13, writeonly ^14))))
 ; CHECK: ^3 = gv: (guid: 2, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 10, calls: ((callee: ^15)))))
 ; CHECK: ^4 = gv: (guid: 3, summaries: (function: (module: ^0, flags: (linkage: internal, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1)))
 ; CHECK: ^5 = gv: (guid: 4, summaries: (alias: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), aliasee: ^14)))
 ; CHECK: ^6 = gv: (guid: 5, summaries: (function: (module: ^0, flags: (linkage: available_externally, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1)))
 ; CHECK: ^7 = gv: (guid: 6, summaries: (function: (module: ^0, flags: (linkage: linkonce, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1)))
 ; CHECK: ^8 = gv: (guid: 7, summaries: (function: (module: ^0, flags: (linkage: linkonce_odr, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1)))
 ; CHECK: ^9 = gv: (guid: 8, summaries: (function: (module: ^0, flags: (linkage: weak_odr, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 1), insts: 1)))
 ; CHECK: ^10 = gv: (guid: 9, summaries: (function: (module: ^0, flags: (linkage: weak, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1)))
 ; CHECK: ^11 = gv: (guid: 10, summaries: (variable: (module: ^0, flags: (linkage: common, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0))))
 ; CHECK: ^12 = gv: (guid: 11, summaries: (variable: (module: ^0, flags: (linkage: appending, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0), refs: (^4))))
 ; CHECK: ^13 = gv: (guid: 12, summaries: (variable: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), varFlags: (readonly: 1, writeonly: 0, constant: 0))))
 ; CHECK: ^14 = gv: (guid: 13, summaries: (variable: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), varFlags: (readonly: 0, writeonly: 0, constant: 0))))
 ; CHECK: ^15 = gv: (guid: 14, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 1, live: 1, dsoLocal: 0, canAutoHide: 0), insts: 1, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 1, alwaysInline: 0))))
 ; CHECK: ^16 = gv: (guid: 15, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1, funcFlags: (readNone: 1, readOnly: 0, noRecurse: 1, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 1))))
 ; CHECK: ^17 = gv: (guid: 16, summaries: (function: (module: ^1, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 1, funcFlags: (readNone: 0, readOnly: 1, noRecurse: 0, returnDoesNotAlias: 1, noInline: 0, alwaysInline: 0), calls: ((callee: ^15)))))
 ; CHECK: ^18 = gv: (guid: 17, summaries: (alias: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), aliasee: ^14)))
-; CHECK: ^19 = gv: (guid: 18, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 4, typeIdInfo: (typeTests: (^24, ^26)))))
-; CHECK: ^20 = gv: (guid: 19, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 8, typeIdInfo: (typeTestAssumeVCalls: (vFuncId: (^27, offset: 16))))))
-; CHECK: ^21 = gv: (guid: 20, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 5, typeIdInfo: (typeCheckedLoadVCalls: (vFuncId: (^25, offset: 16))))))
-; CHECK: ^22 = gv: (guid: 21, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 15, typeIdInfo: (typeTestAssumeConstVCalls: ((vFuncId: (^27, offset: 16), args: (42)), (vFuncId: (^27, offset: 24)))))))
-; CHECK: ^23 = gv: (guid: 22, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 5, typeIdInfo: (typeCheckedLoadConstVCalls: ((vFuncId: (^28, offset: 16), args: (42)))))))
-; CHECK: ^24 = typeid: (name: "_ZTS1C", summary: (typeTestRes: (kind: single, sizeM1BitWidth: 0))) ; guid = 1884921850105019584
-; CHECK: ^25 = typeid: (name: "_ZTS1B", summary: (typeTestRes: (kind: inline, sizeM1BitWidth: 0, alignLog2: 1, sizeM1: 2, bitMask: 3, inlineBits: 4))) ; guid = 6203814149063363976
-; CHECK: ^26 = typeid: (name: "_ZTS1A", summary: (typeTestRes: (kind: allOnes, sizeM1BitWidth: 7), wpdResolutions: ((offset: 0, wpdRes: (kind: branchFunnel)), (offset: 8, wpdRes: (kind: singleImpl, singleImplName: "_ZN1A1nEi")), (offset: 16, wpdRes: (kind: indir, resByArg: (args: (1, 2), byArg: (kind: indir, byte: 2, bit: 3), args: (3), byArg: (kind: uniformRetVal, info: 1), args: (4), byArg: (kind: uniqueRetVal, info: 1), args: (5), byArg: (kind: virtualConstProp))))))) ; guid = 7004155349499253778
-; CHECK: ^27 = typeid: (name: "_ZTS1D", summary: (typeTestRes: (kind: byteArray, sizeM1BitWidth: 0))) ; guid = 9614786172484273522
-; CHECK: ^28 = typeid: (name: "_ZTS1E", summary: (typeTestRes: (kind: unsat, sizeM1BitWidth: 0))) ; guid = 17437243864166745132
-; CHECK: ^29 = flags: 8
-; CHECK: ^30 = blockcount: 1888
+; CHECK: ^19 = gv: (guid: 18, summaries: (ifunc: (module: ^0, flags: (linkage: private, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), resolver: ^20)))
+; CHECK: ^20 = gv: (guid: 19, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, refs: (^21))))
+; CHECK: ^21 = gv: (guid: 20, summaries: (function: (module: ^0, flags: (linkage: internal, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1)))
+; CHECK: ^22 = gv: (guid: 21, summaries: (ifunc: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), resolver: ^20)))
+; CHECK: ^23 = gv: (guid: 22, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 4, typeIdInfo: (typeTests: (^28, ^30)))))
+; CHECK: ^24 = gv: (guid: 23, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 8, typeIdInfo: (typeTestAssumeVCalls: (vFuncId: (^31, offset: 16))))))
+; CHECK: ^25 = gv: (guid: 24, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 5, typeIdInfo: (typeCheckedLoadVCalls: (vFuncId: (^29, offset: 16))))))
+; CHECK: ^26 = gv: (guid: 25, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 15, typeIdInfo: (typeTestAssumeConstVCalls: ((vFuncId: (^31, offset: 16), args: (42)), (vFuncId: (^31, offset: 24)))))))
+; CHECK: ^27 = gv: (guid: 26, summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 0, canAutoHide: 0), insts: 5, typeIdInfo: (typeCheckedLoadConstVCalls: ((vFuncId: (^32, offset: 16), args: (42)))))))
+; CHECK: ^28 = typeid: (name: "_ZTS1C", summary: (typeTestRes: (kind: single, sizeM1BitWidth: 0))) ; guid = 1884921850105019584
+; CHECK: ^29 = typeid: (name: "_ZTS1B", summary: (typeTestRes: (kind: inline, sizeM1BitWidth: 0, alignLog2: 1, sizeM1: 2, bitMask: 3, inlineBits: 4))) ; guid = 6203814149063363976
+; CHECK: ^30 = typeid: (name: "_ZTS1A", summary: (typeTestRes: (kind: allOnes, sizeM1BitWidth: 7), wpdResolutions: ((offset: 0, wpdRes: (kind: branchFunnel)), (offset: 8, wpdRes: (kind: singleImpl, singleImplName: "_ZN1A1nEi")), (offset: 16, wpdRes: (kind: indir, resByArg: (args: (1, 2), byArg: (kind: indir, byte: 2, bit: 3), args: (3), byArg: (kind: uniformRetVal, info: 1), args: (4), byArg: (kind: uniqueRetVal, info: 1), args: (5), byArg: (kind: virtualConstProp))))))) ; guid = 7004155349499253778
+; CHECK: ^31 = typeid: (name: "_ZTS1D", summary: (typeTestRes: (kind: byteArray, sizeM1BitWidth: 0))) ; guid = 9614786172484273522
+; CHECK: ^32 = typeid: (name: "_ZTS1E", summary: (typeTestRes: (kind: unsat, sizeM1BitWidth: 0))) ; guid = 17437243864166745132
+; CHECK: ^33 = flags: 8
+; CHECK: ^34 = blockcount: 1888
 
 ; Make sure parsing of a non-summary entry containing a ":" does not fail
 ; after summary parsing, which handles colons differently.
 !0 = !DIFile(filename: "thinlto-summary.ll", directory: "", source: "")

llvm/test/Bitcode/summary_version.ll

 ; Check summary versioning
 ; RUN: opt  -module-summary  %s -o - | llvm-bcanalyzer -dump | FileCheck %s
 
 ; CHECK: <GLOBALVAL_SUMMARY_BLOCK
-; CHECK: <VERSION op0=9/>
+; CHECK: <VERSION op0=10/>
 
 
 
 ; Need a function for the summary to be populated.
 define void @foo() {
     ret void
 }

llvm/test/Bitcode/thinlto-ifunc.ll

+; Test to check the callgraph in summary
+; RUN: opt -module-summary %s -o %t.o
+; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
+; RUN: llvm-dis -o - %t.o | FileCheck %s --check-prefix=DIS
+
+@ifunc = dso_local ifunc i32 (), bitcast (i32 ()* ()* @resolver to i32 ()*)
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 ()* @resolver() #0 {
+  ret i32 ()* @called
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define internal i32 @called() #0 {
+  ret i32 1
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @main() #0 {
+  %1 = call i32 @ifunc()
+  ret i32 0
+}
+
+; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
+; CHECK-NEXT:    <VERSION
+; CHECK-NEXT:    <FLAGS
+; CHECK-NEXT:    <PERMODULE {{.*}} op0=[[RESOLVERID:[0-9]+]] {{.*}} op7=[[CALLEDID:[0-9]+]]/>
+; CHECK-NEXT:    <PERMODULE {{.*}} op0=[[CALLEDID]]
+; CHECK-NEXT:    <PERMODULE {{.*}} op7=[[IFUNCID:[0-9]+]]/>
+; CHECK-NEXT:    <IFUNC {{.*}} op0=[[IFUNCID]] {{.*}} op2=[[RESOLVERID]]/>
+; CHECK-NEXT:    <BLOCK_COUNT op0=3/>
+; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
+
+; DIS: ^0 = module: (path: "{{.*}}", hash: (0, 0, 0, 0, 0))
+; DIS: ^1 = gv: (name: "ifunc", summaries: (ifunc: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), resolver: ^4))) ; guid = 1234216394087659437
+; DIS: ^2 = gv: (name: "called", summaries: (function: (module: ^0, flags: (linkage: internal, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1))) ; guid = 14789455179670652464
+; DIS: ^3 = gv: (name: "main", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 2, calls: ((callee: ^1))))) ; guid = 15822663052811949562
+; DIS: ^4 = gv: (name: "resolver", summaries: (function: (module: ^0, flags: (linkage: external, visibility: default, notEligibleToImport: 0, live: 0, dsoLocal: 1, canAutoHide: 0), insts: 1, refs: (^2)))) ; guid = 18291748799076262136

llvm/test/ThinLTO/X86/Inputs/ifunc_import.ll

+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+
+define dso_local void @called() {
+  ret void
+}
+
+@globalIfunc = ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+@globalWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+@globalLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+@globalWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+@globalLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+define hidden void ()* @globalResolver() {
+entry:
+  ret void ()* @called
+}
+
+@internalIfunc = ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+@internalWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+@internalLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+@internalWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+@internalLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+define internal void ()* @internalResolver() {
+entry:
+  ret void ()* @called
+}
+
+@linkonceODRIfunc = ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+@linkonceODRWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+@linkonceODRLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+@linkonceODRWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+@linkonceODRLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+define linkonce_odr void ()* @linkonceODRResolver() {
+entry:
+  ret void ()* @called
+}
+
+@weakODRIfunc = ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+@weakODRWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+@weakODRLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+@weakODRWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+@weakODRLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+define weak_odr void ()* @weakODRResolver() {
+entry:
+  ret void ()* @called
+}
+
+@linkonceIfunc = ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+@linkonceWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+@linkonceLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+@linkonceWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+@linkonceLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+define linkonce void ()* @linkonceResolver() {
+entry:
+  ret void ()* @called
+}
+
+@weakIfunc = ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+@weakWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+@weakLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+@weakWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+@weakLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+define weak void ()* @weakResolver() {
+entry:
+  ret void ()* @called
+}

llvm/test/ThinLTO/X86/ifunc_import.ll

+; RUN: opt -module-summary %s -o %t1.bc
+; RUN: opt -module-summary %p/Inputs/ifunc_import.ll -o %t2.bc
+; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc %t2.bc
+; RUN: llvm-lto -thinlto-action=promote -thinlto-index %t.index.bc %t2.bc -o - | llvm-dis -o - | FileCheck -allow-deprecated-dag-overlap %s --check-prefix=PROMOTE
+; RUN: llvm-lto -thinlto-action=import -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck -allow-deprecated-dag-overlap %s --check-prefix=IMPORT
+
+; PROMOTE-DAG: @globalIfunc = ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+; PROMOTE-DAG: @globalWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+; PROMOTE-DAG: @globalLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+; PROMOTE-DAG: @globalWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+; PROMOTE-DAG: @globalLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @globalResolver to void ()*)
+; PROMOTE-DAG: @internalIfunc = ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+; PROMOTE-DAG: @internalWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+; PROMOTE-DAG: @internalLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+; PROMOTE-DAG: @internalWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+; PROMOTE-DAG: @internalLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @internalResolver to void ()*)
+; PROMOTE-DAG: @linkonceODRIfunc = ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+; PROMOTE-DAG: @linkonceODRWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+; PROMOTE-DAG: @linkonceODRLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+; PROMOTE-DAG: @linkonceODRWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+; PROMOTE-DAG: @linkonceODRLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @linkonceODRResolver to void ()*)
+; PROMOTE-DAG: @weakODRIfunc = ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+; PROMOTE-DAG: @weakODRWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+; PROMOTE-DAG: @weakODRLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+; PROMOTE-DAG: @weakODRWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+; PROMOTE-DAG: @weakODRLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @weakODRResolver to void ()*)
+; PROMOTE-DAG: @linkonceIfunc = ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+; PROMOTE-DAG: @linkonceWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+; PROMOTE-DAG: @linkonceLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+; PROMOTE-DAG: @linkonceWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+; PROMOTE-DAG: @linkonceLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @linkonceResolver to void ()*)
+; PROMOTE-DAG: @weakIfunc = ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+; PROMOTE-DAG: @weakWeakIfunc = weak ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+; PROMOTE-DAG: @weakLinkonceIfunc = linkonce ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+; PROMOTE-DAG: @weakWeakODRIfunc = weak_odr ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+; PROMOTE-DAG: @weakLinkonceODRIfunc = linkonce_odr ifunc void (), bitcast (void ()* ()* @weakResolver to void ()*)
+
+; PROMOTE-DAG: define hidden void ()* @globalResolver()
+; PROMOTE-DAG: define internal void ()* @internalResolver()
+; PROMOTE-DAG: define weak_odr void ()* @linkonceODRResolver()
+; PROMOTE-DAG: define weak_odr void ()* @weakODRResolver()
+; PROMOTE-DAG: define weak void ()*  @linkonceResolver()
+; PROMOTE-DAG: define weak void ()* @weakResolver()
+
+; IMPORT-DAG: declare void @globalIfunc()
+; IMPORT-DAG: declare void @globalWeakIfunc()
+; IMPORT-DAG: declare void @globalLinkonceIfunc()
+; IMPORT-DAG: declare void @globalWeakODRIfunc()
+; IMPORT-DAG: declare void @globalLinkonceODRIfunc()
+; IMPORT-DAG: declare void @internalIfunc()
+; IMPORT-DAG: declare void @internalWeakIfunc()
+; IMPORT-DAG: declare void @internalLinkonceIfunc()
+; IMPORT-DAG: declare void @internalWeakODRIfunc()
+; IMPORT-DAG: declare void @internalLinkonceODRIfunc()
+; IMPORT-DAG: declare void @linkonceODRIfunc()
+; IMPORT-DAG: declare void @linkonceODRWeakIfunc()
+; IMPORT-DAG: declare void @linkonceODRLinkonceIfunc()
+; IMPORT-DAG: declare void @linkonceODRWeakODRIfunc()
+; IMPORT-DAG: declare void @linkonceODRLinkonceODRIfunc()
+; IMPORT-DAG: declare void @weakODRIfunc()
+; IMPORT-DAG: declare void @weakODRWeakIfunc()
+; IMPORT-DAG: declare void @weakODRLinkonceIfunc()
+; IMPORT-DAG: declare void @weakODRWeakODRIfunc()
+; IMPORT-DAG: declare void @weakODRLinkonceODRIfunc()
+; IMPORT-DAG: declare void @linkonceIfunc()
+; IMPORT-DAG: declare void @linkonceWeakIfunc()
+; IMPORT-DAG: declare void @linkonceLinkonceIfunc()
+; IMPORT-DAG: declare void @linkonceWeakODRIfunc()
+; IMPORT-DAG: declare void @linkonceLinkonceODRIfunc()
+; IMPORT-DAG: declare void @weakIfunc()
+; IMPORT-DAG: declare void @weakWeakIfunc()
+; IMPORT-DAG: declare void @weakLinkonceIfunc()
+; IMPORT-DAG: declare void @weakWeakODRIfunc()
+; IMPORT-DAG: declare void @weakLinkonceODRIfunc()
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+
+define i32 @main() {
+entry:
+  call void @globalIfunc()
+  call void @globalWeakIfunc()
+  call void @globalLinkonceIfunc()
+  call void @globalWeakODRIfunc()
+  call void @globalLinkonceODRIfunc()
+
+  call void @internalIfunc()
+  call void @internalWeakIfunc()
+  call void @internalLinkonceIfunc()
+  call void @internalWeakODRIfunc()
+  call void @internalLinkonceODRIfunc()
+
+  call void @linkonceODRIfunc()
+  call void @linkonceODRWeakIfunc()
+  call void @linkonceODRLinkonceIfunc()
+  call void @linkonceODRWeakODRIfunc()
+  call void @linkonceODRLinkonceODRIfunc()
+
+  call void @weakODRIfunc()
+  call void @weakODRWeakIfunc()
+  call void @weakODRLinkonceIfunc()
+  call void @weakODRWeakODRIfunc()
+  call void @weakODRLinkonceODRIfunc()
+
+  call void @linkonceIfunc()
+  call void @linkonceWeakIfunc()
+  call void @linkonceLinkonceIfunc()
+  call void @linkonceWeakODRIfunc()
+  call void @linkonceLinkonceODRIfunc()
+
+  call void @weakIfunc()
+  call void @weakWeakIfunc()
+  call void @weakLinkonceIfunc()
+  call void @weakWeakODRIfunc()
+  call void @weakLinkonceODRIfunc()
+
+  ret i32 0
+}
+
+
+declare void @globalIfunc()
+declare void @globalWeakIfunc()
+declare void @globalLinkonceIfunc()
+declare void @globalWeakODRIfunc()
+declare void @globalLinkonceODRIfunc()
+
+declare void @internalIfunc()
+declare void @internalWeakIfunc()
+declare void @internalLinkonceIfunc()
+declare void @internalWeakODRIfunc()
+declare void @internalLinkonceODRIfunc()
+
+declare void @linkonceODRIfunc()
+declare void @linkonceODRWeakIfunc()
+declare void @linkonceODRLinkonceIfunc()
+declare void @linkonceODRWeakODRIfunc()
+declare void @linkonceODRLinkonceODRIfunc()
+
+declare void @weakODRIfunc()
+declare void @weakODRWeakIfunc()
+declare void @weakODRLinkonceIfunc()
+declare void @weakODRWeakODRIfunc()
+declare void @weakODRLinkonceODRIfunc()
+
+declare void @linkonceIfunc()
+declare void @linkonceWeakIfunc()
+declare void @linkonceLinkonceIfunc()
+declare void @linkonceWeakODRIfunc()
+declare void @linkonceLinkonceODRIfunc()
+
+declare void @weakIfunc()
+declare void @weakWeakIfunc()
+declare void @weakLinkonceIfunc()
+declare void @weakWeakODRIfunc()
+declare void @weakLinkonceODRIfunc()