};
-//===----------------------------------------------------------------------===//
-// MemAccessInst Class
-//===----------------------------------------------------------------------===//
-//
-// MemAccessInst - Common base class of GetElementPtrInst...
-//
-class MemAccessInst : public Instruction {
-protected:
- inline MemAccessInst(const Type *Ty, unsigned Opcode,
- const std::string &Nam = "")
- : Instruction(Ty, Opcode, Nam) {}
-public:
- // 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.
- //
- static const Type *getIndexedType(const Type *Ptr,
- const std::vector<Value*> &Indices,
- bool AllowStructLeaf = false);
-
- inline op_iterator idx_begin() {
- return op_begin()+getFirstIndexOperandNumber();
- }
- inline const_op_iterator idx_begin() const {
- return op_begin()+getFirstIndexOperandNumber();
- }
- inline op_iterator idx_end() { return op_end(); }
- inline const_op_iterator idx_end() const { return op_end(); }
-
-
- std::vector<Value*> copyIndices() const {
- return std::vector<Value*>(idx_begin(), idx_end());
- }
-
- Value *getPointerOperand() {
- return getOperand(getFirstIndexOperandNumber()-1);
- }
- const Value *getPointerOperand() const {
- return getOperand(getFirstIndexOperandNumber()-1);
- }
-
- virtual unsigned getFirstIndexOperandNumber() const = 0;
-
- inline unsigned getNumIndices() const { // Note: always non-negative
- return (getNumOperands() - getFirstIndexOperandNumber());
- }
-
- inline bool hasIndices() const {
- return getNumIndices() > 0;
- }
-
- // Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const MemAccessInst *) { return true; }
- static inline bool classof(const Instruction *I) {
- return I->getOpcode() == GetElementPtr;
- }
- static inline bool classof(const Value *V) {
- return isa<Instruction>(V) && classof(cast<Instruction>(V));
- }
-};
-
-
//===----------------------------------------------------------------------===//
// LoadInst Class
//===----------------------------------------------------------------------===//
// GetElementPtrInst Class
//===----------------------------------------------------------------------===//
-class GetElementPtrInst : public MemAccessInst {
+class GetElementPtrInst : public Instruction {
GetElementPtrInst(const GetElementPtrInst &EPI)
- : MemAccessInst((Type*)EPI.getType(), GetElementPtr) {
+ : Instruction((Type*)EPI.getType(), GetElementPtr) {
Operands.reserve(EPI.Operands.size());
for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
Operands.push_back(Use(EPI.Operands[i], this));
GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name = "");
virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
- virtual unsigned getFirstIndexOperandNumber() const { return 1; }
// getType - Overload to return most specific pointer type...
inline const PointerType *getType() const {
return (PointerType*)Instruction::getType();
}
+ /// 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.
+ ///
+ static const Type *getIndexedType(const Type *Ptr,
+ const std::vector<Value*> &Indices,
+ bool AllowStructLeaf = false);
+
+ inline op_iterator idx_begin() {
+ return op_begin()+1;
+ }
+ inline const_op_iterator idx_begin() const {
+ return op_begin()+1;
+ }
+ inline op_iterator idx_end() { return op_end(); }
+ inline const_op_iterator idx_end() const { return op_end(); }
+
+ Value *getPointerOperand() {
+ return getOperand(0);
+ }
+ const Value *getPointerOperand() const {
+ return getOperand(0);
+ }
+
+ inline unsigned getNumIndices() const { // Note: always non-negative
+ return getNumOperands() - 1;
+ }
+
+ inline bool hasIndices() const {
+ return getNumOperands() > 1;
+ }
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const GetElementPtrInst *) { return true; }
static inline bool classof(const Instruction *I) {
Idx.push_back(V = getValue(TopTy->getIndexType(), Raw.Arg2));
if (!V) return true;
- const Type *ETy = MemAccessInst::getIndexedType(TopTy, Idx, true);
+ const Type *ETy = GetElementPtrInst::getIndexedType(TopTy, Idx, true);
const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
if (!ElTy) return true;
vector<unsigned> &args = *Raw.VarArgs;
for (unsigned i = 0, E = args.size(); i != E; ++i) {
- const Type *ETy = MemAccessInst::getIndexedType(Raw.Ty, Idx, true);
+ const Type *ETy = GetElementPtrInst::getIndexedType(Raw.Ty, Idx, true);
const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
if (!ElTy) return true;
Idx.push_back(V = getValue(ElTy->getIndexType(), args[i]));
if (!Idx.empty()) {
cerr << "WARNING: Bytecode contains load instruction with indices. "
<< "Replacing with getelementptr/load pair\n";
- assert(MemAccessInst::getIndexedType(Raw.Ty, Idx) &&
+ assert(GetElementPtrInst::getIndexedType(Raw.Ty, Idx) &&
"Bad indices for Load!");
Src = new GetElementPtrInst(Src, Idx);
// FIXME: Remove this compatibility code and the BB parameter to this
Idx.push_back(V = getValue(ElTy->getIndexType(), args[i]));
if (!V) return true;
- const Type *ETy = MemAccessInst::getIndexedType(Raw.Ty, Idx, true);
+ const Type *ETy = GetElementPtrInst::getIndexedType(Raw.Ty, Idx, true);
ElTy = dyn_cast_or_null<CompositeType>(ETy);
}
if (i != E)
{
opLabel = AllocaN; // Alloca(ptr, N) operation
}
- else if ((opLabel == Instruction::Load ||
- opLabel == Instruction::GetElementPtr) &&
- cast<MemAccessInst>(I)->hasIndices())
+ else if (opLabel == Instruction::GetElementPtr &&
+ cast<GetElementPtrInst>(I)->hasIndices())
{
- opLabel = opLabel + 100; // load/getElem with index vector
+ opLabel = opLabel + 100; // getElem with index vector
}
else if (opLabel == Instruction::Xor &&
BinaryOperator::isNot(I))
FoldGetElemChain(const InstructionNode* getElemInstrNode,
vector<Value*>& chainIdxVec)
{
- MemAccessInst* getElemInst = (MemAccessInst*)
- getElemInstrNode->getInstruction();
+ GetElementPtrInst* getElemInst =
+ cast<GetElementPtrInst>(getElemInstrNode->getInstruction());
// Return NULL if we don't fold any instructions in.
Value* ptrVal = NULL;
ptrChild->getOpLabel() == GetElemPtrIdx)
{
// Child is a GetElemPtr instruction
- getElemInst = cast<MemAccessInst>(ptrChild->getValue());
- MemAccessInst::op_iterator OI, firstIdx = getElemInst->idx_begin();
- MemAccessInst::op_iterator lastIdx = getElemInst->idx_end();
+ getElemInst = cast<GetElementPtrInst>(ptrChild->getValue());
+ User::op_iterator OI, firstIdx = getElemInst->idx_begin();
+ User::op_iterator lastIdx = getElemInst->idx_end();
bool allConstantOffsets = true;
// Check that all offsets are constant for this instruction
// the offset that arguments ArgOff+1 -> NumArgs specify for the pointer type
// specified by argument Arg.
//
-static PointerTy getElementOffset(MemAccessInst &I, ExecutionContext &SF) {
+static PointerTy getElementOffset(GetElementPtrInst &I, ExecutionContext &SF) {
assert(isa<PointerType>(I.getPointerOperand()->getType()) &&
"Cannot getElementOffset of a nonpointer type!");
PointerTy Total = 0;
const Type *Ty = I.getPointerOperand()->getType();
- unsigned ArgOff = I.getFirstIndexOperandNumber();
+ unsigned ArgOff = 1;
while (ArgOff < I.getNumOperands()) {
if (const StructType *STy = dyn_cast<StructType>(Ty)) {
const StructLayout *SLO = TD.getStructLayout(STy);
if (Idx >= AT->getNumElements() && ArrayChecksEnabled) {
cerr << "Out of range memory access to element #" << Idx
<< " of a " << AT->getNumElements() << " element array."
- << " Subscript #" << (ArgOff-I.getFirstIndexOperandNumber())
- << "\n";
+ << " Subscript #" << (ArgOff-1) << "\n";
// Get outta here!!!
siglongjmp(SignalRecoverBuffer, SIGTRAP);
}
{
opLabel = AllocaN; // Alloca(ptr, N) operation
}
- else if ((opLabel == Instruction::Load ||
- opLabel == Instruction::GetElementPtr) &&
- cast<MemAccessInst>(I)->hasIndices())
+ else if (opLabel == Instruction::GetElementPtr &&
+ cast<GetElementPtrInst>(I)->hasIndices())
{
- opLabel = opLabel + 100; // load/getElem with index vector
+ opLabel = opLabel + 100; // getElem with index vector
}
else if (opLabel == Instruction::Xor &&
BinaryOperator::isNot(I))
FoldGetElemChain(const InstructionNode* getElemInstrNode,
vector<Value*>& chainIdxVec)
{
- MemAccessInst* getElemInst = (MemAccessInst*)
- getElemInstrNode->getInstruction();
+ GetElementPtrInst* getElemInst =
+ cast<GetElementPtrInst>(getElemInstrNode->getInstruction());
// Return NULL if we don't fold any instructions in.
Value* ptrVal = NULL;
ptrChild->getOpLabel() == GetElemPtrIdx)
{
// Child is a GetElemPtr instruction
- getElemInst = cast<MemAccessInst>(ptrChild->getValue());
- MemAccessInst::op_iterator OI, firstIdx = getElemInst->idx_begin();
- MemAccessInst::op_iterator lastIdx = getElemInst->idx_end();
+ getElemInst = cast<GetElementPtrInst>(ptrChild->getValue());
+ User::op_iterator OI, firstIdx = getElemInst->idx_begin();
+ User::op_iterator lastIdx = getElemInst->idx_end();
bool allConstantOffsets = true;
// Check that all offsets are constant for this instruction
static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal,
ValueMapCache &VMC);
-// AllIndicesZero - Return true if all of the indices of the specified memory
-// access instruction are zero, indicating an effectively nil offset to the
-// pointer value.
-//
-static bool AllIndicesZero(const MemAccessInst *MAI) {
- for (User::const_op_iterator S = MAI->idx_begin(), E = MAI->idx_end();
- S != E; ++S)
- if (!isa<Constant>(S->get()) || !cast<Constant>(S->get())->isNullValue())
- return false;
- return true;
-}
-
-
// Peephole Malloc instructions: we take a look at the use chain of the
// malloc instruction, and try to find out if the following conditions hold:
// 1. The malloc is of the form: 'malloc [sbyte], uint <constant>'
// index array. If there are, check to see if removing them causes us to
// get to the right type...
//
- std::vector<Value*> Indices = GEP->copyIndices();
+ std::vector<Value*> Indices(GEP->idx_begin(), GEP->idx_end());
const Type *BaseType = GEP->getPointerOperand()->getType();
const Type *ElTy = 0;
// index array. If there are, check to see if removing them causes us to
// get to the right type...
//
- std::vector<Value*> Indices = GEP->copyIndices();
+ std::vector<Value*> Indices(GEP->idx_begin(), GEP->idx_end());
const Type *BaseType = GEP->getPointerOperand()->getType();
const Type *PVTy = cast<PointerType>(Ty)->getElementType();
Res = 0;
//
if (Res == 0) {
const PointerType *NewSrcTy = PointerType::get(PVTy);
+ std::vector<Value*> Indices(GEP->idx_begin(), GEP->idx_end());
Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy),
- GEP->copyIndices(), Name);
+ Indices, Name);
VMC.ExprMap[I] = Res;
Res->setOperand(0, ConvertExpressionToType(I->getOperand(0),
NewSrcTy, VMC));
// to getelementptr long * %reg123, uint %N
// ... where the type must simply stay the same size...
//
- Res = new GetElementPtrInst(NewVal,
- cast<GetElementPtrInst>(I)->copyIndices(),
- Name);
+ GetElementPtrInst *GEP = cast<GetElementPtrInst>(I);
+ std::vector<Value*> Indices(GEP->idx_begin(), GEP->idx_end());
+ Res = new GetElementPtrInst(NewVal, Indices, Name);
}
#endif
break;
{
bool Changed = false;
for (BasicBlock::iterator II = BB.begin(); II != BB.end(); ) {
- if (MemAccessInst *MAI = dyn_cast<MemAccessInst>(&*II))
- if (MAI->getNumIndices() >= 2) {
+ if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&*II))
+ if (GEP->getNumIndices() >= 2) {
Changed |= decomposeArrayRef(II); // always modifies II
continue;
}
return (isa<ConstantInt>(idx) && cast<ConstantInt>(idx)->isNullValue());
}
-// For any MemAccessInst with 2 or more array and structure indices:
+// For any GetElementPtrInst with 2 or more array and structure indices:
//
// opCode CompositeType* P, [uint|ubyte] idx1, ..., [uint|ubyte] idxN
//
bool
DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI)
{
- MemAccessInst &MAI = cast<MemAccessInst>(*BBI);
- BasicBlock *BB = MAI.getParent();
- Value *LastPtr = MAI.getPointerOperand();
+ GetElementPtrInst &GEP = cast<GetElementPtrInst>(*BBI);
+ BasicBlock *BB = GEP.getParent();
+ Value *LastPtr = GEP.getPointerOperand();
// Remove the instruction from the stream
BB->getInstList().remove(BBI);
std::vector<Instruction*> NewInsts;
// Process each index except the last one.
- User::const_op_iterator OI = MAI.idx_begin(), OE = MAI.idx_end();
+ User::const_op_iterator OI = GEP.idx_begin(), OE = GEP.idx_end();
for (; OI+1 != OE; ++OI) {
std::vector<Value*> Indices;
// If this is the first index and is 0, skip it and move on!
- if (OI == MAI.idx_begin()) {
+ if (OI == GEP.idx_begin()) {
if (IsZero(*OI)) continue;
} else
// Not the first index: include initial [0] to deref the last ptr
Indices.push_back(Constant::getNullValue(Type::UIntTy));
Indices.push_back(*OI);
- Instruction *NewI = 0;
- switch(MAI.getOpcode()) {
- case Instruction::GetElementPtr:
- NewI = new GetElementPtrInst(LastPtr, Indices, MAI.getName());
- break;
- default:
- assert(0 && "Unrecognized memory access instruction");
- }
+ Instruction *NewI = new GetElementPtrInst(LastPtr, Indices, GEP.getName());
NewInsts.push_back(NewI);
// Replace all uses of the old instruction with the new
- MAI.replaceAllUsesWith(NewI);
+ GEP.replaceAllUsesWith(NewI);
// Now delete the old instruction...
- delete &MAI;
+ delete &GEP;
// Insert all of the new instructions...
BB->getInstList().insert(BBI, NewInsts.begin(), NewInsts.end());
// Instructions that cannot be folded away...
void visitStoreInst (Instruction &I) { /*returns void*/ }
- void visitMemAccessInst (Instruction &I) { markOverdefined(&I); }
+ void visitLoadInst (Instruction &I) { markOverdefined(&I); }
+ void visitGetElementPtrInst(Instruction &I) { markOverdefined(&I); } // FIXME
void visitCallInst (Instruction &I) { markOverdefined(&I); }
void visitInvokeInst (Instruction &I) { markOverdefined(&I); }
void visitAllocationInst(Instruction &I) { markOverdefined(&I); }
static inline bool isSafeAlloca(const AllocaInst *AI) {
if (AI->isArrayAllocation()) return false;
+ // Only allow direct loads and stores...
for (Value::use_const_iterator UI = AI->use_begin(), UE = AI->use_end();
- UI != UE; ++UI) { // Loop over all of the uses of the alloca
-
- // Only allow nonindexed memory access instructions...
- if (MemAccessInst *MAI = dyn_cast<MemAccessInst>(*UI)) {
- if (MAI->getPointerOperand() != (Value*)AI)
- return false; // Reject stores of alloca pointer into some other loc.
-
- if (MAI->hasIndices()) { // indexed?
- // Allow the access if there is only one index and the index is
- // zero.
- if (*MAI->idx_begin() != Constant::getNullValue(Type::UIntTy) ||
- MAI->idx_begin()+1 != MAI->idx_end())
- return false;
- }
- } else {
+ UI != UE; ++UI) // Loop over all of the uses of the alloca
+ if (!isa<LoadInst>(*UI) && !isa<StoreInst>(*UI))
return false; // Not a load or store?
- }
- }
return true;
}
}
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
- const Type *ElTy = MemAccessInst::getIndexedType(GEP.getOperand(0)->getType(),
- GEP.copyIndices(), true);
+ const Type *ElTy =
+ GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
+ std::vector<Value*>(GEP.idx_begin(), GEP.idx_end()), true);
Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
Assert2(PointerType::get(ElTy) == GEP.getType(),
"GEP is not of right type for indices!", &GEP, ElTy);
}
-//===----------------------------------------------------------------------===//
-// 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 std::vector<Value*> &Idx,
- bool AllowCompositeLeaf) {
- if (!isa<PointerType>(Ptr)) return 0; // Type isn't a pointer type!
-
- // Handle the special case of the empty set index set...
- if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
-
- unsigned CurIDX = 0;
- 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!?!?
- }
-
- Value *Index = Idx[CurIDX++];
- if (!CT->indexValid(Index)) return 0;
- Ptr = CT->getTypeAtIndex(Index);
- }
- return CurIDX == Idx.size() ? Ptr : 0;
-}
-
-
//===----------------------------------------------------------------------===//
// LoadInst Implementation
//===----------------------------------------------------------------------===//
GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name)
- : MemAccessInst(PointerType::get(checkType(getIndexedType(Ptr->getType(),
+ : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
Idx, true))),
GetElementPtr, Name) {
assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!");
Operands.push_back(Use(Idx[i], this));
}
+// 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<Value*> &Idx,
+ bool AllowCompositeLeaf) {
+ if (!isa<PointerType>(Ptr)) return 0; // Type isn't a pointer type!
+
+ // Handle the special case of the empty set index set...
+ if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
+
+ unsigned CurIDX = 0;
+ 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!?!?
+ }
+
+ Value *Index = Idx[CurIDX++];
+ if (!CT->indexValid(Index)) return 0;
+ Ptr = CT->getTypeAtIndex(Index);
+ }
+ return CurIDX == Idx.size() ? Ptr : 0;
+}
+
//===----------------------------------------------------------------------===//
// FreeInst Implementation
projects / oota-llvm.git / commitdiff