[BOLT] ZeroIdiom stats

[Amir]

Compute code size

[Amir]

Fix SavedBytes computation

[Amir]

Fix saved bytes computation

bolt/include/bolt/Passes/ZeroIdiom.h

 
 namespace llvm {
 namespace bolt {
 
 class DataflowInfoManager;
 
 /// Pass for converting eligible instructions into zero idiom.
 class ZeroIdiomPass : public BinaryFunctionPass {
-  void runOnFunction(BinaryFunction &Function, DataflowInfoManager &Info);
+  void runOnFunction(BinaryFunction &Function, DataflowInfoManager &Info,
+                     BinaryContext::IndependentCodeEmitter &Emitter);
+
+  static std::atomic<std::uint64_t> ReplacedInsts;
+  static std::atomic<std::uint64_t> ModifiedFunctions;
+  static std::atomic<std::uint64_t> ReplacedDynamicCount;
+  static std::atomic<std::uint64_t> SavedBytes;
 
 public:
   explicit ZeroIdiomPass(const cl::opt<bool> &PrintPass)
       : BinaryFunctionPass(PrintPass) {}
 
   const char *getName() const override { return "zero-idiom"; }
 
   void runOnFunctions(BinaryContext &BC) override;
 };
 
 } // end namespace bolt
 } // end namespace llvm
 
 #endif

bolt/lib/Passes/ZeroIdiom.cpp

 #include "bolt/Passes/BinaryFunctionCallGraph.h"
 #include "bolt/Passes/DataflowInfoManager.h"
 
 #define DEBUG_TYPE "zeroidiom"
 
 namespace llvm {
 namespace bolt {
 
-void ZeroIdiomPass::runOnFunction(BinaryFunction &BF,
-                                  DataflowInfoManager &Info) {
+std::atomic<std::uint64_t> ZeroIdiomPass::ReplacedInsts{0};
+std::atomic<std::uint64_t> ZeroIdiomPass::ModifiedFunctions{0};
+std::atomic<std::uint64_t> ZeroIdiomPass::ReplacedDynamicCount{0};
+std::atomic<std::uint64_t> ZeroIdiomPass::SavedBytes{0};
+
+void ZeroIdiomPass::runOnFunction(
+    BinaryFunction &BF, DataflowInfoManager &Info,
+    BinaryContext::IndependentCodeEmitter &Emitter) {
   BinaryContext &BC = BF.getBinaryContext();
   LivenessAnalysis &LA = Info.getLivenessAnalysis();
+  MCCodeEmitter *MCE = Emitter.MCE.get();
 
+  bool Modified = false;
   for (BinaryBasicBlock &BB : BF) {
     for (MCInst &Inst : BB) {
       if (LA.isAlive(ProgramPoint(&Inst), BC.MIB->getFlagsReg()))
         continue;
-      BC.MIB->replaceZeroIdiom(Inst);
+      const uint64_t SizeBefore = BC.computeInstructionSize(Inst, MCE);
+      if (BC.MIB->replaceZeroIdiom(Inst)) {
+        Modified = true;
+        ++ReplacedInsts;
+        ReplacedDynamicCount += BB.getExecutionCount();
+        const uint64_t SizeAfter = BC.computeInstructionSize(Inst, MCE);
+        SavedBytes += (SizeAfter - SizeBefore);
       }
     }
   }
+  if (Modified)
+    ++ModifiedFunctions;
+}
 
 void ZeroIdiomPass::runOnFunctions(BinaryContext &BC) {
   if (!BC.isX86())
     return;
 
   std::unique_ptr<BinaryFunctionCallGraph> CG(
       new BinaryFunctionCallGraph(buildCallGraph(BC)));
   std::unique_ptr<RegAnalysis> RA(
       new RegAnalysis(BC, &BC.getBinaryFunctions(), &*CG));
 
   ParallelUtilities::WorkFuncWithAllocTy WorkFun =
       [&](BinaryFunction &BF, MCPlusBuilder::AllocatorIdTy AllocId) {
         DataflowInfoManager Info(BF, RA.get(), nullptr, AllocId);
-        runOnFunction(BF, Info);
+        BinaryContext::IndependentCodeEmitter MCE =
+            BC.createIndependentMCCodeEmitter();
+        runOnFunction(BF, Info, MCE);
       };
 
   ParallelUtilities::runOnEachFunctionWithUniqueAllocId(
       BC, ParallelUtilities::SchedulingPolicy::SP_INST_LINEAR, WorkFun, nullptr,
       "ZeroIdiom");
+
+  if (!ReplacedInsts)
+    return;
+
+  outs() << "BOLT-INFO: zero-idiom replaced " << ReplacedInsts
+         << " instructions (exec count " << ReplacedDynamicCount << ") in "
+         << ModifiedFunctions << " functions saving " << SavedBytes
+         << " bytes\n";
 }
 
 } // end namespace bolt
 } // end namespace llvm