Changes in directory llvm/lib/VMCore:
Globals.cpp updated: 1.15 -> 1.16
---
Log message:
Rework GlobalValue::removeDeadConstantUsers to always remove dead constant
exprs hanging off a global, even if the global is not otherwise dead. This
requires some tricky iterator gymnastics.
This implements Transforms/GlobalOpt/constantexpr-dangle.ll by deleting a
constantexpr that made it appear that the address of the function was taken.
---
Diffs of the changes: (+29 -21)
Globals.cpp | 50 +++++++++++++++++++++++++++++---------------------
1 files changed, 29 insertions(+), 21 deletions(-)
Index: llvm/lib/VMCore/Globals.cpp
diff -u llvm/lib/VMCore/Globals.cpp:1.15 llvm/lib/VMCore/Globals.cpp:1.16
--- llvm/lib/VMCore/Globals.cpp:1.15 Mon Feb 5 14:47:20 2007
+++ llvm/lib/VMCore/Globals.cpp Sun Feb 25 15:06:13 2007
@@ -22,20 +22,18 @@
// GlobalValue Class
//===----------------------------------------------------------------------===//
-/// This could be named "SafeToDestroyGlobalValue". It just makes sure that
-/// there are no non-constant uses of this GlobalValue. If there aren't then
-/// this and the transitive closure of the constants can be deleted. See the
-/// destructor for details.
-static bool removeDeadConstantUsers(Constant* C) {
+/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
+/// it. This involves recursively eliminating any dead users of the
+/// constantexpr.
+static bool removeDeadUsersOfConstant(Constant *C) {
if (isa<GlobalValue>(C)) return false; // Cannot remove this
- while (!C->use_empty())
- if (Constant *User = dyn_cast<Constant>(C->use_back())) {
- if (!removeDeadConstantUsers(User))
- return false; // Constant wasn't dead
- } else {
- return false; // Non-constant usage;
- }
+ while (!C->use_empty()) {
+ Constant *User = dyn_cast<Constant>(C->use_back());
+ if (!User) return false; // Non-constant usage;
+ if (!removeDeadUsersOfConstant(User))
+ return false; // Constant wasn't dead
+ }
C->destroyConstant();
return true;
@@ -45,17 +43,27 @@
/// 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
/// 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() {
- while(!use_empty()) {
- if (Constant* User = dyn_cast<Constant>(use_back())) {
- if (!::removeDeadConstantUsers(User))
- return; // Constant wasn't dead
+
+ Value::use_iterator I = use_begin(), E = use_end();
+ Value::use_iterator LastNonDeadUser = E;
+ for (; I != E; ++I) {
+ 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 {
- return; // Non-constant usage;
+ LastNonDeadUser = I;
}
}
}
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
