6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-18 06:38:41 +00:00
Code Issues Projects Releases Wiki Activity

eliminate a bunch of code in favor of using AliasAnalysis::getModRefInfo.

Browse Source 
Put a some code back to handle buggy behavior that GVN expects: it wants
loads to depend on each other, and accesses to depend on their allocations.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60240 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-11-29 09:09:48 +00:00
parent 10ca770020
commit a161ab06d9
1 changed files with 53 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -311,55 +311,19 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt,
while (ScanIt != BB->begin()) { while (ScanIt != BB->begin()) {
Instruction *Inst = --ScanIt; Instruction *Inst = --ScanIt;
// If this inst is a memory op, get the pointer it accessed // If the access is volatile and this is a volatile load/store, return a
Value *Pointer = 0; // dependence.
uint64_t PointerSize = 0; if (MemVolatile &&
if (StoreInst *S = dyn_cast<StoreInst>(Inst)) { ((isa<LoadInst>(Inst) && cast<LoadInst>(Inst)->isVolatile()) ||
// All volatile loads/stores depend on each other. (isa<StoreInst>(Inst) && cast<StoreInst>(Inst)->isVolatile())))
if (MemVolatile && S->isVolatile())
return MemDepResult::get(S);
Pointer = S->getPointerOperand();
PointerSize = TD.getTypeStoreSize(S->getOperand(0)->getType());
} else if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
// All volatile loads/stores depend on each other
if (MemVolatile && L->isVolatile())
return MemDepResult::get(L);
Pointer = L->getPointerOperand();
PointerSize = TD.getTypeStoreSize(L->getType());
} else if (AllocationInst *AI = dyn_cast<AllocationInst>(Inst)) {
Pointer = AI;
if (ConstantInt *C = dyn_cast<ConstantInt>(AI->getArraySize()))
PointerSize = C->getZExtValue() *
TD.getTypeStoreSize(AI->getAllocatedType());
else
PointerSize = ~0UL;
} else if (VAArgInst *V = dyn_cast<VAArgInst>(Inst)) {
Pointer = V->getOperand(0);
PointerSize = TD.getTypeStoreSize(V->getType());
} else if (FreeInst *F = dyn_cast<FreeInst>(Inst)) {
Pointer = F->getPointerOperand();
// FreeInsts erase the entire structure.
PointerSize = ~0UL;
} else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) {
// Calls need special handling. Check if they can modify our pointer.
AliasAnalysis::ModRefResult MR =
AA.getModRefInfo(CallSite::get(Inst), MemPtr, MemSize);
if (MR == AliasAnalysis::NoModRef)
continue;
// Loads don't depend on read-only calls
if (isa<LoadInst>(QueryInst) && MR == AliasAnalysis::Ref)
continue;
return MemDepResult::get(Inst); return MemDepResult::get(Inst);
} else {
// Non memory instruction, move to the next one. // MemDep is broken w.r.t. loads: it says that two loads of the same pointer
continue; // depend on each other. :(
} // FIXME: ELIMINATE THIS!
if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
Value *Pointer = L->getPointerOperand();
uint64_t PointerSize = TD.getTypeStoreSize(L->getType());
// If we found a pointer, check if it could be the same as our pointer // If we found a pointer, check if it could be the same as our pointer
AliasAnalysis::AliasResult R = AliasAnalysis::AliasResult R =
@ -369,12 +333,46 @@ getDependencyFrom(Instruction *QueryInst, BasicBlock::iterator ScanIt,
continue; continue;
// May-alias loads don't depend on each other without a dependence. // May-alias loads don't depend on each other without a dependence.
if (isa<LoadInst>(QueryInst) && isa<LoadInst>(Inst) && if (isa<LoadInst>(QueryInst) && R == AliasAnalysis::MayAlias)
R == AliasAnalysis::MayAlias)
continue; continue;
return MemDepResult::get(Inst); return MemDepResult::get(Inst);
} }
// FIXME: This claims that an access depends on the allocation. This may
// make sense, but is dubious at best. It would be better to fix GVN to
// handle a 'None' Query.
if (AllocationInst *AI = dyn_cast<AllocationInst>(Inst)) {
Value *Pointer = AI;
uint64_t PointerSize;
if (ConstantInt *C = dyn_cast<ConstantInt>(AI->getArraySize()))
PointerSize = C->getZExtValue() *
TD.getTypeStoreSize(AI->getAllocatedType());
else
PointerSize = ~0UL;
AliasAnalysis::AliasResult R =
AA.alias(Pointer, PointerSize, MemPtr, MemSize);
if (R == AliasAnalysis::NoAlias)
continue;
return MemDepResult::get(Inst);
}
// See if this instruction mod/ref's the pointer.
AliasAnalysis::ModRefResult MRR = AA.getModRefInfo(Inst, MemPtr, MemSize);
if (MRR == AliasAnalysis::NoModRef)
continue;
// Loads don't depend on read-only instructions.
if (isa<LoadInst>(QueryInst) && MRR == AliasAnalysis::Ref)
continue;
// Otherwise, there is a dependence.
return MemDepResult::get(Inst);
}
// If we found nothing, return the non-local flag. // If we found nothing, return the non-local flag.
return MemDepResult::getNonLocal(); return MemDepResult::getNonLocal();
} }