Subzero: Basic Block Profiler.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Cfg class, including constant pool
 // management.
 //
 //===----------------------------------------------------------------------===//
 
 #include "assembler.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
+#include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 ICE_TLS_DEFINE_FIELD(const Cfg *, Cfg, CurrentCfg);
 
 ArenaAllocator<> *getCurrentCfgAllocator() {
@@ skipping 37 matching lines @@
 
 void Cfg::addImplicitArg(Variable *Arg) {
   Arg->setIsImplicitArg();
   ImplicitArgs.push_back(Arg);
 }
 
 // Returns whether the stack frame layout has been computed yet.  This
 // is used for dumping the stack frame location of Variables.
 bool Cfg::hasComputedFrame() const { return getTarget()->hasComputedFrame(); }
 
+namespace {
+constexpr char BlockNameGlobalPrefix[] = ".L$profiler$block_name$";
+constexpr char BlockStatsGlobalPrefix[] = ".L$profiler$block_info$";
+
+VariableDeclaration *nodeNameDeclaration(const IceString &NodeAsmName) {
+  VariableDeclaration *Var = VariableDeclaration::create();
+  Var->setName(BlockNameGlobalPrefix + NodeAsmName);
+  Var->setIsConstant(true);
+  Var->addInitializer(new VariableDeclaration::DataInitializer(
+      NodeAsmName.data(), NodeAsmName.size() + 1));
+  const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
+  Var->setAlignment(Int64ByteSize); // Wasteful, 32-bit could use 4 bytes.
+  return Var;
+}
+
+VariableDeclaration *
+blockProfilingInfoDeclaration(const IceString &NodeAsmName,
+                              VariableDeclaration *NodeNameDeclaration) {
+  VariableDeclaration *Var = VariableDeclaration::create();
+  Var->setName(BlockStatsGlobalPrefix + NodeAsmName);
+  const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
+  Var->addInitializer(new VariableDeclaration::ZeroInitializer(Int64ByteSize));
+
+  const RelocOffsetT NodeNameDeclarationOffset = 0;
+  Var->addInitializer(new VariableDeclaration::RelocInitializer(
+      NodeNameDeclaration, NodeNameDeclarationOffset));
+  Var->setAlignment(Int64ByteSize);
+  return Var;
+}
+
+} // end of anonymous namespace
+
+void Cfg::profileBlocks() {
+  if (GlobalInits == nullptr)
+    GlobalInits.reset(new VariableDeclarationList());
+
+  for (CfgNode *Node : Nodes) {
+    IceString NodeAsmName = Node->getAsmName();
+    GlobalInits->push_back(nodeNameDeclaration(NodeAsmName));
+    GlobalInits->push_back(
+        blockProfilingInfoDeclaration(NodeAsmName, GlobalInits->back()));
+    Node->profileExecutionCount(GlobalInits->back());
+  }
+}
+
+bool Cfg::isProfileGlobal(const VariableDeclaration &Var) {
+  return Var.getName().find(BlockStatsGlobalPrefix) == 0;
+}
+
+void Cfg::addCallToProfileSummary() {
+  // The call(s) to __Sz_profile_summary are added by the profiler in functions
+  // that cause the program to exit. This function is defined in
+  // runtime/szrt_profiler.c.
+  Constant *ProfileSummarySym =
+      Ctx->getConstantExternSym("__Sz_profile_summary");
+  constexpr SizeT NumArgs = 0;
+  constexpr Variable *Void = nullptr;
+  constexpr bool HasTailCall = false;
+  auto *Call =
+      InstCall::create(this, NumArgs, Void, ProfileSummarySym, HasTailCall);
+  getEntryNode()->getInsts().push_front(Call);
+}
+
 void Cfg::translate() {
   if (hasError())
     return;
   // FunctionTimer conditionally pushes/pops a TimerMarker if
   // TimeEachFunction is enabled.
   std::unique_ptr<TimerMarker> FunctionTimer;
   if (ALLOW_DUMP) {
     const IceString &TimingFocusOn =
         getContext()->getFlags().getTimingFocusOn();
     const IceString &Name = getFunctionName();
     if (TimingFocusOn == "*" || TimingFocusOn == Name) {
       setFocusedTiming();
       getContext()->resetTimer(GlobalContext::TSK_Default);
       getContext()->setTimerName(GlobalContext::TSK_Default, Name);
     }
     if (getContext()->getFlags().getTimeEachFunction())
       FunctionTimer.reset(new TimerMarker(
           getContext()->getTimerID(GlobalContext::TSK_Funcs, Name),
           getContext(), GlobalContext::TSK_Funcs));
   }
   TimerMarker T(TimerStack::TT_translate, this);
 
   dump("Initial CFG");
 
+  if (getContext()->getFlags().getEnableBlockProfile()) {
+    profileBlocks();
+    // TODO(jpp): this is fragile, at best. Figure out a better way of detecting
+    // exit functions.
+    if (GlobalContext::matchSymbolName(getFunctionName(), "exit")) {
+      addCallToProfileSummary();
+    }
+    dump("Profiled CFG");
+  }
+
   // The set of translation passes and their order are determined by
   // the target.
   getTarget()->translate();
 
   dump("Final output");
   if (getFocusedTiming())
     getContext()->dumpTimers();
 }
 
 void Cfg::computeInOutEdges() {
@@ skipping 429 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice