summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorChris Lattner <sabre@nondot.org>2011-02-18 04:41:42 +0000
committerChris Lattner <sabre@nondot.org>2011-02-18 04:41:42 +0000
commit13fb0db0c26ec498cf8ffb0f9943d28962d4ced7 (patch)
treeb9406d131bfbbef9ad308fdfec368346a223da74
parentf5ebfb0d2852e70f11ca7b8d11f704a1378756d8 (diff)
downloadllvm-13fb0db0c26ec498cf8ffb0f9943d28962d4ced7.tar.gz
llvm-13fb0db0c26ec498cf8ffb0f9943d28962d4ced7.tar.bz2
llvm-13fb0db0c26ec498cf8ffb0f9943d28962d4ced7.tar.xz
hoist GlobalValue::removeDeadConstantUsers up to being a method on Constant.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125828 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r--include/llvm/Constant.h12
-rw-r--r--include/llvm/GlobalValue.h6
-rw-r--r--lib/VMCore/Constants.cpp53
-rw-r--r--lib/VMCore/Globals.cpp49
4 files changed, 62 insertions, 58 deletions
diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h
index defe474fb5..38045fc0c1 100644
--- a/include/llvm/Constant.h
+++ b/include/llvm/Constant.h
@@ -141,16 +141,22 @@ public:
assert(0 && "Constants that do not have operands cannot be using 'From'!");
}
- static Constant* getNullValue(const Type* Ty);
+ static Constant *getNullValue(const Type* Ty);
/// @returns the value for an integer constant of the given type that has all
/// its bits set to true.
/// @brief Get the all ones value
- static Constant* getAllOnesValue(const Type* Ty);
+ static Constant *getAllOnesValue(const Type* Ty);
/// getIntegerValue - Return the value for an integer or pointer constant,
/// or a vector thereof, with the given scalar value.
- static Constant* getIntegerValue(const Type* Ty, const APInt &V);
+ static Constant *getIntegerValue(const Type* Ty, const APInt &V);
+
+ /// removeDeadConstantUsers - If there are any dead constant users dangling
+ /// off of this constant, 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.
+ void removeDeadConstantUsers() const;
};
} // End llvm namespace
diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h
index ccadc1c603..b184b8e449 100644
--- a/include/llvm/GlobalValue.h
+++ b/include/llvm/GlobalValue.h
@@ -282,12 +282,6 @@ public:
inline Module *getParent() { return Parent; }
inline const Module *getParent() const { return Parent; }
- /// removeDeadConstantUsers - If there are any dead constant users dangling
- /// 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.
- void removeDeadConstantUsers() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const GlobalValue *) { return true; }
static inline bool classof(const Value *V) {
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index a2ac768d22..246fde1569 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -262,6 +262,59 @@ void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const {
}
+/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
+/// it. This involves recursively eliminating any dead users of the
+/// constantexpr.
+static bool removeDeadUsersOfConstant(const Constant *C) {
+ if (isa<GlobalValue>(C)) return false; // Cannot remove this
+
+ while (!C->use_empty()) {
+ const Constant *User = dyn_cast<Constant>(C->use_back());
+ if (!User) return false; // Non-constant usage;
+ if (!removeDeadUsersOfConstant(User))
+ return false; // Constant wasn't dead
+ }
+
+ const_cast<Constant*>(C)->destroyConstant();
+ return true;
+}
+
+
+/// removeDeadConstantUsers - If there are any dead constant users dangling
+/// off of this constant, 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.
+void Constant::removeDeadConstantUsers() const {
+ Value::const_use_iterator I = use_begin(), E = use_end();
+ Value::const_use_iterator LastNonDeadUser = E;
+ while (I != E) {
+ const Constant *User = dyn_cast<Constant>(*I);
+ if (User == 0) {
+ LastNonDeadUser = I;
+ ++I;
+ continue;
+ }
+
+ 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;
+ ++I;
+ continue;
+ }
+
+ // If the constant was dead, then the iterator is invalidated.
+ if (LastNonDeadUser == E) {
+ I = use_begin();
+ if (I == E) break;
+ } else {
+ I = LastNonDeadUser;
+ ++I;
+ }
+ }
+}
+
+
//===----------------------------------------------------------------------===//
// ConstantInt
diff --git a/lib/VMCore/Globals.cpp b/lib/VMCore/Globals.cpp
index 96716eeb34..60000ad1b5 100644
--- a/lib/VMCore/Globals.cpp
+++ b/lib/VMCore/Globals.cpp
@@ -26,23 +26,6 @@ using namespace llvm;
// GlobalValue Class
//===----------------------------------------------------------------------===//
-/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
-/// it. This involves recursively eliminating any dead users of the
-/// constantexpr.
-static bool removeDeadUsersOfConstant(const Constant *C) {
- if (isa<GlobalValue>(C)) return false; // Cannot remove this
-
- while (!C->use_empty()) {
- const Constant *User = dyn_cast<Constant>(C->use_back());
- if (!User) return false; // Non-constant usage;
- if (!removeDeadUsersOfConstant(User))
- return false; // Constant wasn't dead
- }
-
- const_cast<Constant*>(C)->destroyConstant();
- return true;
-}
-
bool GlobalValue::isMaterializable() const {
return getParent() && getParent()->isMaterializable(this);
}
@@ -56,38 +39,6 @@ void GlobalValue::Dematerialize() {
getParent()->Dematerialize(this);
}
-/// removeDeadConstantUsers - If there are any dead constant users dangling
-/// 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.
-void GlobalValue::removeDeadConstantUsers() const {
- Value::const_use_iterator I = use_begin(), E = use_end();
- Value::const_use_iterator LastNonDeadUser = E;
- while (I != E) {
- if (const 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;
- ++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;
- ++I;
- }
- }
- } else {
- LastNonDeadUser = I;
- ++I;
- }
- }
-}
-
-
/// Override destroyConstant to make sure it doesn't get called on
/// GlobalValue's because they shouldn't be treated like other constants.
void GlobalValue::destroyConstant() {