Add a few Subzero intrinsics (not the atomic ones yet).

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction 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 InstX8632 and OperandX8632 classes,
@@ skipping 32 matching lines @@
 } TypeX8632Attributes[] = {
 #define X(tag, cvt, sdss, width)                                               \
   { cvt, "" sdss, width }                                                      \
   ,
     ICETYPEX8632_TABLE
 #undef X
   };
 const size_t TypeX8632AttributesSize =
     llvm::array_lengthof(TypeX8632Attributes);
 
+const char *InstX8632SegmentRegNames[] = {
+#define X(val, name)                            \
+  name,
+    SEG_REGX8632_TABLE
+#undef X
+};
+const size_t InstX8632SegmentRegNamesSize =
+    llvm::array_lengthof(InstX8632SegmentRegNames);
+
 } // end of anonymous namespace
 
 const char *InstX8632::getWidthString(Type Ty) {
   return TypeX8632Attributes[Ty].WidthString;
 }
 
 OperandX8632Mem::OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base,
                                  Constant *Offset, Variable *Index,
                                  uint32_t Shift)
     : OperandX8632(kMem, Ty), Base(Base), Offset(Offset), Index(Index),
@@ skipping 78 matching lines @@
   addSource(Src0);
   addSource(Src1);
 }
 
 InstX8632Ucomiss::InstX8632Ucomiss(Cfg *Func, Operand *Src0, Operand *Src1)
     : InstX8632(Func, InstX8632::Ucomiss, 2, NULL) {
   addSource(Src0);
   addSource(Src1);
 }
 
+InstX8632UD2::InstX8632UD2(Cfg *Func)
+    : InstX8632(Func, InstX8632::UD2, 0, NULL) {
+}
+
 InstX8632Test::InstX8632Test(Cfg *Func, Operand *Src1, Operand *Src2)
     : InstX8632(Func, InstX8632::Test, 2, NULL) {
   addSource(Src1);
   addSource(Src2);
 }
 
 InstX8632Store::InstX8632Store(Cfg *Func, Operand *Value, OperandX8632 *Mem)
     : InstX8632(Func, InstX8632::Store, 2, NULL) {
   addSource(Value);
   addSource(Mem);
@@ skipping 357 matching lines @@
   getSrc(1)->emit(Func);
   Str << "\n";
 }
 
 void InstX8632Ucomiss::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "ucomiss." << getSrc(0)->getType() << " ";
   dumpSources(Func);
 }
 
+void InstX8632UD2::emit(const Cfg *Func) const {
+  Ostream &Str = Func->getContext()->getStrEmit();
+  assert(getSrcSize() == 0);
+  Str << "\tud2\n";
+}
+
+void InstX8632UD2::dump(const Cfg *Func) const {
+  Ostream &Str = Func->getContext()->getStrDump();
+  Str << "ud2\n";
+}
+
 void InstX8632Test::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Str << "\ttest\t";
   getSrc(0)->emit(Func);
   Str << ", ";
   getSrc(1)->emit(Func);
   Str << "\n";
 }
 
@@ skipping 281 matching lines @@
   if (!OffsetIsZero) { // Suppress if Offset is known to be 0
     if (Dumped) {
       if (!OffsetIsNegative) // Suppress if Offset is known to be negative
         Str << "+";
     }
     Offset->dump(Func);
   }
   Str << "]";
 }
 
+void OperandX8632MemOffSeg::emit(const Cfg *Func) const {
+  Ostream &Str = Func->getContext()->getStrEmit();
+  Str << TypeX8632Attributes[getType()].WidthString << " ";
+  assert(SegmentReg < InstX8632SegmentRegNamesSize);
+  Str << InstX8632SegmentRegNames[SegmentReg] << ":";
+  int64_t OffVal = 0;
+  if (ConstantInteger *CI = llvm::dyn_cast<ConstantInteger>(Offset)) {
+    OffVal = CI->getValue();
+  } else {
+    assert (Offset == NULL && "Offset should be NULL or ConstantInteger");
+    OffVal = 0;
+  }
+  Str << "[" << OffVal << "]";
+}
+
+void OperandX8632MemOffSeg::dump(const Cfg *Func) const {
+  // Same as emit for now.
+  emit(Func);
+}
+
 void VariableSplit::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(Var->getLocalUseNode() == NULL ||
          Var->getLocalUseNode() == Func->getCurrentNode());
   assert(!Var->hasReg());
   // The following is copied/adapted from TargetX8632::emitVariable().
   const TargetLowering *Target = Func->getTarget();
   const Type Ty = IceType_i32;
   Str << TypeX8632Attributes[Ty].WidthString << " ["
       << Target->getRegName(Target->getFrameOrStackReg(), Ty);
@@ skipping 20 matching lines @@
   default:
     Str << "???";
     break;
   }
   Str << "(";
   Var->dump(Func);
   Str << ")";
 }
 
 } // end of namespace Ice