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"
|
|
|
|
#include "llvm/ConstPoolVals.h"
|
|
|
|
|
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,
|
2001-11-26 17:02:05 +00:00
|
|
|
const vector<Value*> &Idx,
|
|
|
|
bool AllowCompositeLeaf = false) {
|
2001-07-08 21:10:27 +00:00
|
|
|
if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type!
|
|
|
|
|
|
|
|
// Get the type pointed to...
|
2001-11-26 17:02:05 +00:00
|
|
|
Ptr = cast<PointerType>(Ptr)->getValueType();
|
2001-07-20 21:07:06 +00:00
|
|
|
|
2001-11-26 17:02:05 +00:00
|
|
|
unsigned CurIDX = 0;
|
|
|
|
while (const CompositeType *ST = dyn_cast<CompositeType>(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);
|
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-11-26 17:02:05 +00:00
|
|
|
const vector<ConstPoolVal*> 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";
|
|
|
|
|
|
|
|
vector<ConstPoolVal*> RetVal;
|
|
|
|
|
|
|
|
// 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<ConstPoolVal>(getOperand(i)));
|
|
|
|
|
|
|
|
return RetVal;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-07-08 23:22:50 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// LoadInst Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2001-11-26 17:02:05 +00:00
|
|
|
LoadInst::LoadInst(Value *Ptr, const vector<Value*> &Idx,
|
2001-07-08 21:10:27 +00:00
|
|
|
const string &Name = "")
|
2001-11-26 17:02:05 +00:00
|
|
|
: MemAccessInst(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
|
|
|
}
|
|
|
|
|
2001-11-01 05:58:42 +00:00
|
|
|
LoadInst::LoadInst(Value *Ptr, const string &Name = "")
|
|
|
|
: MemAccessInst(cast<PointerType>(Ptr->getType())->getValueType(),
|
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
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2001-11-26 17:02:05 +00:00
|
|
|
StoreInst::StoreInst(Value *Val, Value *Ptr, const vector<Value*> &Idx,
|
2001-07-08 23:22:50 +00:00
|
|
|
const string &Name = "")
|
2001-11-26 17:02:05 +00:00
|
|
|
: MemAccessInst(Type::VoidTy, Store, Name) {
|
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));
|
|
|
|
}
|
|
|
|
|
2001-11-01 05:58:42 +00:00
|
|
|
StoreInst::StoreInst(Value *Val, Value *Ptr, const string &Name = "")
|
2001-11-26 17:02:05 +00:00
|
|
|
: MemAccessInst(Type::VoidTy, Store, Name) {
|
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
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2001-11-26 17:02:05 +00:00
|
|
|
GetElementPtrInst::GetElementPtrInst(Value *Ptr, const vector<Value*> &Idx,
|
2001-07-08 23:22:50 +00:00
|
|
|
const string &Name = "")
|
2001-09-07 16:57:29 +00:00
|
|
|
: MemAccessInst(PointerType::get(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));
|
|
|
|
}
|
|
|
|
|
2001-07-14 06:13:19 +00:00
|
|
|
bool GetElementPtrInst::isStructSelector() const {
|
|
|
|
return ((PointerType*)Operands[0]->getType())->getValueType()->isStructType();
|
|
|
|
}
|