[ThinLTO] add constArgumentsBitmask to caller summary

[Prazek]

Summary

In order to import functions that exceeds size threshold, additional
information is needed. By knowing which arguments are constant on
the caller site, we can build some heuristics to give some additional
bonus to calls with multiple constant arguments (assuming that the
called functions will get simplified enough to be worth inlining).

[Prazek]

include/llvm/IR/ModuleSummaryIndex.h

246

I wasn't sure about the size here, maybe it is even enough to have bitmask here of 8 or less bits.
I assume that this struct will be used to add some extra information that is usefull

[Prazek]

removed empty line

[mehdi_amini]

Why a bit mask and not an integer with the number of arguments that are constant?
Do you plan to benefit from knowing which argument is constant?

lib/Bitcode/Reader/BitcodeReader.cpp

6369

You need to handle existing bitcode.

if (Record.size() >= ...)

[Prazek]

In D23885#525493, @mehdi_amini wrote:

Why a bit mask and not an integer with the number of arguments that are constant?
Do you plan to benefit from knowing which argument is constant?

Yes, in order to make better heuristic, like the one that Easwaran come up with

• have some bitmask to say if the argument is compered inside function body as heuristic to determine if branch depends on it.

I will need the the information about the arguments.

[eraman]

In D23885#525602, @Prazek wrote:

In D23885#525493, @mehdi_amini wrote:

Why a bit mask and not an integer with the number of arguments that are constant?
Do you plan to benefit from knowing which argument is constant?

Yes, in order to make better heuristic, like the one that Easwaran come up with

• have some bitmask to say if the argument is compered inside function body as heuristic to determine if branch depends on it.

I will need the the information about the arguments.

In D23885#525602, @Prazek wrote:

In D23885#525493, @mehdi_amini wrote:

Why a bit mask and not an integer with the number of arguments that are constant?
Do you plan to benefit from knowing which argument is constant?

Yes, in order to make better heuristic, like the one that Easwaran come up with

• have some bitmask to say if the argument is compered inside function body as heuristic to determine if branch depends on it.

I will need the the information about the arguments.

More context on this (which was an offline conversation I had with Piotr). One major use of knowing the constant parameters in inline cost analysis is to determine if any branch condition becomes constant and not count the body of blocks that becomes unreachable. One thing we could do is to build a map from conditions based on parameters to number of instructions that become unreachable if the predicate is true. For example,

define i32 @foo(i32 %a) {
entry:

%cmp = icmp sgt i32 %a, 10
br i1 %cmp, label %if.then, label %if.end

if.then: ; preds = %entry
// Lots of instructions here.
if.end: ; preds = %if.then, %entry

ret i32 %a

}

we could analyze this and map the (a > 10) condition to the potential reduction in instructions. If we were to build something like this, it will be useful to know the constant values of parameters. This patch only keeps track of whether a parameter receives a constant value in some callsite, so it is less information than what would be needed, but better than knowing how many parameters are constants in some context.

[tejohnson]

It seems like in order to make the bitmask useful (over a simple count of the number of constant args), we would at a minimum need to have info on the function summary as well (e.g. a bitmask of which formal parameters yield constant folding opportunities because they are compared against constants). And as Easwaran noted, in order to make good conclusions we may need to know what the constant values are (both passed at the callsite, and which are compared against in the callee function summary).

I think until there are some uses of this new info in the function importer and an exploration of the resulting gains (e.g. we start importing and therefore inlining additional profitable functions, or are able to use this to reduce the amount of importing without losing performance) we won't know which summary representation is useful. I'm a little concerned about bloating the summary index with an extra vbr per call edge without any data or specific use cases. I suggest adding the importer heuristic and collecting some data before pushing the index change upstream.

I have some additional comments below, but you probably don't want to address these until the above points are resolved.

include/llvm/Bitcode/LLVMBitCodes.h

197

Naming convention for fields uses "_" not lower camel case.

include/llvm/IR/ModuleSummaryIndex.h

244

Since we are accumulating the info for all callsites, there isn't a reason to keep this in a separate structure from CalleeInfo. I.e. the profile counts are accumulated in CalleeInfo, even though that is essentially also callsite info. If we decide to keep a separate edge per callsite eventually, the CalleeInfo struct will simply change to a CallsiteInfo struct and we would remove CallsiteCount. So better to have this info in CalleeInfo directly.

lib/Analysis/ModuleSummaryAnalysis.cpp

125

It isn't clear why it would result in nonsense data - we are setting this based on arguments passed to the indirect call, so if argument N is constant, it presumably should be marked constant for each profiled target.

If there is a reason to not do it at this time, then IndirectCallEdges should go back to its previous type (no std::pair).

lib/Bitcode/Reader/BitcodeReader.cpp

6276

Similar to Mehdi's comment below, this part needs to handle existing bitcode.

lib/Bitcode/Writer/BitcodeWriter.cpp

3359

Descriptions here and below record need to be updated.

3444

Descriptions here and below record need updating.

3501

Remove newline change.

[Prazek]

include/llvm/IR/ModuleSummaryIndex.h

244

oh I see, it doesn't matter what caller calls with constants as long as the info is accumulated only in one module.

[tejohnson]

include/llvm/IR/ModuleSummaryIndex.h

244

Sorry I don't understand your comment? Each caller function summary contains a single edge to each unique callee, and the info is accumulated for all calls from that function to a given callee function. I don't understand the "as long as the info is accumulated only in one module"?

[Prazek]

include/llvm/IR/ModuleSummaryIndex.h

244

So my I firstly thought that I should make a separate Callsite info because this info would be different depending on the caller in one module, so I would probably want to
keep it somewhere else than the callee info. But the Callee info is combined only in one module, so it really doesn't matter if I will decide to import one function only based on the one caller or on combined all callers.

[tejohnson]

include/llvm/IR/ModuleSummaryIndex.h

244

Well the CalleeInfo is only combined within each function within each module. If there are calls from multiple functions within a module, it will not be combined across the different callers.

Or are you talking about functions with weak linkage where there can be a multiple callers with the same name in different modules? In that case, right, we do not combine across modules.

[Prazek]

include/llvm/IR/ModuleSummaryIndex.h

244

Ok nevermind. I though that in computeFunctionSummary it is iterating on every function, which would combine the data of all calls together.

[Prazek]

After testing it on SPEC 2k6, there was no improvement with this. Dropping

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, flags, instcount, numrefs, numrefs x valueid,
-  //             n x (valueid, callsitecount)]
+  //             n x (valueid, callsitecount, constArgumentsBitmask)]
   FS_PERMODULE = 1,
   // PERMODULE_PROFILE: [valueid, flags, instcount, numrefs,
   //                     numrefs x valueid,
-  //                     n x (valueid, callsitecount, profilecount)]
+  //                     n x (valueid, callsitecount, constArgumentsBitmask,
+  //                          profilecount)]
   FS_PERMODULE_PROFILE = 2,
   // PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
   FS_PERMODULE_GLOBALVAR_INIT_REFS = 3,
   // COMBINED: [valueid, modid, flags, instcount, numrefs, numrefs x valueid,
-  //            n x (valueid, callsitecount)]
+  //            n x (valueid, callsitecount, constArgumentBitmask)]
   FS_COMBINED = 4,
   // COMBINED_PROFILE: [valueid, modid, flags, instcount, numrefs,
   //                    numrefs x valueid,
-  //                    n x (valueid, callsitecount, profilecount)]
+  //                    n x (valueid, callsitecount, constArgumentsBitmask,
+  //                         profilecount)]
   FS_COMBINED_PROFILE = 5,
   // COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
   FS_COMBINED_GLOBALVAR_INIT_REFS = 6,
   // ALIAS: [valueid, flags, valueid]
   FS_ALIAS = 7,
   // COMBINED_ALIAS: [valueid, modid, flags, valueid]
   FS_COMBINED_ALIAS = 8,
   // COMBINED_ORIGINAL_NAME: [original_name_hash]

include/llvm/IR/ModuleSummaryIndex.h

const GlobalValueSummary &getAliasee() const {
     return const_cast<AliasSummary *>(this)->getAliasee();
   }
 
   GlobalValueSummary &getAliasee() {
     assert(AliaseeSummary && "Unexpected missing aliasee summary");
     return *AliaseeSummary;
   }
 };
+/// Specific info about the call site, like the info about the arguments.
+struct CallsiteInfo {
+  /// if n_th bit is set, it means that n_th argument is constant.
+  /// Only 16 bits, because functions with more than that are very rare.
+  typedef uint16_t ConstArgumentsBitmaskTy;
+  ConstArgumentsBitmaskTy ConstArgumentsBitmask = 0;
+
+  void setConstArgument(unsigned int ArgNumber);
+  // Returns count of set bits of ConstArgumentBitmask.
+  int getConstArgumentsCount() const;
+};
 
 /// \brief Function summary information to aid decisions and implementation of
 /// importing.
 class FunctionSummary : public GlobalValueSummary {
 public:
-  /// <CalleeValueInfo, CalleeInfo> call edge pair.
-  typedef std::pair<ValueInfo, CalleeInfo> EdgeTy;
+  /// <CalleeValueInfo, <CallsiteInfo, CalleeInfo>> call edge pair.
+  typedef std::pair<ValueInfo, std::pair<CalleeInfo, CallsiteInfo>> EdgeTy;
 
 private:
   /// Number of instructions (ignoring debug instructions, e.g.) computed
   /// 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:
   }
 
   /// Get the instruction count recorded for this function.
   unsigned instCount() const { return InstCount; }
 
   /// Record a call graph edge from this function to the function identified
   /// by \p CalleeGUID, with \p CalleeInfo including the cumulative profile
   /// count (across all calls from this function) or 0 if no PGO.
-  void addCallGraphEdge(GlobalValue::GUID CalleeGUID, CalleeInfo Info) {
-    CallGraphEdgeList.push_back(std::make_pair(CalleeGUID, Info));
+  void addCallGraphEdge(GlobalValue::GUID CalleeGUID, CalleeInfo Info,
+                        CallsiteInfo SiteInfo) {
+    CallGraphEdgeList.emplace_back(CalleeGUID, std::make_pair(Info, SiteInfo));
   }
 
   /// Record a call graph edge from this function to each function GUID recorded
   /// in \p CallGraphEdges.
-  void
-  addCallGraphEdges(DenseMap<GlobalValue::GUID, CalleeInfo> &CallGraphEdges) {
+  void addCallGraphEdges(
+      DenseMap<GlobalValue::GUID, std::pair<CalleeInfo, CallsiteInfo>>
+          &CallGraphEdges) {
     for (auto &EI : CallGraphEdges)
-      addCallGraphEdge(EI.first, EI.second);
+      addCallGraphEdge(EI.first, EI.second.first, EI.second.second);
   }
 
   /// Record a call graph edge from this function to the function identified
   /// by \p CalleeV, with \p CalleeInfo including the cumulative profile
   /// count (across all calls from this function) or 0 if no PGO.
-  void addCallGraphEdge(const Value *CalleeV, CalleeInfo Info) {
-    CallGraphEdgeList.push_back(std::make_pair(CalleeV, Info));
+  void addCallGraphEdge(const Value *CalleeV, CalleeInfo Info,
+                        CallsiteInfo SiteInfo) {
+    CallGraphEdgeList.emplace_back(CalleeV, std::make_pair(Info, SiteInfo));
   }
 
   /// Record a call graph edge from this function to each function recorded
   /// in \p CallGraphEdges.
-  void addCallGraphEdges(DenseMap<const Value *, CalleeInfo> &CallGraphEdges) {
+  void
+  addCallGraphEdges(DenseMap<const Value *, std::pair<CalleeInfo, CallsiteInfo>>
+                        &CallGraphEdges) {
     for (auto &EI : CallGraphEdges)
-      addCallGraphEdge(EI.first, EI.second);
+      addCallGraphEdge(EI.first, EI.second.first, EI.second.second);
   }
 
   /// Return the list of <CalleeValueInfo, CalleeInfo> pairs.
   std::vector<EdgeTy> &calls() { return CallGraphEdgeList; }
   const std::vector<EdgeTy> &calls() const { return CallGraphEdgeList; }
 };
 
 /// \brief Global variable summary information to aid decisions and

lib/Analysis/ModuleSummaryAnalysis.cpp

static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
   // Summary not currently supported for anonymous functions, they must
   // be renamed.
   if (!F.hasName())
     return;
 
   unsigned NumInsts = 0;
   // Map from callee ValueId to profile count. Used to accumulate profile
   // counts for all static calls to a given callee.
-  DenseMap<const Value *, CalleeInfo> CallGraphEdges;
-  DenseMap<GlobalValue::GUID, CalleeInfo> IndirectCallEdges;
+  DenseMap<const Value *, std::pair<CalleeInfo, CallsiteInfo>> CallGraphEdges;
+  DenseMap<GlobalValue::GUID, std::pair<CalleeInfo, CallsiteInfo>>
+      IndirectCallEdges;
   DenseSet<const Value *> RefEdges;
   ICallPromotionAnalysis ICallAnalysis;
 
   SmallPtrSet<const User *, 8> Visited;
   for (const BasicBlock &BB : F)
     for (const Instruction &I : BB) {
       if (!isa<DbgInfoIntrinsic>(I))
         ++NumInsts;
 
       if (auto CS = ImmutableCallSite(&I)) {
         auto *CalledFunction = CS.getCalledFunction();
         // Check if this is a direct call to a known function.
         if (CalledFunction) {
           if (CalledFunction->hasName() && !CalledFunction->isIntrinsic()) {
             auto ScaledCount = BFI ? BFI->getBlockProfileCount(&BB) : None;
             auto *CalleeId =
                 M.getValueSymbolTable().lookup(CalledFunction->getName());
-            CallGraphEdges[CalleeId] +=
+            CallGraphEdges[CalleeId].first +=
                 (ScaledCount ? ScaledCount.getValue() : 0);
+
+            auto *Call = cast<CallInst>(CS.getInstruction());
+            // For each const argument add bit into CallsiteInfo.
+            // Note that multiple calls to same function from this function
+            // with different set of const arguments will result in union of
+            // all bits.
+            for (unsigned ArgNum = 0; ArgNum < Call->getNumArgOperands();
+                 ArgNum++) {
+              if (isa<Constant>(Call->getArgOperand(ArgNum)))
+                CallGraphEdges[CalleeId].second.setConstArgument(ArgNum);
+            }
           }
         } else {
           // Otherwise, check for an indirect call (call to a non-const value
           // that isn't an inline assembly call).
           const CallInst *CI = dyn_cast<CallInst>(&I);
           if (CS.getCalledValue() && !isa<Constant>(CS.getCalledValue()) &&
               !(CI && CI->isInlineAsm())) {
             uint32_t NumVals, NumCandidates;
             uint64_t TotalCount;
             auto CandidateProfileData =
                 ICallAnalysis.getPromotionCandidatesForInstruction(
                     &I, NumVals, TotalCount, NumCandidates);
-            for (auto &Candidate : CandidateProfileData)
-              IndirectCallEdges[Candidate.Value] += Candidate.Count;
+            for (auto &Candidate : CandidateProfileData) {
+              IndirectCallEdges[Candidate.Value].first += Candidate.Count;
+              // FIXME: CallsiteInfo should be set here, but we would end up
+              // setting it for every candidate which might result in
+              // nonsense data. It is worth investigating later.
+            }
           }
         }
       }
       findRefEdges(&I, RefEdges, Visited);
     }
 
   GlobalValueSummary::GVFlags Flags(F);
   std::unique_ptr<FunctionSummary> FuncSummary =

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FS_PERMODULE_PROFILE: {
         GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId).first;
         FS->addRefEdge(RefGUID);
       }
       bool HasProfile = (BitCode == bitc::FS_PERMODULE_PROFILE);
       for (unsigned I = CallGraphEdgeStartIndex, E = Record.size(); I != E;
            ++I) {
         unsigned CalleeValueId = Record[I];
         unsigned CallsiteCount = Record[++I];
+        CallsiteInfo Info;
+        Info.ConstArgumentsBitmask = Record[++I];
         uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
         GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId).first;
         FS->addCallGraphEdge(CalleeGUID,
-                             CalleeInfo(CallsiteCount, ProfileCount));
+                             CalleeInfo(CallsiteCount, ProfileCount), Info);
       }
       auto GUID = getGUIDFromValueId(ValueID);
       FS->setOriginalName(GUID.second);
       TheIndex->addGlobalValueSummary(GUID.first, std::move(FS));
       break;
     }
     // FS_ALIAS: [valueid, flags, valueid]
     // Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as
case bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {
         FS->addRefEdge(RefGUID);
       }
       auto GUID = getGUIDFromValueId(ValueID);
       FS->setOriginalName(GUID.second);
       TheIndex->addGlobalValueSummary(GUID.first, std::move(FS));
       break;
     }
     // FS_COMBINED: [valueid, modid, flags, instcount, numrefs,
-    //               numrefs x valueid, n x (valueid, callsitecount)]
+    //               numrefs x valueid, n x (valueid, callsitecount,
+    //                                       constArgumentBitmask)]
     // FS_COMBINED_PROFILE: [valueid, modid, flags, instcount, numrefs,
     //                       numrefs x valueid,
-    //                       n x (valueid, callsitecount, profilecount)]
+    //                       n x (valueid, callsitecount, constArgumentBitmask,
+    //                            profilecount)]
     case bitc::FS_COMBINED:
     case bitc::FS_COMBINED_PROFILE: {
       unsigned ValueID = Record[0];
       uint64_t ModuleId = Record[1];
       uint64_t RawFlags = Record[2];
       unsigned InstCount = Record[3];
       unsigned NumRefs = Record[4];
       auto Flags = getDecodedGVSummaryFlags(RawFlags, Version);
case bitc::FS_COMBINED_PROFILE: {
         GlobalValue::GUID RefGUID = getGUIDFromValueId(RefValueId).first;
         FS->addRefEdge(RefGUID);
       }
       bool HasProfile = (BitCode == bitc::FS_COMBINED_PROFILE);
       for (unsigned I = CallGraphEdgeStartIndex, E = Record.size(); I != E;
            ++I) {
         unsigned CalleeValueId = Record[I];
         unsigned CallsiteCount = Record[++I];
+        CallsiteInfo Info;
+        Info.ConstArgumentsBitmask = Record[++I];
         uint64_t ProfileCount = HasProfile ? Record[++I] : 0;
         GlobalValue::GUID CalleeGUID = getGUIDFromValueId(CalleeValueId).first;
         FS->addCallGraphEdge(CalleeGUID,
-                             CalleeInfo(CallsiteCount, ProfileCount));
+                             CalleeInfo(CallsiteCount, ProfileCount), Info);
       }
       GlobalValue::GUID GUID = getGUIDFromValueId(ValueID).first;
       TheIndex->addGlobalValueSummary(GUID, std::move(FS));
       Combined = true;
       break;
     }
     // FS_COMBINED_ALIAS: [valueid, modid, flags, valueid]
     // Aliases must be emitted (and parsed) after all FS_COMBINED entries, as

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writePerModuleFunctionSummaryRecord(
   std::sort(Calls.begin(), Calls.end(),
             [this](const FunctionSummary::EdgeTy &L,
                    const FunctionSummary::EdgeTy &R) {
               return getValueId(L.first) < getValueId(R.first);
             });
   bool HasProfileData = F.getEntryCount().hasValue();
   for (auto &ECI : Calls) {
     NameVals.push_back(getValueId(ECI.first));
-    assert(ECI.second.CallsiteCount > 0 && "Expected at least one callsite");
-    NameVals.push_back(ECI.second.CallsiteCount);
+    assert(ECI.second.first.CallsiteCount > 0 &&
+           "Expected at least one callsite");
+    NameVals.push_back(ECI.second.first.CallsiteCount);
+    NameVals.push_back(ECI.second.second.ConstArgumentsBitmask);
     if (HasProfileData)
-      NameVals.push_back(ECI.second.ProfileCount);
+      NameVals.push_back(ECI.second.first.ProfileCount);
   }
 
   unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
   unsigned Code =
       (HasProfileData ? bitc::FS_PERMODULE_PROFILE : bitc::FS_PERMODULE);
 
   // Emit the finished record.
   Stream.EmitRecord(Code, NameVals, FSAbbrev);
void ModuleBitcodeWriter::writePerModuleGlobalValueSummary() {
 
   // 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::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
void IndexBitcodeWriter::writeCombinedGlobalValueSummary() {
   // Abbrev for FS_COMBINED.
   BitCodeAbbrev *Abbv = new BitCodeAbbrev();
   Abbv->Add(BitCodeAbbrevOp(bitc::FS_COMBINED));
   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));   // 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));   // valueid
auto MaybeEmitOriginalName = [&](GlobalValueSummary &S) {
     NameVals.push_back(S.getOriginalName());
     Stream.EmitRecord(bitc::FS_COMBINED_ORIGINAL_NAME, NameVals);
     NameVals.clear();
   };
 
   for (const auto &I : *this) {
     GlobalValueSummary *S = I.second;
     assert(S);
-
     assert(hasValueId(I.first));
     unsigned ValueId = getValueId(I.first);
     SummaryToValueIdMap[S] = ValueId;
 
     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);
for (const auto &I : *this) {
     NameVals.push_back(FS->refs().size());
 
     for (auto &RI : FS->refs()) {
       NameVals.push_back(getValueId(RI.getGUID()));
     }
 
     bool HasProfileData = false;
     for (auto &EI : FS->calls()) {
-      HasProfileData |= EI.second.ProfileCount != 0;
+      HasProfileData |= EI.second.first.ProfileCount != 0;
       if (HasProfileData)
         break;
     }
-
+    // Write if HasProfileData:
+    //        n x (valueid, callsitecount, constArgumentBitmask, profilecount)
+    // else:
+    //        n x (valueid, callsitecount, constArgumentBitmask)
     for (auto &EI : FS->calls()) {
       // If this GUID doesn't have a value id, it doesn't have a function
       // summary and we don't need to record any calls to it.
       if (!hasValueId(EI.first.getGUID()))
         continue;
       NameVals.push_back(getValueId(EI.first.getGUID()));
-      assert(EI.second.CallsiteCount > 0 && "Expected at least one callsite");
-      NameVals.push_back(EI.second.CallsiteCount);
+      assert(EI.second.first.CallsiteCount > 0 &&
+             "Expected at least one callsite");
+      NameVals.push_back(EI.second.first.CallsiteCount);
+      NameVals.push_back(EI.second.second.ConstArgumentsBitmask);
       if (HasProfileData)
-        NameVals.push_back(EI.second.ProfileCount);
+        NameVals.push_back(EI.second.first.ProfileCount);
     }
 
     unsigned FSAbbrev = (HasProfileData ? FSCallsProfileAbbrev : FSCallsAbbrev);
     unsigned Code =
         (HasProfileData ? bitc::FS_COMBINED_PROFILE : bitc::FS_COMBINED);
 
     // Emit the finished record.
     Stream.EmitRecord(Code, NameVals, FSAbbrev);

lib/IR/ModuleSummaryIndex.cpp

 //===-- ModuleSummaryIndex.cpp - Module Summary Index ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the module index and summary classes for the
 // IR library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/Support/MathExtras.h"
 using namespace llvm;
 
 // Create the combined module index/summary from multiple
 // per-module instances.
 void ModuleSummaryIndex::mergeFrom(std::unique_ptr<ModuleSummaryIndex> Other,
                                    uint64_t NextModuleId) {
 
   StringRef ModPath;
ModuleSummaryIndex::getGlobalValueSummary(uint64_t ValueGUID,
                                           bool PerModuleIndex) const {
   auto SummaryList = findGlobalValueSummaryList(ValueGUID);
   assert(SummaryList != end() && "GlobalValue not found in index");
   assert((!PerModuleIndex || SummaryList->second.size() == 1) &&
          "Expected a single entry per global value in per-module index");
   auto &Summary = SummaryList->second[0];
   return Summary.get();
 }
+void CallsiteInfo::setConstArgument(unsigned int ArgNumber) {
+  // Don't store information about any argument greater than 16, because it
+  // is very uncommon to have such function. Maybe it would make sense
+  // to set bit number ArgNumber % 16 depending on importer heuristic.
+  if (ArgNumber >= 16)
+    return;
+
+  ConstArgumentsBitmask |= 1u << ArgNumber;
+}
+int CallsiteInfo::getConstArgumentsCount() const {
+  return countPopulation(ConstArgumentsBitmask);
+}

test/Bitcode/Inputs/thinlto-function-summary-callgraph-const-arguments.ll

+; ModuleID = 'thinlto-function-summary-callgraph-const-arguments2.ll'
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function with 17 arguments
+; Function Attrs: nounwind uwtable
+define void @multipleArgs(i32, i32, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8) #0 {
+entry:
+    ret void
+}
+

test/Bitcode/thinlto-alias.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: opt -module-summary %p/Inputs/thinlto-alias.ll -o %t2.o
 ; RUN: llvm-lto -thinlto -o %t3 %t.o %t2.o
 ; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered, using the expected callsite count
 ; and value id matching the subsequent value symbol table.
-; CHECK-NEXT:    <PERMODULE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1/>
+; CHECK-NEXT:    <PERMODULE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1 op6=0/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK-NEXT:  <VALUE_SYMTAB
 ; CHECK-NEXT:    <FNENTRY {{.*}} record string = 'main'
 ; External function analias should have entry with value id FUNCID
 ; CHECK-NEXT:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'analias'
 ; CHECK-NEXT:  </VALUE_SYMTAB>
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; See if the call to analias is registered, using the expected callsite count
 ; and value id matching the subsequent value symbol table.
-; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[ALIASID:[0-9]+]] op6=1/>
+; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[ALIASID:[0-9]+]] op6=1 op7=0/>
 ; Followed by the alias and aliasee
 ; COMBINED-NEXT:    <COMBINED {{.*}}
 ; COMBINED-NEXT:    <COMBINED_ALIAS  {{.*}} op3=[[ALIASEEID:[0-9]+]]
 ; COMBINED-NEXT:  </GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:  <VALUE_SYMTAB
 ; Entry for function func should have entry with value id ALIASID
 ; COMBINED-NEXT:    <COMBINED_ENTRY {{.*}} op0=[[ALIASID]] op1=-5751648690987223394/>
 ; COMBINED-NEXT:    <COMBINED

test/Bitcode/thinlto-function-summary-callgraph-const-arguments.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: opt -module-summary %p/Inputs/thinlto-function-summary-callgraph.ll -o %t2.o
+; RUN: opt -module-summary %p/Inputs/thinlto-function-summary-callgraph-const-arguments.ll -o %t2.o
 ; RUN: llvm-lto -thinlto -o %t3 %t.o %t2.o
 ; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
-; See if the call to func is registered, using the expected callsite count
-; and value id matching the subsequent value symbol table.
-; CHECK-NEXT:    <PERMODULE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1/>
+; op8 is bitmask for const arguments op8=32781 = 1000000000001101b
+; CHECK-NEXT:    <PERMODULE {{.*}} op6=[[FUNCID:[0-9]+]] op7=1 op8=32781/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK-NEXT:  <VALUE_SYMTAB
+; CHECK-NEXT:    <ENTRY {{.*}} record string = 'p32'
 ; CHECK-NEXT:    <FNENTRY {{.*}} record string = 'main'
+; CHECK-NEXT:    <ENTRY {{.*}} record string = 'p8'
+
 ; External function func should have entry with value id FUNCID
-; CHECK-NEXT:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'func'
+; CHECK-NEXT:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'multipleArgs'
 ; CHECK-NEXT:  </VALUE_SYMTAB>
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <COMBINED
 ; See if the call to func is registered, using the expected callsite count
 ; and value id matching the subsequent value symbol table.
-; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[FUNCID:[0-9]+]] op6=1/>
+; COMBINED-NEXT:    <COMBINED {{.*}} op7=1 op8=1 op9=32781/>
 ; COMBINED-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
-; COMBINED-NEXT:  <VALUE_SYMTAB
-; Entry for function func should have entry with value id FUNCID
-; COMBINED-NEXT:    <COMBINED_ENTRY {{.*}} op0=[[FUNCID]] op1=7289175272376759421/>
-; COMBINED-NEXT:    <COMBINED
-; COMBINED-NEXT:  </VALUE_SYMTAB>
 
-; ModuleID = 'thinlto-function-summary-callgraph.ll'
+
+; ModuleID = 'thinlto-function-summary-callgraph-const-arguments.ll'
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
+@p8 = external global i8
+@p32 = external global i32
 ; Function Attrs: nounwind uwtable
 define i32 @main() #0 {
 entry:
-    call void (...) @func()
+    %n8 = load i8, i8* @p8
+    %n = load i32, i32* @p32
+    
+    ; Passing some 0th, 1st, 2nd, 3rd, 15th, 16th argument as const.
+    ; This should set 0th, 2nd, 3rd, 15th bit in ConstArgumentsBitmask and skip
+    ; 16th argument (mask have only 16 bits)
+    call void @multipleArgs(i32 0, i32 %n, i8 2, i8 3, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 %n8, i8 15, i8 16)
     ret i32 0
 }
 
-declare void @func(...) #1
+declare void @multipleArgs(i32, i32, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8) #1

test/Bitcode/thinlto-function-summary-callgraph-pgo.ll

 ; Test to check the callgraph in summary when there is PGO
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: llvm-bcanalyzer -dump %t.o | FileCheck %s
 ; RUN: opt -module-summary %p/Inputs/thinlto-function-summary-callgraph.ll -o %t2.o
 ; RUN: llvm-lto -thinlto -o %t3 %t.o %t2.o
 ; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered, using the expected callsite count
 ; and profile count, with value id matching the subsequent value symbol table.
-; CHECK-NEXT:    <PERMODULE_PROFILE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1 op6=1/>
+; CHECK-NEXT:    <PERMODULE_PROFILE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1 op6=0 op7=1/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK-NEXT:  <VALUE_SYMTAB
 ; CHECK-NEXT:    <FNENTRY {{.*}} record string = 'main'
 ; External function func should have entry with value id FUNCID
 ; CHECK-NEXT:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'func'
 ; CHECK-NEXT:  </VALUE_SYMTAB>
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <COMBINED
 ; See if the call to func is registered, using the expected callsite count
 ; and profile count, with value id matching the subsequent value symbol table.
-; COMBINED-NEXT:    <COMBINED_PROFILE {{.*}} op5=[[FUNCID:[0-9]+]] op6=1 op7=1/>
+; COMBINED-NEXT:    <COMBINED_PROFILE {{.*}} op5=[[FUNCID:[0-9]+]] op6=1 op7=0 op8=1/>
 ; COMBINED-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; COMBINED-NEXT:  <VALUE_SYMTAB
 ; Entry for function func should have entry with value id FUNCID
 ; COMBINED-NEXT:    <COMBINED_ENTRY {{.*}} op0=[[FUNCID]] op1=7289175272376759421/>
 ; COMBINED-NEXT:    <COMBINED
 ; COMBINED-NEXT:  </VALUE_SYMTAB>
 
 ; ModuleID = 'thinlto-function-summary-callgraph.ll'

test/Bitcode/thinlto-function-summary-callgraph.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: opt -module-summary %p/Inputs/thinlto-function-summary-callgraph.ll -o %t2.o
 ; RUN: llvm-lto -thinlto -o %t3 %t.o %t2.o
 ; RUN: llvm-bcanalyzer -dump %t3.thinlto.bc | FileCheck %s --check-prefix=COMBINED
 
 ; CHECK:       <GLOBALVAL_SUMMARY_BLOCK
 ; CHECK-NEXT:    <VERSION
 ; See if the call to func is registered, using the expected callsite count
 ; and value id matching the subsequent value symbol table.
-; CHECK-NEXT:    <PERMODULE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1/>
+; CHECK-NEXT:    <PERMODULE {{.*}} op4=[[FUNCID:[0-9]+]] op5=1 op6=0/>
 ; CHECK-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; CHECK-NEXT:  <VALUE_SYMTAB
 ; CHECK-NEXT:    <FNENTRY {{.*}} record string = 'main'
 ; External function func should have entry with value id FUNCID
 ; CHECK-NEXT:    <ENTRY {{.*}} op0=[[FUNCID]] {{.*}} record string = 'func'
 ; CHECK-NEXT:  </VALUE_SYMTAB>
 
 ; COMBINED:       <GLOBALVAL_SUMMARY_BLOCK
 ; COMBINED-NEXT:    <VERSION
 ; COMBINED-NEXT:    <COMBINED
 ; See if the call to func is registered, using the expected callsite count
 ; and value id matching the subsequent value symbol table.
-; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[FUNCID:[0-9]+]] op6=1/>
+; COMBINED-NEXT:    <COMBINED {{.*}} op5=[[FUNCID:[0-9]+]] op6=1 op7=0/>
 ; COMBINED-NEXT:  </GLOBALVAL_SUMMARY_BLOCK>
 ; COMBINED-NEXT:  <VALUE_SYMTAB
 ; Entry for function func should have entry with value id FUNCID
 ; COMBINED-NEXT:    <COMBINED_ENTRY {{.*}} op0=[[FUNCID]] op1=7289175272376759421/>
 ; COMBINED-NEXT:    <COMBINED
 ; COMBINED-NEXT:  </VALUE_SYMTAB>
 
 ; ModuleID = 'thinlto-function-summary-callgraph.ll'

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/>
+; CHECK-DAG:    <PERMODULE {{.*}} op0=[[MAINID:[0-9]+]] op1=0 {{.*}} op3=1 op4=[[FUNCID:[0-9]+]] op5=[[FUNCID]] op6=1 op7=0/>
 ; Function W contains a call to func3 as well as a reference to globalvar:
-; CHECK-DAG:    <PERMODULE {{.*}} op0=[[WID:[0-9]+]] op1=5 {{.*}} 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 op7=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=1 {{.*}} 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 op7=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=8 {{.*}} 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 op6=0/>
 ; 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=3 {{.*}} 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 op6=0/>
 ; 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'