Add timing of bitcode parser to Subzero.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        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 PNaCl bitcode file to Ice, to machine code
@@ skipping 613 matching lines @@
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Don't know how to process record: " << Record;
   Error(StrBuf.str());
 }
 
 // Class to parse a types block.
 class TypesParser : public BlockParserBaseClass {
 public:
   TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
-      : BlockParserBaseClass(BlockID, EnclosingParser), NextTypeId(0) {}
+      : BlockParserBaseClass(BlockID, EnclosingParser),
+        Timer(Ice::TimerStack::TT_parseTypes, getTranslator().getContext()),
+        NextTypeId(0) {}
 
   ~TypesParser() override {}
 
 private:
+  Ice::TimerMarker Timer;
   // The type ID that will be associated with the next type defining
   // record in the types block.
   unsigned NextTypeId;
 
   void ProcessRecord() override;
 
   void setNextTypeIDAsSimpleType(Ice::Type Ty) {
     Context->getTypeByIDForDefining(NextTypeId++)->setAsSimpleType(Ty);
   }
 };
@@ skipping 145 matching lines @@
     return;
   }
   llvm_unreachable("Unknown type block record not processed!");
 }
 
 /// Parses the globals block (i.e. global variable declarations and
 /// corresponding initializers).
 class GlobalsParser : public BlockParserBaseClass {
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
-      : BlockParserBaseClass(BlockID, EnclosingParser), InitializersNeeded(0),
-        NextGlobalID(0), DummyGlobalVar(Ice::VariableDeclaration::create(
-                             getTranslator().getContext())),
+      : BlockParserBaseClass(BlockID, EnclosingParser),
+        Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
+        InitializersNeeded(0), NextGlobalID(0),
+        DummyGlobalVar(
+            Ice::VariableDeclaration::create(getTranslator().getContext())),
         CurGlobalVar(DummyGlobalVar) {}
 
 private:
+  Ice::TimerMarker Timer;
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
   unsigned InitializersNeeded;
 
   // The index of the next global variable declaration.
   unsigned NextGlobalID;
 
   // Dummy global variable declaration to guarantee CurGlobalVar is
   // always defined (allowing code to not need to check if
   // CurGlobalVar is nullptr).
@@ skipping 177 matching lines @@
 
 /// Parses function blocks in the bitcode file.
 class FunctionParser : public BlockParserBaseClass {
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
   friend class FunctionValuesymtabParser;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
+        Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
         Func(new Ice::Cfg(getTranslator().getContext())), CurrentBbIndex(0),
         FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()),
         InstIsTerminating(false) {
     Func->setFunctionName(FuncDecl->getName());
     if (getFlags().TimeEachFunction)
       getTranslator().getContext()->pushTimer(
           getTranslator().getContext()->getTimerID(
@@ skipping 12 matching lines @@
   }
 
   ~FunctionParser() override {};
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) {
     setOperand(NextLocalInstIndex++, C);
   }
 
 private:
+  Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
   Ice::Cfg *Func;
   // The index to the current basic block being built.
   uint32_t CurrentBbIndex;
   // The basic block being built.
   Ice::CfgNode *CurrentNode;
   // The ID for the function.
   unsigned FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
@@ skipping 1195 matching lines @@
   }
 }
 
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser(const ConstantsParser &) = delete;
   ConstantsParser &operator=(const ConstantsParser &) = delete;
 
 public:
   ConstantsParser(unsigned BlockID, FunctionParser *FuncParser)
-      : BlockParserBaseClass(BlockID, FuncParser), FuncParser(FuncParser),
-        NextConstantType(Ice::IceType_void) {}
+      : BlockParserBaseClass(BlockID, FuncParser),
+        Timer(Ice::TimerStack::TT_parseConstants, getTranslator().getContext()),
+        FuncParser(FuncParser), NextConstantType(Ice::IceType_void) {}
 
   ~ConstantsParser() override {}
 
 private:
+  Ice::TimerMarker Timer;
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
   Ice::Type NextConstantType;
 
   void ProcessRecord() override;
 
   Ice::GlobalContext *getContext() { return getTranslator().getContext(); }
 
   // Returns true if the type to use for succeeding constants is defined.
@@ skipping 89 matching lines @@
   }
 }
 
 // Parses valuesymtab blocks appearing in a function block.
 class FunctionValuesymtabParser : public ValuesymtabParser {
   FunctionValuesymtabParser(const FunctionValuesymtabParser &) = delete;
   void operator=(const FunctionValuesymtabParser &) = delete;
 
 public:
   FunctionValuesymtabParser(unsigned BlockID, FunctionParser *EnclosingParser)
-      : ValuesymtabParser(BlockID, EnclosingParser) {}
+      : ValuesymtabParser(BlockID, EnclosingParser),
+        Timer(Ice::TimerStack::TT_parseFunctionValuesymtabs,
+              getTranslator().getContext()) {}
 
 private:
+  Ice::TimerMarker Timer;
   // Returns the enclosing function parser.
   FunctionParser *getFunctionParser() const {
     return reinterpret_cast<FunctionParser *>(GetEnclosingParser());
   }
 
   void setValueName(uint64_t Index, StringType &Name) override;
   void setBbName(uint64_t Index, StringType &Name) override;
 
   // Reports that the assignment of Name to the value associated with
   // index is not possible, for the given Context.
@@ skipping 50 matching lines @@
     break;
   }
   return BlockParserBaseClass::ParseBlock(BlockID);
 }
 
 /// Parses the module block in the bitcode file.
 class ModuleParser : public BlockParserBaseClass {
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
+        Timer(Ice::TimerStack::TT_parseModule,
+              Context->getTranslator().getContext()),
         GlobalDeclarationNamesAndInitializersInstalled(false) {}
 
   ~ModuleParser() override {}
 
 private:
+  Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled;
 
   // Generates names for unnamed global addresses (i.e. functions and
   // global variables). Then lowers global variable declaration
   // initializers to the target. May be called multiple times. Only
   // the first call will do the installation.
   void InstallGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
@@ skipping 41 matching lines @@
 
   void ProcessRecord() override;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser(const ModuleValuesymtabParser &) = delete;
   void operator=(const ModuleValuesymtabParser &) = delete;
 
 public:
   ModuleValuesymtabParser(unsigned BlockID, ModuleParser *MP)
-      : ValuesymtabParser(BlockID, MP) {}
+      : ValuesymtabParser(BlockID, MP),
+        Timer(Ice::TimerStack::TT_parseModuleValuesymtabs,
+              getTranslator().getContext()) {}
 
   ~ModuleValuesymtabParser() override {}
 
 private:
+  Ice::TimerMarker Timer;
   void setValueName(uint64_t Index, StringType &Name) override;
   void setBbName(uint64_t Index, StringType &Name) override;
 };
 
 void ModuleValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
   Context->getGlobalDeclarationByID(Index)
       ->setName(StringRef(Name.data(), Name.size()));
 }
 
 void ModuleValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
@@ skipping 140 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice