InlineCost - method ::print() to allow dump of statistics to non-debug builds

[knaumov]

Summary

This is a logical continuation of https://reviews.llvm.org/D81743.
My intention of the said patch was to introduce a pass that would allow us to print the debug stats to check the functionality of the inline and its decisions outside of debug builds. However, the definition of InlineCostCallAnalyzer::dump() is hidden inside preprocessing macros which caused the fall of several buildbots when I commit the change:
http://lab.llvm.org:8011/builders/fuchsia-x86_64-linux/builds/6688
http://lab.llvm.org:8011/builders/llvm-clang-x86_64-win-fast/builds/17841

The idea of this change is to create another dumping function for InlineCostCallAnalyzer (namely, InlineCostCallAnalyzer::print()) with essentially identical purpose, but with the difference that its definition is not dependent on any preprocessing macros and, consequently build types.

[mtrofin]

I believe the reason dump() is hidden behind conditional compilation flags, is to avoid the size overhead in the respective builds.

Alternatively, could your use of dump() be guarded by similar conditional compilation flags, and, then, conditionally-depend on that in tests that would use the feature?

[apilipenko]

@mtrofin, I think it makes sense to have these tests available in all configurations. We have a bunch of printer passes which are not conditioned by NDEBUG.

llvm/lib/Analysis/InlineCost.cpp

2176

Please, avoid duplication and call print here.

[knaumov]

Answering @mtrofin :
Although what you suggested is a valid solution, it will go against the point of this whole pass - to enable the checks of inliner's inner works for all builds, not just the debug ones. If we apply your solution, then still we will get several builds which will avoid being checked due to the conditioning flags.

[mtrofin]

In D82205#2104505, @knaumov wrote:

Answering @mtrofin :
Although what you suggested is a valid solution, it will go against the point of this whole pass - to enable the checks of inliner's inner works for all builds, not just the debug ones. If we apply your solution, then still we will get several builds which will avoid being checked due to the conditioning flags.

Ah - and we don't seem to have non-debug build bots with LLVM_ENABLE_DUMP enabled.

[knaumov]

• To avoid redundancy, used the preprocessing function DEBUG_PRINT_STAT defined for ::dump()

[mtrofin]

llvm/lib/Analysis/InlineCost.cpp

2176

maybe I'm missing something, but why not just call print() from dump() ?

[knaumov]

• Because print() performs the same functionality as did dump(), instead of copying the code just call print() from dump()

[knaumov]

ping

[mtrofin]

lgtm

llvm/lib/Analysis/InlineCost.cpp

InlineCostCallAnalyzer(
         BoostIndirectCalls(BoostIndirect), IgnoreThreshold(IgnoreThreshold),
         Writer(this) {}
 
   /// Annotation Writer for instruction details
   InlineCostAnnotationWriter Writer;
 
   void dump();
 
+  // Prints the same analysis as dump(), but its definition is not dependent
+  // on the build.
+  void print();
+
   Optional<InstructionCostDetail> getCostDetails(const Instruction *I) {
     if (InstructionCostDetailMap.find(I) != InstructionCostDetailMap.end())
       return InstructionCostDetailMap[I];
     return None;
   }
 
   virtual ~InlineCostCallAnalyzer() {}
   int getThreshold() { return Threshold; }
InlineResult CallAnalyzer::analyze() {
   // inlining this would cause the removal of the caller (so the instruction
   // is not actually duplicated, just moved).
   if (!OnlyOneCallAndLocalLinkage && ContainsNoDuplicateCall)
     return InlineResult::failure("noduplicate");
 
   return finalizeAnalysis();
 }
 
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-/// Dump stats about this call's analysis.
-LLVM_DUMP_METHOD void InlineCostCallAnalyzer::dump() {
+void InlineCostCallAnalyzer::print() {
 #define DEBUG_PRINT_STAT(x) dbgs() << "      " #x ": " << x << "\n"
   if (PrintInstructionComments)
     F.print(dbgs(), &Writer);
   DEBUG_PRINT_STAT(NumConstantArgs);
   DEBUG_PRINT_STAT(NumConstantOffsetPtrArgs);
   DEBUG_PRINT_STAT(NumAllocaArgs);
   DEBUG_PRINT_STAT(NumConstantPtrCmps);
   DEBUG_PRINT_STAT(NumConstantPtrDiffs);
   DEBUG_PRINT_STAT(NumInstructionsSimplified);
   DEBUG_PRINT_STAT(NumInstructions);
   DEBUG_PRINT_STAT(SROACostSavings);
   DEBUG_PRINT_STAT(SROACostSavingsLost);
   DEBUG_PRINT_STAT(LoadEliminationCost);
   DEBUG_PRINT_STAT(ContainsNoDuplicateCall);
   DEBUG_PRINT_STAT(Cost);
   DEBUG_PRINT_STAT(Threshold);
 #undef DEBUG_PRINT_STAT
 }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+/// Dump stats about this call's analysis.
+LLVM_DUMP_METHOD void InlineCostCallAnalyzer::dump() {
+  print();
+}
 #endif
 
 /// Test that there are no attribute conflicts between Caller and Callee
 ///        that prevent inlining.
 static bool functionsHaveCompatibleAttributes(
     Function *Caller, Function *Callee, TargetTransformInfo &TTI,
     function_ref<const TargetLibraryInfo &(Function &)> &GetTLI) {
   // Note that CalleeTLI must be a copy not a reference. The legacy pass manager