6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-07-06 01:24:35 +00:00
Code Issues Projects Releases Wiki Activity

revert my previous change, something strange is happening.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34626 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2007-02-26 04:43:19 +00:00
parent 54e3efde46
commit e2c2b76c8a
1 changed files with 21 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
lib/VMCore/Globals.cpp
View File

@ -22,18 +22,20 @@ using namespace llvm;
// GlobalValue Class // GlobalValue Class
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove /// This could be named "SafeToDestroyGlobalValue". It just makes sure that
/// it. This involves recursively eliminating any dead users of the /// there are no non-constant uses of this GlobalValue. If there aren't then
/// constantexpr. /// this and the transitive closure of the constants can be deleted. See the
static bool removeDeadUsersOfConstant(Constant *C) { /// destructor for details.
static bool removeDeadConstantUsers(Constant* C) {
if (isa<GlobalValue>(C)) return false; // Cannot remove this if (isa<GlobalValue>(C)) return false; // Cannot remove this
while (!C->use_empty()) { while (!C->use_empty())
Constant *User = dyn_cast<Constant>(C->use_back()); if (Constant *User = dyn_cast<Constant>(C->use_back())) {
if (!User) return false; // Non-constant usage; if (!removeDeadConstantUsers(User))
if (!removeDeadUsersOfConstant(User)) return false; // Constant wasn't dead
return false; // Constant wasn't dead } else {
} return false; // Non-constant usage;
}
C->destroyConstant(); C->destroyConstant();
return true; return true;
@ -43,27 +45,17 @@ static bool removeDeadUsersOfConstant(Constant *C) {
/// off of this global value, remove them. This method is useful for clients /// off of this global value, remove them. This method is useful for clients
/// that want to check to see if a global is unused, but don't want to deal /// that want to check to see if a global is unused, but don't want to deal
/// with potentially dead constants hanging off of the globals. /// with potentially dead constants hanging off of the globals.
///
/// This function returns true if the global value is now dead. If all
/// users of this global are not dead, this method may return false and
/// leave some of them around.
void GlobalValue::removeDeadConstantUsers() { void GlobalValue::removeDeadConstantUsers() {
while(!use_empty()) {
Value::use_iterator I = use_begin(), E = use_end(); if (Constant* User = dyn_cast<Constant>(use_back())) {
Value::use_iterator LastNonDeadUser = E; if (!::removeDeadConstantUsers(User))
for (; I != E; ++I) { return; // Constant wasn't dead
if (Constant *User = dyn_cast<Constant>(*I)) {
if (!removeDeadUsersOfConstant(User)) {
// If the constant wasn't dead, remember that this was the last live use
// and move on to the next constant.
LastNonDeadUser = I;
} else {
// If the constant was dead, then the iterator is invalidated.
if (LastNonDeadUser == E) {
I = use_begin();
if (I == E) break;
} else {
I = LastNonDeadUser;
}
}
} else { } else {
LastNonDeadUser = I; return; // Non-constant usage;
} }
} }
} }