bool runOnModule(Module &M) override;
private:
- SmallPtrSet<GlobalValue*, 32> AliveGlobals;
+ SmallPtrSet<Constant *, 32> AliveGlobals;
SmallPtrSet<Constant *, 8> SeenConstants;
+ SmallPtrSet<GlobalVariable *, 8> DiscardableGlobalInitializers;
/// GlobalIsNeeded - mark the specific global value as needed, and
/// recursively mark anything that it uses as also needed.
void GlobalIsNeeded(GlobalValue *GV);
void MarkUsedGlobalsAsNeeded(Constant *C);
+ /// \brief Checks if C is alive or is a ConstantExpr that refers to an alive
+ /// value.
+ bool ContainsUsedGlobal(Constant *C);
+
bool RemoveUnusedGlobalValue(GlobalValue &GV);
};
}
I->setAliasee(nullptr);
}
+ // Look for available externally constants that we can turn into normal
+ // externals by deleting their initalizers. This allows us to remove other
+ // globals that are referenced by the initializer.
+ if (!DiscardableGlobalInitializers.empty()) {
+ for (GlobalVariable *GV : DiscardableGlobalInitializers) {
+ if (!ContainsUsedGlobal(GV->getInitializer())) {
+ GV->setInitializer(nullptr);
+ GV->setLinkage(GlobalValue::ExternalLinkage);
+ Changed = true;
+ }
+ }
+ }
+
if (!DeadFunctions.empty()) {
// Now that all interferences have been dropped, delete the actual objects
// themselves.
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(G)) {
// If this is a global variable, we must make sure to add any global values
// referenced by the initializer to the alive set.
- if (GV->hasInitializer())
- MarkUsedGlobalsAsNeeded(GV->getInitializer());
+ if (GV->hasInitializer()) {
+ if (GV->hasAvailableExternallyLinkage())
+ DiscardableGlobalInitializers.insert(GV);
+ else
+ MarkUsedGlobalsAsNeeded(GV->getInitializer());
+ }
} else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(G)) {
// The target of a global alias is needed.
MarkUsedGlobalsAsNeeded(GA->getAliasee());
}
}
+bool GlobalDCE::ContainsUsedGlobal(Constant *C) {
+ // C contains a used global If C is alive or we visited it while marking
+ // values alive.
+ if (AliveGlobals.count(C) || SeenConstants.count(C))
+ return true;
+
+ // Now check all operands of a ConstantExpr.
+ for (User::op_iterator I = C->op_begin(), E = C->op_end(); I != E; ++I) {
+ Constant *Op = dyn_cast<Constant>(*I);
+ if (Op && ContainsUsedGlobal(Op))
+ return true;
+ }
+ return false;
+}
+
// RemoveUnusedGlobalValue - Loop over all of the uses of the specified
// GlobalValue, looking for the constant pointer ref that may be pointing to it.
// If found, check to see if the constant pointer ref is safe to destroy, and if
-; RUN: opt < %s -globaldce -S | not grep test_
+; RUN: opt < %s -globaldce -S | FileCheck %s
; test_function should not be emitted to the .s file.
+; CHECK-NOT: @test_function
define available_externally i32 @test_function() {
ret i32 4
}
; test_global should not be emitted to the .s file.
+; CHECK-NOT: @test_global
@test_global = available_externally global i32 4
+; CHECK: @x = external constant void ()*
+@x = available_externally constant void()* @f
+; CHECK: @y = external constant i32
+@y = available_externally constant i32 ptrtoint (void()* @g to i32)
+; @h is still alive, so don't remove the initializer too eagerly.
+; CHECK: @z = available_externally constant i8 ptrtoint (void (i8)* @h to i8)
+@z = available_externally constant i8 ptrtoint (void(i8)* @h to i8)
+
+; CHECK-NOT: @f
+define linkonce_odr void @f() {
+ ret void
+}
+
+; CHECK-NOT: @g
+define linkonce_odr void @g() {
+ ret void
+}
+
+; CHECK: define linkonce_odr void @h
+define linkonce_odr void @h(i8) {
+ ret void
+}
+
+define i32 @main() {
+ %f = load void()** @x
+ call void %f()
+ %g = load i32* @y
+ %h = load i8* @z
+ call void @h(i8 %h)
+ ret i32 %g
+}