6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-03 14:08:57 +00:00
Code Issues Projects Releases Wiki Activity

Load tracking means that the value analyzed may

Browse Source 
not have pointer type.  In particular, it may
be the condition argument for a select or a GEP
index.  While I was unable to construct a testcase
for which some bits of the original pointer are
captured due to one of these, it's very very close
to being possible - so play safe and exclude these
possibilities.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61580 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2009-01-02 15:16:38 +00:00
parent c3651569c1
commit 9c5a5b01b4
1 changed files with 8 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/Transforms/IPO/FunctionAttrs.cpp
View File

@ -198,6 +198,7 @@ bool FunctionAttrs::isCaptured(Function &F, Value *V) {
UseWithDepth UD = Worklist.pop_back_val();
Use *U = UD.getPointer();
Instruction *I = cast<Instruction>(U->getUser());
// The value V may have any type if it comes from tracking a load.
V = U->get();
// The depth represents the number of loads that need to be performed to
// get back the original pointer (or a bitcast etc of it). For example,
@ -253,7 +254,10 @@ bool FunctionAttrs::isCaptured(Function &F, Value *V) {
// Only passed via 'nocapture' arguments, or is the called function - not
// captured.
} else if (isa<BitCastInst>(I) || isa<LoadInst>(I) || isa<PHINode>(I) ||
isa<GetElementPtrInst>(I) || isa<SelectInst>(I)) {
// Play safe and exclude GEP indices.
(isa<GetElementPtrInst>(I) && V == I->getOperand(0)) ||
// Play safe and exclude the select condition.
(isa<SelectInst>(I) && V != I->getOperand(0))) {
// Usually loads can be ignored because they dereference the original
// pointer. However the loaded value needs to be tracked if loading
@ -267,7 +271,9 @@ bool FunctionAttrs::isCaptured(Function &F, Value *V) {
continue;
// Loading a pointer to (a pointer to...) the original pointer or a
// variation of it. Track uses of the loaded value, noting that one
// dereference was performed.
// dereference was performed. Note that the loaded value need not be
// of pointer type. For example, an alloca may have been bitcast to
// a pointer to another type, which was then loaded.
--Depth;
}