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

Revert "GlobalDCE: Delete available_externally initializers if it allows removing the value the initializer is referring to."

Browse Source 
This reverts commit 5b55a47e94.

A test case was found to crash after this was applied.  I'll file a bug to track fixing this with the test case needed.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@212550 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Pete Cooper 2014-07-08 17:06:03 +00:00
parent b7fdc7ff16
commit 54bca0cb09
2 changed files with 4 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -44,19 +44,14 @@ namespace {
bool runOnModule(Module &M) override;
private:
SmallPtrSet<Constant *, 32> AliveGlobals;
SmallPtrSet<GlobalValue*, 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);
};
}
@ -167,19 +162,6 @@ bool GlobalDCE::runOnModule(Module &M) {
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.
@ -227,12 +209,8 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
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()) {
if (GV->hasAvailableExternallyLinkage())
DiscardableGlobalInitializers.insert(GV);
else
MarkUsedGlobalsAsNeeded(GV->getInitializer());
}
if (GV->hasInitializer())
MarkUsedGlobalsAsNeeded(GV->getInitializer());
} else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(G)) {
// The target of a global alias is needed.
MarkUsedGlobalsAsNeeded(GA->getAliasee());
@ -270,21 +248,6 @@ void GlobalDCE::MarkUsedGlobalsAsNeeded(Constant *C) {
}
}
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

35
test/Transforms/GlobalDCE/externally_available.ll
View File

@ -1,43 +1,10 @@
; RUN: opt < %s -globaldce -S | FileCheck %s
; RUN: opt < %s -globaldce -S | not grep test_
; 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
}