Update Subzero to start parsing PNaCl bitcode files.

src/IceTranslator.h

+//===- subzero/src/IceTranslator.h - Translate IR to ICE --------*- 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 IR to ICE.

[jvoung (off chromium), 2014/07/01 17:32:52]

Clarify what IR to ICE? I guess it has to be serialized bitcode IR, but both
LLVM flavor and PNaCl flavor?

Does it do more than just translate IR to ICE? Also translate ICE to machine
code?

[Karl, 2014/07/01 21:31:06]

Rewrote this to try and be more clear.

[jvoung (off chromium), 2014/07/02 17:00:15]

For this one-line summary, it feels like this class should be described as an
ICE -> Machine code translator. (Also the one-line summary at the top/first line
of this file, and the .cpp file).

After all, that's all it exposes as an API. Some derived class conjures a Cfg,
then calls translateFcn(Cfg) or emitConstants().

Your later description makes sense though ("Base class for translating ICE to
machine code").

[Karl, 2014/07/02 18:09:54]

Good point. Fixing.

+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_ICETRANSLATOR_H
+#define SUBZERO_SRC_ICETRANSLATOR_H
+
+#include "IceCfg.h"
+#include "IceClFlags.h"
+#include "IceGlobalContext.h"

[jvoung (off chromium), 2014/07/01 17:32:52]

Could probably fwd declare the IceGlobalContext class.

I think usually Jim just #include "IceDefs.h", which has a bunch of the fwd
declarations... but that also means that if you modify IceDefs.h you have to
recompile everything.

[Karl, 2014/07/01 21:31:06]

Removing unnecessary includes.

+#include "llvm/ADT/OwningPtr.h"
+
+namespace Ice {
+
+// Base class for translating IR to ICE. The input IR is handled by
+// derived classes. This code assumes that derived classes define one
+// (or more) methods to translate the input IR. Whenever a function is
+// converted to ICE, these methods call translateFcn to finish the
+// translation.
+class Translator {
+public:
+  Translator(Ice::GlobalContext *Ctx, Ice::ClFlags &Flags)
+      : Ctx(Ctx),
+        Flags(Flags),
+        ExitStatus(0) {}
+
+  ~Translator();
+
+protected:
+  Ice::GlobalContext *Ctx;
+  Ice::ClFlags &Flags;
+  // The exit status of the translation. 0 is successful. Nonzero
+  // otherwise.
+  int 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 Ice::GlobalContext
+  // object, change all Ice::Constant related functions to use
+  // GlobalContext instead of Cfg, and then make emitConstantPool use
+  // that.
+  llvm::OwningPtr<Ice::Cfg> Func;
+
+  /// Translates the constructed ICE function Fcn to machine code.
+  /// Note: As a side effect, Field Func is set to Fcn.
+  void translateFcn(Ice::Cfg *Fcn);
+
+  /// Emits the constant pool.
+  void emitConstants();
+};
+
+}
+
+#endif  // SUBZERO_SRC_ICETRANSLATOR_H