Lower bitmanip intrinsics, assuming absence of BMI/SSE4.2 for now.

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
@@ skipping 121 matching lines @@
 class InstX8632 : public InstTarget {
 public:
   enum InstKindX8632 {
     k__Start = Inst::Target,
     Adc,
     Add,
     Addps,
     Addss,
     And,
     Br,
+    Bsf,
+    Bsr,
     Call,
     Cdq,
+    Cmov,
     Cmpxchg,
     Cmpxchg8b,
     Cvt,
     Div,
     Divps,
     Divss,
     Fld,
     Fstp,
     Icmp,
     Idiv,
@@ skipping 27 matching lines @@
     Sub,
     Subps,
     Subss,
     Test,
     Ucomiss,
     UD2,
     Xadd,
     Xchg,
     Xor
   };
+
+  enum BrCond {
+#define X(tag, dump, emit) tag,
+    ICEINSTX8632BR_TABLE
+#undef X
+        Br_None
+  };
+
   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() {}
   static bool isClassof(const Inst *Inst, InstKindX8632 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
@@ skipping 54 matching lines @@
   InstX8632Label(Cfg *Func, TargetX8632 *Target);
   InstX8632Label(const InstX8632Label &) LLVM_DELETED_FUNCTION;
   InstX8632Label &operator=(const InstX8632Label &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Label() {}
   SizeT Number; // used only for unique label string generation
 };
 
 // Conditional and unconditional branch instruction.
 class InstX8632Br : public InstX8632 {
 public:
-  enum BrCond {
-#define X(tag, dump, emit) tag,
-    ICEINSTX8632BR_TABLE
-#undef X
-        Br_None
-  };
-
   // Create a conditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *TargetTrue,
                              CfgNode *TargetFalse, BrCond Condition) {
     return new (Func->allocate<InstX8632Br>())
         InstX8632Br(Func, TargetTrue, TargetFalse, NULL, Condition);
   }
   // Create an unconditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *Target) {
     return new (Func->allocate<InstX8632Br>())
         InstX8632Br(Func, NULL, Target, NULL, Br_None);
@@ skipping 256 matching lines @@
   static bool classof(const Inst *Inst) { return isClassof(Inst, Shrd); }
 
 private:
   InstX8632Shrd(Cfg *Func, Variable *Dest, Variable *Source1,
                 Variable *Source2);
   InstX8632Shrd(const InstX8632Shrd &) LLVM_DELETED_FUNCTION;
   InstX8632Shrd &operator=(const InstX8632Shrd &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Shrd() {}
 };
 
+// Bit-scan-{forward,reverse} instructions. Finds the {least,most} significant
+// '1' bit, and stores the 0-based position in the Dest register.
+// If the Source is all zeroes, then the Dest is undefined and the ZF flag
+// is set. Otherwise, the ZF flag is cleared.
+template <InstX8632::InstKindX8632 K>
+class InstX8632BitScan : public InstX8632 {

[wala, 2014/07/15 00:16:31]

The other instruction classes in the file are defined based on their structural
similarities, not their semantic similarities (i.e., we have InstX8632Binop,
InstX8632Ternop, and then "everything else"). This looks like it should be
InstX8632Unary. Sqrtss also fits the pattern for a unary instruction.

[Jim Stichnoth, 2014/07/15 17:15:02]

You're right that this is a unary op, but not the same as the currently defined
InstX8632Unaryop, where Dest and Src(0) are always the same (and Dest can be a
memory operand).

Maybe Unaryop should be redefined to fit bsf/bsr/sqrtss and then neg is its own
special instruction (since it's currently the only instance of a Unaryop).

[jvoung (off chromium), 2014/07/15 21:30:23]

That sounds reasonable. I'll refactor.

I think movsx and movzx were also Unaryop-like.

+public:
+  static InstX8632BitScan *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    return new (Func->allocate<InstX8632BitScan>())
+        InstX8632BitScan(Func, Dest, Source);
+  }
+  virtual void emit(const Cfg *Func) const {
+    Ostream &Str = Func->getContext()->getStrEmit();
+    assert(getSrcSize() == 1);
+    Str << "\t" << Opcode << "\t";
+    getDest()->emit(Func);
+    Str << ", ";
+    getSrc(0)->emit(Func);
+    Str << "\n";
+  }
+  virtual void dump(const Cfg *Func) const {
+    Ostream &Str = Func->getContext()->getStrDump();
+    dumpDest(Func);
+    Str << " = " << Opcode << "." << getDest()->getType() << " ";
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstX8632BitScan(Cfg *Func, Variable *Dest, Operand *Source)
+      : InstX8632(Func, K, 1, Dest) {
+    addSource(Source);
+  }
+  InstX8632BitScan(const InstX8632BitScan &) LLVM_DELETED_FUNCTION;
+  InstX8632BitScan &operator=(const InstX8632BitScan &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632BitScan() {}
+
+  static const char *Opcode;
+};
+
+typedef InstX8632BitScan<InstX8632::Bsf> InstX8632Bsf;
+typedef InstX8632BitScan<InstX8632::Bsr> InstX8632Bsr;
+
 // Cdq instruction - sign-extend eax into edx
 class InstX8632Cdq : public InstX8632 {
 public:
   static InstX8632Cdq *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Cdq>())
         InstX8632Cdq(Func, Dest, Source);
   }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Cdq); }
 
 private:
   InstX8632Cdq(Cfg *Func, Variable *Dest, Operand *Source);
   InstX8632Cdq(const InstX8632Cdq &) LLVM_DELETED_FUNCTION;
   InstX8632Cdq &operator=(const InstX8632Cdq &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cdq() {}
 };
 
+// Conditional move instruction.
+class InstX8632Cmov : public InstX8632 {
+public:
+  static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
+                               BrCond Cond) {
+    return new (Func->allocate<InstX8632Cmov>())
+        InstX8632Cmov(Func, Dest, Source, Cond);
+  }
+  virtual void emit(const Cfg *Func) const;
+  virtual void dump(const Cfg *Func) const;
+  static bool classof(const Inst *Inst) { return isClassof(Inst, Cmov); }
+
+private:
+  InstX8632Cmov(Cfg *Func, Variable *Dest, Operand *Source, BrCond Cond);
+  InstX8632Cmov(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
+  InstX8632Cmov &operator=(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632Cmov() {}
+
+  BrCond Condition;
+};
+
 // Cmpxchg instruction - cmpxchg <dest>, <desired> will compare if <dest>
 // equals eax. If so, the ZF is set and <desired> is stored in <dest>.
 // If not, ZF is cleared and <dest> is copied to eax (or subregister).
 // <dest> can be a register or memory, while <desired> must be a register.
 // It is the user's responsiblity to mark eax with a FakeDef.
 class InstX8632Cmpxchg : public InstX8632Lockable {
 public:
   static InstX8632Cmpxchg *create(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                                   Variable *Desired, bool Locked) {
     return new (Func->allocate<InstX8632Cmpxchg>())
@@ skipping 434 matching lines @@
 private:
   InstX8632Xchg(Cfg *Func, Operand *Dest, Variable *Source);
   InstX8632Xchg(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   InstX8632Xchg &operator=(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Xchg() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H