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;
+}
+
+// Convert a vector to a list of strings.

[Jim Stichnoth, 2014/06/27 18:30:16]

Seems overly complicated to build up a StringList and then just iterate through
it and dump the elements.  Can you simplify by just passing an OStream&
argument?  (A slight function renaming would be in order too.)

[wala, 2014/06/27 21:09:19]

If it's being emitted directly to an Ostream, I could just inline all of this
into ConstantVector::dump.

+StringList getVectorRepr(const Vect128 &Vector, const Type Ty) {
+  StringList Repr;
+  const char *Window = Vector.data();
+
+  Type ElementType = typeElementType(Ty);
+  size_t NumElements = typeNumElements(Ty);
+
+  assert(Vector.size() == VECT128_BYTES);
+  assert(typeElementType(Ty) != IceType_i1);
+
+  for (unsigned I = 0; I < NumElements; ++I) {
+    IceString Result;
+    llvm::raw_string_ostream OS(Result);
+    switch (ElementType) {
+    default:
+      llvm_unreachable("Unknown element type");
+      break;
+    case IceType_i8:
+      OS << (unsigned)convertAndAdvance<uint8_t>(Window);
+      break;
+    case IceType_i16:
+      OS << convertAndAdvance<uint16_t>(Window);
+      break;
+    case IceType_i32:
+      OS << convertAndAdvance<uint32_t>(Window);
+      break;
+    case IceType_f32:
+      OS << convertAndAdvance<float>(Window);
+      break;
+    }
+    Repr.push_back(OS.str());
+  }
+
+  assert(Window == Vector.data() + 16);

[jvoung (off chromium), 2014/06/26 23:33:46]

Could use VECT128_BYTES here too.

+  return Repr;
+}
+}

[Jim Stichnoth, 2014/06/27 18:30:16]

"end of anonymous namespace" comment

+
+template <> void ConstantVector::dump(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrDump();
+  Type Ty = getType();
+  StringList Elements = getVectorRepr(Value, Ty);
+  Str << "<";
+  for (StringList::const_iterator I = Elements.begin(), E = Elements.end();
+       I != E;) {
+    Str << typeElementType(Ty) << " " << *I;
+    ++I;
+    Str << (I != E ? ", " : "");
+  }
+  Str << ">";
+}
+
+template <> void ConstantBitVector::dump(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrDump();
+  unsigned NumElements = typeNumElements(getType());
+  Str << "<";
+  for (unsigned I = 0; I != NumElements;) {

[Jim Stichnoth, 2014/06/27 18:30:16]

This loop would probably be more "natural" written like this:

for (unsigned I = 0; I < NumElements; ++I) {
  if (I > 0)
    Str << ", ";
  Str << "i1 " << (Value[I] ? "1" : "0");
}

Same for the ConstantVector::dump() loop above.

+    Str << "i1 " << (Value[I] ? "1" : "0");
+    ++I;
+    Str << (I != NumElements ? ", " : "");
+  }
+  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