X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FiMemory.cpp;h=4ec9e26fbe2a83990273a5e9f92d77f6141ba4fb;hb=1a143aef993a95e1caef2c8196d0b2f3f5f52c63;hp=c793783b2f850eef5b6bb49324271d5e798f9e88;hpb=ca112b361e7d9faab2171935532663f639e400e9;p=oota-llvm.git diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp index c793783b2f8..4ec9e26fbe2 100644 --- a/lib/VMCore/iMemory.cpp +++ b/lib/VMCore/iMemory.cpp @@ -5,99 +5,48 @@ //===----------------------------------------------------------------------===// #include "llvm/iMemory.h" -#include "llvm/ConstPoolVals.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" -//===----------------------------------------------------------------------===// -// MemAccessInst Implementation -//===----------------------------------------------------------------------===// +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Invalid indices for type!"); + return Ty; +} -// 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 AllowStructLeaf = false) { - if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type! - - // Get the type pointed to... - Ptr = ((const PointerType*)Ptr)->getValueType(); - - if (Ptr->isStructType()) { - unsigned CurIDX = 0; - while (Ptr->isStructType()) { - if (Idx.size() == CurIDX) - return AllowStructLeaf ? Ptr : 0; // Can't load a whole structure!?!? - if (Idx[CurIDX]->getType() != Type::UByteTy) return 0; // Illegal idx - unsigned NextIdx = ((ConstPoolUInt*)Idx[CurIDX++])->getValue(); - - const StructType *ST = (const StructType *)Ptr; - Ptr = ST->getElementTypes()[NextIdx]; - } - return Ptr; - } else if (Ptr->isArrayType()) { - assert(0 && "Loading from arrays not implemented yet!"); - } else { - return (Idx.size() == 0) ? Ptr : 0; // Load directly through ptr - } +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); + + Operands.reserve(1); + assert(ArraySize->getType() == Type::UIntTy && + "Malloc/Allocation array size != UIntTy!"); + + Operands.push_back(Use(ArraySize, this)); } -unsigned int -MemAccessInst::getIndexedOfsetForTarget(const Type *Ptr, - const vector &Idx, - const TargetMachine& targetMachine) -{ - if (!Ptr->isPointerType()) - return 0; // Type isn't a pointer type! - - unsigned int curOffset = 0; - - // Get the type pointed to... - Ptr = ((const PointerType*) Ptr)->getValueType(); - - if (Ptr->isStructType()) { - unsigned CurIDX = 0; // which element of Idx vector - while (Ptr->isStructType()) { - const StructType * SPtr = (StructType *) Ptr; - - if (Idx.size() == CurIDX) - break; - - assert (Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx"); - unsigned NextIdx = ((ConstPoolUInt*)Idx[CurIDX++])->getValue(); - - // add the offset for the current element - curOffset += SPtr->getElementOffset(NextIdx, targetMachine); - - // and update Ptr to refer to current element - Ptr = SPtr->getElementTypes()[NextIdx]; - } - return curOffset; - } else if (Ptr->isArrayType()) { - assert(0 && "Loading from arrays not implemented yet!"); - } else { - assert (Idx.size() == 0 && "Indexing type that is not struct or array?"); - return 0; // Load directly through ptr - } +bool AllocationInst::isArrayAllocation() const { + return getNumOperands() == 1 && + getOperand(0) != ConstantUInt::get(Type::UIntTy, 1); } - + +const Type *AllocationInst::getAllocatedType() const { + return getType()->getElementType(); +} + //===----------------------------------------------------------------------===// // LoadInst Implementation //===----------------------------------------------------------------------===// -LoadInst::LoadInst(Value *Ptr, const vector &Idx, - const string &Name = "") - : MemAccessInst(getIndexedType(Ptr->getType(), Idx), Load, Idx, Name) { - assert(getIndexedType(Ptr->getType(), Idx) && "Load operands invalid!"); - Operands.reserve(1+Idx.size()); +LoadInst::LoadInst(Value *Ptr, const std::string &Name) + : Instruction(cast(Ptr->getType())->getElementType(), + Load, Name) { + 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)); - } @@ -105,17 +54,12 @@ LoadInst::LoadInst(Value *Ptr, const vector &Idx, // StoreInst Implementation //===----------------------------------------------------------------------===// -StoreInst::StoreInst(Value *Val, Value *Ptr, const vector &Idx, - const string &Name = "") - : MemAccessInst(Type::VoidTy, Store, Idx, Name) { - assert(getIndexedType(Ptr->getType(), Idx) && "Store operands invalid!"); +StoreInst::StoreInst(Value *Val, Value *Ptr) + : Instruction(Type::VoidTy, Store, "") { - Operands.reserve(2+Idx.size()); + Operands.reserve(2); 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)); } @@ -123,12 +67,11 @@ StoreInst::StoreInst(Value *Val, Value *Ptr, const vector &Idx, // GetElementPtrInst Implementation //===----------------------------------------------------------------------===// -GetElementPtrInst::GetElementPtrInst(Value *Ptr, - const vector &Idx, - const string &Name = "") - : MemAccessInst(PointerType::getPointerType(getIndexedType(Ptr->getType(), - Idx, true)), - GetElementPtr, Idx, Name) { +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()); Operands.push_back(Use(Ptr, this)); @@ -137,6 +80,42 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, 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)); } +