Add support for vector types and vector constants.

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
@@ skipping 14 matching lines @@
 
 class Operand {
 public:
   enum OperandKind {
     kConst_Base,
     kConstInteger,
     kConstFloat,
     kConstDouble,
     kConstRelocatable,
     kConstUndef,
+    kConstVector,
+    kConstBitVector,
     kConst_Num,
     kVariable,
     // Target-specific operand classes use kTarget as the starting
     // point for their Kind enum space.
     kTarget
   };
   OperandKind getKind() const { return Kind; }
   Type getType() const { return Ty; }
 
   // Every Operand keeps an array of the Variables referenced in
@@ skipping 57 matching lines @@
   // PoolEntryID is an integer that uniquely identifies the constant
   // within its constant pool.  It is used for building the constant
   // pool in the object code and for referencing its entries.
   const uint32_t PoolEntryID;
 
 private:
   Constant(const Constant &) LLVM_DELETED_FUNCTION;
   Constant &operator=(const Constant &) LLVM_DELETED_FUNCTION;
 };
 
-// ConstantPrimitive<> wraps a primitive type.
+// ConstantValue<> wraps a concrete constant value.
 template <typename T, Operand::OperandKind K>
-class ConstantPrimitive : public Constant {
+class ConstantValue : public Constant {
 public:
-  static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty, T Value,
-                                   uint32_t PoolEntryID) {
-    return new (Ctx->allocate<ConstantPrimitive>())
-        ConstantPrimitive(Ty, Value, PoolEntryID);
+  static ConstantValue *create(GlobalContext *Ctx, Type Ty, T Value,
+                               uint32_t PoolEntryID) {
+    return new (Ctx->allocate<ConstantValue>())
+        ConstantValue(Ty, Value, PoolEntryID);
   }
   T getValue() const { return Value; }
+
   using Constant::emit;
-  virtual void emit(GlobalContext *Ctx) const {
-    Ostream &Str = Ctx->getStrEmit();
-    Str << getValue();
-  }
+  // The target needs to implement this for each ConstantValue
+  // specialization.
+  virtual void emit(GlobalContext *Ctx) const;
+
   using Constant::dump;
   virtual void dump(GlobalContext *Ctx) const {
     Ostream &Str = Ctx->getStrDump();
     Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
 private:
-  ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
+  ConstantValue(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() {}
+  ConstantValue(const ConstantValue &) LLVM_DELETED_FUNCTION;
+  ConstantValue &operator=(const ConstantValue &) LLVM_DELETED_FUNCTION;
+  virtual ~ConstantValue() {}
   const T Value;
 };
 
-typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger;
-typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
-typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
+// Wrappers for primitive types
+typedef ConstantValue<uint64_t, Operand::kConstInteger> ConstantInteger;
+typedef ConstantValue<float, Operand::kConstFloat> ConstantFloat;
+typedef ConstantValue<double, Operand::kConstDouble> ConstantDouble;
+
+// ConstantVector wraps a 128 bit value.
+typedef ConstantValue<Vect128, Operand::kConstVector> ConstantVector;
+template <> void ConstantVector::dump(GlobalContext *Ctx) const;
+
+// ConstantBitVector wraps a vector of I1s.
+typedef ConstantValue<BitVect, Operand::kConstBitVector> ConstantBitVector;
+template <> void ConstantBitVector::dump(GlobalContext *Ctx) const;
 
 // 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:
   RelocatableTuple(const int64_t Offset, const IceString &Name,
@@ skipping 305 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