RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-03 08:51:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Eliminated the MemAccessInst class, folding contents into GEP class.

Browse Source 
llvm-svn: 3488
This commit is contained in:
Chris Lattner 2002-08-22 23:37:24 +00:00
parent 20b85d96e4
commit 9f18db8156
4 changed files with 16 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Support/InstVisitor.h
View File

@ -54,7 +54,7 @@ class Module;
// Forward declare the intermediate types...
class TerminatorInst; class BinaryOperator;
class AllocationInst; class MemAccessInst;
class AllocationInst;
#define DELEGATE(CLASS_TO_VISIT) \
@ -166,7 +166,7 @@ struct InstVisitor {
RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); }
RetTy visitLoadInst(LoadInst &I) { DELEGATE(Instruction); }
RetTy visitStoreInst(StoreInst &I) { DELEGATE(Instruction); }
RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(MemAccessInst); }
RetTy visitGetElementPtrInst(GetElementPtrInst &I){ DELEGATE(Instruction); }
RetTy visitPHINode(PHINode &I) { DELEGATE(Instruction); }
RetTy visitCastInst(CastInst &I) { DELEGATE(Instruction); }
RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
@ -179,7 +179,6 @@ struct InstVisitor {
RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); }
RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); }
RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); }
RetTy visitMemAccessInst (MemAccessInst &I) { DELEGATE(Instruction); }
// If the user wants a 'default' case, they can choose to override this
// function. If this function is not overloaded in the users subclass, then

17
lib/Analysis/DataStructure/Local.cpp
View File

@ -101,7 +101,7 @@ namespace {
// getSubscriptedNode - Perform the basic getelementptr functionality that
// must be factored out of gep, load and store while they are all MAI's.
//
DSNode *getSubscriptedNode(MemAccessInst &MAI, DSNode *Ptr);
DSNode *getSubscriptedNode(GetElementPtrInst &GEP, DSNode *Ptr);
};
}
@ -218,16 +218,15 @@ DSNode *GraphBuilder::getLink(DSNode *Node, unsigned Link) {
// getSubscriptedNode - Perform the basic getelementptr functionality that must
// be factored out of gep, load and store while they are all MAI's.
//
DSNode *GraphBuilder::getSubscriptedNode(MemAccessInst &MAI, DSNode *Ptr) {
for (unsigned i = MAI.getFirstIndexOperandNumber(), e = MAI.getNumOperands();
i != e; ++i)
if (MAI.getOperand(i)->getType() == Type::UIntTy)
DSNode *GraphBuilder::getSubscriptedNode(GetElementPtrInst &GEP, DSNode *Ptr) {
for (unsigned i = 1, e = GEP.getNumOperands(); i != e; ++i)
if (GEP.getOperand(i)->getType() == Type::UIntTy)
Ptr = getLink(Ptr, 0);
else if (MAI.getOperand(i)->getType() == Type::UByteTy)
Ptr = getLink(Ptr, cast<ConstantUInt>(MAI.getOperand(i))->getValue());
else if (GEP.getOperand(i)->getType() == Type::UByteTy)
Ptr = getLink(Ptr, cast<ConstantUInt>(GEP.getOperand(i))->getValue());
if (MAI.getFirstIndexOperandNumber() == MAI.getNumOperands())
Ptr = getLink(Ptr, 0); // All MAI's have an implicit 0 if nothing else.
if (GEP.getNumOperands() == 1)
Ptr = getLink(Ptr, 0); // All GEP's have an implicit 0 if nothing else.
return Ptr;
}

10
lib/Target/Sparc/SparcInstrSelection.cpp
View File

@ -963,7 +963,8 @@ SetOperandsForMemInstr(vector<MachineInstr*>& mvec,
const InstructionNode* vmInstrNode,
const TargetMachine& target)
{
MemAccessInst* memInst = (MemAccessInst*) vmInstrNode->getInstruction();
GetElementPtrInst* memInst =
cast<GetElementPtrInst>(vmInstrNode->getInstruction());
// Variables to hold the index vector and ptr value.
// The major work here is to extract these for all 3 instruction types
@ -982,7 +983,7 @@ SetOperandsForMemInstr(vector<MachineInstr*>& mvec,
: vmInstrNode->leftChild());
// Check if all indices are constant for this instruction
for (MemAccessInst::op_iterator OI=memInst->idx_begin(),OE=memInst->idx_end();
for (User::op_iterator OI=memInst->idx_begin(),OE=memInst->idx_end();
allConstantIndices && OI != OE; ++OI)
if (! isa<Constant>(*OI))
allConstantIndices = false;
@ -1024,7 +1025,8 @@ SetMemOperands_Internal(vector<MachineInstr*>& mvec,
bool allConstantIndices,
const TargetMachine& target)
{
MemAccessInst* memInst = (MemAccessInst*) vmInstrNode->getInstruction();
GetElementPtrInst* memInst =
cast<GetElementPtrInst>(vmInstrNode->getInstruction());
// Initialize so we default to storing the offset in a register.
int64_t smallConstOffset = 0;
@ -1035,7 +1037,7 @@ SetMemOperands_Internal(vector<MachineInstr*>& mvec,
// Check if there is an index vector and if so, compute the
// right offset for structures and for arrays
//
if (idxVec.size() > 0)
if (!idxVec.empty())
{
const PointerType* ptrType = cast<PointerType>(ptrVal->getType());

6
lib/Transforms/IPO/MutateStructTypes.cpp
View File

@ -413,15 +413,9 @@ void MutateStructTypes::transformFunction(Function *m) {
break;
case Instruction::Load:
assert(cast<MemAccessInst>(I).idx_begin() ==
cast<MemAccessInst>(I).idx_end() &&
"Indexing loads not supported!");
NewI = new LoadInst(ConvertValue(I.getOperand(0)));
break;
case Instruction::Store:
assert(cast<MemAccessInst>(I).idx_begin() ==
cast<MemAccessInst>(I).idx_end() &&
"Indexing loads not supported!");
NewI = new StoreInst(ConvertValue(I.getOperand(0)),
ConvertValue(I.getOperand(1)));
break;