Reorganize GlobalValueSummary with a "Flags" bitfield.

[mehdi_amini]

Summary

Right now it only contains the LinkageType, but will be extended
with "hasSection", "isOptSize", "hasInlineAssembly", etc.

[mehdi_amini]

remove debug

[tejohnson]

I suppose the advantage of encoding all of these flags into a single "flags" bitcode field (rather than having separate fixed bitcode fields for each flag) is twofold:

1. It is easier to add new flags in the future (requires touching less places in the code)
2. They can be compressed with the VBR encoding (assuming most individual flags are "off"/0).

The disadvantages are:

1. The bitcode record doesn't document the supported flags
2. Harder to distinguish old bitcode files that are missing any new flag altogether from newer bitcode that has the flags but they are "off"/0.

The biggest potential issue seems to me the second disadvantage. Particularly if the a 0 value for the new flag allows us to be more aggressive in certain cases than we were with the older bitcode version that didn't have the flag. Any thoughts on how we could mitigate this risk? Otherwise, it seems like it might be more robust to explicitly list each flag in the bitcode format.

lib/Bitcode/Reader/BitcodeReader.cpp

723

Don't understand the first sentence, can you clarify what that is saying?

Oh, I think what you are saying is that we don't need to do getDecodeLinkage since we aren't (yet) supporting any legacy linkage encodings? Could you clarify?

lib/Bitcode/Writer/BitcodeWriter.cpp

792

Similarly didn't at first understand the first sentence here - needs a similar clarification.

[mehdi_amini]

In D19404#409074, @tejohnson wrote:

I suppose the advantage of encoding all of these flags into a single "flags" bitcode field (rather than having separate fixed bitcode fields for each flag) is twofold:

1. It is easier to add new flags in the future (requires touching less places in the code)
2. They can be compressed with the VBR encoding (assuming most individual flags are "off"/0).

The disadvantages are:

1. The bitcode record doesn't document the supported flags
2. Harder to distinguish old bitcode files that are missing any new flag altogether from newer bitcode that has the flags but they are "off"/0.

The biggest potential issue seems to me the second disadvantage. Particularly if the a 0 value for the new flag allows us to be more aggressive in certain cases than we were with the older bitcode version that didn't have the flag. Any thoughts on how we could mitigate this risk? Otherwise, it seems like it might be more robust to explicitly list each flag in the bitcode format.

You're right. We need to version the record somehow.
Even with separate fields with have the issue. Usually we can work around it with separate field because the number of entries in the record tells us which "version" we have. Here we can't do that for every record because some record have variable-length entries.
Something that could work is to have [ ..., FlagsVersion (VBR6), Flags (VBR6), ...] with FlagsVersion an integer incremented every time we make a change to the Flags content.

lib/Bitcode/Reader/BitcodeReader.cpp

723

Yes, ThinLTO is too recent so there is no summary that needs auto-upgrade.
(I think I can already submit a separate patch that does this change for the current representation of the summary)

lib/Bitcode/Writer/BitcodeWriter.cpp

792

OK

[tejohnson]

In D19404#409351, @joker.eph wrote:

In D19404#409074, @tejohnson wrote:

The biggest potential issue seems to me the second disadvantage. Particularly if the a 0 value for the new flag allows us to be more aggressive in certain cases than we were with the older bitcode version that didn't have the flag. Any thoughts on how we could mitigate this risk? Otherwise, it seems like it might be more robust to explicitly list each flag in the bitcode format.

You're right. We need to version the record somehow.
Even with separate fields with have the issue. Usually we can work around it with separate field because the number of entries in the record tells us which "version" we have. Here we can't do that for every record because some record have variable-length entries.
Something that could work is to have [ ..., FlagsVersion (VBR6), Flags (VBR6), ...] with FlagsVersion an integer incremented every time we make a change to the Flags content.

I like the version idea. However, instead of bloating out every single summary with this info, since all summaries should have the same version, I think we should put a single summary version id record at the start the summary section (not specific to the flags, since we will want to use this to detect other summary changes too).

[mehdi_amini]

Indeed, great suggestion!

But now that I think about it, we have a global "epoch" number that I added recently in the bitcode (see IDENTIFICATION_BLOCK_ID). We could bump it when needed.

[tejohnson]

In D19404#409415, @joker.eph wrote:

Indeed, great suggestion!

But now that I think about it, we have a global "epoch" number that I added recently in the bitcode (see IDENTIFICATION_BLOCK_ID). We could bump it when needed.

If we use this it will need to be emitted into the combined index as well (it isn't currently - easy enough to do).

The only issue with that is that I would expect more "churn" at least for awhile with the summary format, not sure if it is a big deal to have the epoch bump frequently due to that. Otherwise seems fine to me.

[mehdi_amini]

Rebase and address comments

[mehdi_amini]

rebase, address comments.

[tejohnson]

One suggestion for comment below.

lib/Bitcode/Reader/BitcodeReader.cpp

724

Like the new comment. Could you put the same thing in getEncodedGVSummaryFlags?

[mehdi_amini]

r267319

include/llvm/Bitcode/LLVMBitCodes.h

 enum ModulePathSymtabCodes {
   MST_CODE_ENTRY = 1, // MST_ENTRY: [modid, namechar x N]
   MST_CODE_HASH = 2,  // MST_HASH:  [5*i32]
 };
 
 // The summary section uses different codes in the per-module
 // and combined index cases.
 enum GlobalValueSummarySymtabCodes {
-  // PERMODULE: [valueid, linkage, instcount, numrefs, numrefs x valueid,
+  // PERMODULE: [valueid, flags, instcount, numrefs, numrefs x valueid,
   //             n x (valueid, callsitecount)]
   FS_PERMODULE = 1,
-  // PERMODULE_PROFILE: [valueid, linkage, instcount, numrefs,
+  // PERMODULE_PROFILE: [valueid, flags, instcount, numrefs,
   //                     numrefs x valueid,
   //                     n x (valueid, callsitecount, profilecount)]
   FS_PERMODULE_PROFILE = 2,
-  // PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid]
+  // PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
   FS_PERMODULE_GLOBALVAR_INIT_REFS = 3,
-  // COMBINED: [modid, linkage, instcount, numrefs, numrefs x valueid,
+  // COMBINED: [modid, flags, instcount, numrefs, numrefs x valueid,
   //            n x (valueid, callsitecount)]
   FS_COMBINED = 4,
-  // COMBINED_PROFILE: [modid, linkage, instcount, numrefs,
+  // COMBINED_PROFILE: [modid, flags, instcount, numrefs,
   //                    numrefs x valueid,
   //                    n x (valueid, callsitecount, profilecount)]
   FS_COMBINED_PROFILE = 5,
-  // COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid]
+  // COMBINED_GLOBALVAR_INIT_REFS: [modid, flags, n x valueid]
   FS_COMBINED_GLOBALVAR_INIT_REFS = 6,
-  // ALIAS: [valueid, linkage, valueid]
+  // ALIAS: [valueid, flags, valueid]
   FS_ALIAS = 7,
-  // COMBINED_ALIAS: [modid, linkage, offset]
+  // COMBINED_ALIAS: [modid, flags, offset]
   FS_COMBINED_ALIAS = 8,
   // COMBINED_ORIGINAL_NAME: [original_name_hash]
   FS_COMBINED_ORIGINAL_NAME = 9,
   // VERSION of the summary, bumped when adding flags for instance.
   FS_VERSION = 10,
 };
 
 enum MetadataCodes {

include/llvm/IR/ModuleSummaryIndex.h

 ///
 /// This is a separate class from GlobalValueInfo to enable lazy reading of this
 /// summary information from the combined index file during imporing.
 class GlobalValueSummary {
 public:
   /// \brief Sububclass discriminator (for dyn_cast<> et al.)
   enum SummaryKind { AliasKind, FunctionKind, GlobalVarKind };
 
+  /// Group flags (Linkage, hasSection, isOptSize, etc.) as a bitfield.
+  struct GVFlags {
+    /// \brief 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.
+    /// In the future this will be used to update and optimize linkage
+    /// types based on global summary-based analysis.
+    GlobalValue::LinkageTypes Linkage : 4;
+
+    /// Convenience Constructors
+    explicit GVFlags(GlobalValue::LinkageTypes Linkage) : Linkage(Linkage) {}
+    GVFlags(const GlobalValue &GV) : Linkage(GV.getLinkage()) {}
+  };
+
 private:
   /// Kind of summary for use in dyn_cast<> et al.
   SummaryKind Kind;
 
   /// This is the hash of the name of the symbol in the original file. It is
   /// identical to the GUID for global symbols, but differs for local since the
   /// GUID includes the module level id in the hash.
   GlobalValue::GUID OriginalName;
 
   /// \brief Path of module IR containing value's definition, used to locate
   /// module during importing.
   ///
   /// This is only used during parsing of the combined index, or when
   /// parsing the per-module index for creation of the combined summary index,
   /// not during writing of the per-module index which doesn't contain a
   /// module path string table.
   StringRef ModulePath;
 
-  /// \brief 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.
-  /// In the future this will be used to update and optimize linkage
-  /// types based on global summary-based analysis.
-  GlobalValue::LinkageTypes Linkage;
+  GVFlags Flags;
 
   /// 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 constructor.
-  GlobalValueSummary(SummaryKind K, GlobalValue::LinkageTypes Linkage)
-      : Kind(K), Linkage(Linkage) {}
+  GlobalValueSummary(SummaryKind K, GVFlags Flags) : Kind(K), Flags(Flags) {}
 
 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() { return OriginalName; }
 
   /// Initialize the original name hash in this summary.
   void setOriginalName(GlobalValue::GUID Name) { OriginalName = Name; }
 
   /// Which kind of summary subclass this is.
   SummaryKind getSummaryKind() const { return Kind; }
 
   /// Set the path to the module containing this function, for use in
   /// the combined index.
   void setModulePath(StringRef ModPath) { ModulePath = ModPath; }
 
   /// Get the path to the module containing this function.
   StringRef modulePath() const { return ModulePath; }
 
+  /// Get the flags for this GlobalValue (see \p struct GVFlags).
+  GVFlags flags() { return Flags; }
+
   /// Return linkage type recorded for this global value.
-  GlobalValue::LinkageTypes linkage() const { return Linkage; }
+  GlobalValue::LinkageTypes linkage() const { return Flags.Linkage; }
 
   /// Record a reference from this global value to the global value identified
   /// by \p RefGUID.
   void addRefEdge(GlobalValue::GUID RefGUID) { RefEdgeList.push_back(RefGUID); }
 
   /// Record a reference from this global value to the global value identified
   /// by \p RefV.
   void addRefEdge(const Value *RefV) { RefEdgeList.push_back(RefV); }

 };
 
 /// \brief Alias summary information.
 class AliasSummary : public GlobalValueSummary {
   GlobalValueSummary *AliaseeSummary;
 
 public:
   /// Summary constructors.
-  AliasSummary(GlobalValue::LinkageTypes Linkage)
-      : GlobalValueSummary(AliasKind, Linkage) {}
+  AliasSummary(GVFlags Flags) : GlobalValueSummary(AliasKind, Flags) {}
 
   /// Check if this is an alias summary.
   static bool classof(const GlobalValueSummary *GVS) {
     return GVS->getSummaryKind() == AliasKind;
   }
 
   void setAliasee(GlobalValueSummary *Aliasee) { AliaseeSummary = Aliasee; }
 
private:
   /// during the initial compile step when the summary index is first built.
   unsigned InstCount;
 
   /// List of <CalleeValueInfo, CalleeInfo> call edge pairs from this function.
   std::vector<EdgeTy> CallGraphEdgeList;
 
 public:
   /// Summary constructors.
-  FunctionSummary(GlobalValue::LinkageTypes Linkage, unsigned NumInsts)
-      : GlobalValueSummary(FunctionKind, Linkage), InstCount(NumInsts) {}
+  FunctionSummary(GVFlags Flags, unsigned NumInsts)
+      : GlobalValueSummary(FunctionKind, Flags), InstCount(NumInsts) {}
 
   /// Check if this is a function summary.
   static bool classof(const GlobalValueSummary *GVS) {
     return GVS->getSummaryKind() == FunctionKind;
   }
 
   /// Get the instruction count recorded for this function.
   unsigned instCount() const { return InstCount; }

 ///
 /// Currently this doesn't add anything to the base \p GlobalValueSummary,
 /// but is a placeholder as additional info may be added to the summary
 /// for variables.
 class GlobalVarSummary : public GlobalValueSummary {
 
 public:
   /// Summary constructors.
-  GlobalVarSummary(GlobalValue::LinkageTypes Linkage)
-      : GlobalValueSummary(GlobalVarKind, Linkage) {}
+  GlobalVarSummary(GVFlags Flags) : GlobalValueSummary(GlobalVarKind, Flags) {}
 
   /// Check if this is a global variable summary.
   static bool classof(const GlobalValueSummary *GVS) {
     return GVS->getSummaryKind() == GlobalVarKind;
   }
 };
 
 /// \brief Class to hold pointer to summary object and information required

lib/Analysis/ModuleSummaryAnalysis.cpp

for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E;
               M->getValueSymbolTable().lookup(CalledFunction->getName());
           CallGraphEdges[CalleeId] +=
               (ScaledCount ? ScaledCount.getValue() : 0);
         }
       }
       findRefEdges(&*I, RefEdges, Visited);
     }
 
+  GlobalValueSummary::GVFlags Flags(F);
   std::unique_ptr<FunctionSummary> FuncSummary =
-      llvm::make_unique<FunctionSummary>(F.getLinkage(), NumInsts);
+      llvm::make_unique<FunctionSummary>(Flags, NumInsts);
   FuncSummary->addCallGraphEdges(CallGraphEdges);
   FuncSummary->addRefEdges(RefEdges);
   std::unique_ptr<GlobalValueInfo> GVInfo =
       llvm::make_unique<GlobalValueInfo>(0, std::move(FuncSummary));
   Index->addGlobalValueInfo(F.getName(), std::move(GVInfo));
 }
 
 void ModuleSummaryIndexBuilder::computeVariableInfo(const GlobalVariable &V) {
   DenseSet<const Value *> RefEdges;
   SmallPtrSet<const User *, 8> Visited;
   findRefEdges(&V, RefEdges, Visited);
+  GlobalValueSummary::GVFlags Flags(V);
   std::unique_ptr<GlobalVarSummary> GVarSummary =
-      llvm::make_unique<GlobalVarSummary>(V.getLinkage());
+      llvm::make_unique<GlobalVarSummary>(Flags);
   GVarSummary->addRefEdges(RefEdges);
   std::unique_ptr<GlobalValueInfo> GVInfo =
       llvm::make_unique<GlobalValueInfo>(0, std::move(GVarSummary));
   Index->addGlobalValueInfo(V.getName(), std::move(GVInfo));
 }
 
 ModuleSummaryIndexBuilder::ModuleSummaryIndexBuilder(
     const Module *M,

lib/Bitcode/Reader/BitcodeReader.cpp

static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) {
   case 18:
     return GlobalValue::LinkOnceAnyLinkage;
   case 11: // Old value with implicit comdat.
   case 19:
     return GlobalValue::LinkOnceODRLinkage;
   }
 }
 
+// Decode the flags for GlobalValue in the summary
+static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags,
+                                                            uint64_t Version) {
+  // Summary were not emitted before LLVM 3.9, we don't need to upgrade Linkage
+  // like getDecodedLinkage() above. Any future change to the linkage enum and
+  // to getDecodedLinkage() will need to be taken into account here as above.
+  auto Linkage = GlobalValue::LinkageTypes(RawFlags & 0xF); // 4 bits
+  return GlobalValueSummary::GVFlags(Linkage);
+}
+
 static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {
   switch (Val) {
   default: // Map unknown visibilities to default.
   case 0: return GlobalValue::DefaultVisibility;
   case 1: return GlobalValue::HiddenVisibility;
   case 2: return GlobalValue::ProtectedVisibility;
   }
 }
while (1) {
     // in the combined index VST entries). The records also contain
     // information used for ThinLTO renaming and importing.
     Record.clear();
     uint64_t CurRecordBit = Stream.GetCurrentBitNo();
     auto BitCode = Stream.readRecord(Entry.ID, Record);
     switch (BitCode) {
     default: // Default behavior: ignore.
       break;
-    // FS_PERMODULE: [valueid, linkage, instcount, numrefs, numrefs x valueid,
+    // FS_PERMODULE: [valueid, flags, instcount, numrefs, numrefs x valueid,
     //                n x (valueid, callsitecount)]
-    // FS_PERMODULE_PROFILE: [valueid, linkage, instcount, numrefs,
+    // FS_PERMODULE_PROFILE: [valueid, flags, instcount, numrefs,
     //                        numrefs x valueid,
     //                        n x (valueid, callsitecount, profilecount)]
     case bitc::FS_PERMODULE:
     case bitc::FS_PERMODULE_PROFILE: {
       unsigned ValueID = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
       unsigned InstCount = Record[2];
       unsigned NumRefs = Record[3];
-      std::unique_ptr<FunctionSummary> FS = llvm::make_unique<FunctionSummary>(
-          getDecodedLinkage(RawLinkage), InstCount);
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      std::unique_ptr<FunctionSummary> FS =
+          llvm::make_unique<FunctionSummary>(Flags, InstCount);
       // The module path string ref set in the summary must be owned by the
       // index's module string table. Since we don't have a module path
       // string table section in the per-module index, we create a single
       // module path string table entry with an empty (0) ID to take
       // ownership.
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
       static int RefListStartIndex = 4;
case bitc::FS_PERMODULE_PROFILE: {
       }
       auto GUID = getGUIDFromValueId(ValueID);
       FS->setOriginalName(GUID.second);
       auto *Info = TheIndex->getGlobalValueInfo(GUID.first);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       break;
     }
-    // FS_ALIAS: [valueid, linkage, valueid]
+    // FS_ALIAS: [valueid, flags, valueid]
     // Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as
     // they expect all aliasee summaries to be available.
     case bitc::FS_ALIAS: {
       unsigned ValueID = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
       unsigned AliaseeID = Record[2];
-      std::unique_ptr<AliasSummary> AS =
-          llvm::make_unique<AliasSummary>(getDecodedLinkage(RawLinkage));
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      std::unique_ptr<AliasSummary> AS = llvm::make_unique<AliasSummary>(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.
       AS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
 
       GlobalValue::GUID AliaseeGUID = getGUIDFromValueId(AliaseeID).first;
       auto *AliaseeInfo = TheIndex->getGlobalValueInfo(AliaseeGUID);
       if (!AliaseeInfo->summary())
         return error("Alias expects aliasee summary to be parsed");
       AS->setAliasee(AliaseeInfo->summary());
 
       GlobalValue::GUID GUID = getGUIDFromValueId(ValueID).first;
       auto *Info = TheIndex->getGlobalValueInfo(GUID);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(AS));
       break;
     }
-    // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, linkage, n x valueid]
+    // FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
     case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
       unsigned ValueID = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       std::unique_ptr<GlobalVarSummary> FS =
-          llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
+          llvm::make_unique<GlobalVarSummary>(Flags);
       FS->setModulePath(
           TheIndex->addModulePath(Buffer->getBufferIdentifier(), 0)->first());
       for (unsigned I = 2, E = Record.size(); I != E; ++I) {
         unsigned RefValueId = Record[I];
         GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId).first;
         FS->addRefEdge(RefGUID);
       }
       GlobalValue::GUID GUID = getGUIDFromValueId(ValueID).first;
       auto *Info = TheIndex->getGlobalValueInfo(GUID);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       break;
     }
-    // FS_COMBINED: [modid, linkage, instcount, numrefs, numrefs x valueid,
+    // FS_COMBINED: [modid, flags, instcount, numrefs, numrefs x valueid,
     //               n x (valueid, callsitecount)]
-    // FS_COMBINED_PROFILE: [modid, linkage, instcount, numrefs,
+    // FS_COMBINED_PROFILE: [modid, flags, instcount, numrefs,
     //                       numrefs x valueid,
     //                       n x (valueid, callsitecount, profilecount)]
     case bitc::FS_COMBINED:
     case bitc::FS_COMBINED_PROFILE: {
       uint64_t ModuleId = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
       unsigned InstCount = Record[2];
       unsigned NumRefs = Record[3];
-      std::unique_ptr<FunctionSummary> FS = llvm::make_unique<FunctionSummary>(
-          getDecodedLinkage(RawLinkage), InstCount);
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      std::unique_ptr<FunctionSummary> FS =
+          llvm::make_unique<FunctionSummary>(Flags, InstCount);
       LastSeenSummary = FS.get();
       FS->setModulePath(ModuleIdMap[ModuleId]);
       static int RefListStartIndex = 4;
       int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;
       assert(Record.size() >= RefListStartIndex + NumRefs &&
              "Record size inconsistent with number of references");
       for (unsigned I = 4, E = CallGraphEdgeStartIndex; I != E; ++I) {
         unsigned RefValueId = Record[I];
case bitc::FS_COMBINED_PROFILE: {
                              CalleeInfo(CallsiteCount, ProfileCount));
       }
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(FS));
       Combined = true;
       break;
     }
-    // FS_COMBINED_ALIAS: [modid, linkage, offset]
+    // FS_COMBINED_ALIAS: [modid, flags, offset]
     // Aliases must be emitted (and parsed) after all FS_COMBINED entries, as
     // they expect all aliasee summaries to be available.
     case bitc::FS_COMBINED_ALIAS: {
       uint64_t ModuleId = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
       uint64_t AliaseeSummaryOffset = Record[2];
-      std::unique_ptr<AliasSummary> AS =
-          llvm::make_unique<AliasSummary>(getDecodedLinkage(RawLinkage));
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
+      std::unique_ptr<AliasSummary> AS = llvm::make_unique<AliasSummary>(Flags);
       LastSeenSummary = AS.get();
       AS->setModulePath(ModuleIdMap[ModuleId]);
 
       auto *AliaseeInfo = getInfoFromSummaryOffset(AliaseeSummaryOffset);
       if (!AliaseeInfo->summary())
         return error("Alias expects aliasee summary to be parsed");
       AS->setAliasee(AliaseeInfo->summary());
 
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);
       assert(!Info->summary() && "Expected a single summary per VST entry");
       Info->setSummary(std::move(AS));
       Combined = true;
       break;
     }
-    // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, linkage, n x valueid]
+    // FS_COMBINED_GLOBALVAR_INIT_REFS: [modid, flags, n x valueid]
     case bitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {
       uint64_t ModuleId = Record[0];
-      uint64_t RawLinkage = Record[1];
+      uint64_t RawFlags = Record[1];
+      auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
       std::unique_ptr<GlobalVarSummary> FS =
-          llvm::make_unique<GlobalVarSummary>(getDecodedLinkage(RawLinkage));
+          llvm::make_unique<GlobalVarSummary>(Flags);
       LastSeenSummary = FS.get();
       FS->setModulePath(ModuleIdMap[ModuleId]);
       for (unsigned I = 2, E = Record.size(); I != E; ++I) {
         unsigned RefValueId = Record[I];
         GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId).first;
         FS->addRefEdge(RefGUID);
       }
       auto *Info = getInfoFromSummaryOffset(CurRecordBit);

lib/Bitcode/Writer/BitcodeWriter.cpp

static unsigned getEncodedLinkage(const GlobalValue::LinkageTypes Linkage) {
   }
   llvm_unreachable("Invalid linkage");
 }
 
 static unsigned getEncodedLinkage(const GlobalValue &GV) {
   return getEncodedLinkage(GV.getLinkage());
 }
 
+// Decode the flags for GlobalValue in the summary
+static uint64_t getEncodedGVSummaryFlags(GlobalValueSummary::GVFlags Flags) {
+  uint64_t RawFlags = 0;
+  // Emit Linkage enum.
+  RawFlags |= Flags.Linkage; // 4 bits
+  return RawFlags;
+}
+
 static unsigned getEncodedVisibility(const GlobalValue &GV) {
   switch (GV.getVisibility()) {
   case GlobalValue::DefaultVisibility:   return 0;
   case GlobalValue::HiddenVisibility:    return 1;
   case GlobalValue::ProtectedVisibility: return 2;
   }
   llvm_unreachable("Invalid visibility");
 }

 // Helper to emit a single function summary record.
 void ModuleBitcodeWriter::writePerModuleFunctionSummaryRecord(
     SmallVector<uint64_t, 64> &NameVals, GlobalValueInfo *Info,
     unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,
     const Function &F) {
   NameVals.push_back(ValueID);
 
   FunctionSummary *FS = cast<FunctionSummary>(Info->summary());
-  NameVals.push_back(getEncodedLinkage(FS->linkage()));
+  NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
   NameVals.push_back(FS->instCount());
   NameVals.push_back(FS->refs().size());
 
   for (auto &RI : FS->refs())
     NameVals.push_back(VE.getValueID(RI.getValue()));
 
   bool HasProfileData = F.getEntryCount().hasValue();
   for (auto &ECI : FS->calls()) {

 // and emit them in a summary record.
 void ModuleBitcodeWriter::writeModuleLevelReferences(
     const GlobalVariable &V, SmallVector<uint64_t, 64> &NameVals,
     unsigned FSModRefsAbbrev) {
   // Only interested in recording variable defs in the summary.
   if (V.isDeclaration())
     return;
   NameVals.push_back(VE.getValueID(&V));
-  NameVals.push_back(getEncodedLinkage(V.getLinkage()));
+  NameVals.push_back(getEncodedGVSummaryFlags(V));
   auto *Info = Index->getGlobalValueInfo(V);
   GlobalVarSummary *VS = cast<GlobalVarSummary>(Info->summary());
   for (auto Ref : VS->refs())
     NameVals.push_back(VE.getValueID(Ref.getValue()));
   Stream.EmitRecord(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS, NameVals,
                     FSModRefsAbbrev);
   NameVals.clear();
 }
 
 // Current version for the summary.
 // This is bumped whenever we introduce changes in the way some record are
 // interpreted, like flags for instance.
 static const uint64_t INDEX_VERSION = 1;
 
 /// Emit the per-module summary section alongside the rest of
 /// the module's bitcode.
 void ModuleBitcodeWriter::writePerModuleGlobalValueSummary() {
   if (M.empty())
     return;
 
   if (Index->begin() == Index->end())
     return;
 
-  Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
+  Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 4);
 
   Stream.EmitRecord(bitc::FS_VERSION, ArrayRef<uint64_t>{INDEX_VERSION});
 
   // Abbrev for FS_PERMODULE.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
   // numrefs x valueid, n x (valueid, callsitecount)
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSCallsAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_PERMODULE_PROFILE.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_PROFILE));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
   // numrefs x valueid, n x (valueid, callsitecount, profilecount)
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_PERMODULE_GLOBALVAR_INIT_REFS.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));  // valueids
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_ALIAS.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_ALIAS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // valueid
   unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv);
 
   SmallVector<uint64_t, 64> NameVals;
   // Iterate over the list of functions instead of the Index to
   // ensure the ordering is stable.
   for (const Function &F : M) {
     if (F.isDeclaration())
void ModuleBitcodeWriter::writePerModuleGlobalValueSummary() {
   for (const GlobalAlias &A : M.aliases()) {
     auto *Aliasee = A.getBaseObject();
     if (!Aliasee->hasName())
       // Nameless function don't have an entry in the summary, skip it.
       continue;
     auto AliasId = VE.getValueID(&A);
     auto AliaseeId = VE.getValueID(Aliasee);
     NameVals.push_back(AliasId);
-    NameVals.push_back(getEncodedLinkage(A.getLinkage()));
+    NameVals.push_back(getEncodedGVSummaryFlags(A));
     NameVals.push_back(AliaseeId);
     Stream.EmitRecord(bitc::FS_ALIAS, NameVals, FSAliasAbbrev);
     NameVals.clear();
   }
 
   Stream.ExitBlock();
 }
 
 /// Emit the combined summary section into the combined index file.
 void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   Stream.EnterSubblock(bitc::GLOBALVAL_SUMMARY_BLOCK_ID, 3);
   Stream.EmitRecord(bitc::FS_VERSION, ArrayRef<uint64_t>{INDEX_VERSION});
 
   // Abbrev for FS_COMBINED.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
   // numrefs x valueid, n x (valueid, callsitecount)
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSCallsAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_COMBINED_PROFILE.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_PROFILE));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // instcount
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4));   // numrefs
   // numrefs x valueid, n x (valueid, callsitecount, profilecount)
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSCallsProfileAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_COMBINED_GLOBALVAR_INIT_REFS.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));    // valueids
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
   unsigned FSModRefsAbbrev = Stream.EmitAbbrev(Abbv);
 
   // Abbrev for FS_COMBINED_ALIAS.
   Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED_ALIAS));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // modid
-  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // linkage
+  Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // flags
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // offset
   unsigned FSAliasAbbrev = Stream.EmitAbbrev(Abbv);
 
   // The aliases are emitted as a post-pass, and will point to the summary
   // offset id of the aliasee. For this purpose we need to be able to get back
   // from the summary to the offset
   SmallVector<GlobalValueInfo *, 64> Aliases;
   DenseMap<const GlobalValueSummary *, uint64_t> SummaryToOffsetMap;
for (auto &FI : FII.second) {
         // Will process aliases as a post-pass because the reader wants all
         // global to be loaded first.
         Aliases.push_back(FI.get());
         continue;
       }
 
       if (auto *VS = dyn_cast<GlobalVarSummary>(S)) {
         NameVals.push_back(Index.getModuleId(VS->modulePath()));
-        NameVals.push_back(getEncodedLinkage(VS->linkage()));
+        NameVals.push_back(getEncodedGVSummaryFlags(VS->flags()));
         for (auto &RI : VS->refs()) {
           NameVals.push_back(getValueId(RI.getGUID()));
         }
 
         // Record the starting offset of this summary entry for use
         // in the VST entry. Add the current code size since the
         // reader will invoke readRecord after the abbrev id read.
         FI->setBitcodeIndex(Stream.GetCurrentBitNo() +
                             Stream.GetAbbrevIDWidth());
         // Store temporarily the offset in the map for a possible alias.
         SummaryToOffsetMap[S] = FI->bitcodeIndex();
 
         // Emit the finished record.
         Stream.EmitRecord(bitc::FS_COMBINED_GLOBALVAR_INIT_REFS, NameVals,
                           FSModRefsAbbrev);
         NameVals.clear();
         MaybeEmitOriginalName(*S);
         continue;
       }
 
       auto *FS = cast<FunctionSummary>(S);
       NameVals.push_back(Index.getModuleId(FS->modulePath()));
-      NameVals.push_back(getEncodedLinkage(FS->linkage()));
+      NameVals.push_back(getEncodedGVSummaryFlags(FS->flags()));
       NameVals.push_back(FS->instCount());
       NameVals.push_back(FS->refs().size());
 
       for (auto &RI : FS->refs()) {
         NameVals.push_back(getValueId(RI.getGUID()));
       }
 
       bool HasProfileData = false;
for (auto &FI : FII.second) {
       NameVals.clear();
       MaybeEmitOriginalName(*S);
     }
   }
 
   for (auto GVI : Aliases) {
     AliasSummary *AS = cast<AliasSummary>(GVI->summary());
     NameVals.push_back(Index.getModuleId(AS->modulePath()));
-    NameVals.push_back(getEncodedLinkage(AS->linkage()));
+    NameVals.push_back(getEncodedGVSummaryFlags(AS->flags()));
     auto AliaseeOffset = SummaryToOffsetMap[&AS->getAliasee()];
     assert(AliaseeOffset);
     NameVals.push_back(AliaseeOffset);
 
     // Record the starting offset of this summary entry for use
     // in the VST entry. Add the current code size since the
     // reader will invoke readRecord after the abbrev id read.
     GVI->setBitcodeIndex(Stream.GetCurrentBitNo() + Stream.GetAbbrevIDWidth());

test/Bitcode/thinlto-function-summary-refgraph.ll

 ; Test to check both the callgraph and refgraph in summary
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
 
 ; See if the calls and other references are recorded properly using the
 ; expected value id and other information as appropriate (callsite cout
 ; for calls). Use different linkage types for the various test cases to
 ; distinguish the test cases here (op1 contains the linkage type).
 ; Note that op3 contains the # non-call references.
 ; This also ensures that we didn't include a call or reference to intrinsic
 ; llvm.ctpop.i8.
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; Function main contains call to func, as well as address reference to func:
 ; CHECK-DAG:    <PERMODULE {{.*}} op0=[[MAINID:[0-9]+]] op1=0 {{.*}} op3=1 op4=[[FUNCID:[0-9]+]] op5=[[FUNCID]] op6=1/>
 ; Function W contains a call to func3 as well as a reference to globalvar:
-; CHECK-DAG:    <PERMODULE {{.*}} op0=[[WID:[0-9]+]] op1=17 {{.*}} op3=1 op4=[[GLOBALVARID:[0-9]+]] op5=[[FUNC3ID:[0-9]+]] op6=1/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=[[WID:[0-9]+]] op1=5 {{.*}} op3=1 op4=[[GLOBALVARID:[0-9]+]] op5=[[FUNC3ID:[0-9]+]] op6=1/>
 ; Function X contains call to foo, as well as address reference to foo
 ; which is in the same instruction as the call:
-; CHECK-DAG:    <PERMODULE {{.*}} op0=[[XID:[0-9]+]] op1=12 {{.*}} op3=1 op4=[[FOOID:[0-9]+]] op5=[[FOOID]] op6=1/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=[[XID:[0-9]+]] op1=1 {{.*}} op3=1 op4=[[FOOID:[0-9]+]] op5=[[FOOID]] op6=1/>
 ; Function Y contains call to func2, and ensures we don't incorrectly add
 ; a reference to it when reached while earlier analyzing the phi using its
 ; return value:
-; CHECK-DAG:    <PERMODULE {{.*}} op0=[[YID:[0-9]+]] op1=9 {{.*}} op3=0 op4=[[FUNC2ID:[0-9]+]] op5=1/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=[[YID:[0-9]+]] op1=8 {{.*}} op3=0 op4=[[FUNC2ID:[0-9]+]] op5=1/>
 ; Function Z contains call to func2, and ensures we don't incorrectly add
 ; a reference to it when reached while analyzing subsequent use of its return
 ; value:
-; CHECK-DAG:    <PERMODULE {{.*}} op0=[[ZID:[0-9]+]] op1=19 {{.*}} op3=0 op4=[[FUNC2ID:[0-9]+]] op5=1/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=[[ZID:[0-9]+]] op1=3 {{.*}} op3=0 op4=[[FUNC2ID:[0-9]+]] op5=1/>
 ; Variable bar initialization contains address reference to func:
 ; CHECK-DAG:    <PERMODULE_GLOBALVAR_INIT_REFS {{.*}} op0=[[BARID:[0-9]+]] op1=0 op2=[[FUNCID]]/>
 ; CHECK:  </GLOBALVAL_SUMMARY_BLOCK>
 
 ; CHECK-NEXT:  <VALUE_SYMTAB
 ; CHECK-DAG:    <ENTRY {{.*}} op0=[[BARID]] {{.*}} record string = 'bar'
 ; CHECK-DAG:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'func'
 ; CHECK-DAG:    <ENTRY {{.*}} op0=[[FOOID]] {{.*}} record string = 'foo'

test/Bitcode/thinlto-function-summary.ll

 ; RUN: opt -name-anon-functions -module-summary < %s | llvm-bcanalyzer -dump | FileCheck %s -check-prefix=BC
 ; Check for summary block/records.
 
 ; Check the value ids in the summary entries against the
 ; same in the ValueSumbolTable, to ensure the ordering is stable.
 ; Also check the linkage field on the summary entries.
 ; BC: <GLOBALVAL_SUMMARY_BLOCK
 ; BC-NEXT: <VERSION
 ; BC-NEXT: <PERMODULE {{.*}} op0=1 op1=0
 ; BC-NEXT: <PERMODULE {{.*}} op0=2 op1=0
-; BC-NEXT: <PERMODULE {{.*}} op0=3 op1=3
+; BC-NEXT: <PERMODULE {{.*}} op0=3 op1=7
 ; BC-NEXT: <ALIAS {{.*}} op0=4 op1=0 op2=3
 ; BC-NEXT: </GLOBALVAL_SUMMARY_BLOCK
 ; BC-NEXT: <VALUE_SYMTAB
 ; BC-NEXT: <FNENTRY {{.*}} op0=3 {{.*}}> record string = 'anon.
 ; BC-NEXT: <FNENTRY {{.*}} op0=1 {{.*}}> record string = 'foo'
 ; BC-NEXT: <FNENTRY {{.*}} op0=2 {{.*}}> record string = 'bar'
 ; BC-NEXT: <FNENTRY {{.*}} op0=4 {{.*}}> record string = 'f'
 

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

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