bool AMDGPUCodeGenPrepare::promoteUniformOpToI32(ICmpInst &I) const {
assert(needsPromotionToI32(I.getOperand(0)->getType()) &&
"I does not need promotion to i32");
IRBuilder<> Builder(&I);
Builder.SetCurrentDebugLocation(I.getDebugLoc());
Type *I32Ty = getI32Ty(Builder, I.getOperand(0)->getType());
Value *ExtOp0 = nullptr;
Value *ExtOp1 = nullptr;
Value *NewICmp = nullptr;
if (I.isSigned()) {
ExtOp0 = Builder.CreateSExt(I.getOperand(0), I32Ty);
ExtOp1 = Builder.CreateSExt(I.getOperand(1), I32Ty);
} else {
ExtOp0 = Builder.CreateZExt(I.getOperand(0), I32Ty);
ExtOp1 = Builder.CreateZExt(I.getOperand(1), I32Ty);
}
NewICmp = Builder.CreateICmp(I.getPredicate(), ExtOp0, ExtOp1);
I.replaceAllUsesWith(NewICmp);
I.eraseFromParent();
return true;
}
// Calculate Edge Weights using "Pointer Heuristics". Predict a comparsion
// between two pointer or pointer and NULL will fail.
bool BranchProbabilityInfo::calcPointerHeuristics(BasicBlock *BB) {
BranchInst * BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
if (!CI || !CI->isEquality())
return false;
Value *LHS = CI->getOperand(0);
if (!LHS->getType()->isPointerTy())
return false;
assert(CI->getOperand(1)->getType()->isPointerTy());
// p != 0 -> isProb = true
// p == 0 -> isProb = false
// p != q -> isProb = true
// p == q -> isProb = false;
unsigned TakenIdx = 0, NonTakenIdx = 1;
bool isProb = CI->getPredicate() == ICmpInst::ICMP_NE;
if (!isProb)
std::swap(TakenIdx, NonTakenIdx);
setEdgeWeight(BB, TakenIdx, PH_TAKEN_WEIGHT);
setEdgeWeight(BB, NonTakenIdx, PH_NONTAKEN_WEIGHT);
return true;
}
bool visitICmpInst(ICmpInst& inst) {
// errs() << "got icmp instruction! " << inst << '\n';
bool changed = false;
if (inst.getPredicate() == CmpInst::ICMP_EQ) {
assert(inst.getNumOperands() == 2);
if (inst.getOperand(1) == processing) {
inst.swapOperands();
changed = true;
any_changes = true;
}
assert(dyn_cast<Instruction>(inst.getOperand(0)) == processing);
Value* other = inst.getOperand(1);
if (isa<ConstantPointerNull>(other)) {
if (VERBOSITY("opt") >= 2) {
errs() << inst << '\n';
errs() << "replacing with false!\n";
}
Value* new_value = ConstantInt::getFalse(other->getContext());
inst.replaceAllUsesWith(new_value);
inst.eraseFromParent();
changed = true;
any_changes = true;
}
}
return changed;
}
void IndVarSimplify::EliminateIVComparisons() {
// Look for ICmp users.
for (IVUsers::iterator I = IU->begin(), E = IU->end(); I != E; ++I) {
IVStrideUse &UI = *I;
ICmpInst *ICmp = dyn_cast<ICmpInst>(UI.getUser());
if (!ICmp) continue;
bool Swapped = UI.getOperandValToReplace() == ICmp->getOperand(1);
ICmpInst::Predicate Pred = ICmp->getPredicate();
if (Swapped) Pred = ICmpInst::getSwappedPredicate(Pred);
// Get the SCEVs for the ICmp operands.
const SCEV *S = IU->getReplacementExpr(UI);
const SCEV *X = SE->getSCEV(ICmp->getOperand(!Swapped));
// Simplify unnecessary loops away.
const Loop *ICmpLoop = LI->getLoopFor(ICmp->getParent());
S = SE->getSCEVAtScope(S, ICmpLoop);
X = SE->getSCEVAtScope(X, ICmpLoop);
// If the condition is always true or always false, replace it with
// a constant value.
if (SE->isKnownPredicate(Pred, S, X))
ICmp->replaceAllUsesWith(ConstantInt::getTrue(ICmp->getContext()));
else if (SE->isKnownPredicate(ICmpInst::getInversePredicate(Pred), S, X))
ICmp->replaceAllUsesWith(ConstantInt::getFalse(ICmp->getContext()));
else
continue;
DEBUG(dbgs() << "INDVARS: Eliminated comparison: " << *ICmp << '\n');
DeadInsts.push_back(ICmp);
}
}
bool BranchProbabilityAnalysis::calcZeroHeuristics(BasicBlock *BB) {
BranchInst * BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
if (!CI)
return false;
Value *RHS = CI->getOperand(1);
ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
if (!CV)
return false;
bool isProb;
if (CV->isZero()) {
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// X == 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_NE:
// X != 0 -> Likely
isProb = true;
break;
case CmpInst::ICMP_SLT:
// X < 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_SGT:
// X > 0 -> Likely
isProb = true;
break;
default:
return false;
}
} else if (CV->isOne() && CI->getPredicate() == CmpInst::ICMP_SLT) {
// InstCombine canonicalizes X <= 0 into X < 1.
// X <= 0 -> Unlikely
isProb = false;
} else if (CV->isAllOnesValue() && CI->getPredicate() == CmpInst::ICMP_SGT) {
// InstCombine canonicalizes X >= 0 into X > -1.
// X >= 0 -> Likely
isProb = true;
} else {
return false;
}
BasicBlock *Taken = BI->getSuccessor(0);
BasicBlock *NonTaken = BI->getSuccessor(1);
if (!isProb)
std::swap(Taken, NonTaken);
BP->setEdgeWeight(BB, Taken, ZH_TAKEN_WEIGHT);
BP->setEdgeWeight(BB, NonTaken, ZH_NONTAKEN_WEIGHT);
return true;
}
/// MatchSelectPattern - Pattern match integer [SU]MIN, [SU]MAX, and ABS idioms,
/// returning the kind and providing the out parameter results if we
/// successfully match.
static SelectPatternFlavor
MatchSelectPattern(Value *V, Value *&LHS, Value *&RHS) {
SelectInst *SI = dyn_cast<SelectInst>(V);
if (SI == 0) return SPF_UNKNOWN;
ICmpInst *ICI = dyn_cast<ICmpInst>(SI->getCondition());
if (ICI == 0) return SPF_UNKNOWN;
LHS = ICI->getOperand(0);
RHS = ICI->getOperand(1);
// (icmp X, Y) ? X : Y
if (SI->getTrueValue() == ICI->getOperand(0) &&
SI->getFalseValue() == ICI->getOperand(1)) {
switch (ICI->getPredicate()) {
default: return SPF_UNKNOWN; // Equality.
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE: return SPF_UMAX;
case ICmpInst::ICMP_SGT:
case ICmpInst::ICMP_SGE: return SPF_SMAX;
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE: return SPF_UMIN;
case ICmpInst::ICMP_SLT:
case ICmpInst::ICMP_SLE: return SPF_SMIN;
}
}
// (icmp X, Y) ? Y : X
if (SI->getTrueValue() == ICI->getOperand(1) &&
SI->getFalseValue() == ICI->getOperand(0)) {
switch (ICI->getPredicate()) {
default: return SPF_UNKNOWN; // Equality.
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE: return SPF_UMIN;
case ICmpInst::ICMP_SGT:
case ICmpInst::ICMP_SGE: return SPF_SMIN;
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE: return SPF_UMAX;
case ICmpInst::ICMP_SLT:
case ICmpInst::ICMP_SLE: return SPF_SMAX;
}
}
// TODO: (X > 4) ? X : 5 --> (X >= 5) ? X : 5 --> MAX(X, 5)
return SPF_UNKNOWN;
}
bool AMDGPUCodeGenPrepare::visitICmpInst(ICmpInst &I) {
bool Changed = false;
if (ST->has16BitInsts() && needsPromotionToI32(I.getOperand(0)->getType()) &&
DA->isUniform(&I))
Changed |= promoteUniformOpToI32(I);
return Changed;
}
bool BranchProbabilityAnalysis::calcZeroHeuristics(BasicBlock *BB) {
BranchInst * BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
if (!CI)
return false;
Value *RHS = CI->getOperand(1);
ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
if (!CV || !CV->isZero())
return false;
bool isProb;
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// Equal to zero is not expected to be taken.
isProb = false;
break;
case CmpInst::ICMP_NE:
// Not equal to zero is expected.
isProb = true;
break;
case CmpInst::ICMP_SLT:
// Less or equal to zero is not expected.
// X < 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_UGT:
case CmpInst::ICMP_SGT:
// Greater or equal to zero is expected.
// X > 0 -> Likely
isProb = true;
break;
default:
return false;
};
BasicBlock *Taken = BI->getSuccessor(0);
BasicBlock *NonTaken = BI->getSuccessor(1);
if (!isProb)
std::swap(Taken, NonTaken);
BP->setEdgeWeight(BB, Taken, ZH_TAKEN_WEIGHT);
BP->setEdgeWeight(BB, NonTaken, ZH_NONTAKEN_WEIGHT);
return true;
}
void IndVarSimplify::EliminateIVComparisons() {
SmallVector<WeakVH, 16> DeadInsts;
// Look for ICmp users.
for (IVUsers::iterator I = IU->begin(), E = IU->end(); I != E; ++I) {
IVStrideUse &UI = *I;
ICmpInst *ICmp = dyn_cast<ICmpInst>(UI.getUser());
if (!ICmp) continue;
bool Swapped = UI.getOperandValToReplace() == ICmp->getOperand(1);
ICmpInst::Predicate Pred = ICmp->getPredicate();
if (Swapped) Pred = ICmpInst::getSwappedPredicate(Pred);
// Get the SCEVs for the ICmp operands.
const SCEV *S = IU->getReplacementExpr(UI);
const SCEV *X = SE->getSCEV(ICmp->getOperand(!Swapped));
// Simplify unnecessary loops away.
const Loop *ICmpLoop = LI->getLoopFor(ICmp->getParent());
S = SE->getSCEVAtScope(S, ICmpLoop);
X = SE->getSCEVAtScope(X, ICmpLoop);
// If the condition is always true or always false, replace it with
// a constant value.
if (SE->isKnownPredicate(Pred, S, X))
ICmp->replaceAllUsesWith(ConstantInt::getTrue(ICmp->getContext()));
else if (SE->isKnownPredicate(ICmpInst::getInversePredicate(Pred), S, X))
ICmp->replaceAllUsesWith(ConstantInt::getFalse(ICmp->getContext()));
else
continue;
DEBUG(dbgs() << "INDVARS: Eliminated comparison: " << *ICmp << '\n');
DeadInsts.push_back(ICmp);
}
// Now that we're done iterating through lists, clean up any instructions
// which are now dead.
while (!DeadInsts.empty())
if (Instruction *Inst =
dyn_cast_or_null<Instruction>(&*DeadInsts.pop_back_val()))
RecursivelyDeleteTriviallyDeadInstructions(Inst);
}
bool LowerExpectIntrinsic::HandleIfExpect(BranchInst *BI) {
if (BI->isUnconditional())
return false;
// Handle non-optimized IR code like:
// %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 1)
// %tobool = icmp ne i64 %expval, 0
// br i1 %tobool, label %if.then, label %if.end
//
// Or the following simpler case:
// %expval = call i1 @llvm.expect.i1(i1 %cmp, i1 1)
// br i1 %expval, label %if.then, label %if.end
CallInst *CI;
ICmpInst *CmpI = dyn_cast<ICmpInst>(BI->getCondition());
if (!CmpI) {
CI = dyn_cast<CallInst>(BI->getCondition());
} else {
if (CmpI->getPredicate() != CmpInst::ICMP_NE)
return false;
CI = dyn_cast<CallInst>(CmpI->getOperand(0));
}
if (!CI)
return false;
Function *Fn = CI->getCalledFunction();
if (!Fn || Fn->getIntrinsicID() != Intrinsic::expect)
return false;
Value *ArgValue = CI->getArgOperand(0);
ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
if (!ExpectedValue)
return false;
MDBuilder MDB(CI->getContext());
MDNode *Node;
// If expect value is equal to 1 it means that we are more likely to take
// branch 0, in other case more likely is branch 1.
if (ExpectedValue->isOne())
Node = MDB.createBranchWeights(LikelyBranchWeight, UnlikelyBranchWeight);
else
Node = MDB.createBranchWeights(UnlikelyBranchWeight, LikelyBranchWeight);
BI->setMetadata(LLVMContext::MD_prof, Node);
if (CmpI)
CmpI->setOperand(0, ArgValue);
else
BI->setCondition(ArgValue);
return true;
}
// createSigmasForCondBranch
void Redefinition::createSigmasForCondBranch(BranchInst *BI) {
assert(BI->isConditional() && "Expected conditional branch");
ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition());
if (!ICI || !ICI->getOperand(0)->getType()->isIntegerTy())
return;
RDEF_DEBUG(dbgs() << "createSigmasForCondBranch: " << *BI << "\n");
Value *Left = ICI->getOperand(0);
Value *Right = ICI->getOperand(1);
BasicBlock *TB = BI->getSuccessor(0);
BasicBlock *FB = BI->getSuccessor(1);
bool HasSinglePredTB = TB->getSinglePredecessor() != NULL;
bool HasSinglePredFB = FB->getSinglePredecessor() != NULL;
bool IsRedefinableRight = IsRedefinable(Right);
bool SameBranchOperands = Left == Right;
//errs() << HasSinglePredTB << ", " << HasSinglePredFB << "\n";
//errs() << IsRedefinable(Left) << ", " << IsRedefinableRight << "\n";
if (IsRedefinable(Left)) {
// We don't want to place extranius definitions of a value, so the only
// place the sigma once if the branch operands are the same.
Value *Second = SameBranchOperands && IsRedefinableRight ? Right : NULL;
if (HasSinglePredTB)
createSigmaNodesForValueAt(Left, Second, TB);
if (HasSinglePredFB)
createSigmaNodesForValueAt(Left, Second, FB);
}
// Left isn't definable down here.
else if (IsRedefinable(Right)) {
if (HasSinglePredTB)
createSigmaNodesForValueAt(Right, NULL, TB);
if (HasSinglePredFB)
createSigmaNodesForValueAt(Right, NULL, FB);
}
}
void TempScopInfo::buildAffineCondition(Value &V, bool inverted,
Comparison **Comp,
TempScop &Scop) const {
Region &R = Scop.getMaxRegion();
ParamSetType &Params = Scop.getParamSet();
if (ConstantInt *C = dyn_cast<ConstantInt>(&V)) {
// If this is always true condition, we will create 1 >= 0,
// otherwise we will create 1 == 0.
SCEVAffFunc *AffLHS = new SCEVAffFunc(SE->getConstant(C->getType(), 0),
SCEVAffFunc::Eq, R, Params, LI, SE);
SCEVAffFunc *AffRHS = new SCEVAffFunc(SE->getConstant(C->getType(), 1),
SCEVAffFunc::Eq, R, Params, LI, SE);
if (C->isOne() == inverted)
*Comp = new Comparison(AffRHS, AffLHS, ICmpInst::ICMP_NE);
else
*Comp = new Comparison(AffLHS, AffLHS, ICmpInst::ICMP_EQ);
return;
}
ICmpInst *ICmp = dyn_cast<ICmpInst>(&V);
assert(ICmp && "Only ICmpInst of constant as condition supported!");
const SCEV *LHS = SE->getSCEV(ICmp->getOperand(0)),
*RHS = SE->getSCEV(ICmp->getOperand(1));
ICmpInst::Predicate Pred = ICmp->getPredicate();
// Invert the predicate if needed.
if (inverted)
Pred = ICmpInst::getInversePredicate(Pred);
SCEVAffFunc *AffLHS = new SCEVAffFunc(LHS, SCEVAffFunc::Eq, R, Params, LI,
SE);
SCEVAffFunc *AffRHS = new SCEVAffFunc(RHS, SCEVAffFunc::Eq, R, Params, LI,
SE);
switch (Pred) {
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE:
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE:
// TODO: At the moment we need to see everything as signed. This is an
// correctness issue that needs to be solved.
//AffLHS->setUnsigned();
//AffRHS->setUnsigned();
break;
default:
break;
}
*Comp = new Comparison(AffLHS, AffRHS, Pred);
}
/// Creates the graphs for this function.
/// It will look for all comparators used in branches, and create them.
/// These comparators will create constraints for any instruction as an
/// operand.
void ABCD::executeABCD(Function &F) {
for (Function::iterator begin = F.begin(), end = F.end();
begin != end; ++begin) {
BasicBlock *BB = begin;
TerminatorInst *TI = BB->getTerminator();
if (TI->getNumOperands() == 0)
continue;
ICmpInst *ICI = dyn_cast<ICmpInst>(TI->getOperand(0));
if (!ICI || !isa<IntegerType>(ICI->getOperand(0)->getType()))
continue;
createConstraintCmpInst(ICI, TI);
seekRedundancy(ICI, TI);
}
}
void TempScopInfo::buildAffineCondition(Value &V, bool inverted,
Comparison **Comp) const {
if (ConstantInt *C = dyn_cast<ConstantInt>(&V)) {
// If this is always true condition, we will create 0 <= 1,
// otherwise we will create 0 >= 1.
const SCEV *LHS = SE->getConstant(C->getType(), 0);
const SCEV *RHS = SE->getConstant(C->getType(), 1);
if (C->isOne() == inverted)
*Comp = new Comparison(LHS, RHS, ICmpInst::ICMP_SLE);
else
*Comp = new Comparison(LHS, RHS, ICmpInst::ICMP_SGE);
return;
}
ICmpInst *ICmp = dyn_cast<ICmpInst>(&V);
assert(ICmp && "Only ICmpInst of constant as condition supported!");
Loop *L = LI->getLoopFor(ICmp->getParent());
const SCEV *LHS = SE->getSCEVAtScope(ICmp->getOperand(0), L);
const SCEV *RHS = SE->getSCEVAtScope(ICmp->getOperand(1), L);
ICmpInst::Predicate Pred = ICmp->getPredicate();
// Invert the predicate if needed.
if (inverted)
Pred = ICmpInst::getInversePredicate(Pred);
switch (Pred) {
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE:
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE:
// TODO: At the moment we need to see everything as signed. This is an
// correctness issue that needs to be solved.
// AffLHS->setUnsigned();
// AffRHS->setUnsigned();
break;
default:
break;
}
*Comp = new Comparison(LHS, RHS, Pred);
}
bool LowerExpectIntrinsic::HandleIfExpect(BranchInst *BI) {
if (BI->isUnconditional())
return false;
// Handle non-optimized IR code like:
// %expval = call i64 @llvm.expect.i64.i64(i64 %conv1, i64 1)
// %tobool = icmp ne i64 %expval, 0
// br i1 %tobool, label %if.then, label %if.end
ICmpInst *CmpI = dyn_cast<ICmpInst>(BI->getCondition());
if (!CmpI || CmpI->getPredicate() != CmpInst::ICMP_NE)
return false;
CallInst *CI = dyn_cast<CallInst>(CmpI->getOperand(0));
if (!CI)
return false;
Function *Fn = CI->getCalledFunction();
if (!Fn || Fn->getIntrinsicID() != Intrinsic::expect)
return false;
Value *ArgValue = CI->getArgOperand(0);
ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
if (!ExpectedValue)
return false;
LLVMContext &Context = CI->getContext();
const Type *Int32Ty = Type::getInt32Ty(Context);
bool Likely = ExpectedValue->isOne();
// If expect value is equal to 1 it means that we are more likely to take
// branch 0, in other case more likely is branch 1.
Value *Ops[] = {
MDString::get(Context, "branch_weights"),
ConstantInt::get(Int32Ty, Likely ? LikelyBranchWeight : UnlikelyBranchWeight),
ConstantInt::get(Int32Ty, Likely ? UnlikelyBranchWeight : LikelyBranchWeight)
};
MDNode *WeightsNode = MDNode::get(Context, Ops);
BI->setMetadata(LLVMContext::MD_prof, WeightsNode);
CmpI->setOperand(0, ArgValue);
return true;
}
/// MatchPointerHeuristic - Predict that a comparison of a pointer against
/// null or of two pointers will fail.
/// @returns a Prediction that is a pair in which the first element is the
/// successor taken, and the second the successor not taken.
Prediction BranchHeuristicsInfo::MatchPointerHeuristic(BasicBlock *root) const {
// Last instruction of basic block.
TerminatorInst *TI = root->getTerminator();
// Basic block successors. True and False branches.
BasicBlock *trueSuccessor = TI->getSuccessor(0);
BasicBlock *falseSuccessor = TI->getSuccessor(1);
// Is the last instruction a Branch Instruction?
BranchInst *BI = dyn_cast<BranchInst>(TI);
if (!BI || !BI->isConditional())
return empty;
// Conditional instruction.
Value *cond = BI->getCondition();
// Pointer comparisons are integer comparisons.
ICmpInst *II = dyn_cast<ICmpInst>(cond);
if (!II)
return empty;
// An integer comparison has always two operands.
Value *operand1 = II->getOperand(0);
Value *operand2 = II->getOperand(1);
// Obtain the type of comparison.
enum ICmpInst::Predicate signedPred = II->getSignedPredicate();
// The heuristic states that it must be compared against null,
// but in LLVM, null is also a PointerType, so it only requires
// to test if there is a comparison between two pointers.
if (signedPred == ICmpInst::ICMP_EQ &&
isa<PointerType>(operand1->getType()) && // NULL is a pointer type too
isa<PointerType>(operand2->getType())) { // NULL is a pointer type too
return std::make_pair(falseSuccessor, trueSuccessor);
} else if (signedPred != ICmpInst::ICMP_EQ &&
isa<PointerType>(operand1->getType()) &&
isa<PointerType>(operand2->getType())) {
return std::make_pair(trueSuccessor, falseSuccessor);
}
return empty;
}
int BranchProbabilities::CheckPointerHeuristic()
{
// Heuristic fails if the last instruction is not a conditional branch
BranchInst *BI = dyn_cast<BranchInst>(_TI);
if ((!BI) || (BI->isUnconditional()))
return -1;
// All pointer comparisons are done with the icmp instruction
ICmpInst *icmp = dyn_cast<ICmpInst>(BI->getCondition());
if (!icmp)
return -1;
Value *v[2];
v[0] = icmp->getOperand(0);
v[1] = icmp->getOperand(1);
// Make sure we're comparing pointers
if (isa<PointerType>(v[0]->getType()))
{
assert(isa<PointerType>(v[1]->getType()) && "v[1] is not a pointer!");
// Choose the prefered branch depending on if this is an eq or neq comp
switch (icmp->getPredicate())
{
case ICmpInst::ICMP_EQ:
return 1;
case ICmpInst::ICMP_NE:
return 0;
default:
assert("non-equality comparison of pointers");
return -1;
}
}
return -1;
}
/// \brief Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
/// Val is not constrained on the edge.
static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom,
BasicBlock *BBTo, LVILatticeVal &Result) {
// TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
// know that v != 0.
if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
// If this is a conditional branch and only one successor goes to BBTo, then
// we maybe able to infer something from the condition.
if (BI->isConditional() &&
BI->getSuccessor(0) != BI->getSuccessor(1)) {
bool isTrueDest = BI->getSuccessor(0) == BBTo;
assert(BI->getSuccessor(!isTrueDest) == BBTo &&
"BBTo isn't a successor of BBFrom");
// If V is the condition of the branch itself, then we know exactly what
// it is.
if (BI->getCondition() == Val) {
Result = LVILatticeVal::get(ConstantInt::get(
Type::getInt1Ty(Val->getContext()), isTrueDest));
return true;
}
// If the condition of the branch is an equality comparison, we may be
// able to infer the value.
ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition());
if (ICI && isa<Constant>(ICI->getOperand(1))) {
if (ICI->isEquality() && ICI->getOperand(0) == Val) {
// We know that V has the RHS constant if this is a true SETEQ or
// false SETNE.
if (isTrueDest == (ICI->getPredicate() == ICmpInst::ICMP_EQ))
Result = LVILatticeVal::get(cast<Constant>(ICI->getOperand(1)));
else
Result = LVILatticeVal::getNot(cast<Constant>(ICI->getOperand(1)));
return true;
}
// Recognize the range checking idiom that InstCombine produces.
// (X-C1) u< C2 --> [C1, C1+C2)
ConstantInt *NegOffset = 0;
if (ICI->getPredicate() == ICmpInst::ICMP_ULT)
match(ICI->getOperand(0), m_Add(m_Specific(Val),
m_ConstantInt(NegOffset)));
ConstantInt *CI = dyn_cast<ConstantInt>(ICI->getOperand(1));
if (CI && (ICI->getOperand(0) == Val || NegOffset)) {
// Calculate the range of values that would satisfy the comparison.
ConstantRange CmpRange(CI->getValue());
ConstantRange TrueValues =
ConstantRange::makeICmpRegion(ICI->getPredicate(), CmpRange);
if (NegOffset) // Apply the offset from above.
TrueValues = TrueValues.subtract(NegOffset->getValue());
// If we're interested in the false dest, invert the condition.
if (!isTrueDest) TrueValues = TrueValues.inverse();
Result = LVILatticeVal::getRange(TrueValues);
return true;
}
}
}
}
// If the edge was formed by a switch on the value, then we may know exactly
// what it is.
if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
if (SI->getCondition() != Val)
return false;
bool DefaultCase = SI->getDefaultDest() == BBTo;
unsigned BitWidth = Val->getType()->getIntegerBitWidth();
ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
i != e; ++i) {
ConstantRange EdgeVal(i.getCaseValue()->getValue());
if (DefaultCase) {
// It is possible that the default destination is the destination of
// some cases. There is no need to perform difference for those cases.
if (i.getCaseSuccessor() != BBTo)
EdgesVals = EdgesVals.difference(EdgeVal);
} else if (i.getCaseSuccessor() == BBTo)
EdgesVals = EdgesVals.unionWith(EdgeVal);
}
Result = LVILatticeVal::getRange(EdgesVals);
return true;
}
return false;
}
void TripCountGenerator::generateVectorEstimatedTripCounts(Function &F){
LoopInfoEx& li = getAnalysis<LoopInfoEx>();
LoopNormalizerAnalysis& ln = getAnalysis<LoopNormalizerAnalysis>();
for(LoopInfoEx::iterator lit = li.begin(); lit != li.end(); lit++){
//Indicates if we don't have ways to determine the trip count
bool unknownTC = false;
Loop* loop = *lit;
BasicBlock* header = loop->getHeader();
BasicBlock* entryBlock = ln.entryBlocks[header];
LoopControllersDepGraph& lcd = getAnalysis<LoopControllersDepGraph>();
lcd.setPerspective(header);
/*
* Here we are looking for the predicate that stops the loop.
*
* At this moment, we are only considering loops that are controlled by
* integer comparisons.
*/
BasicBlock* exitBlock = findLoopControllerBlock(loop);
assert(exitBlock && "Exiting Block not found!");
TerminatorInst* T = exitBlock->getTerminator();
BranchInst* BI = dyn_cast<BranchInst>(T);
ICmpInst* CI = BI ? dyn_cast<ICmpInst>(BI->getCondition()) : NULL;
Value* Op1 = NULL;
Value* Op2 = NULL;
if (!CI) unknownTC = true;
else {
int LoopClass;
if (isIntervalComparison(CI)) {
LoopClass = 0;
NumIntervalLoops++;
} else {
LoopClass = 1;
NumEqualityLoops++;
}
Op1 = getValueAtEntryPoint(CI->getOperand(0), header);
Op2 = getValueAtEntryPoint(CI->getOperand(1), header);
if((!Op1) || (!Op2) ) {
if (!LoopClass) NumUnknownConditionsIL++;
else NumUnknownConditionsEL++;
unknownTC = true;
} else {
if (!(Op1->getType()->isIntegerTy() && Op2->getType()->isIntegerTy())) {
//We only handle loop conditions that compares integer variables
NumIncompatibleOperandTypes++;
unknownTC = true;
}
}
}
ProgressVector* V1 = NULL;
ProgressVector* V2 = NULL;
if (!unknownTC) {
V1 = generateConstantProgressVector(CI->getOperand(0), header);
V2 = generateConstantProgressVector(CI->getOperand(1), header);
if ((!V1) || (!V2)) {
//TODO: Increment a statistic here
unknownTC = true;
}
}
if(!unknownTC) {
generateVectorEstimatedTripCount(header, entryBlock, Op1, Op2, V1, V2, CI);
NumVectorEstimatedTCs++;
}
}
}
bool CallAnalyzer::visitICmp(ICmpInst &I) {
Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
// First try to handle simplified comparisons.
if (!isa<Constant>(LHS))
if (Constant *SimpleLHS = SimplifiedValues.lookup(LHS))
LHS = SimpleLHS;
if (!isa<Constant>(RHS))
if (Constant *SimpleRHS = SimplifiedValues.lookup(RHS))
RHS = SimpleRHS;
if (Constant *CLHS = dyn_cast<Constant>(LHS))
if (Constant *CRHS = dyn_cast<Constant>(RHS))
if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
SimplifiedValues[&I] = C;
return true;
}
// Otherwise look for a comparison between constant offset pointers with
// a common base.
Value *LHSBase, *RHSBase;
APInt LHSOffset, RHSOffset;
llvm::tie(LHSBase, LHSOffset) = ConstantOffsetPtrs.lookup(LHS);
if (LHSBase) {
llvm::tie(RHSBase, RHSOffset) = ConstantOffsetPtrs.lookup(RHS);
if (RHSBase && LHSBase == RHSBase) {
// We have common bases, fold the icmp to a constant based on the
// offsets.
Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
if (Constant *C = ConstantExpr::getICmp(I.getPredicate(), CLHS, CRHS)) {
SimplifiedValues[&I] = C;
++NumConstantPtrCmps;
return true;
}
}
}
// If the comparison is an equality comparison with null, we can simplify it
// for any alloca-derived argument.
if (I.isEquality() && isa<ConstantPointerNull>(I.getOperand(1)))
if (isAllocaDerivedArg(I.getOperand(0))) {
// We can actually predict the result of comparisons between an
// alloca-derived value and null. Note that this fires regardless of
// SROA firing.
bool IsNotEqual = I.getPredicate() == CmpInst::ICMP_NE;
SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
: ConstantInt::getFalse(I.getType());
return true;
}
// Finally check for SROA candidates in comparisons.
Value *SROAArg;
DenseMap<Value *, int>::iterator CostIt;
if (lookupSROAArgAndCost(I.getOperand(0), SROAArg, CostIt)) {
if (isa<ConstantPointerNull>(I.getOperand(1))) {
accumulateSROACost(CostIt, InlineConstants::InstrCost);
return true;
}
disableSROA(CostIt);
}
return false;
}
bool TripCountProfiler::runOnFunction(Function &F) {
IRBuilder<> Builder(F.getEntryBlock().getTerminator());
if (!moduleIdentifierStr) {
moduleIdentifierStr = Builder.CreateGlobalStringPtr(F.getParent()->getModuleIdentifier(), "moduleIdentifierStr");
}
Value* main = F.getParent()->getFunction("main");
if(!main) main = F.getParent()->getFunction("MAIN__"); //Fortan hack
bool isMain = (&F == main);
if (isMain) {
Builder.CreateCall(initLoopList, "");
}
if (&F == F.getParent()->getFunction("P7Traces2Alignment")) {
errs() << F << "\n";
return false;
}
LoopInfoEx& li = getAnalysis<LoopInfoEx>();
TripCountAnalysis& tca = getAnalysis<TripCountAnalysis>();
/*
* Here we have all the instructions that will stop the program
*
* E.g.: abort, exit, return of function main
*
* Before those instructions, we will print all the data we have collected.
*/
ExitInfo& eI = getAnalysis<ExitInfo>();
for(std::set<Instruction*>::iterator Iit = eI.exitPoints.begin(), Iend = eI.exitPoints.end(); Iit != Iend; Iit++) {
Instruction* I = *Iit;
if(I->getParent()->getParent() == &F) {
Builder.SetInsertPoint(I);
std::vector<Value*> args;
args.push_back(moduleIdentifierStr);
llvm::ArrayRef<llvm::Value *> arrayArgs(args);
Builder.CreateCall(flushLoopStats, arrayArgs, "");
}
}
LoopNormalizerAnalysis& ln = getAnalysis<LoopNormalizerAnalysis>();
Constant* constZero = ConstantInt::get(Type::getInt64Ty(F.getContext()), 0);
Constant* unknownTripCount = ConstantInt::get(Type::getInt64Ty(F.getContext()), -2);
for(LoopInfoEx::iterator lit = li.begin(); lit != li.end(); lit++) {
bool mustInstrument = true;
Loop* loop = *lit;
BasicBlock* header = loop->getHeader();
BasicBlock* entryBlock = ln.entryBlocks[header];
/*
* Here we are looking for the predicate that stops the loop.
*
* At this moment, we are only considering loops that are controlled by
* integer comparisons.
*/
BasicBlock* exitBlock = findLoopControllerBlock(loop);
assert (exitBlock && "Exit block not found!");
TerminatorInst* T = exitBlock->getTerminator();
BranchInst* BI = dyn_cast<BranchInst>(T);
ICmpInst* CI = BI ? dyn_cast<ICmpInst>(BI->getCondition()) : NULL;
Value* Op1 = NULL;
Value* Op2 = NULL;
int LoopClass;
if (!CI) {
LoopClass = 2;
mustInstrument = false;
}
else {
if (isIntervalComparison(CI)) {
LoopClass = 0;
} else {
LoopClass = 1;
}
Op1 = getValueAtEntryPoint(CI->getOperand(0), header);
Op2 = getValueAtEntryPoint(CI->getOperand(1), header);
if((!Op1) || (!Op2) ) {
} else if((!Op1->getType()->isIntegerTy()) || (!Op2->getType()->isIntegerTy())) {
mustInstrument = false;
}
}
Value* estimatedTripCount = tca.getTripCount(header);
if((!estimatedTripCount) && mustInstrument) {
estimatedTripCount = unknownTripCount;
LoopClass += 3; // 3 = UnknownIntervalLoop; 4 = UnknownEqualityLoop
NumUnknownTripCount++;
}
if (estimatedTripCount) {
//Before the loop starts, the trip count is zero
AllocaInst* tripCount = insertAlloca(entryBlock, constZero);
//Every time the loop header is executed, we increment the trip count
insertAdd(header, tripCount);
/*
* We will collect the actual trip count and the estimate trip count in every
* basic block that is outside the loop
*/
std::set<BasicBlock*> blocksToInstrument;
SmallVector<BasicBlock*, 2> exitBlocks;
loop->getExitBlocks(exitBlocks);
for (SmallVectorImpl<BasicBlock*>::iterator eb = exitBlocks.begin(); eb != exitBlocks.end(); eb++) {
BasicBlock* CurrentEB = *eb;
/*
* Does not instrument landingPad (exception handling) blocks
* TODO: Handle LandingPad blocks (if possible)
*/
if(!CurrentEB->isLandingPad())
blocksToInstrument.insert(CurrentEB);
}
saveTripCount(blocksToInstrument, tripCount, estimatedTripCount, header, LoopClass);
NumInstrumentedLoops++;
} else {
NumIgnoredLoops++;
}
}
return true;
}
bool BranchProbabilityInfo::calcZeroHeuristics(const BasicBlock *BB,
const TargetLibraryInfo *TLI) {
const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
if (!CI)
return false;
Value *RHS = CI->getOperand(1);
ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
if (!CV)
return false;
// If the LHS is the result of AND'ing a value with a single bit bitmask,
// we don't have information about probabilities.
if (Instruction *LHS = dyn_cast<Instruction>(CI->getOperand(0)))
if (LHS->getOpcode() == Instruction::And)
if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(LHS->getOperand(1)))
if (AndRHS->getValue().isPowerOf2())
return false;
// Check if the LHS is the return value of a library function
LibFunc Func = NumLibFuncs;
if (TLI)
if (CallInst *Call = dyn_cast<CallInst>(CI->getOperand(0)))
if (Function *CalledFn = Call->getCalledFunction())
TLI->getLibFunc(*CalledFn, Func);
bool isProb;
if (Func == LibFunc_strcasecmp ||
Func == LibFunc_strcmp ||
Func == LibFunc_strncasecmp ||
Func == LibFunc_strncmp ||
Func == LibFunc_memcmp) {
// strcmp and similar functions return zero, negative, or positive, if the
// first string is equal, less, or greater than the second. We consider it
// likely that the strings are not equal, so a comparison with zero is
// probably false, but also a comparison with any other number is also
// probably false given that what exactly is returned for nonzero values is
// not specified. Any kind of comparison other than equality we know
// nothing about.
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
isProb = false;
break;
case CmpInst::ICMP_NE:
isProb = true;
break;
default:
return false;
}
} else if (CV->isZero()) {
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// X == 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_NE:
// X != 0 -> Likely
isProb = true;
break;
case CmpInst::ICMP_SLT:
// X < 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_SGT:
// X > 0 -> Likely
isProb = true;
break;
default:
return false;
}
} else if (CV->isOne() && CI->getPredicate() == CmpInst::ICMP_SLT) {
// InstCombine canonicalizes X <= 0 into X < 1.
// X <= 0 -> Unlikely
isProb = false;
} else if (CV->isMinusOne()) {
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// X == -1 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_NE:
// X != -1 -> Likely
isProb = true;
break;
case CmpInst::ICMP_SGT:
// InstCombine canonicalizes X >= 0 into X > -1.
// X >= 0 -> Likely
isProb = true;
break;
default:
return false;
}
} else {
return false;
}
unsigned TakenIdx = 0, NonTakenIdx = 1;
if (!isProb)
std::swap(TakenIdx, NonTakenIdx);
BranchProbability TakenProb(ZH_TAKEN_WEIGHT,
ZH_TAKEN_WEIGHT + ZH_NONTAKEN_WEIGHT);
setEdgeProbability(BB, TakenIdx, TakenProb);
setEdgeProbability(BB, NonTakenIdx, TakenProb.getCompl());
return true;
}
bool BranchProbabilityInfo::calcZeroHeuristics(BasicBlock *BB) {
BranchInst * BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
return false;
Value *Cond = BI->getCondition();
ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
if (!CI)
return false;
Value *RHS = CI->getOperand(1);
ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
if (!CV)
return false;
// If the LHS is the result of AND'ing a value with a single bit bitmask,
// we don't have information about probabilities.
if (Instruction *LHS = dyn_cast<Instruction>(CI->getOperand(0)))
if (LHS->getOpcode() == Instruction::And)
if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(LHS->getOperand(1)))
if (AndRHS->getUniqueInteger().isPowerOf2())
return false;
bool isProb;
if (CV->isZero()) {
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// X == 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_NE:
// X != 0 -> Likely
isProb = true;
break;
case CmpInst::ICMP_SLT:
// X < 0 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_SGT:
// X > 0 -> Likely
isProb = true;
break;
default:
return false;
}
} else if (CV->isOne() && CI->getPredicate() == CmpInst::ICMP_SLT) {
// InstCombine canonicalizes X <= 0 into X < 1.
// X <= 0 -> Unlikely
isProb = false;
} else if (CV->isAllOnesValue()) {
switch (CI->getPredicate()) {
case CmpInst::ICMP_EQ:
// X == -1 -> Unlikely
isProb = false;
break;
case CmpInst::ICMP_NE:
// X != -1 -> Likely
isProb = true;
break;
case CmpInst::ICMP_SGT:
// InstCombine canonicalizes X >= 0 into X > -1.
// X >= 0 -> Likely
isProb = true;
break;
default:
return false;
}
} else {
return false;
}
unsigned TakenIdx = 0, NonTakenIdx = 1;
if (!isProb)
std::swap(TakenIdx, NonTakenIdx);
BranchProbability TakenProb(ZH_TAKEN_WEIGHT,
ZH_TAKEN_WEIGHT + ZH_NONTAKEN_WEIGHT);
setEdgeProbability(BB, TakenIdx, TakenProb);
setEdgeProbability(BB, NonTakenIdx, TakenProb.getCompl());
return true;
}
bool AtomicExpandLoadLinked::expandAtomicCmpXchg(AtomicCmpXchgInst *CI) {
AtomicOrdering SuccessOrder = CI->getSuccessOrdering();
AtomicOrdering FailureOrder = CI->getFailureOrdering();
Value *Addr = CI->getPointerOperand();
BasicBlock *BB = CI->getParent();
Function *F = BB->getParent();
LLVMContext &Ctx = F->getContext();
// Given: cmpxchg some_op iN* %addr, iN %desired, iN %new success_ord fail_ord
//
// The full expansion we produce is:
// [...]
// fence?
// cmpxchg.start:
// %loaded = @load.linked(%addr)
// %should_store = icmp eq %loaded, %desired
// br i1 %should_store, label %cmpxchg.trystore,
// label %cmpxchg.end/%cmpxchg.barrier
// cmpxchg.trystore:
// %stored = @store_conditional(%new, %addr)
// %try_again = icmp i32 ne %stored, 0
// br i1 %try_again, label %loop, label %cmpxchg.end
// cmpxchg.barrier:
// fence?
// br label %cmpxchg.end
// cmpxchg.end:
// [...]
BasicBlock *ExitBB = BB->splitBasicBlock(CI, "cmpxchg.end");
auto BarrierBB = BasicBlock::Create(Ctx, "cmpxchg.barrier", F, ExitBB);
auto TryStoreBB = BasicBlock::Create(Ctx, "cmpxchg.trystore", F, BarrierBB);
auto LoopBB = BasicBlock::Create(Ctx, "cmpxchg.start", F, TryStoreBB);
// This grabs the DebugLoc from CI
IRBuilder<> Builder(CI);
// The split call above "helpfully" added a branch at the end of BB (to the
// wrong place), but we might want a fence too. It's easiest to just remove
// the branch entirely.
std::prev(BB->end())->eraseFromParent();
Builder.SetInsertPoint(BB);
AtomicOrdering MemOpOrder = insertLeadingFence(Builder, SuccessOrder);
Builder.CreateBr(LoopBB);
// Start the main loop block now that we've taken care of the preliminaries.
Builder.SetInsertPoint(LoopBB);
Value *Loaded = TLI->emitLoadLinked(Builder, Addr, MemOpOrder);
Value *ShouldStore =
Builder.CreateICmpEQ(Loaded, CI->getCompareOperand(), "should_store");
// If the the cmpxchg doesn't actually need any ordering when it fails, we can
// jump straight past that fence instruction (if it exists).
BasicBlock *FailureBB = FailureOrder == Monotonic ? ExitBB : BarrierBB;
Builder.CreateCondBr(ShouldStore, TryStoreBB, FailureBB);
Builder.SetInsertPoint(TryStoreBB);
Value *StoreSuccess = TLI->emitStoreConditional(
Builder, CI->getNewValOperand(), Addr, MemOpOrder);
Value *TryAgain = Builder.CreateICmpNE(
StoreSuccess, ConstantInt::get(Type::getInt32Ty(Ctx), 0), "success");
Builder.CreateCondBr(TryAgain, LoopBB, BarrierBB);
// Make sure later instructions don't get reordered with a fence if necessary.
Builder.SetInsertPoint(BarrierBB);
insertTrailingFence(Builder, SuccessOrder);
Builder.CreateBr(ExitBB);
// Finally, we have control-flow based knowledge of whether the cmpxchg
// succeeded or not. We expose this to later passes by converting any
// subsequent "icmp eq/ne %loaded, %oldval" into a use of an appropriate PHI.
// Setup the builder so we can create any PHIs we need.
Builder.SetInsertPoint(FailureBB, FailureBB->begin());
BasicBlock *SuccessBB = FailureOrder == Monotonic ? BarrierBB : TryStoreBB;
PHINode *Success = 0, *Failure = 0;
// Look for any users of the cmpxchg that are just comparing the loaded value
// against the desired one, and replace them with the CFG-derived version.
for (auto User : CI->users()) {
ICmpInst *ICmp = dyn_cast<ICmpInst>(User);
if (!ICmp)
continue;
// Because we know ICmp uses CI, we only need one operand to be the old
// value.
if (ICmp->getOperand(0) != CI->getCompareOperand() &&
ICmp->getOperand(1) != CI->getCompareOperand())
continue;
if (ICmp->getPredicate() == CmpInst::ICMP_EQ) {
if (!Success) {
Success = Builder.CreatePHI(Type::getInt1Ty(Ctx), 2);
Success->addIncoming(ConstantInt::getTrue(Ctx), SuccessBB);
Success->addIncoming(ConstantInt::getFalse(Ctx), LoopBB);
}
ICmp->replaceAllUsesWith(Success);
} else if (ICmp->getPredicate() == CmpInst::ICMP_NE) {
if (!Failure) {
Failure = Builder.CreatePHI(Type::getInt1Ty(Ctx), 2);
Failure->addIncoming(ConstantInt::getFalse(Ctx), SuccessBB);
Failure->addIncoming(ConstantInt::getTrue(Ctx), LoopBB);
}
ICmp->replaceAllUsesWith(Failure);
}
}
CI->replaceAllUsesWith(Loaded);
CI->eraseFromParent();
return true;
}
bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
IU = &getAnalysis<IVUsers>();
LI = &getAnalysis<LoopInfo>();
SE = &getAnalysis<ScalarEvolution>();
DT = &getAnalysis<DominatorTree>();
Changed = false;
// If there are any floating-point recurrences, attempt to
// transform them to use integer recurrences.
RewriteNonIntegerIVs(L);
BasicBlock *ExitingBlock = L->getExitingBlock(); // may be null
const SCEV *BackedgeTakenCount = SE->getBackedgeTakenCount(L);
// Create a rewriter object which we'll use to transform the code with.
SCEVExpander Rewriter(*SE);
// Check to see if this loop has a computable loop-invariant execution count.
// If so, this means that we can compute the final value of any expressions
// that are recurrent in the loop, and substitute the exit values from the
// loop into any instructions outside of the loop that use the final values of
// the current expressions.
//
if (!isa<SCEVCouldNotCompute>(BackedgeTakenCount))
RewriteLoopExitValues(L, Rewriter);
// Compute the type of the largest recurrence expression, and decide whether
// a canonical induction variable should be inserted.
const Type *LargestType = 0;
bool NeedCannIV = false;
if (!isa<SCEVCouldNotCompute>(BackedgeTakenCount)) {
LargestType = BackedgeTakenCount->getType();
LargestType = SE->getEffectiveSCEVType(LargestType);
// If we have a known trip count and a single exit block, we'll be
// rewriting the loop exit test condition below, which requires a
// canonical induction variable.
if (ExitingBlock)
NeedCannIV = true;
}
for (IVUsers::const_iterator I = IU->begin(), E = IU->end(); I != E; ++I) {
const Type *Ty =
SE->getEffectiveSCEVType(I->getOperandValToReplace()->getType());
if (!LargestType ||
SE->getTypeSizeInBits(Ty) >
SE->getTypeSizeInBits(LargestType))
LargestType = Ty;
NeedCannIV = true;
}
// Now that we know the largest of the induction variable expressions
// in this loop, insert a canonical induction variable of the largest size.
Value *IndVar = 0;
if (NeedCannIV) {
// Check to see if the loop already has any canonical-looking induction
// variables. If any are present and wider than the planned canonical
// induction variable, temporarily remove them, so that the Rewriter
// doesn't attempt to reuse them.
SmallVector<PHINode *, 2> OldCannIVs;
while (PHINode *OldCannIV = L->getCanonicalInductionVariable()) {
if (SE->getTypeSizeInBits(OldCannIV->getType()) >
SE->getTypeSizeInBits(LargestType))
OldCannIV->removeFromParent();
else
break;
OldCannIVs.push_back(OldCannIV);
}
IndVar = Rewriter.getOrInsertCanonicalInductionVariable(L, LargestType);
++NumInserted;
Changed = true;
DEBUG(dbgs() << "INDVARS: New CanIV: " << *IndVar << '\n');
// Now that the official induction variable is established, reinsert
// any old canonical-looking variables after it so that the IR remains
// consistent. They will be deleted as part of the dead-PHI deletion at
// the end of the pass.
while (!OldCannIVs.empty()) {
PHINode *OldCannIV = OldCannIVs.pop_back_val();
OldCannIV->insertBefore(L->getHeader()->getFirstNonPHI());
}
}
// If we have a trip count expression, rewrite the loop's exit condition
// using it. We can currently only handle loops with a single exit.
ICmpInst *NewICmp = 0;
if (!isa<SCEVCouldNotCompute>(BackedgeTakenCount) &&
!BackedgeTakenCount->isZero() &&
ExitingBlock) {
assert(NeedCannIV &&
"LinearFunctionTestReplace requires a canonical induction variable");
// Can't rewrite non-branch yet.
if (BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator()))
NewICmp = LinearFunctionTestReplace(L, BackedgeTakenCount, IndVar,
ExitingBlock, BI, Rewriter);
}
// Rewrite IV-derived expressions. Clears the rewriter cache.
RewriteIVExpressions(L, Rewriter);
// The Rewriter may not be used from this point on.
// Loop-invariant instructions in the preheader that aren't used in the
// loop may be sunk below the loop to reduce register pressure.
SinkUnusedInvariants(L);
// For completeness, inform IVUsers of the IV use in the newly-created
// loop exit test instruction.
if (NewICmp)
IU->AddUsersIfInteresting(cast<Instruction>(NewICmp->getOperand(0)));
// Clean up dead instructions.
Changed |= DeleteDeadPHIs(L->getHeader());
// Check a post-condition.
assert(L->isLCSSAForm(*DT) && "Indvars did not leave the loop in lcssa form!");
return Changed;
}
string esp::parseName(Value *value){
// has existed
if(names.find(value) != names.end())
return names[value];
string name = "";
Value *current = value;
/*
bool continueFlag = true;
do{
if(isa<Instruction > (current)){
Instruction* inst = dyn_cast<Instruction>(current);
unsigned op = inst->getOpcode();
switch(op){
case Instruction::Ret :{
break;
}
case Instruction::Br :{
break;
}
case Instruction::Switch :{
break;
}
case Instruction::Call :{
CallInst *callinst = (CallInst*) current;
if (((CallInst*) current)->getCalledFunction() != NULL) {
name += string("@")+((CallInst*) current)->getCalledFunction()->getNameStr() + "(";
} else {
name += string("@[funcPTR](");
name += ((CallInst*) current)->getCalledValue()->getNameStr();
}
for (unsigned i = 1; i < callinst->getNumOperands(); i++) {
name += esp::parseName(callinst->getOperand(i));
}
name += string(")");
continueFlag = false;
break;
}
case Instruction::PHI :{
name += string("PHI[");
name += current->getNameStr();
PHINode *phi = (PHINode*) current;
for (unsigned i = 0; i < phi->getNumIncomingValues(); i++) {
Value *incoming = phi->getIncomingValue(i);
if (i != 0) name += ",";
if (!hasLoop(incoming)) {
if (!incoming->hasName()) {
name += esp::parseName(incoming);
} else {
name += incoming->getNameStr();
}
}
}
name += std::string("]");
continueFlag = false;
break;
}
case Instruction::Select :{
break;
}
case Instruction::Add :{
name += "+";
name += parseBinaryOpName(inst);
break;
}
case Instruction::Sub :{
name += "-";
name += parseBinaryOpName(inst);
break;
}
case Instruction::Mul :{
name += "*";
name += parseBinaryOpName(inst);
break;
}
case Instruction::UDiv :{
name += "/";
name += parseBinaryOpName(inst);
break;
}
case Instruction::SDiv :{
name += "//";
name += parseBinaryOpName(inst);
break;
}
case Instruction::And :{
name += "&";
name += parseBinaryOpName(inst);
break;
}
case Instruction::Or :{
name += "|";
name += parseBinaryOpName(inst);
break;
}
case Instruction::Xor :{
name += "^";
name += parseBinaryOpName(inst);
break;
}
case Instruction::Shl :{
name += "<<";
name += parseBinaryOpName(inst);
break;
}
case Instruction::LShr :{
name += ">>";
name += parseBinaryOpName(inst);
break;
}
case Instruction::AShr :{
name += ">>>";
name += parseBinaryOpName(inst);
break;
}
case Instruction::ICmp :{
ICmpInst * icmp = dyn_cast<ICmpInst>(current);
if (isa<Constant>(icmp->getOperand(0))) {
name += esp::parseName(icmp->getOperand(1));
continueFlag = false;
} else {
name += esp::parseName(icmp->getOperand(0));
continueFlag = false;
}
break;
}
case Instruction::Alloca :{
name += current->getNameStr();
break;
}
case Instruction::Load :{
if (((LoadInst*) inst)->isVolatile())
name += std::string("@VolatileLoad");
name += "*";
name += esp::parseName(inst->getOperand(0));
continueFlag = false;
break;
}
case Instruction::Store :{
// need to handle
continueFlag = false;
break;
}
case Instruction::GetElementPtr :{
GetElementPtrInst * gep = dyn_cast<GetElementPtrInst>(current);
unsigned ops = gep->getNumOperands();
name += "[";
for (unsigned i = 1; i < ops; i++) {
Value *v = gep->getOperand(i);
if (ConstantInt * ci = dyn_cast<ConstantInt>(v)) {
if (i == 1 && ci->equalsInt(0))
continue;
name += ".";
name += ci->getValue().toString(10, false);
} else {
name += ".";
name += esp::parseName(v);
}
}
name += "]";
name += esp::parseName(gep->getOperand(0));
continueFlag = false;
break;
}
case Instruction::BitCast:{
name += esp::parseName(inst->getOperand(0));
continueFlag = false;
break;
}
default :{
// Illegal or unsupported instruction
name += current->getNameStr();
break;
}
}
}else if(isa<Argument>(current)){
if (arguments.find(current) != arguments.end())
name += std::string("$") + current->getNameStr();
}else if(isa<GlobalValue>(current)){
name += std::string("@") + current->getNameStr();
}else if(isa<ConstantInt>(current)){
ConstantInt * cint = dyn_cast<ConstantInt > (current);
name += cint->getValue().toString(10, true);
}else if (isa<Constant > (current)) {
Constant *c = dyn_cast<Constant > (current);
if (c->isNullValue()) {
name += "null";
}
}else{
// Illegal format
}
if(!continueFlag)
break;
current = parents[current];
}while(current);
*/
//Refactor
do {
if (isa<LoadInst > (current)) {
name += "*";
if (parents[current] == NULL)
name += (((LoadInst*) current)->getOperand(0))->getNameStr();
if (((LoadInst*) current)->isVolatile())
name += std::string("@VolatileLoad");
} else if (dyn_cast<GetElementPtrInst > (current)) {
GetElementPtrInst * gep = dyn_cast<GetElementPtrInst > (current);
unsigned ops = gep->getNumOperands();
name += "[";
for (unsigned i = 1; i < ops; i++) {
Value *v = gep->getOperand(i);
if (dyn_cast<ConstantInt > (current)) {
ConstantInt * ci = dyn_cast<ConstantInt > (current);
if (i == 1 && ci->equalsInt(0)) continue;
name += ".";
name += ci->getValue().toString(10, false);
} else {
name += ".";
name += parseName(v);
}
}
name += "]";
name += parseName(gep->getOperand(0));
break;
} else if (isa<AllocaInst > (current)) {
name += current->getNameStr();
} else if (isa<Argument > (current)) {
if (arguments.find(current) != arguments.end())
name += std::string("$") + current->getNameStr();
} else if (isa<GlobalValue > (current)) {
name += std::string("@") + current->getNameStr();
} else if (isa<CallInst > (current)) {
CallInst *callinst = (CallInst*) current;
if (((CallInst*) current)->getCalledFunction() != NULL) {
name += std::string("@")+((CallInst*) current)->getCalledFunction()->getNameStr() + "(";
} else {
name += std::string("@[funcPTR](");
name += ((CallInst*) current)->getCalledValue()->getNameStr();
}
for (unsigned i = 1; i < callinst->getNumOperands(); i++) {
name += parseName(callinst->getOperand(i));
}
name += std::string(")");
break;
} else if (isa<CastInst > (current)) {
} else if (isa<PHINode > (current)) {
/*
name += std::string("PHI[");
s += parent->getNameStr();
PHINode *phi = (PHINode*) parent;
for (unsigned i = 0; i < phi->getNumIncomingValues(); i++) {
//s+=phi->getIncomingBlock(i)->getNameStr();
Value *incoming = phi->getIncomingValue(i);
if (i != 0) s += ",";
if (!hasLoop(incoming)) {
DEBUG(errs() << "incoming#" << i << " no loop(i rather doubt it)\n");
if (!incoming->hasName()) {
s += parseName(incoming);
} else {
s += incoming->getNameStr();
}
}
}
// PHI nodes...ugh
s += std::string("]");
break;
*/
} else if (isa<BinaryOperator > (current)) {
BinaryOperator *bo = dyn_cast<BinaryOperator > (current);
Instruction::BinaryOps opcode = bo->getOpcode();
if (opcode == Instruction::Add) {
name.append("+");
} else if (opcode == Instruction::Sub) {
name.append("-");
} else if (opcode == Instruction::Or) {
name.append("||");
} else if (opcode == Instruction::Mul) {
name.append("*");
} else if (opcode == Instruction::Xor) {
name.append("^");
} else if (opcode == Instruction::And) {
name.append("&&");
} else if (opcode == Instruction::Shl) {
name.append("<<");
} else if (opcode == Instruction::AShr) {
name.append(">>");
} else if (opcode == Instruction::LShr) {
name.append(">>>");
}
Value *v0 = bo->getOperand(0);
Value *v1 = bo->getOperand(1);
if (isa<ConstantInt > (v0)) {
name += ((ConstantInt*) v0)->getValue().toString(10, false);
} else if (isa<ConstantInt > (v1)) {
name += ((ConstantInt*) v1)->getValue().toString(10, false);
} else {
printDebugMsg("Binary Operation between non-constants\n");
}
} else if (dyn_cast<GEPOperator > (current)) {
GEPOperator * gep = dyn_cast<GEPOperator > (current);
unsigned ops = gep->getNumOperands();
name += "[";
for (unsigned i = 1; i < ops; i++) {
Value *v = gep->getOperand(i);
if (dyn_cast<ConstantInt > (v)) {
ConstantInt * ci = dyn_cast<ConstantInt > (v);
if (i == 1 && ci->equalsInt(0)) continue;
name += ".";
name += ci->getValue().toString(10, false);
}
}
name += "]";
name += parseName(gep->getOperand(0));
break;
} else if (dyn_cast<ICmpInst > (current)) {
ICmpInst * icmp = dyn_cast<ICmpInst > (current);
if (isa<Constant > (icmp->getOperand(0))) {
name += parseName(icmp->getOperand(1));
break;
} else {
name += parseName(icmp->getOperand(0));
break;
}
} else if (dyn_cast<ConstantInt > (current)) {
ConstantInt * cint = dyn_cast<ConstantInt > (current);
name += cint->getValue().toString(10, true);
} else {
name += current->getNameStr(); // might not work
}
} while ((current = parents[current]));
names[value] = name;
return name;
}
bool GambasPass::runOnFunction(Function &F){
IRBuilder<> Builder(F.getContext());
bool changed = false;
for(Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
for(BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ){
ICmpInst* ICI = dyn_cast<ICmpInst>(I);
CallInst* CI = dyn_cast<CallInst>(I++);
if (ICI && ICI->hasMetadata() && ICI->getMetadata("unref_slt") && dyn_cast<LoadInst>(ICI->getOperand(0))){
ICI->replaceAllUsesWith(ConstantInt::get(ICI->getType(), false));
ICI->eraseFromParent();
changed = true;
continue;
}
if (!CI)
continue;
Function* callee = CI->getCalledFunction();
if (callee == NULL || !callee->isDeclaration())
continue;
StringRef name = callee->getName();
if (name == "JR_release_variant" || name == "JR_borrow_variant"){
ConstantInt* vtype_int = dyn_cast<ConstantInt>(CI->getArgOperand(0));
if (!vtype_int)
continue;
uint64_t vtype = vtype_int->getZExtValue();
if (TYPE_is_string(vtype) || TYPE_is_object(vtype))
continue;
CI->eraseFromParent();
changed = true;
} else if (name == FUNCTION_NAME(__finite)){
ConstantFP* op = dyn_cast<ConstantFP>(CI->getArgOperand(0));
if (!op)
continue;
int val = __finite(op->getValueAPF().convertToDouble());
Constant* res = ConstantInt::get(CI->getType(), val);
CI->replaceAllUsesWith(res);
CI->eraseFromParent();
changed = true;
} else if (name == FUNCTION_NAME(__isnan)){
ConstantFP* op = dyn_cast<ConstantFP>(CI->getArgOperand(0));
if (!op)
continue;
int val = __isnan(op->getValueAPF().convertToDouble());
Constant* res = ConstantInt::get(CI->getType(), val);
CI->replaceAllUsesWith(res);
CI->eraseFromParent();
changed = true;
} else if (name == FUNCTION_NAME(__isinf)){
ConstantFP* op = dyn_cast<ConstantFP>(CI->getArgOperand(0));
if (!op)
continue;
int val = __isinf(op->getValueAPF().convertToDouble());
Constant* res = ConstantInt::get(CI->getType(), val);
CI->replaceAllUsesWith(res);
CI->eraseFromParent();
changed = true;
}
}
}
return changed;
}
/// MatchSelectPattern - Pattern match integer [SU]MIN, [SU]MAX, and ABS idioms,
/// returning the kind and providing the out parameter results if we
/// successfully match.
static SelectPatternFlavor
MatchSelectPattern(Value *V, Value *&LHS, Value *&RHS) {
SelectInst *SI = dyn_cast<SelectInst>(V);
if (!SI) return SPF_UNKNOWN;
ICmpInst *ICI = dyn_cast<ICmpInst>(SI->getCondition());
if (!ICI) return SPF_UNKNOWN;
ICmpInst::Predicate Pred = ICI->getPredicate();
Value *CmpLHS = ICI->getOperand(0);
Value *CmpRHS = ICI->getOperand(1);
Value *TrueVal = SI->getTrueValue();
Value *FalseVal = SI->getFalseValue();
LHS = CmpLHS;
RHS = CmpRHS;
// (icmp X, Y) ? X : Y
if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
switch (Pred) {
default: return SPF_UNKNOWN; // Equality.
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE: return SPF_UMAX;
case ICmpInst::ICMP_SGT:
case ICmpInst::ICMP_SGE: return SPF_SMAX;
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE: return SPF_UMIN;
case ICmpInst::ICMP_SLT:
case ICmpInst::ICMP_SLE: return SPF_SMIN;
}
}
// (icmp X, Y) ? Y : X
if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
switch (Pred) {
default: return SPF_UNKNOWN; // Equality.
case ICmpInst::ICMP_UGT:
case ICmpInst::ICMP_UGE: return SPF_UMIN;
case ICmpInst::ICMP_SGT:
case ICmpInst::ICMP_SGE: return SPF_SMIN;
case ICmpInst::ICMP_ULT:
case ICmpInst::ICMP_ULE: return SPF_UMAX;
case ICmpInst::ICMP_SLT:
case ICmpInst::ICMP_SLE: return SPF_SMAX;
}
}
if (ConstantInt *C1 = dyn_cast<ConstantInt>(CmpRHS)) {
if ((CmpLHS == TrueVal && match(FalseVal, m_Neg(m_Specific(CmpLHS)))) ||
(CmpLHS == FalseVal && match(TrueVal, m_Neg(m_Specific(CmpLHS))))) {
// ABS(X) ==> (X >s 0) ? X : -X and (X >s -1) ? X : -X
// NABS(X) ==> (X >s 0) ? -X : X and (X >s -1) ? -X : X
if (Pred == ICmpInst::ICMP_SGT && (C1->isZero() || C1->isMinusOne())) {
return (CmpLHS == TrueVal) ? SPF_ABS : SPF_NABS;
}
// ABS(X) ==> (X <s 0) ? -X : X and (X <s 1) ? -X : X
// NABS(X) ==> (X <s 0) ? X : -X and (X <s 1) ? X : -X
if (Pred == ICmpInst::ICMP_SLT && (C1->isZero() || C1->isOne())) {
return (CmpLHS == FalseVal) ? SPF_ABS : SPF_NABS;
}
}
}
// TODO: (X > 4) ? X : 5 --> (X >= 5) ? X : 5 --> MAX(X, 5)
return SPF_UNKNOWN;
}
Value* LoopTripCount::insertTripCount(Loop* L, Instruction* InsertPos)
{
// inspired from Loop::getCanonicalInductionVariable
BasicBlock *H = L->getHeader();
BasicBlock* LoopPred = L->getLoopPredecessor();
BasicBlock* startBB = NULL;//which basicblock stores start value
int OneStep = 0;// the extra add or plus step for calc
Assert(LoopPred, "Require Loop has a Pred");
DEBUG(errs()<<"loop depth:"<<L->getLoopDepth()<<"\n");
/** whats difference on use of predecessor and preheader??*/
//RET_ON_FAIL(self->getLoopLatch()&&self->getLoopPreheader());
//assert(self->getLoopLatch() && self->getLoopPreheader() && "need loop simplify form" );
ret_null_fail(L->getLoopLatch(), "need loop simplify form");
BasicBlock* TE = NULL;//True Exit
SmallVector<BasicBlock*,4> Exits;
L->getExitingBlocks(Exits);
if(Exits.size()==1) TE = Exits.front();
else{
if(std::find(Exits.begin(),Exits.end(),L->getLoopLatch())!=Exits.end()) TE = L->getLoopLatch();
else{
SmallVector<llvm::Loop::Edge,4> ExitEdges;
L->getExitEdges(ExitEdges);
//stl 用法,先把所有满足条件的元素(出口的结束符是不可到达)移动到数组的末尾,再统一删除
ExitEdges.erase(std::remove_if(ExitEdges.begin(), ExitEdges.end(),
[](llvm::Loop::Edge& I){
return isa<UnreachableInst>(I.second->getTerminator());
}), ExitEdges.end());
if(ExitEdges.size()==1) TE = const_cast<BasicBlock*>(ExitEdges.front().first);
}
}
//process true exit
ret_null_fail(TE, "need have a true exit");
Instruction* IndOrNext = NULL;
Value* END = NULL;
//终止块的终止指令：分情况讨论branchinst,switchinst;
//跳转指令br bool a1,a2;condition<-->bool
if(isa<BranchInst>(TE->getTerminator())){
const BranchInst* EBR = cast<BranchInst>(TE->getTerminator());
Assert(EBR->isConditional(), "end branch is not conditional");
ICmpInst* EC = dyn_cast<ICmpInst>(EBR->getCondition());
if(EC->getPredicate() == EC->ICMP_SGT){
Assert(!L->contains(EBR->getSuccessor(0)), *EBR<<":abnormal exit with great than");//终止块的终止指令---->跳出执行循环外的指令
OneStep += 1;
} else if(EC->getPredicate() == EC->ICMP_EQ)
Assert(!L->contains(EBR->getSuccessor(0)), *EBR<<":abnormal exit with great than");
else if(EC->getPredicate() == EC->ICMP_SLT) {
ret_null_fail(!L->contains(EBR->getSuccessor(1)), *EBR<<":abnormal exit with less than");
} else {
ret_null_fail(0, *EC<<" unknow combination of end condition");
}
IndOrNext = dyn_cast<Instruction>(castoff(EC->getOperand(0)));//去掉类型转化
END = EC->getOperand(1);
DEBUG(errs()<<"end value:"<<*EC<<"\n");
}else if(isa<SwitchInst>(TE->getTerminator())){
SwitchInst* ESW = const_cast<SwitchInst*>(cast<SwitchInst>(TE->getTerminator()));
IndOrNext = dyn_cast<Instruction>(castoff(ESW->getCondition()));
for(auto I = ESW->case_begin(),E = ESW->case_end();I!=E;++I){
if(!L->contains(I.getCaseSuccessor())){
ret_null_fail(!END,"");
assert(!END && "shouldn't have two ends");
END = I.getCaseValue();
}
}
DEBUG(errs()<<"end value:"<<*ESW<<"\n");
}else{
assert(0 && "unknow terminator type");
}
ret_null_fail(L->isLoopInvariant(END), "end value should be loop invariant");//至此得END值
Value* start = NULL;
Value* ind = NULL;
Instruction* next = NULL;
bool addfirst = false;//add before icmp ed
DISABLE(errs()<<*IndOrNext<<"\n");
if(isa<LoadInst>(IndOrNext)){
//memory depend analysis
Value* PSi = IndOrNext->getOperand(0);//point type Step.i
int SICount[2] = {0};//store in predecessor count,store in loop body count
for( auto I = PSi->use_begin(),E = PSi->use_end();I!=E;++I){
DISABLE(errs()<<**I<<"\n");
StoreInst* SI = dyn_cast<StoreInst>(*I);
if(!SI || SI->getOperand(1) != PSi) continue;
if(!start&&L->isLoopInvariant(SI->getOperand(0))) {
if(SI->getParent() != LoopPred)
if(std::find(pred_begin(LoopPred),pred_end(LoopPred),SI->getParent()) == pred_end(LoopPred)) continue;
start = SI->getOperand(0);
startBB = SI->getParent();
++SICount[0];
}
Instruction* SI0 = dyn_cast<Instruction>(SI->getOperand(0));
if(L->contains(SI) && SI0 && SI0->getOpcode() == Instruction::Add){
next = SI0;
++SICount[1];
}
}
Assert(SICount[0]==1 && SICount[1]==1, "");
ind = IndOrNext;
}else{
if(isa<PHINode>(IndOrNext)){
PHINode* PHI = cast<PHINode>(IndOrNext);
ind = IndOrNext;
if(castoff(PHI->getIncomingValue(0)) == castoff(PHI->getIncomingValue(1)) && PHI->getParent() != H)
ind = castoff(PHI->getIncomingValue(0));
addfirst = false;
}else if(IndOrNext->getOpcode() == Instruction::Add){
next = IndOrNext;
addfirst = true;
}else{
Assert(0 ,"unknow how to analysis");
}
for(auto I = H->begin();isa<PHINode>(I);++I){
PHINode* P = cast<PHINode>(I);
if(ind && P == ind){
//start = P->getIncomingValueForBlock(L->getLoopPredecessor());
start = tryFindStart(P, L, startBB);
next = dyn_cast<Instruction>(P->getIncomingValueForBlock(L->getLoopLatch()));
}else if(next && P->getIncomingValueForBlock(L->getLoopLatch()) == next){
//start = P->getIncomingValueForBlock(L->getLoopPredecessor());
start = tryFindStart(P, L, startBB);
ind = P;
}
}
}
Assert(start ,"couldn't find a start value");
//process complex loops later
//DEBUG(if(L->getLoopDepth()>1 || !L->getSubLoops().empty()) return NULL);
DEBUG(errs()<<"start value:"<<*start<<"\n");
DEBUG(errs()<<"ind value:"<<*ind<<"\n");
DEBUG(errs()<<"next value:"<<*next<<"\n");
//process non add later
unsigned next_phi_idx = 0;
ConstantInt* Step = NULL,*PrevStep = NULL;/*only used if next is phi node*/
ret_null_fail(next, "");
PHINode* next_phi = dyn_cast<PHINode>(next);
do{
if(next_phi) {
next = dyn_cast<Instruction>(next_phi->getIncomingValue(next_phi_idx));
ret_null_fail(next, "");
DEBUG(errs()<<"next phi "<<next_phi_idx<<":"<<*next<<"\n");
if(Step&&PrevStep){
Assert(Step->getSExtValue() == PrevStep->getSExtValue(),"");
}
PrevStep = Step;
}
Assert(next->getOpcode() == Instruction::Add , "why induction increment is not Add");
Assert(next->getOperand(0) == ind ,"why induction increment is not add it self");
Step = dyn_cast<ConstantInt>(next->getOperand(1));
Assert(Step,"");
}while(next_phi && ++next_phi_idx<next_phi->getNumIncomingValues());
//RET_ON_FAIL(Step->equalsInt(1));
//assert(VERBOSE(Step->equalsInt(1),Step) && "why induction increment number is not 1");
Value* RES = NULL;
//if there are no predecessor, we can insert code into start value basicblock
IRBuilder<> Builder(InsertPos);
Assert(start->getType()->isIntegerTy() && END->getType()->isIntegerTy() , " why increment is not integer type");
if(start->getType() != END->getType()){
start = Builder.CreateCast(CastInst::getCastOpcode(start, false,
END->getType(), false),start,END->getType());
}
if(Step->getType() != END->getType()){
//Because Step is a Constant, so it casted is constant
Step = dyn_cast<ConstantInt>(Builder.CreateCast(CastInst::getCastOpcode(Step, false,
END->getType(), false),Step,END->getType()));
AssertRuntime(Step);
}
if(Step->isMinusOne())
RES = Builder.CreateSub(start,END);
else//Step Couldn't be zero
RES = Builder.CreateSub(END, start);
if(addfirst) OneStep -= 1;
if(Step->isMinusOne()) OneStep*=-1;
assert(OneStep<=1 && OneStep>=-1);
RES = (OneStep==1)?Builder.CreateAdd(RES,Step):(OneStep==-1)?Builder.CreateSub(RES, Step):RES;
if(!Step->isMinusOne()&&!Step->isOne())
RES = Builder.CreateSDiv(RES, Step);
RES->setName(H->getName()+".tc");
return RES;
}
bool AlignmentFromAssumptions::extractAlignmentInfo(CallInst *I,
Value *&AAPtr, const SCEV *&AlignSCEV,
const SCEV *&OffSCEV) {
// An alignment assume must be a statement about the least-significant
// bits of the pointer being zero, possibly with some offset.
ICmpInst *ICI = dyn_cast<ICmpInst>(I->getArgOperand(0));
if (!ICI)
return false;
// This must be an expression of the form: x & m == 0.
if (ICI->getPredicate() != ICmpInst::ICMP_EQ)
return false;
// Swap things around so that the RHS is 0.
Value *CmpLHS = ICI->getOperand(0);
Value *CmpRHS = ICI->getOperand(1);
const SCEV *CmpLHSSCEV = SE->getSCEV(CmpLHS);
const SCEV *CmpRHSSCEV = SE->getSCEV(CmpRHS);
if (CmpLHSSCEV->isZero())
std::swap(CmpLHS, CmpRHS);
else if (!CmpRHSSCEV->isZero())
return false;
BinaryOperator *CmpBO = dyn_cast<BinaryOperator>(CmpLHS);
if (!CmpBO || CmpBO->getOpcode() != Instruction::And)
return false;
// Swap things around so that the right operand of the and is a constant
// (the mask); we cannot deal with variable masks.
Value *AndLHS = CmpBO->getOperand(0);
Value *AndRHS = CmpBO->getOperand(1);
const SCEV *AndLHSSCEV = SE->getSCEV(AndLHS);
const SCEV *AndRHSSCEV = SE->getSCEV(AndRHS);
if (isa<SCEVConstant>(AndLHSSCEV)) {
std::swap(AndLHS, AndRHS);
std::swap(AndLHSSCEV, AndRHSSCEV);
}
const SCEVConstant *MaskSCEV = dyn_cast<SCEVConstant>(AndRHSSCEV);
if (!MaskSCEV)
return false;
// The mask must have some trailing ones (otherwise the condition is
// trivial and tells us nothing about the alignment of the left operand).
unsigned TrailingOnes = MaskSCEV->getAPInt().countTrailingOnes();
if (!TrailingOnes)
return false;
// Cap the alignment at the maximum with which LLVM can deal (and make sure
// we don't overflow the shift).
uint64_t Alignment;
TrailingOnes = std::min(TrailingOnes,
unsigned(sizeof(unsigned) * CHAR_BIT - 1));
Alignment = std::min(1u << TrailingOnes, +Value::MaximumAlignment);
Type *Int64Ty = Type::getInt64Ty(I->getParent()->getParent()->getContext());
AlignSCEV = SE->getConstant(Int64Ty, Alignment);
// The LHS might be a ptrtoint instruction, or it might be the pointer
// with an offset.
AAPtr = nullptr;
OffSCEV = nullptr;
if (PtrToIntInst *PToI = dyn_cast<PtrToIntInst>(AndLHS)) {
AAPtr = PToI->getPointerOperand();
OffSCEV = SE->getZero(Int64Ty);
} else if (const SCEVAddExpr* AndLHSAddSCEV =
dyn_cast<SCEVAddExpr>(AndLHSSCEV)) {
// Try to find the ptrtoint; subtract it and the rest is the offset.
for (SCEVAddExpr::op_iterator J = AndLHSAddSCEV->op_begin(),
JE = AndLHSAddSCEV->op_end(); J != JE; ++J)
if (const SCEVUnknown *OpUnk = dyn_cast<SCEVUnknown>(*J))
if (PtrToIntInst *PToI = dyn_cast<PtrToIntInst>(OpUnk->getValue())) {
AAPtr = PToI->getPointerOperand();
OffSCEV = SE->getMinusSCEV(AndLHSAddSCEV, *J);
break;
}
}
if (!AAPtr)
return false;
// Sign extend the offset to 64 bits (so that it is like all of the other
// expressions).
unsigned OffSCEVBits = OffSCEV->getType()->getPrimitiveSizeInBits();
if (OffSCEVBits < 64)
OffSCEV = SE->getSignExtendExpr(OffSCEV, Int64Ty);
else if (OffSCEVBits > 64)
return false;
AAPtr = AAPtr->stripPointerCasts();
return true;
}
