6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2026-04-25 05:22:04 +00:00
Code Issues Projects Releases Wiki Activity

Rather than marking all internal globals "Ref"

Browse Source 
when a readonly declaration is called, set a
flag.  This is faster and uses less memory.
In theory it is less accurate, because before
only those internal globals that were read
by someone were being marked "Ref", but now
all are.  But in practice, thanks to other
passes, all internal globals of the kind
considered here will be both read and stored
to: those only read will have been turned
into constants, and those only stored to will
have been deleted.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56143 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
2008-09-12 07:29:58 +00:00
parent e2f2083f9c
commit 2bb4a4d315
1 changed files with 11 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/Analysis/IPA/GlobalsModRef.cpp
+11 -17
View File
@@ -49,18 +49,22 @@ namespace {
/// function.
std::map<GlobalValue*, unsigned> GlobalInfo;
/// MayReadAnyGlobal - May read global variables, but it is not known which.
bool MayReadAnyGlobal;
unsigned getInfoForGlobal(GlobalValue *GV) const {
unsigned Effect = MayReadAnyGlobal ? AliasAnalysis::Ref : 0;
std::map<GlobalValue*, unsigned>::const_iterator I = GlobalInfo.find(GV);
if (I != GlobalInfo.end())
return I->second;
return 0;
Effect |= I->second;
return Effect;
}
/// FunctionEffect - Capture whether or not this function reads or writes to
/// ANY memory. If not, we can do a lot of aggressive analysis on it.
unsigned FunctionEffect;
FunctionRecord() : FunctionEffect(0) {}
FunctionRecord() : MayReadAnyGlobal (false), FunctionEffect(0) {}
};
/// GlobalsModRef - The actual analysis pass.
@@ -70,10 +74,6 @@ namespace {
/// taken.
std::set<GlobalValue*> NonAddressTakenGlobals;
/// ReadGlobals - The globals without addresses taken that are read by
/// some function.
std::set<GlobalValue*> ReadGlobals;
/// IndirectGlobals - The memory pointed to by this global is known to be
/// 'owned' by the global.
std::set<GlobalValue*> IndirectGlobals;
@@ -203,10 +203,6 @@ void GlobalsModRef::AnalyzeGlobals(Module &M) {
// Remember that we are tracking this global, and the mod/ref fns
NonAddressTakenGlobals.insert(I);
if (!Readers.empty())
// Some function read this global - remember that.
ReadGlobals.insert(I);
for (unsigned i = 0, e = Readers.size(); i != e; ++i)
FunctionInfo[Readers[i]].GlobalInfo[I] |= Ref;
@@ -384,13 +380,10 @@ void GlobalsModRef::AnalyzeCallGraph(CallGraph &CG, Module &M) {
// Can't do better than that!
} else if (F->onlyReadsMemory()) {
FunctionEffect |= Ref;
if (!F->isIntrinsic()) {
if (!F->isIntrinsic())
// This function might call back into the module and read a global -
// mark all globals read somewhere as being read by this function.
for (std::set<GlobalValue*>::iterator GI = ReadGlobals.begin(),
E = ReadGlobals.end(); GI != E; ++GI)
FR.GlobalInfo[*GI] |= Ref;
}
// consider every global as possibly being read by this function.
FR.MayReadAnyGlobal = true;
} else {
FunctionEffect |= ModRef;
// Can't say anything useful unless it's an intrinsic - they don't
@@ -412,6 +405,7 @@ void GlobalsModRef::AnalyzeCallGraph(CallGraph &CG, Module &M) {
CalleeFR->GlobalInfo.begin(), E = CalleeFR->GlobalInfo.end();
GI != E; ++GI)
FR.GlobalInfo[GI->first] |= GI->second;
FR.MayReadAnyGlobal |= CalleeFR->MayReadAnyGlobal;
} else {
// Can't say anything about it. However, if it is inside our SCC,
// then nothing needs to be done.