Subzero: Rewrite the pass timing infrastructure.

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
 // translator.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PNaClTranslator.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTypeConverter.h"
+#include "PNaClTranslator.h"
 #include "llvm/Analysis/NaCl/PNaClABIProps.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Format.h"
@@ skipping 812 matching lines @@
     Func->setInternal(LLVMFunc->hasInternalLinkage());
     CurrentNode = InstallNextBasicBlock();
     Func->setEntryNode(CurrentNode);
     for (Function::const_arg_iterator ArgI = LLVMFunc->arg_begin(),
                                       ArgE = LLVMFunc->arg_end();
          ArgI != ArgE; ++ArgI) {
       Func->addArg(getNextInstVar(Context->convertToIceType(ArgI->getType())));
     }
   }
 
-  ~FunctionParser() override;
+  ~FunctionParser() override {};
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) {
     setOperand(NextLocalInstIndex++, C);
   }
 
 private:
-  // Timer for reading function bitcode and converting to ICE.
-  Ice::Timer TConvert;
   // 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 LLVM function.
   Function *LLVMFunc;
@@ skipping 494 matching lines @@
       return true;
     case naclbitc::FCMP_TRUE:
       Cond = Ice::InstFcmp::True;
       return true;
     default:
       return false;
     }
   }
 };
 
-FunctionParser::~FunctionParser() {
-  if (getFlags().SubzeroTimingEnabled) {
-    errs() << "[Subzero timing] Convert function " << Func->getFunctionName()
-           << ": " << TConvert.getElapsedSec() << " sec\n";
-  }
-}
-
 void FunctionParser::ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
   Error(StrBuf.str());
 }
 
 void FunctionParser::ExitBlock() {
   // Before translating, check for blocks without instructions, and
   // insert unreachable. This shouldn't happen, but be safe.
@@ skipping 1034 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice