Subzero: Basic Block Profiler.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include <ctype.h> // isdigit(), isupper()
 #include <locale>  // locale
 #include <unordered_map>
 
 #include "llvm/Support/Timer.h"
 
 #include "IceCfg.h"
+#include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 
@@ skipping 238 matching lines @@
     // current function matches the -translate-only option.  If
     // translation is disabled, just dump the high-level IR and
     // continue.
     if (getFlags().getDisableTranslation() ||
         !matchSymbolName(Func->getFunctionName(),
                          getFlags().getTranslateOnly())) {
       Func->dump();
       Cfg::setCurrentCfg(nullptr);
       continue; // Func goes out of scope and gets deleted
     }
+
     Func->translate();
     EmitterWorkItem *Item = nullptr;
     if (Func->hasError()) {
       getErrorStatus()->assign(EC_Translation);
       OstreamLocker L(this);
       getStrError() << "ICE translation error: " << Func->getFunctionName()
                     << ": " << Func->getError() << "\n";
       Item = new EmitterWorkItem(Func->getSequenceNumber());
+      Item->setGlobalInits(Func->getGlobalInits());
     } else {
       Func->getAssembler<>()->setInternal(Func->getInternal());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
       case FT_Iasm: {
         Func->emitIAS();
         // The Cfg has already emitted into the assembly buffer, so
         // stats have been fully collected into this thread's TLS.
         // Dump them before TLS is reset for the next Cfg.
         dumpStats(Func->getFunctionName());
         Assembler *Asm = Func->releaseAssembler();
         // Copy relevant fields into Asm before Func is deleted.
         Asm->setFunctionName(Func->getFunctionName());
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Asm);
+        Item->setGlobalInits(Func->getGlobalInits());
       } break;
       case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
+        std::unique_ptr<VariableDeclarationList> GlobalInits =
+            Func->getGlobalInits();
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
+        Item->setGlobalInits(std::move(GlobalInits));
         break;
       }
     }
     Cfg::setCurrentCfg(nullptr);
     assert(Item);
     emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
+VariableDeclaration *blockProfileInfo(const VariableDeclarationList &Globals) {
+  auto *Var = VariableDeclaration::create();
+  Var->setAlignment(8);
+  Var->setIsConstant(true);
+  Var->setName("__Sz_block_profile_info");
+  Var->setLinkage(llvm::GlobalValue::ExternalLinkage);
+  for (const auto *Global : Globals) {
+    if (Cfg::isProfileGlobal(*Global)) {
+      constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
+      Var->addInitializer(new VariableDeclaration::RelocInitializer(
+          Global, BlockExecutionCounterOffset));
+    }
+  }
+
+  constexpr SizeT ByteCountOf64BitNullPtr = 8;

[Jim Stichnoth, 2015/06/09 16:39:46]

I think the 8 could be typeWidthInBytes(IceType_i64), right?

I thought this would be "byte count of primitive 64-bit integer", not "byte
count of some pointer", especially since all PNaCl pointers are 32-bits
regardless of architecture.

Should the setAlignment(8) above also use typeWidthInBytes(IceType_i64)?

[John, 2015/06/09 22:01:16]

Done.

+  Var->addInitializer(
+      new VariableDeclaration::ZeroInitializer(ByteCountOf64BitNullPtr));
+
+  return Var;
+}
+
+void addBlockProfileInfoArrayToGlobals(VariableDeclarationList *Globals) {
+  // Purposefully create the Var temp to prevent bugs in case the compiler
+  // reorders instructions in a way that Globals is extended before the call
+  // to profileInfoArray.
+  auto *Var = blockProfileInfo(*Globals);
+  Globals->push_back(Var);
+}
+
 void lowerGlobals(GlobalContext *Ctx,
                   std::unique_ptr<VariableDeclarationList> VariableDeclarations,
                   TargetDataLowering *DataLowering) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
   const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getFlags().getVerbose() &&
                                    Ctx->getFlags().getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(Ctx);
     Ostream &Stream = Ctx->getStrDump();
     for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
       Global->dump(Ctx, Stream);
     }
   }
   if (Ctx->getFlags().getDisableTranslation())
     return;
+
+  // There should be no need to emit the block_profile_info array if profiling
+  // is disabled. In practice, given that szrt_profiler.o will always be
+  // embedded in the application, we need to add it. In a non-profiled build
+  // this array will only contain the nullptr terminator.
+  addBlockProfileInfoArrayToGlobals(VariableDeclarations.get());
+
   DataLowering->lowerGlobals(std::move(VariableDeclarations));
 }
 
 // Ensure Pending is large enough that Pending[Index] is valid.
 void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
   if (Index >= Pending.size())
     Pending.resize(Index + 1);
 }
 
+void addAllIfNotNull(std::unique_ptr<VariableDeclarationList> src,
+                     VariableDeclarationList *dst) {
+  if (src != nullptr) {
+    dst->insert(dst->end(), src->begin(), src->end());
+  }
+}
+
 } // end of anonymous namespace
 
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
   // work items.  When we're ready for the next item, we first check
   // whether it's in the Pending list.  If not, we take an item from
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
+  std::unique_ptr<VariableDeclarationList> GlobalInits(
+      new VariableDeclarationList());
   std::vector<EmitterWorkItem *> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   while (true) {
     resizePending(Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
     EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
     if (RawItem == nullptr)
       RawItem = emitQueueBlockingPop();
     if (RawItem == nullptr)
-      return;
+      break;
     uint32_t ItemSeq = RawItem->getSequenceNumber();
     if (Threaded && ItemSeq != DesiredSequenceNumber) {
       resizePending(Pending, ItemSeq);
       Pending[ItemSeq] = RawItem;
       continue;
     }
 
     std::unique_ptr<EmitterWorkItem> Item(RawItem);
     ++DesiredSequenceNumber;
     switch (Item->getKind()) {
     case EmitterWorkItem::WI_Nop:
       break;
     case EmitterWorkItem::WI_GlobalInits: {
-      lowerGlobals(this, Item->getGlobalInits(),
-                   TargetDataLowering::createLowering(this).get());
+      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
     } break;
     case EmitterWorkItem::WI_Asm: {
+      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
       std::unique_ptr<Assembler> Asm = Item->getAsm();
       Asm->alignFunction();
       IceString MangledName = mangleName(Asm->getFunctionName());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
         getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
                                              Asm.get());
         break;
       case FT_Iasm: {
         OstreamLocker L(this);
         Cfg::emitTextHeader(MangledName, this, Asm.get());
         Asm->emitIASBytes(this);
       } break;
       case FT_Asm:
         llvm::report_fatal_error("Unexpected FT_Asm");
         break;
       }
     } break;
     case EmitterWorkItem::WI_Cfg: {
       if (!ALLOW_DUMP)
         llvm::report_fatal_error("WI_Cfg work item created inappropriately");
+
+      addAllIfNotNull(Item->getGlobalInits(), GlobalInits.get());
+
       assert(getFlags().getOutFileType() == FT_Asm);
       std::unique_ptr<Cfg> Func = Item->getCfg();
       // Unfortunately, we have to temporarily install the Cfg in TLS
       // because Variable::asType() uses the allocator to create the
       // differently-typed copy.
       Cfg::setCurrentCfg(Func.get());
       Func->emit();
       Cfg::setCurrentCfg(nullptr);
       dumpStats(Func->getFunctionName());
     } break;
     }
   }
+
+  lowerGlobals(this, std::move(GlobalInits),
+               TargetDataLowering::createLowering(this).get());
 }
 
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
@@ skipping 406 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice