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

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- 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 InstX8632 and OperandX8632 classes and
 // their subclasses.  This represents the machine instructions and
 // operands used for x86-32 code selection.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINSTX8632_H
 #define SUBZERO_SRC_ICEINSTX8632_H
 
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceInstX8632.def"
 #include "IceOperand.h"
 
 namespace Ice {
 
 class TargetX8632;
 
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
-// OperandX8632Mem and VariableSplit.
+// OperandX8632Mem, OperandX8632MemOffSeg, and VariableSplit.
 class OperandX8632 : public Operand {
 public:
   enum OperandKindX8632 {
     k__Start = Operand::kTarget,
     kMem,
+    kMemOffSeg,
     kSplit
   };
   virtual void emit(const Cfg *Func) const = 0;
   void dump(const Cfg *Func) const;
 
 protected:
   OperandX8632(OperandKindX8632 Kind, Type Ty)
       : Operand(static_cast<OperandKind>(Kind), Ty) {}
   virtual ~OperandX8632() {}
 
@@ skipping 29 matching lines @@
                   Variable *Index, uint32_t Shift);
   OperandX8632Mem(const OperandX8632Mem &) LLVM_DELETED_FUNCTION;
   OperandX8632Mem &operator=(const OperandX8632Mem &) LLVM_DELETED_FUNCTION;
   virtual ~OperandX8632Mem() {}
   Variable *Base;
   Constant *Offset;
   Variable *Index;
   uint32_t Shift;
 };
 
+// OperandX8632MemOffSeg represents the moffs addressing mode, where
+// the address is given by an offset relative to the segment base.
+class OperandX8632MemOffSeg : public OperandX8632 {

[Jim Stichnoth, 2014/06/10 22:58:28]

Instead of creating this new class, couldn't we just add a segment register to
OperandX8632Mem?  That way the segment register could be used for all addressing
modes, not just immediate addresses.

I would probably use a separate OperandX8632Mem ctor with an explicit segment
register, and the original ctor would be for the default segment.

Address mode optimization would have to preserve the original segment register. 
Legalization would have to do the same.

[jvoung (off chromium), 2014/06/12 05:48:30]

Done.

The initial concern was that we would be wasting some space for OperandX8632Mem
when the common case is a default segment register. Added to OperandX8632Mem,
but sharing some bits w/ Shift.

I kept it to a single ctor though, since the ctor itself is non-trivial, and
leveraged the create() instead. The create() already had a bunch of default
args... preference for (a) continuing to use the default args or (b) splitting
it up? Either way, if the function name is still called "create" in all
instances and we rely on overloading, it seems likely to forget to propagate
some of the arguments (e.g., the segment register) during legalize(), or
loOperand().

[Jim Stichnoth, 2014/06/12 20:52:06]

You're right, I should have been looking at create() not the ctor.  The current
implementation looks good to me.

+public:
+  static OperandX8632MemOffSeg *create(Cfg *Func, Type Ty,
+                                       Constant *Offset,
+                                       SizeT SegmentReg) {
+    return new (Func->allocate<OperandX8632MemOffSeg>())
+        OperandX8632MemOffSeg(Ty, Offset, SegmentReg);
+  }
+  Constant *getOffset() const { return Offset; }
+  SizeT getSegmentRegister() const { return SegmentReg; }

[JF, 2014/06/10 03:50:41]

It seems weird to have SegmentReg as a SizeT. Shouldn't it have a separate
typedef?

[Jim Stichnoth, 2014/06/10 22:58:28]

The regular registers are using int32_t, but I wonder if this should just be
using enum SegmentRegisters.

[jvoung (off chromium), 2014/06/12 05:48:30]

Moved to using the enum.

+  virtual void emit(const Cfg *Func) const;
+  virtual void dump(const Cfg *Func) const;
+
+  static bool classof(const Operand *Operand) {
+    return Operand->getKind() == static_cast<OperandKind>(kMemOffSeg);
+  }
+
+private:
+  OperandX8632MemOffSeg(Type Ty, Constant *Offset, SizeT SegmentReg)
+      : OperandX8632(kMemOffSeg, Ty), Offset(Offset), SegmentReg(SegmentReg) {}
+  OperandX8632MemOffSeg(
+      const OperandX8632MemOffSeg &) LLVM_DELETED_FUNCTION;
+  OperandX8632MemOffSeg &operator=(
+      const OperandX8632MemOffSeg &) LLVM_DELETED_FUNCTION;
+  virtual ~OperandX8632MemOffSeg() {}
+  Constant *Offset;
+  SizeT SegmentReg;
+};
+
 // VariableSplit is a way to treat an f64 memory location as a pair
 // of i32 locations (Low and High).  This is needed for some cases
 // of the Bitcast instruction.  Since it's not possible for integer
 // registers to access the XMM registers and vice versa, the
 // lowering forces the f64 to be spilled to the stack and then
 // accesses through the VariableSplit.
 class VariableSplit : public OperandX8632 {
 public:
   enum Portion {
     Low,
@@ skipping 59 matching lines @@
     Sbb,
     Shl,
     Shld,
     Shr,
     Shrd,
     Store,
     Sub,
     Subss,
     Test,
     Ucomiss,
+    UD2,
     Xor
   };
   static const char *getWidthString(Type Ty);
   virtual void emit(const Cfg *Func) const = 0;
   virtual void dump(const Cfg *Func) const;
 
 protected:
   InstX8632(Cfg *Func, InstKindX8632 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
   virtual ~InstX8632() {}
@@ skipping 351 matching lines @@
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Ucomiss); }
 
 private:
   InstX8632Ucomiss(Cfg *Func, Operand *Src1, Operand *Src2);
   InstX8632Ucomiss(const InstX8632Ucomiss &) LLVM_DELETED_FUNCTION;
   InstX8632Ucomiss &operator=(const InstX8632Ucomiss &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Ucomiss() {}
 };
 
+// UD2 instruction.
+class InstX8632UD2 : public InstX8632 {
+public:
+  static InstX8632UD2 *create(Cfg *Func) {
+    return new (Func->allocate<InstX8632UD2>())
+        InstX8632UD2(Func);
+  }
+  virtual void emit(const Cfg *Func) const;
+  virtual void dump(const Cfg *Func) const;
+  static bool classof(const Inst *Inst) { return isClassof(Inst, UD2); }
+
+private:
+  InstX8632UD2(Cfg *Func);
+  InstX8632UD2(const InstX8632UD2 &) LLVM_DELETED_FUNCTION;
+  InstX8632UD2 &operator=(const InstX8632UD2 &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632UD2() {}
+};
+
 // Test instruction.
 class InstX8632Test : public InstX8632 {
 public:
   static InstX8632Test *create(Cfg *Func, Operand *Source1, Operand *Source2) {
     return new (Func->allocate<InstX8632Test>())
         InstX8632Test(Func, Source1, Source2);
   }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Test); }
@@ skipping 167 matching lines @@
 private:
   InstX8632Ret(Cfg *Func, Variable *Source);
   InstX8632Ret(const InstX8632Ret &) LLVM_DELETED_FUNCTION;
   InstX8632Ret &operator=(const InstX8632Ret &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Ret() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H