Start adding an integrated assembler.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs ---*- 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 aspects of the compilation that persist across
@@ skipping 91 matching lines @@
 // The global constant pool bundles individual pools of each type of
 // interest.
 class ConstantPool {
   ConstantPool(const ConstantPool &) LLVM_DELETED_FUNCTION;
   ConstantPool &operator=(const ConstantPool &) LLVM_DELETED_FUNCTION;
 
 public:
   ConstantPool() {}
   TypePool<float, ConstantFloat, true> Floats;
   TypePool<double, ConstantDouble, true> Doubles;
-  TypePool<uint64_t, ConstantInteger> Integers;
+  TypePool<uint32_t, ConstantInteger32> Integers32;
+  TypePool<uint64_t, ConstantInteger64> Integers64;
   TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
   UndefPool Undefs;
 };
 
 GlobalContext::GlobalContext(llvm::raw_ostream *OsDump,
                              llvm::raw_ostream *OsEmit, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
@@ skipping 159 matching lines @@
     return NewName.data();
   }
 
   // Transform bar ==> Prefixbar
   //                   ^^^^^^
   return getTestPrefix() + Name;
 }
 
 GlobalContext::~GlobalContext() {}
 
-Constant *GlobalContext::getConstantInt(Type Ty, uint64_t ConstantInt64) {
+Constant *GlobalContext::getConstantInt64(Type Ty, uint64_t ConstantInt64) {
+  assert(Ty == IceType_i64);
+  return ConstPool->Integers64.getOrAdd(this, Ty, ConstantInt64);
+}
+
+Constant *GlobalContext::getConstantInt32(Type Ty, uint32_t ConstantInt32) {
   if (Ty == IceType_i1)
-    ConstantInt64 &= UINT64_C(1);
-  return ConstPool->Integers.getOrAdd(this, Ty, ConstantInt64);
+    ConstantInt32 &= UINT32_C(1);
+  return ConstPool->Integers32.getOrAdd(this, Ty, ConstantInt32);
 }
 
 Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
   return ConstPool->Floats.getOrAdd(this, IceType_f32, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
   return ConstPool->Doubles.getOrAdd(this, IceType_f64, ConstantDouble);
 }
 
 Constant *GlobalContext::getConstantSym(Type Ty, int64_t Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
   return ConstPool->Relocatables.getOrAdd(
       this, Ty, RelocatableTuple(Offset, Name, SuppressMangling));
 }
 
 Constant *GlobalContext::getConstantUndef(Type Ty) {
   return ConstPool->Undefs.getOrAdd(this, Ty);
 }
 
 Constant *GlobalContext::getConstantZero(Type Ty) {
   switch (Ty) {
   case IceType_i1:
   case IceType_i8:
   case IceType_i16:
   case IceType_i32:
+    return getConstantInt32(Ty, 0);
   case IceType_i64:
-    return getConstantInt(Ty, 0);
+    return getConstantInt64(Ty, 0);
   case IceType_f32:
     return getConstantFloat(0);
   case IceType_f64:
     return getConstantDouble(0);
   case IceType_v4i1:
   case IceType_v8i1:
   case IceType_v16i1:
   case IceType_v16i8:
   case IceType_v8i16:
   case IceType_v4i32:
   case IceType_v4f32: {
     IceString Str;
     llvm::raw_string_ostream BaseOS(Str);
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantPool(Type Ty) const {
   switch (Ty) {
   case IceType_i1:
   case IceType_i8:
   case IceType_i16:
   case IceType_i32:
+    return ConstPool->Integers32.getConstantPool();
   case IceType_i64:
-    return ConstPool->Integers.getConstantPool();
+    return ConstPool->Integers64.getConstantPool();
   case IceType_f32:
     return ConstPool->Floats.getConstantPool();
   case IceType_f64:
     return ConstPool->Doubles.getConstantPool();
   case IceType_v4i1:
   case IceType_v8i1:
   case IceType_v16i1:
   case IceType_v16i8:
   case IceType_v8i16:
   case IceType_v4i32:
@@ skipping 12 matching lines @@
 
 void Timer::printElapsedUs(GlobalContext *Ctx, const IceString &Tag) const {
   if (Ctx->isVerbose(IceV_Timing)) {
     // Prefixing with '#' allows timing strings to be included
     // without error in textual assembly output.
     Ctx->getStrDump() << "# " << getElapsedUs() << " usec " << Tag << "\n";
   }
 }
 
 } // end of namespace Ice