RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-30 23:33:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[ConstnatFolding] Teach the folder how to fold ConstantVector

Browse Source 
A ConstantVector can have ConstantExpr operands and vice versa.
However, the folder had no ability to fold ConstantVectors which, in
some cases, was an optimization barrier.

Instead, rephrase the folder in terms of Constants instead of
ConstantExprs and teach callers how to deal with failure.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@277099 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Majnemer 2016-07-29 03:27:26 +00:00
parent c6c1814d38
commit e43ff14879
13 changed files with 114 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/llvm/Analysis/ConstantFolding.h
View File

@ -25,6 +25,7 @@ class APInt;
template <typename T> class ArrayRef;
class Constant;
class ConstantExpr;
class ConstantVector;
class DataLayout;
class Function;
class GlobalValue;
@ -45,11 +46,11 @@ bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset,
Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldConstantExpression - Attempt to fold the constant expression
/// using the specified DataLayout. If successful, the constant result is
/// result is returned, if not, null is returned.
Constant *
ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL,
/// ConstantFoldConstant - Attempt to fold the constant using the
/// specified DataLayout.
/// If successful, the constant result is result is returned, if not,
/// null is returned.
Constant *ConstantFoldConstant(const Constant *C, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the

5
include/llvm/Analysis/TargetFolder.h
View File

@ -34,9 +34,8 @@ class TargetFolder {
/// Fold - Fold the constant using target specific information.
Constant *Fold(Constant *C) const {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
if (Constant *CF = ConstantFoldConstantExpression(CE, DL))
return CF;
if (Constant *CF = ConstantFoldConstant(C, DL))
return CF;
return C;
}

117
lib/Analysis/ConstantFolding.cpp
View File

@ -714,10 +714,8 @@ Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops,
return nullptr;
Constant *C = ConstantExpr::getGetElementPtr(SrcElemTy, Ops[0], NewIdxs);
if (auto *CE = dyn_cast<ConstantExpr>(C)) {
if (Constant *Folded = ConstantFoldConstantExpression(CE, DL, TLI))
C = Folded;
}
if (Constant *Folded = ConstantFoldConstant(C, DL, TLI))
C = Folded;
return C;
}
@ -775,10 +773,8 @@ Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP,
Constant *Res = ConstantExpr::getPtrToInt(Ptr, CE->getType());
Res = ConstantExpr::getSub(Res, CE->getOperand(1));
Res = ConstantExpr::getIntToPtr(Res, ResTy);
if (auto *ResCE = dyn_cast<ConstantExpr>(Res))
if (auto *FoldedRes =
ConstantFoldConstantExpression(ResCE, DL, TLI))
Res = FoldedRes;
if (auto *FoldedRes = ConstantFoldConstant(Res, DL, TLI))
Res = FoldedRes;
return Res;
}
}
@ -968,12 +964,59 @@ Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, Type *DestTy,
// Constant Folding public APIs
//===----------------------------------------------------------------------===//
namespace {
Constant *
ConstantFoldConstantImpl(const Constant *C, const DataLayout &DL,
const TargetLibraryInfo *TLI,
SmallDenseMap<Constant *, Constant *> &FoldedOps) {
if (!isa<ConstantVector>(C) && !isa<ConstantExpr>(C))
return nullptr;
SmallVector<Constant *, 8> Ops;
for (const Use &NewU : C->operands()) {
auto *NewC = cast<Constant>(&NewU);
// Recursively fold the ConstantExpr's operands. If we have already folded
// a ConstantExpr, we don't have to process it again.
if (isa<ConstantVector>(NewC) || isa<ConstantExpr>(NewC)) {
auto It = FoldedOps.find(NewC);
if (It == FoldedOps.end()) {
if (auto *FoldedC =
ConstantFoldConstantImpl(NewC, DL, TLI, FoldedOps)) {
NewC = FoldedC;
FoldedOps.insert({NewC, FoldedC});
} else {
FoldedOps.insert({NewC, NewC});
}
} else {
NewC = It->second;
}
}
Ops.push_back(NewC);
}
if (auto *CE = dyn_cast<ConstantExpr>(C)) {
if (CE->isCompare())
return ConstantFoldCompareInstOperands(CE->getPredicate(), Ops[0], Ops[1],
DL, TLI);
return ConstantFoldInstOperandsImpl(CE, CE->getType(), CE->getOpcode(), Ops,
DL, TLI);
}
assert(isa<ConstantVector>(C));
return ConstantVector::get(Ops);
}
} // end anonymous namespace
Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
const TargetLibraryInfo *TLI) {
// Handle PHI nodes quickly here...
if (auto *PN = dyn_cast<PHINode>(I)) {
Constant *CommonValue = nullptr;
SmallDenseMap<Constant *, Constant *> FoldedOps;
for (Value *Incoming : PN->incoming_values()) {
// If the incoming value is undef then skip it. Note that while we could
// skip the value if it is equal to the phi node itself we choose not to
@ -986,9 +1029,8 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
if (!C)
return nullptr;
// Fold the PHI's operands.
if (auto *NewC = dyn_cast<ConstantExpr>(C))
if (auto *FoldedC = ConstantFoldConstantExpression(NewC, DL, TLI))
C = FoldedC;
if (auto *FoldedC = ConstantFoldConstantImpl(C, DL, TLI, FoldedOps))
C = FoldedC;
// If the incoming value is a different constant to
// the one we saw previously, then give up.
if (CommonValue && C != CommonValue)
@ -996,7 +1038,6 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
CommonValue = C;
}
// If we reach here, all incoming values are the same constant or undef.
return CommonValue ? CommonValue : UndefValue::get(PN->getType());
}
@ -1006,13 +1047,13 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
if (!all_of(I->operands(), [](Use &U) { return isa<Constant>(U); }))
return nullptr;
SmallDenseMap<Constant *, Constant *> FoldedOps;
SmallVector<Constant *, 8> Ops;
for (const Use &OpU : I->operands()) {
auto *Op = cast<Constant>(&OpU);
// Fold the Instruction's operands.
if (auto *NewCE = dyn_cast<ConstantExpr>(Op))
if (auto *FoldedOp = ConstantFoldConstantExpression(NewCE, DL, TLI))
Op = FoldedOp;
if (auto *FoldedOp = ConstantFoldConstantImpl(Op, DL, TLI, FoldedOps))
Op = FoldedOp;
Ops.push_back(Op);
}
@ -1040,48 +1081,10 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
return ConstantFoldInstOperands(I, Ops, DL, TLI);
}
namespace {
Constant *ConstantFoldConstantExpressionImpl(
const ConstantExpr *CE, const DataLayout &DL, const TargetLibraryInfo *TLI,
SmallDenseMap<ConstantExpr *, Constant *> &FoldedOps) {
SmallVector<Constant *, 8> Ops;
for (const Use &NewU : CE->operands()) {
auto *NewC = cast<Constant>(&NewU);
// Recursively fold the ConstantExpr's operands. If we have already folded
// a ConstantExpr, we don't have to process it again.
if (auto *NewCE = dyn_cast<ConstantExpr>(NewC)) {
auto It = FoldedOps.find(NewCE);
if (It == FoldedOps.end()) {
if (auto *FoldedC =
ConstantFoldConstantExpressionImpl(NewCE, DL, TLI, FoldedOps)) {
NewC = FoldedC;
FoldedOps.insert({NewCE, FoldedC});
} else {
FoldedOps.insert({NewCE, NewCE});
}
} else {
NewC = It->second;
}
}
Ops.push_back(NewC);
}
if (CE->isCompare())
return ConstantFoldCompareInstOperands(CE->getPredicate(), Ops[0], Ops[1],
DL, TLI);
return ConstantFoldInstOperandsImpl(CE, CE->getType(), CE->getOpcode(), Ops,
DL, TLI);
}
} // end anonymous namespace
Constant *llvm::ConstantFoldConstantExpression(const ConstantExpr *CE,
const DataLayout &DL,
const TargetLibraryInfo *TLI) {
SmallDenseMap<ConstantExpr *, Constant *> FoldedOps;
return ConstantFoldConstantExpressionImpl(CE, DL, TLI, FoldedOps);
Constant *llvm::ConstantFoldConstant(const Constant *C, const DataLayout &DL,
const TargetLibraryInfo *TLI) {
SmallDenseMap<Constant *, Constant *> FoldedOps;
return ConstantFoldConstantImpl(C, DL, TLI, FoldedOps);
}
Constant *llvm::ConstantFoldInstOperands(Instruction *I,

6
lib/Analysis/Lint.cpp
View File

@ -680,9 +680,9 @@ Value *Lint::findValueImpl(Value *V, bool OffsetOk,
if (Instruction *Inst = dyn_cast<Instruction>(V)) {
if (Value *W = SimplifyInstruction(Inst, *DL, TLI, DT, AC))
return findValueImpl(W, OffsetOk, Visited);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
if (Value *W = ConstantFoldConstantExpression(CE, *DL, TLI))
if (W != V)
} else if (auto *C = dyn_cast<Constant>(V)) {
if (Value *W = ConstantFoldConstant(C, *DL, TLI))
if (W && W != V)
return findValueImpl(W, OffsetOk, Visited);
}

4
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -1764,7 +1764,7 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
// If the code isn't optimized, there may be outstanding folding
// opportunities. Attempt to fold the expression using DataLayout as a
// last resort before giving up.
if (Constant *C = ConstantFoldConstantExpression(CE, getDataLayout()))
if (Constant *C = ConstantFoldConstant(CE, getDataLayout()))
if (C != CE)
return lowerConstant(C);
@ -2299,7 +2299,7 @@ static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
// If the constant expression's size is greater than 64-bits, then we have
// to emit the value in chunks. Try to constant fold the value and emit it
// that way.
Constant *New = ConstantFoldConstantExpression(CE, DL);
Constant *New = ConstantFoldConstant(CE, DL);
if (New && New != CE)
return emitGlobalConstantImpl(DL, New, AP);
}

14
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
View File

@ -1848,9 +1848,9 @@ void NVPTXAsmPrinter::bufferLEByte(const Constant *CPV, int Bytes,
ConvertIntToBytes<>(ptr, int32);
aggBuffer->addBytes(ptr, 4, Bytes);
break;
} else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
ConstantFoldConstantExpression(Cexpr, DL))) {
} else if (const auto *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
ConstantFoldConstant(Cexpr, DL))) {
int int32 = (int)(constInt->getZExtValue());
ConvertIntToBytes<>(ptr, int32);
aggBuffer->addBytes(ptr, 4, Bytes);
@ -1871,8 +1871,8 @@ void NVPTXAsmPrinter::bufferLEByte(const Constant *CPV, int Bytes,
aggBuffer->addBytes(ptr, 8, Bytes);
break;
} else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
ConstantFoldConstantExpression(Cexpr, DL))) {
if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
ConstantFoldConstant(Cexpr, DL))) {
long long int64 = (long long)(constInt->getZExtValue());
ConvertIntToBytes<>(ptr, int64);
aggBuffer->addBytes(ptr, 8, Bytes);
@ -2074,8 +2074,8 @@ NVPTXAsmPrinter::lowerConstantForGV(const Constant *CV, bool ProcessingGeneric)
// If the code isn't optimized, there may be outstanding folding
// opportunities. Attempt to fold the expression using DataLayout as a
// last resort before giving up.
if (Constant *C = ConstantFoldConstantExpression(CE, getDataLayout()))
if (C != CE)
if (Constant *C = ConstantFoldConstant(CE, getDataLayout()))
if (C && C != CE)
return lowerConstantForGV(C, ProcessingGeneric);
// Otherwise report the problem to the user.

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

@ -2079,10 +2079,10 @@ OptimizeGlobalVars(Module &M, TargetLibraryInfo *TLI,
GV->setLinkage(GlobalValue::InternalLinkage);
// Simplify the initializer.
if (GV->hasInitializer())
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GV->getInitializer())) {
if (auto *C = dyn_cast<Constant>(GV->getInitializer())) {
auto &DL = M.getDataLayout();
Constant *New = ConstantFoldConstantExpression(CE, DL, TLI);
if (New && New != CE)
Constant *New = ConstantFoldConstant(C, DL, TLI);
if (New && New != C)
GV->setInitializer(New);
}

5
lib/Transforms/InstCombine/InstCombineCasts.cpp
View File

@ -161,9 +161,8 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
if (Constant *C = dyn_cast<Constant>(V)) {
C = ConstantExpr::getIntegerCast(C, Ty, isSigned /*Sext or ZExt*/);
// If we got a constantexpr back, try to simplify it with DL info.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
if (Constant *FoldedC = ConstantFoldConstantExpression(CE, DL, TLI))
C = FoldedC;
if (Constant *FoldedC = ConstantFoldConstant(C, DL, TLI))
C = FoldedC;
return C;
}

6
lib/Transforms/InstCombine/InstCombineShifts.cpp
View File

@ -194,8 +194,10 @@ static Value *GetShiftedValue(Value *V, unsigned NumBits, bool isLeftShift,
else
V = IC.Builder->CreateLShr(C, NumBits);
// If we got a constantexpr back, try to simplify it with TD info.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
V = ConstantFoldConstantExpression(CE, DL, IC.getTargetLibraryInfo());
if (auto *C = dyn_cast<Constant>(V))
if (auto *FoldedC =
ConstantFoldConstant(C, DL, IC.getTargetLibraryInfo()))
V = FoldedC;
return V;
}

14
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -2981,7 +2981,7 @@ static bool AddReachableCodeToWorklist(BasicBlock *BB, const DataLayout &DL,
Worklist.push_back(BB);
SmallVector<Instruction*, 128> InstrsForInstCombineWorklist;
DenseMap<ConstantExpr*, Constant*> FoldedConstants;
DenseMap<Constant *, Constant *> FoldedConstants;
do {
BB = Worklist.pop_back_val();
@ -3017,17 +3017,17 @@ static bool AddReachableCodeToWorklist(BasicBlock *BB, const DataLayout &DL,
// See if we can constant fold its operands.
for (User::op_iterator i = Inst->op_begin(), e = Inst->op_end(); i != e;
++i) {
ConstantExpr *CE = dyn_cast<ConstantExpr>(i);
if (CE == nullptr)
if (!isa<ConstantVector>(i) && !isa<ConstantExpr>(i))
continue;
Constant *&FoldRes = FoldedConstants[CE];
auto *C = cast<Constant>(i);
Constant *&FoldRes = FoldedConstants[C];
if (!FoldRes)
FoldRes = ConstantFoldConstantExpression(CE, DL, TLI);
FoldRes = ConstantFoldConstant(C, DL, TLI);
if (!FoldRes)
FoldRes = CE;
FoldRes = C;
if (FoldRes != CE) {
if (FoldRes != C) {
*i = FoldRes;
MadeIRChange = true;
}

15
lib/Transforms/Scalar/GVN.cpp
View File

@ -725,8 +725,9 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
assert(CanCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
"precondition violation - materialization can't fail");
if (auto *CExpr = dyn_cast<ConstantExpr>(StoredVal))
StoredVal = ConstantFoldConstantExpression(CExpr, DL);
if (auto *C = dyn_cast<Constant>(StoredVal))
if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
StoredVal = FoldedStoredVal;
// If this is already the right type, just return it.
Type *StoredValTy = StoredVal->getType();
@ -759,8 +760,9 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
StoredVal = IRB.CreateIntToPtr(StoredVal, LoadedTy);
}
if (auto *CExpr = dyn_cast<ConstantExpr>(StoredVal))
StoredVal = ConstantFoldConstantExpression(CExpr, DL);
if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
StoredVal = FoldedStoredVal;
return StoredVal;
}
@ -804,8 +806,9 @@ static Value *CoerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
StoredVal = IRB.CreateBitCast(StoredVal, LoadedTy, "bitcast");
}
if (auto *CExpr = dyn_cast<ConstantExpr>(StoredVal))
StoredVal = ConstantFoldConstantExpression(CExpr, DL);
if (auto *C = dyn_cast<Constant>(StoredVal))
if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
StoredVal = FoldedStoredVal;
return StoredVal;
}

16
lib/Transforms/Utils/Evaluator.cpp
View File

@ -203,9 +203,9 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
return false; // no volatile/atomic accesses.
}
Constant *Ptr = getVal(SI->getOperand(1));
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
if (auto *FoldedPtr = ConstantFoldConstant(Ptr, DL, TLI)) {
DEBUG(dbgs() << "Folding constant ptr expression: " << *Ptr);
Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
Ptr = FoldedPtr;
DEBUG(dbgs() << "; To: " << *Ptr << "\n");
}
if (!isSimpleEnoughPointerToCommit(Ptr)) {
@ -249,8 +249,8 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
Constant * const IdxList[] = {IdxZero, IdxZero};
Ptr = ConstantExpr::getGetElementPtr(nullptr, Ptr, IdxList);
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr))
Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
if (auto *FoldedPtr = ConstantFoldConstant(Ptr, DL, TLI))
Ptr = FoldedPtr;
// If we can't improve the situation by introspecting NewTy,
// we have to give up.
@ -324,8 +324,8 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
}
Constant *Ptr = getVal(LI->getOperand(0));
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
if (auto *FoldedPtr = ConstantFoldConstant(Ptr, DL, TLI)) {
Ptr = FoldedPtr;
DEBUG(dbgs() << "Found a constant pointer expression, constant "
"folding: " << *Ptr << "\n");
}
@ -512,8 +512,8 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
}
if (!CurInst->use_empty()) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InstResult))
InstResult = ConstantFoldConstantExpression(CE, DL, TLI);
if (auto *FoldedInstResult = ConstantFoldConstant(InstResult, DL, TLI))
InstResult = FoldedInstResult;
setVal(&*CurInst, InstResult);
}

4
test/Transforms/InstCombine/icmp-vec.ll
View File

@ -159,11 +159,9 @@ define <2 x i1> @ule_max(<2 x i3> %x) {
ret <2 x i1> %cmp
}
; If we can't determine if a constant element is min/max (eg, it's a ConstantExpr), do nothing.
define <2 x i1> @PR27756_1(<2 x i8> %a) {
; CHECK-LABEL: @PR27756_1(
; CHECK-NEXT: [[CMP:%.*]] = icmp sle <2 x i8> %a, <i8 bitcast (<2 x i4> <i4 1, i4 2> to i8), i8 0>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> %a, <i8 34, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%cmp = icmp sle <2 x i8> %a, <i8 bitcast (<2 x i4> <i4 1, i4 2> to i8), i8 0>