X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FiMemory.cpp;h=4ec9e26fbe2a83990273a5e9f92d77f6141ba4fb;hb=1a143aef993a95e1caef2c8196d0b2f3f5f52c63;hp=a0a7b0f9793684a65bee8fceacfad184a6f0ffe2;hpb=e9bb2df410f7a22decad9a883f7139d5857c1520;p=oota-llvm.git diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp index a0a7b0f9793..4ec9e26fbe2 100644 --- a/lib/VMCore/iMemory.cpp +++ b/lib/VMCore/iMemory.cpp @@ -5,74 +5,46 @@ //===----------------------------------------------------------------------===// #include "llvm/iMemory.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" -//===----------------------------------------------------------------------===// -// MemAccessInst Implementation -//===----------------------------------------------------------------------===// - -// 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)->getValueType(); - - unsigned CurIDX = 0; - while (const CompositeType *ST = dyn_cast(Ptr)) { - if (Idx.size() == CurIDX) - return AllowCompositeLeaf ? Ptr : 0; // Can't load a whole structure!?!? - - Value *Index = Idx[CurIDX++]; - if (!ST->indexValid(Index)) return 0; - Ptr = ST->getTypeAtIndex(Index); - } - return CurIDX == Idx.size() ? Ptr : 0; +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Invalid indices for type!"); + return Ty; } +AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, + const std::string &Name) + : Instruction(Ty, iTy, Name) { + assert(isa(Ty) && "Can't allocate a non pointer type!"); + + // ArraySize defaults to 1. + if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1); -#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"; + Operands.reserve(1); + assert(ArraySize->getType() == Type::UIntTy && + "Malloc/Allocation array size != UIntTy!"); - vector RetVal; + Operands.push_back(Use(ArraySize, this)); +} - // 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))); +bool AllocationInst::isArrayAllocation() const { + return getNumOperands() == 1 && + getOperand(0) != ConstantUInt::get(Type::UIntTy, 1); +} - return RetVal; +const Type *AllocationInst::getAllocatedType() const { + return getType()->getElementType(); } -#endif + //===----------------------------------------------------------------------===// // LoadInst 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()); - 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())->getValueType(), - Load, Name) { +LoadInst::LoadInst(Value *Ptr, const std::string &Name) + : Instruction(cast(Ptr->getType())->getElementType(), + Load, Name) { Operands.reserve(1); Operands.push_back(Use(Ptr, this)); } @@ -82,21 +54,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(Type::VoidTy, Store, "") { Operands.reserve(2); Operands.push_back(Use(Val, this)); @@ -108,9 +67,10 @@ 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)), +GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &Idx, + const std::string &Name) + : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), + Idx, true))), GetElementPtr, Name) { assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!"); Operands.reserve(1+Idx.size()); @@ -120,6 +80,42 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const vector &Idx, Operands.push_back(Use(Idx[i], this)); } -bool GetElementPtrInst::isStructSelector() const { - return ((PointerType*)Operands[0]->getType())->getValueType()->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; +} + + +//===----------------------------------------------------------------------===// +// FreeInst Implementation +//===----------------------------------------------------------------------===// + +FreeInst::FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") { + assert(isa(Ptr->getType()) && "Can't free nonpointer!"); + Operands.reserve(1); + Operands.push_back(Use(Ptr, this)); } +