Update Subzero to start parsing PNaCl bitcode files.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        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 LLVM to ICE converter.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceConverter.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
+#include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceInst.h"
 #include "IceOperand.h"
-#include "IceTargetLowering.h"
 #include "IceTypes.h"
 
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 
@@ skipping 576 matching lines @@
 private:
   // Data
   Ice::GlobalContext *Ctx;
   Ice::Cfg *Func;
   Ice::CfgNode *CurrentNode;
   Ice::Type SubzeroPointerType;
   std::map<const Value *, Ice::Variable *> VarMap;
   std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
 };
 
-}
+} // end of anonymous namespace.
 
 int Ice::Converter::convertToIce(llvm::Module *Mod) {
-  int ExitStatus = 0;
-
-  // Ideally, Func would be declared inside the loop and its object
-  // would be automatically deleted at the end of the loop iteration.
-  // However, emitting the constant pool requires a valid Cfg object,
-  // so we need to defer deleting the last non-empty Cfg object until
-  // outside the loop and after emitting the constant pool.  TODO:
-  // Since all constants are globally pooled in the Ice::GlobalContext
-  // object, change all Ice::Constant related functions to use
-  // GlobalContext instead of Cfg, and then clean up this loop.
-  OwningPtr<Ice::Cfg> Func;
-
   for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
     if (I->empty())
       continue;
     LLVM2ICEConverter FunctionConverter(Ctx);
 
     Ice::Timer TConvert;
-    Func.reset(FunctionConverter.convertFunction(I));
-    if (DisableInternal)
-      Func->setInternal(false);
-
-    if (SubzeroTimingEnabled) {
+    Ice::Cfg *Fcn = FunctionConverter.convertFunction(I);
+    if (Flags.SubzeroTimingEnabled) {
       std::cerr << "[Subzero timing] Convert function "
-                << Func->getFunctionName() << ": " << TConvert.getElapsedSec()
+                << Fcn->getFunctionName() << ": " << TConvert.getElapsedSec()
                 << " sec\n";
     }
-
-    if (DisableTranslation) {
-      Func->dump();
-    } else {
-      Ice::Timer TTranslate;
-      Func->translate();
-      if (SubzeroTimingEnabled) {
-        std::cerr << "[Subzero timing] Translate function "
-                  << Func->getFunctionName() << ": "
-                  << TTranslate.getElapsedSec() << " sec\n";
-      }
-      if (Func->hasError()) {
-        errs() << "ICE translation error: " << Func->getError() << "\n";
-        ExitStatus = 1;
-      }
-
-      Ice::Timer TEmit;
-      Func->emit();
-      if (SubzeroTimingEnabled) {
-        std::cerr << "[Subzero timing] Emit function "
-                  << Func->getFunctionName() << ": " << TEmit.getElapsedSec()
-                  << " sec\n";
-      }
-    }
+    translateFcn(Fcn);
   }
 
-  if (!DisableTranslation && Func)
-    Func->getTarget()->emitConstants();
-
+  emitConstants();
   return ExitStatus;
 }