6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-17 20:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Major overhaul to FoldGetElemPtr to handle mixed array and struct refs.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1968 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Vikram S. Adve 2002-03-24 03:37:53 +00:00
parent 4e7bc49b54
commit c941b87397
2 changed files with 70 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
lib/CodeGen/InstrSelection/InstrSelectionSupport.cpp
View File

@ -107,9 +107,10 @@ GetConstantValueAsSignedInt(const Value *V,
// Function: FoldGetElemChain
//
// Purpose:
// Fold a chain of GetElementPtr instructions into an equivalent
// (Pointer, IndexVector) pair. Returns the pointer Value, and
// stores the resulting IndexVector in argument chainIdxVec.
// Fold a chain of GetElementPtr instructions containing only
// structure offsets into an equivalent (Pointer, IndexVector) pair.
// Returns the pointer Value, and stores the resulting IndexVector
// in argument chainIdxVec.
//---------------------------------------------------------------------------
Value*
@ -120,11 +121,13 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
getElemInstrNode->getInstruction();
// Initialize return values from the incoming instruction
Value* ptrVal = getElemInst->getPointerOperand();
chainIdxVec = getElemInst->copyIndices();
Value* ptrVal = NULL;
assert(chainIdxVec.size() == 0);
// Now chase the chain of getElementInstr instructions, if any
InstrTreeNode* ptrChild = getElemInstrNode->leftChild();
// Now chase the chain of getElementInstr instructions, if any.
// Check for any array indices and stop there.
//
const InstrTreeNode* ptrChild = getElemInstrNode;
while (ptrChild->getOpLabel() == Instruction::GetElementPtr ||
ptrChild->getOpLabel() == GetElemPtrIdx)
{
@ -132,10 +135,32 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
getElemInst = (MemAccessInst*)
((InstructionNode*) ptrChild)->getInstruction();
const vector<Value*>& idxVec = getElemInst->copyIndices();
bool allStructureOffsets = true;
// Get the pointer value out of ptrChild and *prepend* its index vector
ptrVal = getElemInst->getPointerOperand();
chainIdxVec.insert(chainIdxVec.begin(), idxVec.begin(), idxVec.end());
// If it is a struct* access, the first offset must be array index [0],
// and all other offsets must be structure (not array) offsets
if (!isa<ConstantUInt>(idxVec.front()) ||
cast<ConstantUInt>(idxVec.front())->getValue() != 0)
allStructureOffsets = false;
if (allStructureOffsets)
for (unsigned int i=1; i < idxVec.size(); i++)
if (idxVec[i]->getType() == Type::UIntTy)
{
allStructureOffsets = false;
break;
}
if (allStructureOffsets)
{ // Get pointer value out of ptrChild and *prepend* its index vector
ptrVal = getElemInst->getPointerOperand();
chainIdxVec.insert(chainIdxVec.begin(),
idxVec.begin()+1, idxVec.end());
((InstructionNode*) ptrChild)->markFoldedIntoParent();
// mark so no code is generated
}
else // cannot fold this getElementPtr instr. or any further ones
break;
ptrChild = ptrChild->leftChild();
}

45
lib/Target/SparcV9/InstrSelection/InstrSelectionSupport.cpp
View File

@ -107,9 +107,10 @@ GetConstantValueAsSignedInt(const Value *V,
// Function: FoldGetElemChain
//
// Purpose:
// Fold a chain of GetElementPtr instructions into an equivalent
// (Pointer, IndexVector) pair. Returns the pointer Value, and
// stores the resulting IndexVector in argument chainIdxVec.
// Fold a chain of GetElementPtr instructions containing only
// structure offsets into an equivalent (Pointer, IndexVector) pair.
// Returns the pointer Value, and stores the resulting IndexVector
// in argument chainIdxVec.
//---------------------------------------------------------------------------
Value*
@ -120,11 +121,13 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
getElemInstrNode->getInstruction();
// Initialize return values from the incoming instruction
Value* ptrVal = getElemInst->getPointerOperand();
chainIdxVec = getElemInst->copyIndices();
Value* ptrVal = NULL;
assert(chainIdxVec.size() == 0);
// Now chase the chain of getElementInstr instructions, if any
InstrTreeNode* ptrChild = getElemInstrNode->leftChild();
// Now chase the chain of getElementInstr instructions, if any.
// Check for any array indices and stop there.
//
const InstrTreeNode* ptrChild = getElemInstrNode;
while (ptrChild->getOpLabel() == Instruction::GetElementPtr ||
ptrChild->getOpLabel() == GetElemPtrIdx)
{
@ -132,10 +135,32 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
getElemInst = (MemAccessInst*)
((InstructionNode*) ptrChild)->getInstruction();
const vector<Value*>& idxVec = getElemInst->copyIndices();
bool allStructureOffsets = true;
// Get the pointer value out of ptrChild and *prepend* its index vector
ptrVal = getElemInst->getPointerOperand();
chainIdxVec.insert(chainIdxVec.begin(), idxVec.begin(), idxVec.end());
// If it is a struct* access, the first offset must be array index [0],
// and all other offsets must be structure (not array) offsets
if (!isa<ConstantUInt>(idxVec.front()) ||
cast<ConstantUInt>(idxVec.front())->getValue() != 0)
allStructureOffsets = false;
if (allStructureOffsets)
for (unsigned int i=1; i < idxVec.size(); i++)
if (idxVec[i]->getType() == Type::UIntTy)
{
allStructureOffsets = false;
break;
}
if (allStructureOffsets)
{ // Get pointer value out of ptrChild and *prepend* its index vector
ptrVal = getElemInst->getPointerOperand();
chainIdxVec.insert(chainIdxVec.begin(),
idxVec.begin()+1, idxVec.end());
((InstructionNode*) ptrChild)->markFoldedIntoParent();
// mark so no code is generated
}
else // cannot fold this getElementPtr instr. or any further ones
break;
ptrChild = ptrChild->leftChild();
}