Set MaxFunctionCount for SampleProfileReader.

[danielcdh]

Summary

This patch sets MaxFunctionCount for SampleProfileReader and SampleProfile pass so that InlineCost can get correct value.

[eraman]

I'm going to check in a patch (Diego has approved it) that will provide profile summary to sample profile reader. Profile summary has max function count, so you should be able to call something like M.setMaximumFunctionCount(Reader->getProfileSummary()->getHeadSamples()). I am also going to replace the MaxFunctionCount module flag with a flag for profile summary. One that lands, setMaximumFunctionCount will be obsolete. So I suggest that you drop this patch.

[danielcdh]

This patch will be obsolete once Easwaran's inline summary patch is in.

include/llvm/ProfileData/SampleProfReader.h

 ///      be relative to the start of the function.
 ///
 /// The reader supports two file formats: text and binary. The text format
 /// is useful for debugging and testing, while the binary format is more
 /// compact and I/O efficient. They can both be used interchangeably.
 class SampleProfileReader {
 public:
   SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
-      : Profiles(0), Ctx(C), Buffer(std::move(B)) {}
+      : Profiles(0), MaxFunctionCount(0), Ctx(C), Buffer(std::move(B)) {}
 
   virtual ~SampleProfileReader() {}
 
   /// \brief Read and validate the file header.
   virtual std::error_code readHeader() = 0;
 
   /// \brief Read sample profiles from the associated file.
   virtual std::error_code read() = 0;
public:
   StringMap<FunctionSamples> &getProfiles() { return Profiles; }
 
   /// \brief Report a parse error message.
   void reportError(int64_t LineNumber, Twine Msg) const {
     Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
                                              LineNumber, Msg));
   }
 
+  /// \brief Return maximum function entry count;
+  uint64_t getMaxFunctionCount() const { return MaxFunctionCount; }
+
   /// \brief Create a sample profile reader appropriate to the file format.
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
   create(StringRef Filename, LLVMContext &C);
 
   /// \brief Create a sample profile reader from the supplied memory buffer.
   static ErrorOr<std::unique_ptr<SampleProfileReader>>
   create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C);
 
 protected:
   /// \brief Map every function to its associated profile.
   ///
   /// The profile of every function executed at runtime is collected
   /// in the structure FunctionSamples. This maps function objects
   /// to their corresponding profiles.
   StringMap<FunctionSamples> Profiles;
 
+  /// \brief Max entry count of all functions.
+  uint64_t MaxFunctionCount;
+
   /// \brief LLVM context used to emit diagnostics.
   LLVMContext &Ctx;
 
   /// \brief Memory buffer holding the profile file.
   std::unique_ptr<MemoryBuffer> Buffer;
 };
 
 class SampleProfileReaderText : public SampleProfileReader {

lib/ProfileData/SampleProfReader.cpp

if ((*LineIt)[0] != ' ') {
         reportError(LineIt.line_number(),
                     "Expected 'mangled_name:NUM:NUM', found " + *LineIt);
         return sampleprof_error::malformed;
       }
       Profiles[FName] = FunctionSamples();
       FunctionSamples &FProfile = Profiles[FName];
       MergeResult(Result, FProfile.addTotalSamples(NumSamples));
       MergeResult(Result, FProfile.addHeadSamples(NumHeadSamples));
+      if (NumHeadSamples > MaxFunctionCount) {
+        MaxFunctionCount = NumHeadSamples;
+      }
       InlineStack.clear();
       InlineStack.push_back(&FProfile);
     } else {
       uint64_t NumSamples;
       StringRef FName;
       DenseMap<StringRef, uint64_t> TargetCountMap;
       bool IsCallsite;
       uint32_t Depth, LineOffset, Discriminator;
while (!at_eof()) {
     auto FName(readStringFromTable());
     if (std::error_code EC = FName.getError())
       return EC;
 
     Profiles[*FName] = FunctionSamples();
     FunctionSamples &FProfile = Profiles[*FName];
 
     FProfile.addHeadSamples(*NumHeadSamples);
+    if (*NumHeadSamples > MaxFunctionCount) {
+      MaxFunctionCount = *NumHeadSamples;
+    }
 
     if (std::error_code EC = readProfile(FProfile))
       return EC;
   }
 
   return sampleprof_error::success;
 }
 
if (InlineStack.size() == 0) {
     // If this is a top function that we have already processed, do not
     // update its profile again.  This happens in the presence of
     // function aliases.  Since these aliases share the same function
     // body, there will be identical replicated profiles for the
     // original function.  In this case, we simply not bother updating
     // the profile of the original function.
     FProfile = &Profiles[Name];
     FProfile->addHeadSamples(HeadCount);
+    if (HeadCount > MaxFunctionCount) {
+      MaxFunctionCount = HeadCount;
+    }
+
     if (FProfile->getTotalSamples() > 0)
       Update = false;
   } else {
     // Otherwise, we are reading an inlined instance. The top of the
     // inline stack contains the profile of the caller. Insert this
     // callee in the caller's CallsiteMap.
     FunctionSamples *CallerProfile = InlineStack.front();
     uint32_t LineOffset = Offset >> 16;

lib/Transforms/IPO/SampleProfile.cpp

 ModulePass *llvm::createSampleProfileLoaderPass(StringRef Name) {
   return new SampleProfileLoader(Name);
 }
 
 bool SampleProfileLoader::runOnModule(Module &M) {
   if (!ProfileIsValid)
     return false;
 
+  M.setMaximumFunctionCount(Reader->getMaxFunctionCount());
+
   // Compute the total number of samples collected in this profile.
   for (const auto &I : Reader->getProfiles())
     TotalCollectedSamples += I.second.getTotalSamples();
 
   bool retval = false;
   for (auto &F : M)
     if (!F.isDeclaration()) {
       clearFunctionData();