X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FiMemory.cpp;h=dacb8fe2a23f9ac757d6cf5de71ade6384a2f4c1;hb=627079d42a1340360f8699cd87865e20799cff21;hp=c61961b58e3574028ee4aacc9f6d11e2333f867b;hpb=7a1767520611d9ff6face702068de858e1cadf2c;p=oota-llvm.git diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp index c61961b58e3..dacb8fe2a23 100644 --- a/lib/VMCore/iMemory.cpp +++ b/lib/VMCore/iMemory.cpp @@ -5,74 +5,60 @@ //===----------------------------------------------------------------------===// #include "llvm/iMemory.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" -//===----------------------------------------------------------------------===// -// MemAccessInst Implementation -//===----------------------------------------------------------------------===// +AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, + const std::string &Name, Instruction *InsertBef) + : Instruction(PointerType::get(Ty), iTy, Name, InsertBef) { -// getIndexedType - Returns the type of the element that would be loaded with -// a load instruction with the specified parameters. -// -// A null type is returned if the indices are invalid for the specified -// pointer type. -// -const Type* MemAccessInst::getIndexedType(const Type *Ptr, - const vector &Idx, - bool AllowCompositeLeaf = false) { - if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type! - - // Get the type pointed to... - Ptr = cast(Ptr)->getElementType(); - - unsigned CurIDX = 0; - while (const CompositeType *ST = dyn_cast(Ptr)) { - if (Idx.size() == CurIDX) - return AllowCompositeLeaf ? Ptr : 0; // Can't load a whole structure!?!? + // ArraySize defaults to 1. + if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1); - Value *Index = Idx[CurIDX++]; - if (!ST->indexValid(Index)) return 0; - Ptr = ST->getTypeAtIndex(Index); - } - return CurIDX == Idx.size() ? Ptr : 0; -} + Operands.reserve(1); + assert(ArraySize->getType() == Type::UIntTy && + "Malloc/Allocation array size != UIntTy!"); + Operands.push_back(Use(ArraySize, this)); +} -#if 1 -#include "llvm/ConstantVals.h" -const vector MemAccessInst::getIndicesBROKEN() const { - cerr << "MemAccessInst::getIndices() does not do what you want it to. Talk" - << " to Chris about this. We can phase it out after the paper.\n"; +bool AllocationInst::isArrayAllocation() const { + return getOperand(0) != ConstantUInt::get(Type::UIntTy, 1); +} - vector RetVal; +const Type *AllocationInst::getAllocatedType() const { + return getType()->getElementType(); +} - // THIS CODE WILL FAIL IF A NON CONSTANT INDEX IS USED AS AN ARRAY INDEX - // THIS IS WHY YOU SHOULD NOT USE THIS FUNCTION ANY MORE!!! - for (unsigned i = getFirstIndexOperandNumber(); i < getNumOperands(); ++i) - RetVal.push_back(cast(getOperand(i))); +AllocaInst::AllocaInst(const AllocaInst &AI) + : AllocationInst(AI.getType()->getElementType(), (Value*)AI.getOperand(0), + Instruction::Alloca) { +} - return RetVal; +MallocInst::MallocInst(const MallocInst &MI) + : AllocationInst(MI.getType()->getElementType(), (Value*)MI.getOperand(0), + Instruction::Malloc) { } -#endif //===----------------------------------------------------------------------===// -// LoadInst Implementation +// FreeInst Implementation //===----------------------------------------------------------------------===// -LoadInst::LoadInst(Value *Ptr, const vector &Idx, - const string &Name = "") - : MemAccessInst(getIndexedType(Ptr->getType(), Idx), Load, Name) { - assert(getIndexedType(Ptr->getType(), Idx) && "Load operands invalid!"); - Operands.reserve(1+Idx.size()); +FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore) + : Instruction(Type::VoidTy, Free, "", InsertBefore) { + assert(isa(Ptr->getType()) && "Can't free nonpointer!"); + Operands.reserve(1); Operands.push_back(Use(Ptr, this)); - - for (unsigned i = 0, E = Idx.size(); i != E; ++i) - Operands.push_back(Use(Idx[i], this)); - } -LoadInst::LoadInst(Value *Ptr, const string &Name = "") - : MemAccessInst(cast(Ptr->getType())->getElementType(), - Load, Name) { + +//===----------------------------------------------------------------------===// +// LoadInst Implementation +//===----------------------------------------------------------------------===// + +LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef) + : Instruction(cast(Ptr->getType())->getElementType(), + Load, Name, InsertBef) { Operands.reserve(1); Operands.push_back(Use(Ptr, this)); } @@ -82,21 +68,8 @@ LoadInst::LoadInst(Value *Ptr, const string &Name = "") // StoreInst Implementation //===----------------------------------------------------------------------===// -StoreInst::StoreInst(Value *Val, Value *Ptr, const vector &Idx, - const string &Name = "") - : MemAccessInst(Type::VoidTy, Store, Name) { - assert(getIndexedType(Ptr->getType(), Idx) && "Store operands invalid!"); - - Operands.reserve(2+Idx.size()); - Operands.push_back(Use(Val, this)); - Operands.push_back(Use(Ptr, this)); - - for (unsigned i = 0, E = Idx.size(); i != E; ++i) - Operands.push_back(Use(Idx[i], this)); -} - -StoreInst::StoreInst(Value *Val, Value *Ptr, const string &Name = "") - : MemAccessInst(Type::VoidTy, Store, Name) { +StoreInst::StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore) + : Instruction(Type::VoidTy, Store, "", InsertBefore) { Operands.reserve(2); Operands.push_back(Use(Val, this)); @@ -108,10 +81,19 @@ StoreInst::StoreInst(Value *Val, Value *Ptr, const string &Name = "") // GetElementPtrInst Implementation //===----------------------------------------------------------------------===// -GetElementPtrInst::GetElementPtrInst(Value *Ptr, const vector &Idx, - const string &Name = "") - : MemAccessInst(PointerType::get(getIndexedType(Ptr->getType(), Idx, true)), - GetElementPtr, Name) { +// checkType - Simple wrapper function to give a better assertion failure +// message on bad indexes for a gep instruction. +// +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Invalid indices for type!"); + return Ty; +} + +GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &Idx, + const std::string &Name, Instruction *InBe) + : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), + Idx, true))), + GetElementPtr, Name, InBe) { assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!"); Operands.reserve(1+Idx.size()); Operands.push_back(Use(Ptr, this)); @@ -120,6 +102,30 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const vector &Idx, Operands.push_back(Use(Idx[i], this)); } -bool GetElementPtrInst::isStructSelector() const { - return ((PointerType*)Operands[0]->getType())->getElementType()->isStructType(); +// getIndexedType - Returns the type of the element that would be loaded with +// a load instruction with the specified parameters. +// +// A null type is returned if the indices are invalid for the specified +// pointer type. +// +const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, + const std::vector &Idx, + bool AllowCompositeLeaf) { + if (!isa(Ptr)) return 0; // Type isn't a pointer type! + + // Handle the special case of the empty set index set... + if (Idx.empty()) return cast(Ptr)->getElementType(); + + unsigned CurIDX = 0; + while (const CompositeType *CT = dyn_cast(Ptr)) { + if (Idx.size() == CurIDX) { + if (AllowCompositeLeaf || CT->isFirstClassType()) return Ptr; + return 0; // Can't load a whole structure or array!?!? + } + + Value *Index = Idx[CurIDX++]; + if (!CT->indexValid(Index)) return 0; + Ptr = CT->getTypeAtIndex(Index); + } + return CurIDX == Idx.size() ? Ptr : 0; }