Start adding an integrated assembler.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent
 // subclasses.  The main classes are Variable, which represents an
 // LLVM variable that is either register- or stack-allocated, and the
 // Constant hierarchy, which represents integer, floating-point,
 // and/or symbolic constants.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class Operand {
 public:
   enum OperandKind {
     kConst_Base,
-    kConstInteger,
+    kConstInteger32,
+    kConstInteger64,
     kConstFloat,
     kConstDouble,
     kConstRelocatable,
     kConstUndef,
     kConst_Num,
     kVariable,
     // Target-specific operand classes use kTarget as the starting
     // point for their Kind enum space.
     kTarget
   };
@@ skipping 94 matching lines @@
 
 private:
   ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ConstantPrimitive(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   ConstantPrimitive &operator=(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   virtual ~ConstantPrimitive() {}
   const T Value;
 };
 
-typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger;
+typedef ConstantPrimitive<uint32_t, Operand::kConstInteger32> ConstantInteger32;
+typedef ConstantPrimitive<uint64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
-template <> inline void ConstantInteger::dump(GlobalContext *Ctx) const {
+template <> inline void ConstantInteger32::dump(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrDump();
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
-    Str << static_cast<int64_t>(getValue());
+    Str << static_cast<int32_t>(getValue());
+}
+
+template <> inline void ConstantInteger64::dump(GlobalContext *Ctx) const {
+  assert(getType() == IceType_i64);
+  Ostream &Str = Ctx->getStrDump();
+  Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
 class RelocatableTuple {
   RelocatableTuple &operator=(const RelocatableTuple &) LLVM_DELETED_FUNCTION;
 
 public:
@@ skipping 319 matching lines @@
   Variable *LoVar;
   Variable *HiVar;
   // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
   // this.
   Variable *VarsReal[1];
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H