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

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

nit: keep the period at the end of the sentence.

 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();
-  }
+  virtual void emit(GlobalContext *Ctx) const { (void)Ctx; }

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

Assuming this is just a stub that the target lowering is expected to
reimplement, can we just declare and not define the method, so that a missing
target definition causes a link error?  Or at least, make the implementation a
call to llvm_unreachable().

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

Just declaring it works. There is enough variation in what the emit method needs
to do that there isn't much sense in a default implementation of emit(). I'll
also leave a comment that the target needs to specialize the emit() method for
each particular constant value, as I was unsure at first about why there was a
specialization implemented in TargetLoweringX8632.cpp.

[Jim Stichnoth, 2014/06/27 23:11:05]

Thanks.  I think it was the original way before I moved some of the emit stuff
into the target lowering, and I didn't come back to clean it up.

+
   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