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)
+                                 uint16_t Shift, SegmentRegisters SegmentReg)
     : OperandX8632(kMem, Ty), Base(Base), Offset(Offset), Index(Index),
-      Shift(Shift) {
+      Shift(Shift), SegmentReg(SegmentReg) {
   assert(Shift <= 3);
   Vars = NULL;
   NumVars = 0;
   if (Base)
     ++NumVars;
   if (Index)
     ++NumVars;
   if (NumVars) {
     Vars = Func->allocateArrayOf<Variable *>(NumVars);
     SizeT I = 0;
@@ skipping 67 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 213 matching lines @@
 }
 
 void OperandX8632::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "<OperandX8632>";
 }
 
 void OperandX8632Mem::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << TypeX8632Attributes[getType()].WidthString << " ";
+  if (SegmentReg != DefaultSegment) {
+    assert(SegmentReg >= 0 &&
+           static_cast<size_t>(SegmentReg) < InstX8632SegmentRegNamesSize);
+    Str << InstX8632SegmentRegNames[SegmentReg] << ":";
+  }
   // TODO: The following is an almost verbatim paste of dump().
   bool Dumped = false;
   Str << "[";
   if (Base) {
     Base->emit(Func);
     Dumped = true;
   }
   if (Index) {
     assert(Base);
     Str << "+";
     if (Shift > 0)
       Str << (1u << Shift) << "*";
     Index->emit(Func);
     Dumped = true;
   }
   // Pretty-print the Offset.
   bool OffsetIsZero = false;
   bool OffsetIsNegative = false;
   if (Offset == NULL) {
     OffsetIsZero = true;
   } else if (ConstantInteger *CI = llvm::dyn_cast<ConstantInteger>(Offset)) {
     OffsetIsZero = (CI->getValue() == 0);
     OffsetIsNegative = (static_cast<int64_t>(CI->getValue()) < 0);
   }
-  if (!OffsetIsZero) { // Suppress if Offset is known to be 0
-    if (Dumped) {
+  if (Dumped) {
+    if (!OffsetIsZero) {     // Suppress if Offset is known to be 0
       if (!OffsetIsNegative) // Suppress if Offset is known to be negative
         Str << "+";
+      Offset->emit(Func);
     }
+  } else {
+    // There is only the offset.
     Offset->emit(Func);
   }
   Str << "]";
 }
 
 void OperandX8632Mem::dump(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrDump();
+  if (SegmentReg != DefaultSegment) {
+    assert(SegmentReg >= 0 &&
+           static_cast<size_t>(SegmentReg) < InstX8632SegmentRegNamesSize);
+    Str << InstX8632SegmentRegNames[SegmentReg] << ":";
+  }
   bool Dumped = false;
   Str << "[";
   if (Base) {
     Base->dump(Func);
     Dumped = true;
   }
   if (Index) {
     assert(Base);
     Str << "+";
     if (Shift > 0)
       Str << (1u << Shift) << "*";
     Index->dump(Func);
     Dumped = true;
   }
   // Pretty-print the Offset.
   bool OffsetIsZero = false;
   bool OffsetIsNegative = false;
   if (Offset == NULL) {
     OffsetIsZero = true;
   } else if (ConstantInteger *CI = llvm::dyn_cast<ConstantInteger>(Offset)) {
     OffsetIsZero = (CI->getValue() == 0);
     OffsetIsNegative = (static_cast<int64_t>(CI->getValue()) < 0);
   }
-  if (!OffsetIsZero) { // Suppress if Offset is known to be 0
-    if (Dumped) {
+  if (Dumped) {
+    if (!OffsetIsZero) {     // Suppress if Offset is known to be 0
       if (!OffsetIsNegative) // Suppress if Offset is known to be negative
         Str << "+";
+      Offset->dump(Func);
     }
+  } else {
+    // There is only the offset.
     Offset->dump(Func);
   }
   Str << "]";
 }
 
 void VariableSplit::emit(const Cfg *Func) const {
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(Var->getLocalUseNode() == NULL ||
          Var->getLocalUseNode() == Func->getCurrentNode());
   assert(!Var->hasReg());
@@ skipping 25 matching lines @@
   default:
     Str << "???";
     break;
   }
   Str << "(";
   Var->dump(Func);
   Str << ")";
 }
 
 } // end of namespace Ice