Add support for vector types and vector constants.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        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 TargetLoweringX8632 class, which
@@ skipping 67 matching lines @@
 #undef X
   };
 const size_t TableIcmp64Size = llvm::array_lengthof(TableIcmp64);
 
 InstX8632Br::BrCond getIcmp32Mapping(InstIcmp::ICond Cond) {
   size_t Index = static_cast<size_t>(Cond);
   assert(Index < TableIcmp32Size);
   return TableIcmp32[Index].Mapping;
 }
 
+// Returns the type name as a valid assembly label.
+IceString typeAsmLabel(Type Ty) {
+  IceString Result;
+  llvm::raw_string_ostream BaseOS(Result);
+  Ostream OS(&BaseOS);
+  unsigned NumElements = typeNumElements(Ty);
+  if (NumElements > 1) {
+    OS << "v" << NumElements;
+  }
+  OS << typeElementType(Ty);
+  return BaseOS.str();
+}
+
 // In some cases, there are x-macros tables for both high-level and
 // low-level instructions/operands that use the same enum key value.
 // The tables are kept separate to maintain a proper separation
 // between abstraction layers.  There is a risk that the tables
 // could get out of sync if enum values are reordered or if entries
 // are added or deleted.  This dummy function uses static_assert to
 // ensure everything is kept in sync.
 void xMacroIntegrityCheck() {
   // Validate the enum values in FCMPX8632_TABLE.
   {
@@ skipping 55 matching lines @@
   {
     // Define a temporary set of enum values based on low-level
     // table entries.
     enum _tmp_enum {
 #define X(tag, cvt, sdss, width) _tmp_##tag,
       ICETYPEX8632_TABLE
 #undef X
           _num
     };
 // Define a set of constants based on high-level table entries.
-#define X(tag, size, align, str) static const int _table1_##tag = tag;
+#define X(tag, size, align, elts, elty, str)                                   \
+  static const int _table1_##tag = tag;
     ICETYPE_TABLE;
 #undef X
 // Define a set of constants based on low-level table entries,
 // and ensure the table entry keys are consistent.
 #define X(tag, cvt, sdss, width)                                               \
   static const int _table2_##tag = _tmp_##tag;                                 \
   STATIC_ASSERT(_table1_##tag == _table2_##tag);
     ICETYPEX8632_TABLE;
 #undef X
 // Repeat the static asserts with respect to the high-level
 // table entries in case the high-level table has extra entries.
-#define X(tag, size, align, str) STATIC_ASSERT(_table1_##tag == _table2_##tag);
+#define X(tag, size, align, elts, elty, str)                                   \
+  STATIC_ASSERT(_table1_##tag == _table2_##tag);
     ICETYPE_TABLE;
 #undef X
   }
 }
 
 } // end of anonymous namespace
 
 TargetX8632::TargetX8632(Cfg *Func)
     : TargetLowering(Func), IsEbpBasedFrame(false), FrameSizeLocals(0),
       LocalsSizeBytes(0), NextLabelNumber(0), ComputedLiveRanges(false),
@@ skipping 488 matching lines @@
   typedef ConstantDouble IceType;
   static const Type Ty = IceType_f64;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<double>::TypeName = "double";
 const char *PoolTypeConverter<double>::AsmTag = ".quad";
 const char *PoolTypeConverter<double>::PrintfString = "0x%llx";
 
-template <typename T> void TargetX8632::emitConstantPool() const {
+template <typename T> void TargetX8632::emitScalarConstantPool() const {
   Ostream &Str = Ctx->getStrEmit();
   Type Ty = T::Ty;
   SizeT Align = typeAlignInBytes(Ty);
   ConstantList Pool = Ctx->getConstantPool(Ty);
 
   Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
       << "\n";
   Str << "\t.align\t" << Align << "\n";
   for (ConstantList::const_iterator I = Pool.begin(), E = Pool.end(); I != E;
        ++I) {
     typename T::IceType *Const = llvm::cast<typename T::IceType>(*I);
     typename T::PrimitiveFpType Value = Const->getValue();
     // Use memcpy() to copy bits from Value into RawValue in a way
     // that avoids breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0 &&
            (size_t)CharsPrinted < llvm::array_lengthof(buf));
     (void)CharsPrinted; // avoid warnings if asserts are disabled
     Str << "L$" << Ty << "$" << Const->getPoolEntryID() << ":\n";
     Str << "\t" << T::AsmTag << "\t" << buf << "\t# " << T::TypeName << " "
         << Value << "\n";
   }
 }
 
+void TargetX8632::emitVectorConstantPool() const {
+  Ostream &Str = Ctx->getStrEmit();
+  Str << "\t.section\t.rodata.cst" << 16 << ",\"aM\",@progbits," << 16 << "\n";
+  Str << "\t.align\t" << 16 << "\n";
+
+  // Emit each (128 bit) vector.
+  ConstantList Vectors = Ctx->getConstantPool(IceType_v8i16);
+  for (ConstantList::const_iterator I = Vectors.begin(), E = Vectors.end();
+       I != E; ++I) {
+    ConstantVector *Vector = llvm::cast<ConstantVector>(*I);
+    Vect128 Value = Vector->getValue();
+    assert(Value.size() == 16);
+    const char *Data = Value.data();
+    Str << "L$" << typeAsmLabel(Vector->getType()) << "$"
+        << Vector->getPoolEntryID() << ":\n";
+    for (unsigned Element = 0; Element != 4; ++Element) {
+      uint32_t RawValue;
+      memcpy(&RawValue, &Data[4 * Element], 4);
+      char buf[30];
+      int CharsPrinted =
+          snprintf(buf, llvm::array_lengthof(buf), "0x%x", RawValue);
+      assert(CharsPrinted >= 0 &&
+             (size_t)CharsPrinted < llvm::array_lengthof(buf));
+      Str << "\t"
+          << ".long"
+          << "\t" << buf << "\t"
+          << "\n";
+    }
+  }
+
+  // Emit each I1 vector expanded to a 128 bit constant.
+  ConstantList BitVectors = Ctx->getConstantPool(IceType_v4i1);
+  for (ConstantList::const_iterator I = BitVectors.begin(),
+                                    E = BitVectors.end();
+       I != E; ++I) {
+    ConstantBitVector *BitVector = llvm::cast<ConstantBitVector>(*I);
+    BitVect Value = BitVector->getValue();
+    Str << "L$" << typeAsmLabel(BitVector->getType()) << "$"
+        << BitVector->getPoolEntryID() << ":\n";
+    const char *AsmString = NULL;
+    switch (BitVector->getType()) {
+    default:
+      llvm_unreachable("Unknown type");
+    case IceType_v4i1:
+      AsmString = ".long";
+      break;
+    case IceType_v8i1:
+      AsmString = ".short";
+      break;
+    case IceType_v16i1:
+      AsmString = ".byte";
+      break;
+    }
+    unsigned NumElements = Value.size();
+    for (unsigned Element = 0; Element != NumElements; ++Element) {
+      Str << "\t" << AsmString << "\t"
+          << "0x";
+      Str << (Value[Element] ? "1" : "0");
+      Str << "\t"
+          << "\n";
+    }
+  }
+}
+
 void TargetX8632::emitConstants() const {
-  emitConstantPool<PoolTypeConverter<float> >();
-  emitConstantPool<PoolTypeConverter<double> >();
+  emitScalarConstantPool<PoolTypeConverter<float> >();
+  emitScalarConstantPool<PoolTypeConverter<double> >();
+  emitVectorConstantPool();
 
   // No need to emit constants from the int pool since (for x86) they
   // are embedded as immediates in the instructions.
 }
 
 void TargetX8632::split64(Variable *Var) {
   switch (Var->getType()) {
   default:
     return;
   case IceType_i64:
@@ skipping 564 matching lines @@
     }
     StackOffset += typeWidthInBytesOnStack(Arg->getType());
   }
   // Generate the call instruction.  Assign its result to a temporary
   // with high register allocation weight.
   Variable *Dest = Instr->getDest();
   Variable *eax = NULL; // doubles as RegLo as necessary
   Variable *edx = NULL;
   if (Dest) {
     switch (Dest->getType()) {
+    case IceType_v4i1:
+    case IceType_v8i1:
+    case IceType_v16i1:
+    case IceType_v16i8:
+    case IceType_v8i16:
+    case IceType_v4i32:
+    case IceType_v4f32:
     case IceType_NUM:
       llvm_unreachable("Invalid Call dest type");
       break;
     case IceType_void:
       break;
     case IceType_i1:
     case IceType_i8:
     case IceType_i16:
     case IceType_i32:
       eax = makeReg(Dest->getType(), Reg_eax);
@@ skipping 954 matching lines @@
   if (Inst->hasRetValue()) {
     Operand *Src0 = legalize(Inst->getRetValue());
     if (Src0->getType() == IceType_i64) {
       Variable *eax = legalizeToVar(loOperand(Src0), false, Reg_eax);
       Variable *edx = legalizeToVar(hiOperand(Src0), false, Reg_edx);
       Reg = eax;
       Context.insert(InstFakeUse::create(Func, edx));
     } else if (Src0->getType() == IceType_f32 ||
                Src0->getType() == IceType_f64) {
       _fld(Src0);
+    } else if (typeNumElements(Src0->getType()) > 1) {
+      _mov(Reg, Src0, Reg_xmm0);

[jvoung (off chromium), 2014/06/26 00:45:41]

See question about reusing _mov or having a separate _movp

     } else {
       _mov(Reg, Src0, Reg_eax);
     }
   }
   _ret(Reg);
   // Add a fake use of esp to make sure esp stays alive for the entire
   // function.  Otherwise post-call esp adjustments get dead-code
   // eliminated.  TODO: Are there more places where the fake use
   // should be inserted?  E.g. "void f(int n){while(1) g(n);}" may not
   // have a ret instruction.
@@ skipping 156 matching lines @@
       // values to uninitialized registers, a FakeDef will be needed:
       //     Context.insert(InstFakeDef::create(Func, Reg));
       // This is in order to ensure that the live range of Reg is not
       // overestimated.  If the constant being lowered is a 64 bit value,
       // then the result should be split and the lo and hi components will
       // need to go in uninitialized registers.
       From = Ctx->getConstantZero(From->getType());
     }
     bool NeedsReg =
         !(Allowed & Legal_Imm) ||
-        // ConstantFloat and ConstantDouble are actually memory operands.
+        // ConstantFloat, ConstantDouble, and vector constants are
+        // actually memory operands.
         (!(Allowed & Legal_Mem) &&
-         (From->getType() == IceType_f32 || From->getType() == IceType_f64));
+         (From->getType() == IceType_f32 || From->getType() == IceType_f64 ||
+          typeNumElements(From->getType()) > 1));
     if (NeedsReg) {
       Variable *Reg = makeReg(From->getType(), RegNum);
       _mov(Reg, From);
       From = Reg;
     }
     return From;
   }
   if (Variable *Var = llvm::dyn_cast<Variable>(From)) {
     // We need a new physical register for the operand if:
     //   Mem is not allowed and Var->getRegNum() is unknown, or
@@ skipping 99 matching lines @@
         }
         assert(AvailableTypedRegisters.any());
         int32_t RegNum = AvailableTypedRegisters.find_first();
         Var->setRegNum(RegNum);
         AvailableRegisters[RegNum] = false;
       }
     }
   }
 }
 
+template <> void ConstantInteger::emit(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrEmit();
+  Str << getValue();
+}
+
 template <> void ConstantFloat::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   // It would be better to prefix with ".L$" instead of "L$", but
   // llvm-mc doesn't parse "dword ptr [.L$foo]".
   Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
 }
 
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
 }
 
+template <> void ConstantVector::emit(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrEmit();
+  Str << "xmmword ptr [L$" << typeAsmLabel(getType()) << "$" << getPoolEntryID()
+      << "]";
+}
+
+template <> void ConstantBitVector::emit(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrEmit();
+  Str << "xmmword ptr [L$" << typeAsmLabel(getType()) << "$" << getPoolEntryID()
+      << "]";
+}
+
 } // end of namespace Ice