6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-15 04:30:12 +00:00
Code Issues Projects Releases Wiki Activity

Use range metadata instead of introducing selects.

Browse Source 
When GlobalOpt has determined that a GlobalVariable only ever has two values,
it would convert the GlobalVariable to a boolean, and introduce SelectInsts
at every load, to choose between the two possible values. These SelectInsts
introduce overhead and other unpleasantness.

This patch makes GlobalOpt just add range metadata to loads from such
GlobalVariables instead. This enables the same main optimization (as seen in
test/Transforms/GlobalOpt/integer-bool.ll), without introducing selects.

The main downside is that it doesn't get the memory savings of shrinking such
GlobalVariables, but this is expected to be negligible.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@204076 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2014-03-17 19:57:04 +00:00
parent 92fca73d52
commit 43873d4f73
3 changed files with 104 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -1588,18 +1588,16 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal,
return false;
}
/// TryToShrinkGlobalToBoolean - At this point, we have learned that the only
/// TryToAddRangeMetadata - At this point, we have learned that the only
/// two values ever stored into GV are its initializer and OtherVal. See if we
/// can shrink the global into a boolean and select between the two values
/// whenever it is used. This exposes the values to other scalar optimizations.
static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
/// can annotate loads from it with range metadata describing this.
/// This exposes the values to other scalar optimizations.
static bool TryToAddRangeMetadata(GlobalVariable *GV, Constant *OtherVal) {
Type *GVElType = GV->getType()->getElementType();
// If GVElType is already i1, it is already shrunk. If the type of the GV is
// an FP value, pointer or vector, don't do this optimization because a select
// between them is very expensive and unlikely to lead to later
// simplification. In these cases, we typically end up with "cond ? v1 : v2"
// where v1 and v2 both require constant pool loads, a big loss.
// If GVElType is already i1, it already has a minimal range. If the type of
// the GV is an FP value, pointer or vector, don't do this optimization
// because range metadata is currently only supported on scalar integers.
if (GVElType == Type::getInt1Ty(GV->getContext()) ||
GVElType->isFloatingPointTy() ||
GVElType->isPointerTy() || GVElType->isVectorTy())
@ -1611,81 +1609,53 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
if (!isa<LoadInst>(U) && !isa<StoreInst>(U))
return false;
DEBUG(dbgs() << " *** SHRINKING TO BOOL: " << *GV);
// Create the new global, initializing it to false.
GlobalVariable *NewGV = new GlobalVariable(Type::getInt1Ty(GV->getContext()),
false,
GlobalValue::InternalLinkage,
ConstantInt::getFalse(GV->getContext()),
GV->getName()+".b",
GV->getThreadLocalMode(),
GV->getType()->getAddressSpace());
GV->getParent()->getGlobalList().insert(GV, NewGV);
Constant *InitVal = GV->getInitializer();
assert(InitVal->getType() != Type::getInt1Ty(GV->getContext()) &&
"No reason to shrink to bool!");
"No reason to add range metadata!");
// If initialized to zero and storing one into the global, we can use a cast
// instead of a select to synthesize the desired value.
bool IsOneZero = false;
if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal))
IsOneZero = InitVal->isNullValue() && CI->isOne();
// The MD_range metadata only supports absolute integer constants.
if (!isa<ConstantInt>(InitVal) || !isa<ConstantInt>(OtherVal))
return false;
while (!GV->use_empty()) {
Instruction *UI = cast<Instruction>(GV->user_back());
if (StoreInst *SI = dyn_cast<StoreInst>(UI)) {
// Change the store into a boolean store.
bool StoringOther = SI->getOperand(0) == OtherVal;
// Only do this if we weren't storing a loaded value.
Value *StoreVal;
if (StoringOther || SI->getOperand(0) == InitVal) {
StoreVal = ConstantInt::get(Type::getInt1Ty(GV->getContext()),
StoringOther);
DEBUG(dbgs() << " *** ADDING RANGE METADATA: " << *GV);
for (User *U : GV->users()) {
Instruction *UI = cast<Instruction>(U);
if (LoadInst *LI = dyn_cast<LoadInst>(UI)) {
// If we already have a range, don't add a new one, so that GlobalOpt
// terminates. In theory, we could merge the two ranges.
if (LI->getMetadata(LLVMContext::MD_range))
return false;
// Add range metadata to the load. Range metadata can represent multiple
// ranges, but they must be discontiguous, so we have two cases: the case
// where the values are adjacent, in which case we add one range, and the
// case where they're not, in which case we add two.
APInt Min = cast<ConstantInt>(InitVal)->getValue();
APInt Max = cast<ConstantInt>(OtherVal)->getValue();
if (Max.slt(Min))
std::swap(Min, Max);
APInt Min1 = Min + 1;
APInt Max1 = Max + 1;
if (Min1 == Max) {
Value *Vals[] = {
ConstantInt::get(GV->getContext(), Min),
ConstantInt::get(GV->getContext(), Max1),
};
MDNode *MD = MDNode::get(LI->getContext(), Vals);
LI->setMetadata(LLVMContext::MD_range, MD);
} else {
// Otherwise, we are storing a previously loaded copy. To do this,
// change the copy from copying the original value to just copying the
// bool.
Instruction *StoredVal = cast<Instruction>(SI->getOperand(0));
// If we've already replaced the input, StoredVal will be a cast or
// select instruction. If not, it will be a load of the original
// global.
if (LoadInst *LI = dyn_cast<LoadInst>(StoredVal)) {
assert(LI->getOperand(0) == GV && "Not a copy!");
// Insert a new load, to preserve the saved value.
StoreVal = new LoadInst(NewGV, LI->getName()+".b", false, 0,
LI->getOrdering(), LI->getSynchScope(), LI);
} else {
assert((isa<CastInst>(StoredVal) || isa<SelectInst>(StoredVal)) &&
"This is not a form that we understand!");
StoreVal = StoredVal->getOperand(0);
assert(isa<LoadInst>(StoreVal) && "Not a load of NewGV!");
}
Value *Vals[] = {
ConstantInt::get(GV->getContext(), Min),
ConstantInt::get(GV->getContext(), Min1),
ConstantInt::get(GV->getContext(), Max),
ConstantInt::get(GV->getContext(), Max1),
};
MDNode *MD = MDNode::get(LI->getContext(), Vals);
LI->setMetadata(LLVMContext::MD_range, MD);
}
new StoreInst(StoreVal, NewGV, false, 0,
SI->getOrdering(), SI->getSynchScope(), SI);
} else {
// Change the load into a load of bool then a select.
LoadInst *LI = cast<LoadInst>(UI);
LoadInst *NLI = new LoadInst(NewGV, LI->getName()+".b", false, 0,
LI->getOrdering(), LI->getSynchScope(), LI);
Value *NSI;
if (IsOneZero)
NSI = new ZExtInst(NLI, LI->getType(), "", LI);
else
NSI = SelectInst::Create(NLI, OtherVal, InitVal, "", LI);
NSI->takeName(LI);
LI->replaceAllUsesWith(NSI);
}
UI->eraseFromParent();
}
// Retain the name of the old global variable. People who are debugging their
// programs may expect these variables to be named the same.
NewGV->takeName(GV);
GV->eraseFromParent();
return true;
}
@ -1839,11 +1809,10 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
DL, TLI))
return true;
// Otherwise, if the global was not a boolean, we can shrink it to be a
// boolean.
// Otherwise, if the global was not a boolean, we can add range metadata.
if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue)) {
if (GS.Ordering == NotAtomic) {
if (TryToShrinkGlobalToBoolean(GV, SOVConstant)) {
if (TryToAddRangeMetadata(GV, SOVConstant)) {
++NumShrunkToBool;
return true;
}

9
test/Transforms/GlobalOpt/integer-bool.ll
View File

@ -1,20 +1,21 @@
; RUN: opt < %s -S -globalopt -instcombine | FileCheck %s
;; check that global opt turns integers that only hold 0 or 1 into bools.
;; check that global opt annotates loads from global variales that only hold 0 or 1
;; such that instcombine can optimize accordingly.
@G = internal addrspace(1) global i32 0
; CHECK: @G
; CHECK: addrspace(1)
; CHECK: global i1 false
; CHECK: global i32 0
define void @set1() {
store i32 0, i32 addrspace(1)* @G
; CHECK: store i1 false
; CHECK: store i32 0
ret void
}
define void @set2() {
store i32 1, i32 addrspace(1)* @G
; CHECK: store i1 true
; CHECK: store i32 1
ret void
}

52
test/Transforms/GlobalOpt/twostore-gv-range.ll Normal file
View File

@ -0,0 +1,52 @@
; RUN: opt < %s -S -globalopt | FileCheck %s
;; check that global opt annotates loads from global variales that have
;; constant values stored to them.
@G = internal global i32 5
@H = internal global i32 7
@I = internal global i32 17
@J = internal global i32 29
@K = internal global i32 31
define void @set() {
store i32 6, i32* @G
store i32 13, i32* @H
store i32 16, i32* @I
store i32 29, i32* @J
store i32 -37, i32* @K
ret void
}
define i32 @getG() {
; CHECK: %t = load i32* @G, !range [[G:![0-9]+]]
%t = load i32* @G
ret i32 %t
}
define i32 @getH() {
; CHECK: %t = load i32* @H, !range [[H:![0-9]+]]
%t = load i32* @H
ret i32 %t
}
define i32 @getI() {
; CHECK: %t = load i32* @I, !range [[I:![0-9]+]]
%t = load i32* @I
ret i32 %t
}
define i32 @getJ() {
; CHECK: ret i32 29
%t = load i32* @J
ret i32 %t
}
define i32 @getK() {
; CHECK: %t = load i32* @K, !range [[K:![0-9]+]]
%t = load i32* @K
ret i32 %t
}
; CHECK: [[G]] = metadata !{i32 5, i32 7}
; CHECK: [[H]] = metadata !{i32 7, i32 8, i32 13, i32 14}
; CHECK: [[I]] = metadata !{i32 16, i32 18}
; CHECK: [[K]] = metadata !{i32 -37, i32 -36, i32 31, i32 32}