I misled Alkis: LLVM should have isnan, not isunordered.

[oota-llvm.git] / lib / VMCore / iMemory.cpp

diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index 75309ad8dc048b081a853d954f56c2bdcc5ffc91..bcba93e253a16a6bfcfccb1b7b9b9419fc74518f 100644 (file)
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -14,11 +14,10 @@
 #include "llvm/iMemory.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+using namespace llvm;
 
-AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
-                               const std::string &Name, Instruction *InsertBef)
-  : Instruction(PointerType::get(Ty), iTy, Name, InsertBef) {
-
+void AllocationInst::init(const Type *Ty, Value *ArraySize, unsigned iTy)
+{
   // ArraySize defaults to 1.
   if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1);
 
@@ -29,6 +28,20 @@ AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
   Operands.push_back(Use(ArraySize, this));
 }
 
+AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
+                               const std::string &Name,
+                               Instruction *InsertBefore)
+  : Instruction(PointerType::get(Ty), iTy, Name, InsertBefore) {
+  init(Ty, ArraySize, iTy);
+}
+
+AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
+                               const std::string &Name,
+                               BasicBlock *InsertAtEnd)
+  : Instruction(PointerType::get(Ty), iTy, Name, InsertAtEnd) {
+  init(Ty, ArraySize, iTy);
+}
+
 bool AllocationInst::isArrayAllocation() const {
   return getOperand(0) != ConstantUInt::get(Type::UIntTy, 1);
 }
@@ -51,13 +64,23 @@ MallocInst::MallocInst(const MallocInst &MI)
 //                             FreeInst Implementation
 //===----------------------------------------------------------------------===//
 
-FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
-  : Instruction(Type::VoidTy, Free, "", InsertBefore) {
-  assert(isa<PointerType>(Ptr->getType()) && "Can't free nonpointer!");
+void FreeInst::init(Value *Ptr)
+{
+  assert(Ptr && isa<PointerType>(Ptr->getType()) && "Can't free nonpointer!");
   Operands.reserve(1);
   Operands.push_back(Use(Ptr, this));
 }
 
+FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
+  : Instruction(Type::VoidTy, Free, "", InsertBefore) {
+  init(Ptr);
+}
+
+FreeInst::FreeInst(Value *Ptr, BasicBlock *InsertAtEnd)
+  : Instruction(Type::VoidTy, Free, "", InsertAtEnd) {
+  init(Ptr);
+}
+
 
 //===----------------------------------------------------------------------===//
 //                           LoadInst Implementation
@@ -66,16 +89,27 @@ FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
 LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef)
   : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
                 Load, Name, InsertBef), Volatile(false) {
-  Operands.reserve(1);
-  Operands.push_back(Use(Ptr, this));
+  init(Ptr);
+}
+
+LoadInst::LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAE)
+  : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
+                Load, Name, InsertAE), Volatile(false) {
+  init(Ptr);
 }
 
 LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
                    Instruction *InsertBef)
   : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
                 Load, Name, InsertBef), Volatile(isVolatile) {
-  Operands.reserve(1);
-  Operands.push_back(Use(Ptr, this));
+  init(Ptr);
+}
+
+LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
+                   BasicBlock *InsertAE)
+  : Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
+                Load, Name, InsertAE), Volatile(isVolatile) {
+  init(Ptr);
 }
 
 //===----------------------------------------------------------------------===//
@@ -84,19 +118,24 @@ LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
 
 StoreInst::StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore)
   : Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(false) {
-  
-  Operands.reserve(2);
-  Operands.push_back(Use(Val, this));
-  Operands.push_back(Use(Ptr, this));
+  init(Val, Ptr);
+}
+
+StoreInst::StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd)
+  : Instruction(Type::VoidTy, Store, "", InsertAtEnd), Volatile(false) {
+  init(Val, Ptr);
 }
 
 StoreInst::StoreInst(Value *Val, Value *Ptr, bool isVolatile, 
                      Instruction *InsertBefore)
   : Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(isVolatile) {
-  
-  Operands.reserve(2);
-  Operands.push_back(Use(Val, this));
-  Operands.push_back(Use(Ptr, this));
+  init(Val, Ptr);
+}
+
+StoreInst::StoreInst(Value *Val, Value *Ptr, bool isVolatile, 
+                     BasicBlock *InsertAtEnd)
+  : Instruction(Type::VoidTy, Store, "", InsertAtEnd), Volatile(isVolatile) {
+  init(Val, Ptr);
 }
 
 
@@ -112,11 +151,8 @@ static inline const Type *checkType(const Type *Ty) {
   return Ty;
 }
 
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
-                                    const std::string &Name, Instruction *InBe)
-  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
-                                                            Idx, true))),
-                 GetElementPtr, Name, InBe) {
+void GetElementPtrInst::init(Value *Ptr, const std::vector<Value*> &Idx)
+{
   Operands.reserve(1+Idx.size());
   Operands.push_back(Use(Ptr, this));
 
@@ -124,6 +160,22 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
     Operands.push_back(Use(Idx[i], this));
 }
 
+GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
+                                    const std::string &Name, Instruction *InBe)
+  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
+                                                          Idx, true))),
+                GetElementPtr, Name, InBe) {
+  init(Ptr, Idx);
+}
+
+GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
+                                    const std::string &Name, BasicBlock *IAE)
+  : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
+                                                          Idx, true))),
+                GetElementPtr, Name, IAE) {
+  init(Ptr, Idx);
+}
+
 // getIndexedType - Returns the type of the element that would be loaded with
 // a load instruction with the specified parameters.
 //
@@ -136,7 +188,12 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr,
   if (!isa<PointerType>(Ptr)) return 0;   // Type isn't a pointer type!
 
   // Handle the special case of the empty set index set...
-  if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
+  if (Idx.empty())
+    if (AllowCompositeLeaf ||
+        cast<PointerType>(Ptr)->getElementType()->isFirstClassType())
+      return cast<PointerType>(Ptr)->getElementType();
+    else
+      return 0;
  
   unsigned CurIdx = 0;
   while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
@@ -150,6 +207,14 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr,
       return 0;  // Can only index into pointer types at the first index!
     if (!CT->indexValid(Index)) return 0;
     Ptr = CT->getTypeAtIndex(Index);
+
+    // If the new type forwards to another type, then it is in the middle
+    // of being refined to another type (and hence, may have dropped all
+    // references to what it was using before).  So, use the new forwarded
+    // type.
+    if (const Type * Ty = Ptr->getForwardedType()) {
+      Ptr = Ty;
+    }
   }
   return CurIdx == Idx.size() ? Ptr : 0;
 }