Add support for vector types and vector constants.

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Operand class and its target-independent
@@ skipping 219 matching lines @@
   }
 }
 
 void ConstantRelocatable::dump(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrDump();
   Str << "@" << Name;
   if (Offset)
     Str << "+" << Offset;
 }
 
+namespace {
+
+// Read an item of type T and return it.  Advance the buffer pointer
+// by the size of T.
+template <typename T> T convertAndAdvance(const char *&Src) {
+  T Dest;
+  std::memcpy(&Dest, Src, sizeof(T));
+  Src += sizeof(T);
+  return Dest;
+}
+
+} // end anonymous namespace
+
+template <> void ConstantVector::dump(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrDump();
+
+  Type Ty = getType();
+  const char *Window = Value.data();
+
+  Type ElementType = typeElementType(Ty);
+  size_t NumElements = typeNumElements(Ty);
+
+  assert(Value.size() == VECT128_BYTES);
+  assert(typeElementType(Ty) != IceType_i1);
+
+  Str << "<";
+  for (unsigned I = 0; I < NumElements; ++I) {
+    if (I > 0)
+      Str << ", ";
+    Str << ElementType << " ";
+    switch (ElementType) {
+    default:
+      llvm_unreachable("Unknown element type");
+      break;
+    case IceType_i8:
+      Str << (unsigned)convertAndAdvance<uint8_t>(Window);
+      break;
+    case IceType_i16:
+      Str << convertAndAdvance<uint16_t>(Window);
+      break;
+    case IceType_i32:
+      Str << convertAndAdvance<uint32_t>(Window);
+      break;
+    case IceType_f32:
+      Str << convertAndAdvance<float>(Window);
+      break;
+    }
+  }
+  assert(Window == Value.data() + VECT128_BYTES);
+  Str << ">";
+}
+
+template <> void ConstantBitVector::dump(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrDump();
+  unsigned NumElements = typeNumElements(getType());
+  Str << "<";
+  for (unsigned I = 0; I < NumElements; ++I) {
+    if (I > 0)
+      Str << ", ";
+    Str << "i1 " << (Value[I] ? "1" : "0");
+  }
+  Str << ">";
+}
+
 void LiveRange::dump(Ostream &Str) const {
   Str << "(weight=" << Weight << ") ";
   for (RangeType::const_iterator I = Range.begin(), E = Range.end(); I != E;
        ++I) {
     if (I != Range.begin())
       Str << ", ";
     Str << "[" << (*I).first << ":" << (*I).second << ")";
   }
 }
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L) {
   L.dump(Str);
   return Str;
 }
 
 Ostream &operator<<(Ostream &Str, const RegWeight &W) {
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 } // end of namespace Ice