Update Subzero to start parsing PNaCl bitcode files.

Makefile.standalone

@@ -30,7 +30,7 @@ LLVM_LDFLAGS := `$(LLVM_BIN_PATH)/llvm-config --ldflags --libs`
 OPTLEVEL := -O0
 CXX := g++
 CXXFLAGS := -Wall -Wextra -Werror -fno-rtti -fno-exceptions \
-	$(OPTLEVEL) -g $(LLVM_CXXFLAGS) -m32
+	$(OPTLEVEL) -g $(LLVM_CXXFLAGS) -m32 -Wno-error=unused-parameter
 LDFLAGS := -m32
 
 SRCS= \
@@ -46,8 +46,10 @@ SRCS= \
 	IceRegAlloc.cpp \
 	IceTargetLowering.cpp \
 	IceTargetLoweringX8632.cpp \
+	IceTranslator.cpp \
 	IceTypes.cpp \
-	llvm2ice.cpp
+	llvm2ice.cpp \
+	PNaClTranslator.cpp
 
 OBJS=$(patsubst %.cpp, build/%.o, $(SRCS))
 

src/IceClFlags.h

+//===- subzero/src/IceClFlags.h - Cl Flags for translation ------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares command line flags controlling translation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_ICECLFLAGS_H
+#define SUBZERO_SRC_ICECLFLAGS_H
+
+namespace Ice {
+
+class ClFlags {
+public:
+  ClFlags()
+      : DisableInternal(false), SubzeroTimingEnabled(false),
+        DisableTranslation(false) {}
+  bool DisableInternal;
+  bool SubzeroTimingEnabled;
+  bool DisableTranslation;
+};
+}
+
+#endif // SUBZERO_SRC_ICECLFLAGS_H

src/IceConverter.cpp

@@ -15,11 +15,11 @@
 
 #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"
@@ -616,64 +616,24 @@ private:
   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;
 }

src/IceConverter.h

@@ -14,7 +14,7 @@
 #ifndef SUBZERO_SRC_ICECONVERTER_H
 #define SUBZERO_SRC_ICECONVERTER_H
 
-#include "IceGlobalContext.h"
+#include "IceTranslator.h"
 
 namespace llvm {
 class Module;
@@ -22,27 +22,17 @@ class Module;
 
 namespace Ice {
 
-class Converter {
+class Converter : public Translator {
 public:
-  Converter(Ice::GlobalContext *Ctx,
-            bool DisableInternal,
-            bool SubzeroTimingEnabled,
-            bool DisableTranslation)
-      : Ctx(Ctx),
-        DisableInternal(DisableInternal),
-        SubzeroTimingEnabled(SubzeroTimingEnabled),
-        DisableTranslation(DisableTranslation)
-  {}
+  Converter(GlobalContext *Ctx, Ice::ClFlags &Flags) : Translator(Ctx, Flags) {}
   /// Converts the LLVM Module to ICE. Returns exit status 0 if successful,
   /// Nonzero otherwise.
   int convertToIce(llvm::Module *Mod);
+
 private:
-  Ice::GlobalContext *Ctx;
-  bool DisableInternal;
-  bool SubzeroTimingEnabled;
-  bool DisableTranslation;
+  Converter(const Converter &) LLVM_DELETED_FUNCTION;
+  Converter &operator=(const Converter &) LLVM_DELETED_FUNCTION;
 };
-
 }
 
-#endif  // SUBZERO_SRC_ICECONVERTER_H
+#endif // SUBZERO_SRC_ICECONVERTER_H

src/IceTranslator.cpp

+//===- subzero/src/IceTranslator.cpp - ICE to machine code ------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the general driver class for translating ICE to
+// machine code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "IceTranslator.h"
+
+#include "IceCfg.h"
+#include "IceClFlags.h"
+#include "IceTargetLowering.h"
+
+#include <iostream>
+
+using namespace Ice;
+
+Translator::~Translator() {}
+
+void Translator::translateFcn(Ice::Cfg *Fcn) {
+  Func.reset(Fcn);
+  if (Flags.DisableInternal)
+    Func->setInternal(false);
+  if (Flags.DisableTranslation) {
+    Func->dump();
+  } else {
+    Ice::Timer TTranslate;
+    Func->translate();
+    if (Flags.SubzeroTimingEnabled) {
+      std::cerr << "[Subzero timing] Translate function "
+                << Func->getFunctionName() << ": " << TTranslate.getElapsedSec()
+                << " sec\n";
+    }
+    if (Func->hasError()) {
+      std::cerr << "ICE translation error: " << Func->getError() << "\n";
+      ExitStatus = 1;
+    }
+
+    Ice::Timer TEmit;
+    Func->emit();
+    if (Flags.SubzeroTimingEnabled) {
+      std::cerr << "[Subzero timing] Emit function " << Func->getFunctionName()
+                << ": " << TEmit.getElapsedSec() << " sec\n";
+    }
+  }
+}
+
+void Translator::emitConstants() {
+  if (!Flags.DisableTranslation && Func)
+    Func->getTarget()->emitConstants();
+}

src/IceTranslator.h

+//===- subzero/src/IceTranslator.h - ICE to machine code --------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the general driver class for translating ICE to
+// machine code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_ICETRANSLATOR_H
+#define SUBZERO_SRC_ICETRANSLATOR_H
+
+#include "llvm/ADT/OwningPtr.h"
+
+namespace Ice {
+
+class ClFlags;
+class Cfg;
+class GlobalContext;
+
+// Base class for translating ICE to machine code.
+// Derived classes convert other intermediate representations down to ICE,
+// and then call the appropriate (inherited) methods to convert ICE into
+// machine instructions.
+class Translator {
+public:
+  Translator(GlobalContext *Ctx, ClFlags &Flags)
+      : Ctx(Ctx), Flags(Flags), ExitStatus(0) {}
+
+  ~Translator();
+  int getExitStatus() const { return ExitStatus; }
+
+protected:
+  GlobalContext *Ctx;
+  ClFlags &Flags;
+  // The exit status of the translation. 0 is successful. Nonzero
+  // otherwise.
+  bool ExitStatus;
+  // Ideally, Func would be inside the methods that converts IR to
+  // functions.  However, emitting the constant pool requires a valid
+  // Cfg object, so we need to defer deleting the last non-empty Cfg
+  // object to emit the constant pool (via emitConstants). TODO:
+  // Since all constants are globally pooled in the GlobalContext
+  // object, change all Constant related functions to use
+  // GlobalContext instead of Cfg, and then make emitConstantPool use
+  // that.
+  llvm::OwningPtr<Cfg> Func;
+
+  /// Translates the constructed ICE function Fcn to machine code.
+  /// Note: As a side effect, Field Func is set to Fcn.
+  void translateFcn(Cfg *Fcn);
+
+  /// Emits the constant pool.
+  void emitConstants();
+
+private:
+  Translator(const Translator &) LLVM_DELETED_FUNCTION;
+  Translator &operator=(const Translator &) LLVM_DELETED_FUNCTION;
+};
+}
+
+#endif // SUBZERO_SRC_ICETRANSLATOR_H

src/PNaClTranslator.h

+//===- subzero/src/PNaClTranslator.h - ICE from bitcode ---------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the PNaCl bitcode file to ICE, to machine code
+// translator.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_PNACLTRANSLATOR_H
+#define SUBZERO_SRC_PNACLTRANSLATOR_H
+
+#include "IceTranslator.h"
+#include <string>
+
+namespace Ice {
+
+class PNaClTranslator : public Translator {
+public:
+  PNaClTranslator(GlobalContext *Ctx, ClFlags &Flags)
+      : Translator(Ctx, Flags) {}
+  // Reads the PNaCl bitcode file and translates to ICE, which is then
+  // converted to machine code. Sets ExitStatus to non-zero if any
+  // errors occurred.
+  void translate(const std::string &IRFilename);
+
+private:
+  PNaClTranslator(const PNaClTranslator &) LLVM_DELETED_FUNCTION;
+  PNaClTranslator &operator=(const PNaClTranslator &) LLVM_DELETED_FUNCTION;
+};
+}
+
+#endif // SUBZERO_SRC_PNACLTRANSLATOR_H

src/llvm2ice.cpp

@@ -14,12 +14,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "IceCfg.h"
+#include "IceClFlags.h"
 #include "IceConverter.h"
 #include "IceDefs.h"
 #include "IceTargetLowering.h"
 #include "IceTypes.h"
+#include "PNaClTranslator.h"
 
-#include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
@@ -128,9 +129,15 @@ int main(int argc, char **argv) {
 
   Ice::GlobalContext Ctx(Ls, Os, VMask, TargetArch, OptLevel, TestPrefix);
 
+  Ice::ClFlags Flags;
+  Flags.DisableInternal = DisableInternal;
+  Flags.SubzeroTimingEnabled = SubzeroTimingEnabled;
+  Flags.DisableTranslation = DisableTranslation;
+
   if (BuildOnRead) {
-    std::cerr << "Direct build from bitcode not implemented yet!\n";
-    return 1;
+    Ice::PNaClTranslator Translator(&Ctx, Flags);
+    Translator.translate(IRFilename);
+    return Translator.getExitStatus();
   } else {
     // Parse the input LLVM IR file into a module.
     SMDiagnostic Err;
@@ -189,8 +196,7 @@ int main(int argc, char **argv) {
     }
     GlobalLowering.reset();
 
-    Ice::Converter Converter(&Ctx, DisableInternal, SubzeroTimingEnabled,
-                             DisableTranslation);
+    Ice::Converter Converter(&Ctx, Flags);
     return Converter.convertToIce(Mod);
   }
 }