Add support for vector types and vector constants.

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 90 matching lines @@
 // 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<Vect128, ConstantVector> Vectors;
+  TypePool<BitVect, ConstantBitVector> BitVectors;
   TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
   UndefPool Undefs;
 };
 
 GlobalContext::GlobalContext(llvm::raw_ostream *OsDump,
                              llvm::raw_ostream *OsEmit, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
@@ skipping 81 matching lines @@
 }
 
 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::getConstantVector(Type Ty, const Vect128 &Vector) {
+  return ConstPool->Vectors.getOrAdd(this, Ty, Vector);
+}
+
+Constant *GlobalContext::getConstantBitVector(Type Ty, const BitVect &Vector) {
+  return ConstPool->BitVectors.getOrAdd(this, Ty, Vector);
+}

[JF, 2014/06/30 17:48:50]

You should never have constant <? x i1> bit vectors loaded or stored: the PNaCl
ABI doesn't allow it. I think this should be an error condition.

[wala, 2014/06/30 22:13:24]

See comment in llvm2ice.cpp.

In addition, undefs are represented as zeros which by default are pooled. There
is way to avoid this for vector types so that we do not need constant pools that
hold zero vectors.

+
 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:
   case IceType_i64:
     return getConstantInt(Ty, 0);
   case IceType_f32:
     return getConstantFloat(0);
   case IceType_f64:
     return getConstantDouble(0);
+  case IceType_v4i1:
+  case IceType_v8i1:
+  case IceType_v16i1: {
+    BitVect Zeros(typeNumElements(Ty));
+    return getConstantBitVector(Ty, Zeros);
+  }
+  case IceType_v16i8:
+  case IceType_v8i16:
+  case IceType_v4i32:
+  case IceType_v4f32: {
+    Vect128 Zeros(16);
+    return getConstantVector(Ty, Zeros);
+  }
   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:
   case IceType_i64:
     return ConstPool->Integers.getConstantPool();
   case IceType_f32:
     return ConstPool->Floats.getConstantPool();
   case IceType_f64:
     return ConstPool->Doubles.getConstantPool();
+  case IceType_v4i1:
+  case IceType_v8i1:
+  case IceType_v16i1:
+    return ConstPool->BitVectors.getConstantPool();

[JF, 2014/06/30 17:48:50]

Same comment, this shouldn't happen.

[wala, 2014/06/30 22:13:24]

Done.

+  case IceType_v16i8:
+  case IceType_v8i16:
+  case IceType_v4i32:
+  case IceType_v4f32:
+    return ConstPool->Vectors.getConstantPool();
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
 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