Skip to content
This repository was archived by the owner on Feb 5, 2019. It is now read-only.

Commit 93ba133

Browse files
zmodemzmodem
committed
CodeGenPrep: turn lookup tables into switches for some targets.
This is a follow-up from r163302, which added a transformation to SimplifyCFG that turns some switches into loads from lookup tables. It was pointed out that some targets, such as GPUs and deeply embedded targets, might not find this appropriate, but SimplifyCFG doesn't have enough information about the target to decide this. This patch adds the reverse transformation to CodeGenPrep: it turns loads from lookup tables back into switches for targets where we do not build jump tables (assuming these are also the targets where lookup tables are inappropriate). Hopefully we will eventually get to have target information in SimplifyCFG, and then this CodeGenPrep transformation can be removed. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@164206 91177308-0d34-0410-b5e6-96231b3b80d8
1 parent 8a312fb commit 93ba133

File tree

2 files changed

+198
-4
lines changed

2 files changed

+198
-4
lines changed

‎lib/Transforms/Scalar/CodeGenPrepare.cpp‎

Lines changed: 114 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
#include "llvm/Constants.h"
1919
#include "llvm/DerivedTypes.h"
2020
#include "llvm/Function.h"
21+
#include "llvm/GlobalVariable.h"
2122
#include "llvm/IRBuilder.h"
2223
#include "llvm/InlineAsm.h"
2324
#include "llvm/Instructions.h"
@@ -126,6 +127,7 @@ namespace {
126127
bool OptimizeSelectInst(SelectInst *SI);
127128
bool DupRetToEnableTailCallOpts(ReturnInst *RI);
128129
bool PlaceDbgValues(Function &F);
130+
bool ConvertLoadToSwitch(LoadInst *LI);
129131
};
130132
}
131133

@@ -169,7 +171,7 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
169171
bool MadeChange = true;
170172
while (MadeChange) {
171173
MadeChange = false;
172-
for (Function::iterator I = F.begin(), E = F.end(); I != E; ) {
174+
for (Function::iterator I = F.begin(); I != F.end(); ) {
173175
BasicBlock *BB = I++;
174176
MadeChange |= OptimizeBlock(*BB);
175177
}
@@ -1283,9 +1285,11 @@ bool CodeGenPrepare::OptimizeInst(Instruction *I) {
12831285
return OptimizeCmpExpression(CI);
12841286

12851287
if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
1288+
bool Changed = false;
12861289
if (TLI)
1287-
return OptimizeMemoryInst(I, I->getOperand(0), LI->getType());
1288-
return false;
1290+
Changed |= OptimizeMemoryInst(I, I->getOperand(0), LI->getType());
1291+
Changed |= ConvertLoadToSwitch(LI);
1292+
return Changed;
12891293
}
12901294

12911295
if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
@@ -1329,7 +1333,7 @@ bool CodeGenPrepare::OptimizeBlock(BasicBlock &BB) {
13291333
bool MadeChange = false;
13301334

13311335
CurInstIterator = BB.begin();
1332-
for (BasicBlock::iterator E = BB.end(); CurInstIterator != E; )
1336+
while (CurInstIterator != BB.end())
13331337
MadeChange |= OptimizeInst(CurInstIterator++);
13341338

13351339
return MadeChange;
@@ -1365,3 +1369,109 @@ bool CodeGenPrepare::PlaceDbgValues(Function &F) {
13651369
}
13661370
return MadeChange;
13671371
}
1372+
1373+
static bool TargetSupportsJumpTables(const TargetLowering &TLI) {
1374+
return TLI.supportJumpTables() &&
1375+
(TLI.isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
1376+
TLI.isOperationLegalOrCustom(ISD::BRIND, MVT::Other));
1377+
}
1378+
1379+
/// ConvertLoadToSwitch - Convert loads from constant lookup tables into
1380+
/// switches. This undos the switch-to-lookup table transformation in
1381+
/// SimplifyCFG for targets where that is inprofitable.
1382+
bool CodeGenPrepare::ConvertLoadToSwitch(LoadInst *LI) {
1383+
// This only applies to targets that don't support jump tables.
1384+
if (!TLI || TargetSupportsJumpTables(*TLI))
1385+
return false;
1386+
1387+
// FIXME: In the future, it would be desirable to have enough target
1388+
// information in SimplifyCFG, so we could decide at that stage whether to
1389+
// transform the switch to a lookup table or not, and this
1390+
// reverse-transformation could be removed.
1391+
1392+
GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(LI->getPointerOperand());
1393+
if (!GEP || !GEP->isInBounds() || GEP->getPointerAddressSpace())
1394+
return false;
1395+
if (GEP->getNumIndices() != 2)
1396+
return false;
1397+
Value *FirstIndex = GEP->idx_begin()[0];
1398+
ConstantInt *FirstIndexInt = dyn_cast<ConstantInt>(FirstIndex);
1399+
if (!FirstIndexInt || !FirstIndexInt->isZero())
1400+
return false;
1401+
1402+
Value *TableIndex = GEP->idx_begin()[1];
1403+
IntegerType *TableIndexTy = cast<IntegerType>(TableIndex->getType());
1404+
1405+
GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getPointerOperand());
1406+
if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
1407+
return false;
1408+
1409+
Constant *Arr = GV->getInitializer();
1410+
uint64_t NumElements;
1411+
if (ConstantArray *CA = dyn_cast<ConstantArray>(Arr))
1412+
NumElements = CA->getType()->getNumElements();
1413+
else if (ConstantDataArray *CDA = dyn_cast<ConstantDataArray>(Arr))
1414+
NumElements = CDA->getNumElements();
1415+
else
1416+
return false;
1417+
if (NumElements < 2)
1418+
return false;
1419+
1420+
// Split the block.
1421+
BasicBlock *OriginalBB = LI->getParent();
1422+
BasicBlock *PostSwitchBB = OriginalBB->splitBasicBlock(LI);
1423+
1424+
// Replace OriginalBB's terminator with a switch.
1425+
IRBuilder<> Builder(OriginalBB->getTerminator());
1426+
SwitchInst *Switch = Builder.CreateSwitch(TableIndex, PostSwitchBB,
1427+
NumElements - 1);
1428+
OriginalBB->getTerminator()->eraseFromParent();
1429+
1430+
// Count the frequency of each value to decide which to use as default.
1431+
SmallDenseMap<Constant*, uint64_t> ValueFreq;
1432+
for (uint64_t I = 0; I < NumElements; ++I)
1433+
++ValueFreq[Arr->getAggregateElement(I)];
1434+
uint64_t MaxCount = 0;
1435+
Constant *DefaultValue = NULL;
1436+
for (SmallDenseMap<Constant*, uint64_t>::iterator I = ValueFreq.begin(),
1437+
E = ValueFreq.end(); I != E; ++I) {
1438+
if (I->second > MaxCount) {
1439+
MaxCount = I->second;
1440+
DefaultValue = I->first;
1441+
}
1442+
}
1443+
assert(DefaultValue && "No values in the array?");
1444+
1445+
// Create the phi node in PostSwitchBB, which will replace the load.
1446+
Builder.SetInsertPoint(PostSwitchBB->begin());
1447+
PHINode *PHI = Builder.CreatePHI(LI->getType(), NumElements);
1448+
PHI->addIncoming(DefaultValue, OriginalBB);
1449+
1450+
// Build basic blocks to target with the switch.
1451+
for (uint64_t I = 0; I < NumElements; ++I) {
1452+
Constant *C = Arr->getAggregateElement(I);
1453+
if (C == DefaultValue) continue; // Already covered by the default case.
1454+
1455+
BasicBlock *BB = BasicBlock::Create(PostSwitchBB->getContext(),
1456+
"lookup.bb",
1457+
PostSwitchBB->getParent(),
1458+
PostSwitchBB);
1459+
Switch->addCase(ConstantInt::get(TableIndexTy, I), BB);
1460+
Builder.SetInsertPoint(BB);
1461+
Builder.CreateBr(PostSwitchBB);
1462+
PHI->addIncoming(C, BB);
1463+
}
1464+
1465+
// Remove the load.
1466+
LI->replaceAllUsesWith(PHI);
1467+
LI->eraseFromParent();
1468+
1469+
// Clean up.
1470+
if (GEP->use_empty())
1471+
GEP->eraseFromParent();
1472+
if (GV->hasUnnamedAddr() && GV->hasPrivateLinkage() && GV->use_empty())
1473+
GV->eraseFromParent();
1474+
1475+
CurInstIterator = Switch;
1476+
return true;
1477+
}

‎test/Transforms/CodeGenPrepare/load_to_switch.ll‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
; RUN: llc -march=sparc < %s | FileCheck %s
2+
3+
; Check that all the switches turned into lookup tables by SimplifyCFG are
4+
; turned back into switches for targets that don't like lookup tables.
5+
6+
@.str = private unnamed_addr constant [4 x i8] c"foo\00", align 1
7+
@.str1 = private unnamed_addr constant [4 x i8] c"bar\00", align 1
8+
@.str2 = private unnamed_addr constant [4 x i8] c"baz\00", align 1
9+
@.str3 = private unnamed_addr constant [4 x i8] c"qux\00", align 1
10+
@.str4 = private unnamed_addr constant [6 x i8] c"error\00", align 1
11+
@switch.table = private unnamed_addr constant [7 x i32] [i32 55, i32 123, i32 0, i32 -1, i32 27, i32 62, i32 1]
12+
@switch.table1 = private unnamed_addr constant [4 x i8] c"*\09X\05"
13+
@switch.table2 = private unnamed_addr constant [4 x float] [float 0x40091EB860000000, float 0x3FF3BE76C0000000, float 0x4012449BA0000000, float 0x4001AE1480000000]
14+
@switch.table3 = private unnamed_addr constant [4 x i8*] [i8* getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8]* @.str2, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8]* @.str3, i64 0, i64 0)]
15+
16+
define i32 @f(i32 %c) {
17+
entry:
18+
%switch.tableidx = sub i32 %c, 42
19+
%0 = icmp ult i32 %switch.tableidx, 7
20+
br i1 %0, label %switch.lookup, label %return
21+
22+
switch.lookup:
23+
%switch.gep = getelementptr inbounds [7 x i32]* @switch.table, i32 0, i32 %switch.tableidx
24+
%switch.load = load i32* %switch.gep
25+
ret i32 %switch.load
26+
27+
return:
28+
ret i32 15
29+
30+
; CHECK: f:
31+
; CHECK: %switch.lookup
32+
; CHECK-NOT: sethi %hi(.Lswitch.table)
33+
}
34+
35+
declare void @dummy(i8 signext, float)
36+
37+
define void @h(i32 %x) {
38+
entry:
39+
%switch.tableidx = sub i32 %x, 0
40+
%0 = icmp ult i32 %switch.tableidx, 4
41+
br i1 %0, label %switch.lookup, label %sw.epilog
42+
43+
switch.lookup:
44+
%switch.gep = getelementptr inbounds [4 x i8]* @switch.table1, i32 0, i32 %switch.tableidx
45+
%switch.load = load i8* %switch.gep
46+
%switch.gep1 = getelementptr inbounds [4 x float]* @switch.table2, i32 0, i32 %switch.tableidx
47+
%switch.load2 = load float* %switch.gep1
48+
br label %sw.epilog
49+
50+
sw.epilog:
51+
%a.0 = phi i8 [ %switch.load, %switch.lookup ], [ 7, %entry ]
52+
%b.0 = phi float [ %switch.load2, %switch.lookup ], [ 0x4023FAE140000000, %entry ]
53+
call void @dummy(i8 signext %a.0, float %b.0)
54+
ret void
55+
56+
; CHECK: h:
57+
; CHECK: %switch.lookup
58+
; CHECK-NOT: sethi %hi(.Lswitch.table{{[0-9]}})
59+
; CHECK-NOT: sethi %hi(.Lswitch.table{{[0-9]}})
60+
}
61+
62+
define i8* @foostring(i32 %x) {
63+
entry:
64+
%switch.tableidx = sub i32 %x, 0
65+
%0 = icmp ult i32 %switch.tableidx, 4
66+
br i1 %0, label %switch.lookup, label %return
67+
68+
switch.lookup:
69+
%switch.gep = getelementptr inbounds [4 x i8*]* @switch.table3, i32 0, i32 %switch.tableidx
70+
%switch.load = load i8** %switch.gep
71+
ret i8* %switch.load
72+
73+
return:
74+
ret i8* getelementptr inbounds ([6 x i8]* @.str4, i64 0, i64 0)
75+
76+
; CHECK: foostring:
77+
; CHECK: %switch.lookup
78+
; CHECK-NOT: sethi %hi(.Lswitch.table3)
79+
}
80+
81+
; CHECK-NOT: .Lswitch.table
82+
; CHECK-NOT: .Lswitch.table1
83+
; CHECK-NOT: .Lswitch.table2
84+
; CHECK-NOT: .Lswitch.table3

0 commit comments

Comments
 (0)