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

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level 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 Inst class and its target-independent
 // subclasses, which represent the high-level Vanilla ICE instructions
 // and map roughly 1:1 to LLVM instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINST_H
 #define SUBZERO_SRC_ICEINST_H
 
 #include "IceDefs.h"
 #include "IceInst.def"
+#include "IceIntrinsics.h"
 #include "IceTypes.h"
 
 // TODO: The Cfg structure, and instructions in particular, need to be
 // validated for things like valid operand types, valid branch
 // targets, proper ordering of Phi and non-Phi instructions, etc.
 // Most of the validity checking will be done in the bitcode reader.
 // We need a list of everything that should be validated, and tests
 // for each.
 
 namespace Ice {
 
 class Inst {
 public:
   enum InstKind {
     // Arbitrary (alphabetical) order, except put Unreachable first.
     Unreachable,
     Alloca,
     Arithmetic,
     Assign, // not part of LLVM/PNaCl bitcode
     Br,
     Call,
     Cast,
     Fcmp,
     Icmp,
+    IntrinsicCall,
     Load,
     Phi,
     Ret,
     Select,
     Store,
     Switch,
     FakeDef,  // not part of LLVM/PNaCl bitcode
     FakeUse,  // not part of LLVM/PNaCl bitcode
     FakeKill, // not part of LLVM/PNaCl bitcode
     Target    // target-specific low-level ICE
@@ skipping 224 matching lines @@
   CfgNode *const TargetFalse; // Doubles as unconditional branch target
   CfgNode *const TargetTrue;  // NULL if unconditional branch
 };
 
 // Call instruction.  The call target is captured as getSrc(0), and
 // arg I is captured as getSrc(I+1).
 class InstCall : public Inst {
 public:
   static InstCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
                           Operand *CallTarget) {
+    // Set HasSideEffects to true so that the call instruction can't be
+    // dead-code eliminated. IntrinsicCalls can override this if the
+    // particular intrinsic is deletable and has no side-effects.
+    const bool HasSideEffects = true;
+    const InstKind Kind = Inst::Call;
     return new (Func->allocateInst<InstCall>())
-        InstCall(Func, NumArgs, Dest, CallTarget);
+        InstCall(Func, NumArgs, Dest, CallTarget, HasSideEffects, Kind);
   }
   void addArg(Operand *Arg) { addSource(Arg); }
   Operand *getCallTarget() const { return getSrc(0); }
   Operand *getArg(SizeT I) const { return getSrc(I + 1); }
   SizeT getNumArgs() const { return getSrcSize() - 1; }
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Call; }
 
-private:
-  InstCall(Cfg *Func, SizeT NumArgs, Variable *Dest, Operand *CallTarget)
-      : Inst(Func, Inst::Call, NumArgs + 1, Dest) {
-    // Set HasSideEffects so that the call instruction can't be
-    // dead-code eliminated.  Don't set this for a deletable intrinsic
-    // call.
-    HasSideEffects = true;
+protected:
+  InstCall(Cfg *Func, SizeT NumArgs, Variable *Dest, Operand *CallTarget,
+           bool HasSideEff, InstKind Kind)
+      : Inst(Func, Kind, NumArgs + 1, Dest) {
+    HasSideEffects = HasSideEff;
     addSource(CallTarget);
   }
+  virtual ~InstCall() {}
+
+private:
   InstCall(const InstCall &) LLVM_DELETED_FUNCTION;
   InstCall &operator=(const InstCall &) LLVM_DELETED_FUNCTION;
-  virtual ~InstCall() {}
 };
 
 // Cast instruction (a.k.a. conversion operation).
 class InstCast : public Inst {
 public:
   enum OpKind {
 #define X(tag, str) tag,
     ICEINSTCAST_TABLE
 #undef X
         _num
@@ skipping 67 matching lines @@
 
 private:
   InstIcmp(Cfg *Func, ICond Condition, Variable *Dest, Operand *Source1,
            Operand *Source2);
   InstIcmp(const InstIcmp &) LLVM_DELETED_FUNCTION;
   InstIcmp &operator=(const InstIcmp &) LLVM_DELETED_FUNCTION;
   virtual ~InstIcmp() {}
   const ICond Condition;
 };
 
+// Call to an intrinsic function.  The call target is captured as getSrc(0),
+// and arg I is captured as getSrc(I+1).
+class InstIntrinsicCall : public InstCall {
+public:
+  static InstIntrinsicCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
+                                   Operand *CallTarget,
+                                   const IntrinsicInfo &Info) {
+    return new (Func->allocateInst<InstIntrinsicCall>())
+        InstIntrinsicCall(Func, NumArgs, Dest, CallTarget, Info);
+  }
+  static bool classof(const Inst *Inst) {
+    return Inst->getKind() == IntrinsicCall;
+  }
+
+  IntrinsicInfo getIntrinsicInfo() const { return Info; }
+private:
+  InstIntrinsicCall(Cfg *Func, SizeT NumArgs, Variable *Dest,
+                    Operand *CallTarget, const IntrinsicInfo &Info)
+      : InstCall(Func, NumArgs, Dest, CallTarget,
+                 Info.HasSideEffects, Inst::IntrinsicCall),
+        Info(Info) {}
+  InstIntrinsicCall(const InstIntrinsicCall &) LLVM_DELETED_FUNCTION;
+  InstIntrinsicCall &operator=(const InstIntrinsicCall &) LLVM_DELETED_FUNCTION;
+  virtual ~InstIntrinsicCall() {}
+  const IntrinsicInfo Info;
+};
+
 // Load instruction.  The source address is captured in getSrc(0).
 class InstLoad : public Inst {
 public:
   static InstLoad *create(Cfg *Func, Variable *Dest, Operand *SourceAddr) {
     return new (Func->allocateInst<InstLoad>())
         InstLoad(Func, Dest, SourceAddr);
   }
   Operand *getSourceAddress() const { return getSrc(0); }
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Load; }
@@ skipping 258 matching lines @@
     assert(Kind >= Target);
   }
   InstTarget(const InstTarget &) LLVM_DELETED_FUNCTION;
   InstTarget &operator=(const InstTarget &) LLVM_DELETED_FUNCTION;
   virtual ~InstTarget() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINST_H