Initialize IsDef of all non-register MachineOperand to false.

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

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 3922cd3e9f5511b56293ff3399c949518bc26b95..a3d70f8f14624e407ae17e7bd11edf0ef0e3d2ea 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
@@ -39,9 +40,10 @@ protected:
                  const std::string &Name = "", Instruction *InsertBefore = 0);
   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, unsigned Align,
                  const std::string &Name, BasicBlock *InsertAtEnd);
-
 public:
-
+  // Out of line virtual method, so the vtable, etc has a home.
+  virtual ~AllocationInst();
+  
   /// isArrayAllocation - Return true if there is an allocation size parameter
   /// to the allocation instruction that is not 1.
   ///
@@ -103,13 +105,20 @@ public:
   MallocInst(const Type *Ty, Value *ArraySize, const std::string &Name,
              BasicBlock *InsertAtEnd)
     : AllocationInst(Ty, ArraySize, Malloc, 0, Name, InsertAtEnd) {}
+  
+  explicit MallocInst(const Type *Ty, const std::string &Name,
+                      Instruction *InsertBefore = 0)
+    : AllocationInst(Ty, 0, Malloc, 0, Name, InsertBefore) {}
+  MallocInst(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
+    : AllocationInst(Ty, 0, Malloc, 0, Name, InsertAtEnd) {}
+  
   MallocInst(const Type *Ty, Value *ArraySize, unsigned Align, 
              const std::string &Name, BasicBlock *InsertAtEnd)
-  : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertAtEnd) {}
-  explicit MallocInst(const Type *Ty, Value *ArraySize, unsigned Align,
+    : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertAtEnd) {}
+  MallocInst(const Type *Ty, Value *ArraySize, unsigned Align,
                       const std::string &Name = "",
                       Instruction *InsertBefore = 0)
-  : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertBefore) {}
+    : AllocationInst(Ty, ArraySize, Malloc, Align, Name, InsertBefore) {}
   
   virtual MallocInst *clone() const;
 
@@ -140,13 +149,19 @@ public:
   AllocaInst(const Type *Ty, Value *ArraySize, const std::string &Name,
              BasicBlock *InsertAtEnd)
     : AllocationInst(Ty, ArraySize, Alloca, 0, Name, InsertAtEnd) {}
+
+  AllocaInst(const Type *Ty, const std::string &Name,
+             Instruction *InsertBefore = 0)
+    : AllocationInst(Ty, 0, Alloca, 0, Name, InsertBefore) {}
+  AllocaInst(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd)
+    : AllocationInst(Ty, 0, Alloca, 0, Name, InsertAtEnd) {}
+  
+  AllocaInst(const Type *Ty, Value *ArraySize, unsigned Align,
+             const std::string &Name = "", Instruction *InsertBefore = 0)
+    : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertBefore) {}
   AllocaInst(const Type *Ty, Value *ArraySize, unsigned Align,
              const std::string &Name, BasicBlock *InsertAtEnd)
-  : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertAtEnd) {}
-  explicit AllocaInst(const Type *Ty, Value *ArraySize, unsigned Align,
-                      const std::string &Name = "",
-                      Instruction *InsertBefore = 0)
-  : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertBefore) {}
+    : AllocationInst(Ty, ArraySize, Alloca, Align, Name, InsertAtEnd) {}
   
   virtual AllocaInst *clone() const;
 
@@ -738,6 +753,10 @@ public:
   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; }
@@ -772,23 +791,28 @@ public:
 ///
 class InsertElementInst : public Instruction {
   Use Ops[3];
-  InsertElementInst(const InsertElementInst &IE) : 
-    Instruction(IE.getType(), InsertElement, Ops, 3) {
-    Ops[0].init(IE.Ops[0], this);
-    Ops[1].init(IE.Ops[1], this);
-    Ops[2].init(IE.Ops[2], this);
-  }
-
+  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!");
@@ -819,20 +843,14 @@ public:
 ///
 class ShuffleVectorInst : public Instruction {
   Use Ops[3];
-  ShuffleVectorInst(const ShuffleVectorInst &IE) : 
-    Instruction(IE.getType(), ShuffleVector, Ops, 3) {
-      Ops[0].init(IE.Ops[0], this);
-      Ops[1].init(IE.Ops[1], this);
-      Ops[2].init(IE.Ops[2], this);
-    }
-  
+  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 value shufflevector instruction can be
+  /// 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);
@@ -841,6 +859,12 @@ public:
   
   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!");
@@ -904,7 +928,7 @@ public:
   ///
   unsigned getNumIncomingValues() const { return getNumOperands()/2; }
 
-  /// getIncomingValue - Return incoming value #x
+  /// getIncomingValue - Return incoming value number x
   ///
   Value *getIncomingValue(unsigned i) const {
     assert(i*2 < getNumOperands() && "Invalid value number!");
@@ -918,7 +942,7 @@ public:
     return i*2;
   }
 
-  /// getIncomingBlock - Return incoming basic block #x
+  /// getIncomingBlock - Return incoming basic block number x
   ///
   BasicBlock *getIncomingBlock(unsigned i) const {
     return reinterpret_cast<BasicBlock*>(getOperand(i*2+1));