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

Remove an unused function SafeToDestroyConstant(). Rename an almost

Browse Source 
identical function ConstantIsDead() to SafeToDestroyConstant(), to
emphasise the connection with Constant::destroyConstant().

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@73149 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jay Foad 2009-06-09 21:37:11 +00:00
parent 7ba520bced
commit e3acf159d9
2 changed files with 9 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
lib/Transforms/IPO/GlobalDCE.cpp
View File

@ -47,7 +47,6 @@ namespace {
void GlobalIsNeeded(GlobalValue *GV); void GlobalIsNeeded(GlobalValue *GV);
void MarkUsedGlobalsAsNeeded(Constant *C); void MarkUsedGlobalsAsNeeded(Constant *C);
bool SafeToDestroyConstant(Constant* C);
bool RemoveUnusedGlobalValue(GlobalValue &GV); bool RemoveUnusedGlobalValue(GlobalValue &GV);
}; };
} }
@ -211,17 +210,3 @@ bool GlobalDCE::RemoveUnusedGlobalValue(GlobalValue &GV) {
GV.removeDeadConstantUsers(); GV.removeDeadConstantUsers();
return GV.use_empty(); return GV.use_empty();
} }
// SafeToDestroyConstant - It is safe to destroy a constant iff it is only used
// by constants itself. Note that constants cannot be cyclic, so this test is
// pretty easy to implement recursively.
//
bool GlobalDCE::SafeToDestroyConstant(Constant *C) {
for (Value::use_iterator I = C->use_begin(), E = C->use_end(); I != E; ++I)
if (Constant *User = dyn_cast<Constant>(*I)) {
if (!SafeToDestroyConstant(User)) return false;
} else {
return false;
}
return true;
}

18
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -136,16 +136,16 @@ struct VISIBILITY_HIDDEN GlobalStatus {
} }
/// ConstantIsDead - Return true if the specified constant is (transitively) // SafeToDestroyConstant - It is safe to destroy a constant iff it is only used
/// dead. The constant may be used by other constants (e.g. constant arrays and // by constants itself. Note that constants cannot be cyclic, so this test is
/// constant exprs) as long as they are dead, but it cannot be used by anything // pretty easy to implement recursively.
/// else. //
static bool ConstantIsDead(Constant *C) { static bool SafeToDestroyConstant(Constant *C) {
if (isa<GlobalValue>(C)) return false; if (isa<GlobalValue>(C)) return false;
for (Value::use_iterator UI = C->use_begin(), E = C->use_end(); UI != E; ++UI) for (Value::use_iterator UI = C->use_begin(), E = C->use_end(); UI != E; ++UI)
if (Constant *CU = dyn_cast<Constant>(*UI)) { if (Constant *CU = dyn_cast<Constant>(*UI)) {
if (!ConstantIsDead(CU)) return false; if (!SafeToDestroyConstant(CU)) return false;
} else } else
return false; return false;
return true; return true;
@ -233,7 +233,7 @@ static bool AnalyzeGlobal(Value *V, GlobalStatus &GS,
} else if (Constant *C = dyn_cast<Constant>(*UI)) { } else if (Constant *C = dyn_cast<Constant>(*UI)) {
GS.HasNonInstructionUser = true; GS.HasNonInstructionUser = true;
// We might have a dead and dangling constant hanging off of here. // We might have a dead and dangling constant hanging off of here.
if (!ConstantIsDead(C)) if (!SafeToDestroyConstant(C))
return true; return true;
} else { } else {
GS.HasNonInstructionUser = true; GS.HasNonInstructionUser = true;
@ -338,7 +338,7 @@ static bool CleanupConstantGlobalUsers(Value *V, Constant *Init) {
} else if (Constant *C = dyn_cast<Constant>(U)) { } else if (Constant *C = dyn_cast<Constant>(U)) {
// If we have a chain of dead constantexprs or other things dangling from // If we have a chain of dead constantexprs or other things dangling from
// us, and if they are all dead, nuke them without remorse. // us, and if they are all dead, nuke them without remorse.
if (ConstantIsDead(C)) { if (SafeToDestroyConstant(C)) {
C->destroyConstant(); C->destroyConstant();
// This could have invalidated UI, start over from scratch. // This could have invalidated UI, start over from scratch.
CleanupConstantGlobalUsers(V, Init); CleanupConstantGlobalUsers(V, Init);
@ -354,7 +354,7 @@ static bool CleanupConstantGlobalUsers(Value *V, Constant *Init) {
static bool isSafeSROAElementUse(Value *V) { static bool isSafeSROAElementUse(Value *V) {
// We might have a dead and dangling constant hanging off of here. // We might have a dead and dangling constant hanging off of here.
if (Constant *C = dyn_cast<Constant>(V)) if (Constant *C = dyn_cast<Constant>(V))
return ConstantIsDead(C); return SafeToDestroyConstant(C);
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) return false; if (!I) return false;