Move some methods out of MachineInstr into MachineOperand

[oota-llvm.git] / include / llvm / Instructions.h

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 8c62d3de3b446d47680bf9423058252ced20a4f0..1c18e9a61837d4689dc1a53557c0e48655f97187 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -24,6 +24,7 @@ namespace llvm {
 class BasicBlock;
 class ConstantInt;
 class PointerType;
+class PackedType;
 
 //===----------------------------------------------------------------------===//
 //                             AllocationInst Class
@@ -717,6 +718,161 @@ public:
   }
 };
 
+//===----------------------------------------------------------------------===//
+//                                ExtractElementInst Class
+//===----------------------------------------------------------------------===//
+
+/// ExtractElementInst - This instruction extracts a single (scalar)
+/// element from a PackedType value
+///
+class ExtractElementInst : public Instruction {
+  Use Ops[2];
+  ExtractElementInst(const ExtractElementInst &EE) : 
+    Instruction(EE.getType(), ExtractElement, Ops, 2) {
+    Ops[0].init(EE.Ops[0], this);
+    Ops[1].init(EE.Ops[1], this);
+  }
+
+public:
+  ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name = "",
+                     Instruction *InsertBefore = 0);
+  ExtractElementInst(Value *Vec, Value *Idx, const std::string &Name,
+                     BasicBlock *InsertAtEnd);
+
+  /// isValidOperands - Return true if an extractelement instruction can be
+  /// formed with the specified operands.
+  static bool isValidOperands(const Value *Vec, const Value *Idx);
+  
+  virtual ExtractElementInst *clone() const;
+
+  virtual bool mayWriteToMemory() const { return false; }
+
+  /// Transparently provide more efficient getOperand methods.
+  Value *getOperand(unsigned i) const {
+    assert(i < 2 && "getOperand() out of range!");
+    return Ops[i];
+  }
+  void setOperand(unsigned i, Value *Val) {
+    assert(i < 2 && "setOperand() out of range!");
+    Ops[i] = Val;
+  }
+  unsigned getNumOperands() const { return 2; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ExtractElementInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::ExtractElement;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+//                                InsertElementInst Class
+//===----------------------------------------------------------------------===//
+
+/// InsertElementInst - This instruction inserts a single (scalar)
+/// element into a PackedType value
+///
+class InsertElementInst : public Instruction {
+  Use Ops[3];
+  InsertElementInst(const InsertElementInst &IE);
+public:
+  InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
+                    const std::string &Name = "",Instruction *InsertBefore = 0);
+  InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
+                    const std::string &Name, BasicBlock *InsertAtEnd);
+
+  /// isValidOperands - Return true if an insertelement instruction can be
+  /// formed with the specified operands.
+  static bool isValidOperands(const Value *Vec, const Value *NewElt,
+                              const Value *Idx);
+  
+  virtual InsertElementInst *clone() const;
+
+  virtual bool mayWriteToMemory() const { return false; }
+
+  /// getType - Overload to return most specific packed type.
+  ///
+  inline const PackedType *getType() const {
+    return reinterpret_cast<const PackedType*>(Instruction::getType());
+  }
+  
+  /// Transparently provide more efficient getOperand methods.
+  Value *getOperand(unsigned i) const {
+    assert(i < 3 && "getOperand() out of range!");
+    return Ops[i];
+  }
+  void setOperand(unsigned i, Value *Val) {
+    assert(i < 3 && "setOperand() out of range!");
+    Ops[i] = Val;
+  }
+  unsigned getNumOperands() const { return 3; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const InsertElementInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::InsertElement;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+//                           ShuffleVectorInst Class
+//===----------------------------------------------------------------------===//
+
+/// ShuffleVectorInst - This instruction constructs a fixed permutation of two
+/// input vectors.
+///
+class ShuffleVectorInst : public Instruction {
+  Use Ops[3];
+  ShuffleVectorInst(const ShuffleVectorInst &IE);  
+public:
+  ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
+                    const std::string &Name = "", Instruction *InsertBefor = 0);
+  ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
+                    const std::string &Name, BasicBlock *InsertAtEnd);
+  
+  /// isValidOperands - Return true if a shufflevector instruction can be
+  /// formed with the specified operands.
+  static bool isValidOperands(const Value *V1, const Value *V2,
+                              const Value *Mask);
+  
+  virtual ShuffleVectorInst *clone() const;
+  
+  virtual bool mayWriteToMemory() const { return false; }
+  
+  /// getType - Overload to return most specific packed type.
+  ///
+  inline const PackedType *getType() const {
+    return reinterpret_cast<const PackedType*>(Instruction::getType());
+  }
+  
+  /// Transparently provide more efficient getOperand methods.
+  Value *getOperand(unsigned i) const {
+    assert(i < 3 && "getOperand() out of range!");
+    return Ops[i];
+  }
+  void setOperand(unsigned i, Value *Val) {
+    assert(i < 3 && "setOperand() out of range!");
+    Ops[i] = Val;
+  }
+  unsigned getNumOperands() const { return 3; }
+  
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ShuffleVectorInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::ShuffleVector;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
+
 //===----------------------------------------------------------------------===//
 //                               PHINode Class
 //===----------------------------------------------------------------------===//