2001-07-08 21:10:27 +00:00
|
|
|
//===-- iMemory.cpp - Implement Memory instructions --------------*- C++ -*--=//
|
|
|
|
//
|
|
|
|
// This file implements the various memory related classes defined in iMemory.h
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/iMemory.h"
|
2002-04-28 19:55:58 +00:00
|
|
|
#include "llvm/Constants.h"
|
2002-04-29 18:46:50 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2001-07-08 21:10:27 +00:00
|
|
|
|
2001-12-14 16:43:26 +00:00
|
|
|
static inline const Type *checkType(const Type *Ty) {
|
|
|
|
assert(Ty && "Invalid indices for type!");
|
|
|
|
return Ty;
|
|
|
|
}
|
|
|
|
|
2002-03-21 22:37:48 +00:00
|
|
|
AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
|
|
|
|
const std::string &Name = "")
|
|
|
|
: Instruction(Ty, iTy, Name) {
|
|
|
|
assert(Ty->isPointerType() && "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));
|
|
|
|
}
|
|
|
|
|
2002-02-19 21:24:17 +00:00
|
|
|
bool AllocationInst::isArrayAllocation() const {
|
|
|
|
return getNumOperands() == 1 &&
|
|
|
|
getOperand(0) != ConstantUInt::get(Type::UIntTy, 1);
|
|
|
|
}
|
|
|
|
|
2002-04-29 18:46:50 +00:00
|
|
|
const Type *AllocationInst::getAllocatedType() const {
|
|
|
|
return getType()->getElementType();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// 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.
|
|
|
|
//
|
2001-07-20 21:07:06 +00:00
|
|
|
const Type* MemAccessInst::getIndexedType(const Type *Ptr,
|
2002-01-20 22:54:45 +00:00
|
|
|
const std::vector<Value*> &Idx,
|
2001-11-26 17:02:05 +00:00
|
|
|
bool AllowCompositeLeaf = false) {
|
2001-07-08 21:10:27 +00:00
|
|
|
if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type!
|
2001-12-14 16:43:26 +00:00
|
|
|
|
|
|
|
// Handle the special case of the empty set index set...
|
|
|
|
if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
|
2001-07-08 21:10:27 +00:00
|
|
|
|
2001-11-26 17:02:05 +00:00
|
|
|
unsigned CurIDX = 0;
|
2001-12-14 16:43:26 +00:00
|
|
|
while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
|
|
|
|
if (Idx.size() == CurIDX) {
|
|
|
|
if (AllowCompositeLeaf || CT->isFirstClassType()) return Ptr;
|
|
|
|
return 0; // Can't load a whole structure or array!?!?
|
|
|
|
}
|
2001-11-26 17:02:05 +00:00
|
|
|
|
|
|
|
Value *Index = Idx[CurIDX++];
|
2001-12-14 16:43:26 +00:00
|
|
|
if (!CT->indexValid(Index)) return 0;
|
|
|
|
Ptr = CT->getTypeAtIndex(Index);
|
2001-07-08 21:10:27 +00:00
|
|
|
}
|
2001-11-26 17:02:05 +00:00
|
|
|
return CurIDX == Idx.size() ? Ptr : 0;
|
2001-07-08 21:10:27 +00:00
|
|
|
}
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// LoadInst Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-01-20 22:54:45 +00:00
|
|
|
LoadInst::LoadInst(Value *Ptr, const std::vector<Value*> &Idx,
|
|
|
|
const std::string &Name = "")
|
2001-12-14 16:43:26 +00:00
|
|
|
: MemAccessInst(checkType(getIndexedType(Ptr->getType(), Idx)), Load, Name) {
|
2001-07-08 21:10:27 +00:00
|
|
|
assert(getIndexedType(Ptr->getType(), Idx) && "Load operands invalid!");
|
2001-07-08 23:22:50 +00:00
|
|
|
Operands.reserve(1+Idx.size());
|
|
|
|
Operands.push_back(Use(Ptr, this));
|
2001-07-20 21:07:06 +00:00
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
for (unsigned i = 0, E = Idx.size(); i != E; ++i)
|
|
|
|
Operands.push_back(Use(Idx[i], this));
|
2001-07-20 21:07:06 +00:00
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
}
|
|
|
|
|
2002-01-20 22:54:45 +00:00
|
|
|
LoadInst::LoadInst(Value *Ptr, const std::string &Name = "")
|
2001-12-04 00:03:30 +00:00
|
|
|
: MemAccessInst(cast<PointerType>(Ptr->getType())->getElementType(),
|
2001-11-26 17:02:05 +00:00
|
|
|
Load, Name) {
|
2001-11-01 05:58:42 +00:00
|
|
|
Operands.reserve(1);
|
|
|
|
Operands.push_back(Use(Ptr, this));
|
|
|
|
}
|
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// StoreInst Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-04-18 14:44:53 +00:00
|
|
|
StoreInst::StoreInst(Value *Val, Value *Ptr, const std::vector<Value*> &Idx)
|
|
|
|
: MemAccessInst(Type::VoidTy, Store, "") {
|
2001-07-08 23:22:50 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2002-04-18 14:44:53 +00:00
|
|
|
StoreInst::StoreInst(Value *Val, Value *Ptr)
|
|
|
|
: MemAccessInst(Type::VoidTy, Store, "") {
|
2001-11-01 05:58:42 +00:00
|
|
|
|
|
|
|
Operands.reserve(2);
|
|
|
|
Operands.push_back(Use(Val, this));
|
|
|
|
Operands.push_back(Use(Ptr, this));
|
|
|
|
}
|
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// GetElementPtrInst Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2002-01-20 22:54:45 +00:00
|
|
|
GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
|
|
|
|
const std::string &Name = "")
|
2001-12-14 16:43:26 +00:00
|
|
|
: MemAccessInst(PointerType::get(checkType(getIndexedType(Ptr->getType(),
|
|
|
|
Idx, true))),
|
2001-11-26 17:02:05 +00:00
|
|
|
GetElementPtr, Name) {
|
2001-07-08 23:22:50 +00:00
|
|
|
assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!");
|
2001-07-08 21:10:27 +00:00
|
|
|
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));
|
|
|
|
}
|
2002-04-29 18:46:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// FreeInst Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
FreeInst::FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") {
|
|
|
|
assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!");
|
|
|
|
Operands.reserve(1);
|
|
|
|
Operands.push_back(Use(Ptr, this));
|
|
|
|
}
|
|
|
|
|