2010-08-31 15:48:34 +08:00
|
|
|
//===- CorrelatedValuePropagation.cpp - Propagate CFG-derived info --------===//
|
2010-08-28 07:31:36 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-08-28 07:31:36 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2010-08-31 15:48:34 +08:00
|
|
|
// This file implements the Correlated Value Propagation pass.
|
2010-08-28 07:31:36 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2016-07-07 07:26:29 +08:00
|
|
|
#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/ADT/DepthFirstIterator.h"
|
|
|
|
#include "llvm/ADT/Optional.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2019-02-06 10:52:52 +08:00
|
|
|
#include "llvm/Analysis/DomTreeUpdater.h"
|
2015-09-10 18:22:12 +08:00
|
|
|
#include "llvm/Analysis/GlobalsModRef.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
|
|
|
#include "llvm/Analysis/LazyValueInfo.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/IR/Attributes.h"
|
|
|
|
#include "llvm/IR/BasicBlock.h"
|
2014-03-04 19:45:46 +08:00
|
|
|
#include "llvm/IR/CFG.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
|
|
|
#include "llvm/IR/Constant.h"
|
2016-08-10 21:08:34 +08:00
|
|
|
#include "llvm/IR/ConstantRange.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
2018-03-22 06:34:23 +08:00
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/IR/InstrTypes.h"
|
|
|
|
#include "llvm/IR/Instruction.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Instructions.h"
|
2017-11-11 03:13:35 +08:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/IR/Operator.h"
|
|
|
|
#include "llvm/IR/PassManager.h"
|
|
|
|
#include "llvm/IR/Type.h"
|
|
|
|
#include "llvm/IR/Value.h"
|
2010-08-28 07:31:36 +08:00
|
|
|
#include "llvm/Pass.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
2013-02-24 23:34:43 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2017-04-26 21:52:13 +08:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2018-08-03 13:08:17 +08:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2017-10-14 05:17:07 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <utility>
|
|
|
|
|
2010-08-28 07:31:36 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "correlated-value-propagation"
|
|
|
|
|
2010-09-04 03:08:37 +08:00
|
|
|
STATISTIC(NumPhis, "Number of phis propagated");
|
2018-04-11 04:42:39 +08:00
|
|
|
STATISTIC(NumPhiCommon, "Number of phis deleted via common incoming value");
|
2010-09-04 03:08:37 +08:00
|
|
|
STATISTIC(NumSelects, "Number of selects propagated");
|
|
|
|
STATISTIC(NumMemAccess, "Number of memory access targets propagated");
|
2010-09-04 06:47:08 +08:00
|
|
|
STATISTIC(NumCmps, "Number of comparisons propagated");
|
2015-11-04 09:43:54 +08:00
|
|
|
STATISTIC(NumReturns, "Number of return values propagated");
|
2012-03-10 03:21:15 +08:00
|
|
|
STATISTIC(NumDeadCases, "Number of switch cases removed");
|
2016-03-14 11:24:28 +08:00
|
|
|
STATISTIC(NumSDivs, "Number of sdiv converted to udiv");
|
2018-03-21 22:08:21 +08:00
|
|
|
STATISTIC(NumUDivs, "Number of udivs whose width was decreased");
|
2016-10-12 21:41:38 +08:00
|
|
|
STATISTIC(NumAShrs, "Number of ashr converted to lshr");
|
2016-07-14 20:23:48 +08:00
|
|
|
STATISTIC(NumSRems, "Number of srem converted to urem");
|
[CVP} Replace SExt with ZExt if the input is known-non-negative
Summary:
zero-extension is far more friendly for further analysis.
While this doesn't directly help with the shift-by-signext problem, this is not unrelated.
This has the following effect on test-suite (numbers collected after the finish of middle-end module pass manager):
| Statistic | old | new | delta | percent change |
| correlated-value-propagation.NumSExt | 0 | 6026 | 6026 | +100.00% |
| instcount.NumAddInst | 272860 | 271283 | -1577 | -0.58% |
| instcount.NumAllocaInst | 27227 | 27226 | -1 | 0.00% |
| instcount.NumAndInst | 63502 | 63320 | -182 | -0.29% |
| instcount.NumAShrInst | 13498 | 13407 | -91 | -0.67% |
| instcount.NumAtomicCmpXchgInst | 1159 | 1159 | 0 | 0.00% |
| instcount.NumAtomicRMWInst | 5036 | 5036 | 0 | 0.00% |
| instcount.NumBitCastInst | 672482 | 672353 | -129 | -0.02% |
| instcount.NumBrInst | 702768 | 702195 | -573 | -0.08% |
| instcount.NumCallInst | 518285 | 518205 | -80 | -0.02% |
| instcount.NumExtractElementInst | 18481 | 18482 | 1 | 0.01% |
| instcount.NumExtractValueInst | 18290 | 18288 | -2 | -0.01% |
| instcount.NumFAddInst | 139035 | 138963 | -72 | -0.05% |
| instcount.NumFCmpInst | 10358 | 10348 | -10 | -0.10% |
| instcount.NumFDivInst | 30310 | 30302 | -8 | -0.03% |
| instcount.NumFenceInst | 387 | 387 | 0 | 0.00% |
| instcount.NumFMulInst | 93873 | 93806 | -67 | -0.07% |
| instcount.NumFPExtInst | 7148 | 7144 | -4 | -0.06% |
| instcount.NumFPToSIInst | 2823 | 2838 | 15 | 0.53% |
| instcount.NumFPToUIInst | 1251 | 1251 | 0 | 0.00% |
| instcount.NumFPTruncInst | 2195 | 2191 | -4 | -0.18% |
| instcount.NumFSubInst | 92109 | 92103 | -6 | -0.01% |
| instcount.NumGetElementPtrInst | 1221423 | 1219157 | -2266 | -0.19% |
| instcount.NumICmpInst | 479140 | 478929 | -211 | -0.04% |
| instcount.NumIndirectBrInst | 2 | 2 | 0 | 0.00% |
| instcount.NumInsertElementInst | 66089 | 66094 | 5 | 0.01% |
| instcount.NumInsertValueInst | 2032 | 2030 | -2 | -0.10% |
| instcount.NumIntToPtrInst | 19641 | 19641 | 0 | 0.00% |
| instcount.NumInvokeInst | 21789 | 21788 | -1 | 0.00% |
| instcount.NumLandingPadInst | 12051 | 12051 | 0 | 0.00% |
| instcount.NumLoadInst | 880079 | 878673 | -1406 | -0.16% |
| instcount.NumLShrInst | 25919 | 25921 | 2 | 0.01% |
| instcount.NumMulInst | 42416 | 42417 | 1 | 0.00% |
| instcount.NumOrInst | 100826 | 100576 | -250 | -0.25% |
| instcount.NumPHIInst | 315118 | 314092 | -1026 | -0.33% |
| instcount.NumPtrToIntInst | 15933 | 15939 | 6 | 0.04% |
| instcount.NumResumeInst | 2156 | 2156 | 0 | 0.00% |
| instcount.NumRetInst | 84485 | 84484 | -1 | 0.00% |
| instcount.NumSDivInst | 8599 | 8597 | -2 | -0.02% |
| instcount.NumSelectInst | 45577 | 45913 | 336 | 0.74% |
| instcount.NumSExtInst | 84026 | 78278 | -5748 | -6.84% |
| instcount.NumShlInst | 39796 | 39726 | -70 | -0.18% |
| instcount.NumShuffleVectorInst | 100272 | 100292 | 20 | 0.02% |
| instcount.NumSIToFPInst | 29131 | 29113 | -18 | -0.06% |
| instcount.NumSRemInst | 1543 | 1543 | 0 | 0.00% |
| instcount.NumStoreInst | 805394 | 804351 | -1043 | -0.13% |
| instcount.NumSubInst | 61337 | 61414 | 77 | 0.13% |
| instcount.NumSwitchInst | 8527 | 8524 | -3 | -0.04% |
| instcount.NumTruncInst | 60523 | 60484 | -39 | -0.06% |
| instcount.NumUDivInst | 2381 | 2381 | 0 | 0.00% |
| instcount.NumUIToFPInst | 5549 | 5549 | 0 | 0.00% |
| instcount.NumUnreachableInst | 9855 | 9855 | 0 | 0.00% |
| instcount.NumURemInst | 1305 | 1305 | 0 | 0.00% |
| instcount.NumXorInst | 10230 | 10081 | -149 | -1.46% |
| instcount.NumZExtInst | 60353 | 66840 | 6487 | 10.75% |
| instcount.TotalBlocks | 829582 | 829004 | -578 | -0.07% |
| instcount.TotalFuncs | 83818 | 83817 | -1 | 0.00% |
| instcount.TotalInsts | 7316574 | 7308483 | -8091 | -0.11% |
TLDR: we produce -0.11% less instructions, -6.84% less `sext`, +10.75% more `zext`.
To be noted, clearly, not all new `zext`'s are produced by this fold.
(And now i guess it might have been interesting to measure this for D68103 :S)
Reviewers: nikic, spatel, reames, dberlin
Reviewed By: nikic
Subscribers: hiraditya, jfb, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D68654
llvm-svn: 374112
2019-10-09 04:29:48 +08:00
|
|
|
STATISTIC(NumSExt, "Number of sext converted to zext");
|
2019-10-11 11:48:56 +08:00
|
|
|
STATISTIC(NumAnd, "Number of ands removed");
|
2019-10-18 21:20:16 +08:00
|
|
|
STATISTIC(NumNW, "Number of no-wrap deductions");
|
|
|
|
STATISTIC(NumNSW, "Number of no-signed-wrap deductions");
|
|
|
|
STATISTIC(NumNUW, "Number of no-unsigned-wrap deductions");
|
|
|
|
STATISTIC(NumAddNW, "Number of no-wrap deductions for add");
|
|
|
|
STATISTIC(NumAddNSW, "Number of no-signed-wrap deductions for add");
|
|
|
|
STATISTIC(NumAddNUW, "Number of no-unsigned-wrap deductions for add");
|
|
|
|
STATISTIC(NumSubNW, "Number of no-wrap deductions for sub");
|
|
|
|
STATISTIC(NumSubNSW, "Number of no-signed-wrap deductions for sub");
|
|
|
|
STATISTIC(NumSubNUW, "Number of no-unsigned-wrap deductions for sub");
|
|
|
|
STATISTIC(NumMulNW, "Number of no-wrap deductions for mul");
|
|
|
|
STATISTIC(NumMulNSW, "Number of no-signed-wrap deductions for mul");
|
|
|
|
STATISTIC(NumMulNUW, "Number of no-unsigned-wrap deductions for mul");
|
2017-11-11 03:13:35 +08:00
|
|
|
STATISTIC(NumOverflows, "Number of overflow checks removed");
|
2019-06-01 04:48:26 +08:00
|
|
|
STATISTIC(NumSaturating,
|
|
|
|
"Number of saturating arithmetics converted to normal arithmetics");
|
2010-08-31 06:45:55 +08:00
|
|
|
|
2019-06-25 04:13:13 +08:00
|
|
|
static cl::opt<bool> DontAddNoWrapFlags("cvp-dont-add-nowrap-flags", cl::init(false));
|
2017-02-24 06:29:00 +08:00
|
|
|
|
2010-08-28 07:31:36 +08:00
|
|
|
namespace {
|
2017-10-14 05:17:07 +08:00
|
|
|
|
2010-08-31 15:48:34 +08:00
|
|
|
class CorrelatedValuePropagation : public FunctionPass {
|
2010-08-28 07:31:36 +08:00
|
|
|
public:
|
|
|
|
static char ID;
|
2017-10-14 05:17:07 +08:00
|
|
|
|
2010-10-20 01:21:58 +08:00
|
|
|
CorrelatedValuePropagation(): FunctionPass(ID) {
|
|
|
|
initializeCorrelatedValuePropagationPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnFunction(Function &F) override;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2018-01-13 05:06:48 +08:00
|
|
|
AU.addRequired<DominatorTreeWrapperPass>();
|
2016-06-14 06:01:25 +08:00
|
|
|
AU.addRequired<LazyValueInfoWrapperPass>();
|
2015-09-10 18:22:12 +08:00
|
|
|
AU.addPreserved<GlobalsAAWrapperPass>();
|
2018-06-17 02:57:31 +08:00
|
|
|
AU.addPreserved<DominatorTreeWrapperPass>();
|
2019-07-25 04:27:32 +08:00
|
|
|
AU.addPreserved<LazyValueInfoWrapperPass>();
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
|
|
|
};
|
2017-10-14 05:17:07 +08:00
|
|
|
|
|
|
|
} // end anonymous namespace
|
2010-08-28 07:31:36 +08:00
|
|
|
|
2010-08-31 15:48:34 +08:00
|
|
|
char CorrelatedValuePropagation::ID = 0;
|
2017-10-14 05:17:07 +08:00
|
|
|
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(CorrelatedValuePropagation, "correlated-propagation",
|
|
|
|
"Value Propagation", false, false)
|
2018-01-13 05:06:48 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
|
2016-06-14 06:01:25 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_END(CorrelatedValuePropagation, "correlated-propagation",
|
2010-10-08 06:25:06 +08:00
|
|
|
"Value Propagation", false, false)
|
2010-08-28 07:31:36 +08:00
|
|
|
|
|
|
|
// Public interface to the Value Propagation pass
|
2010-08-31 15:48:34 +08:00
|
|
|
Pass *llvm::createCorrelatedValuePropagationPass() {
|
|
|
|
return new CorrelatedValuePropagation();
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
|
|
|
|
2016-05-26 01:39:54 +08:00
|
|
|
static bool processSelect(SelectInst *S, LazyValueInfo *LVI) {
|
2010-08-31 07:34:17 +08:00
|
|
|
if (S->getType()->isVectorTy()) return false;
|
2010-09-04 03:08:37 +08:00
|
|
|
if (isa<Constant>(S->getOperand(0))) return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2018-03-17 02:18:47 +08:00
|
|
|
Constant *C = LVI->getConstant(S->getCondition(), S->getParent(), S);
|
2010-08-28 07:31:36 +08:00
|
|
|
if (!C) return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-08-28 07:31:36 +08:00
|
|
|
ConstantInt *CI = dyn_cast<ConstantInt>(C);
|
|
|
|
if (!CI) return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2018-03-17 02:18:47 +08:00
|
|
|
Value *ReplaceWith = S->getTrueValue();
|
|
|
|
Value *Other = S->getFalseValue();
|
2010-12-15 08:55:35 +08:00
|
|
|
if (!CI->isOne()) std::swap(ReplaceWith, Other);
|
|
|
|
if (ReplaceWith == S) ReplaceWith = UndefValue::get(S->getType());
|
|
|
|
|
|
|
|
S->replaceAllUsesWith(ReplaceWith);
|
2010-08-31 07:34:17 +08:00
|
|
|
S->eraseFromParent();
|
|
|
|
|
2010-08-31 06:45:55 +08:00
|
|
|
++NumSelects;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-08-28 07:31:36 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-04-11 04:42:39 +08:00
|
|
|
/// Try to simplify a phi with constant incoming values that match the edge
|
|
|
|
/// values of a non-constant value on all other edges:
|
|
|
|
/// bb0:
|
|
|
|
/// %isnull = icmp eq i8* %x, null
|
|
|
|
/// br i1 %isnull, label %bb2, label %bb1
|
|
|
|
/// bb1:
|
|
|
|
/// br label %bb2
|
|
|
|
/// bb2:
|
|
|
|
/// %r = phi i8* [ %x, %bb1 ], [ null, %bb0 ]
|
|
|
|
/// -->
|
|
|
|
/// %r = %x
|
|
|
|
static bool simplifyCommonValuePhi(PHINode *P, LazyValueInfo *LVI,
|
2018-05-21 19:06:28 +08:00
|
|
|
DominatorTree *DT) {
|
2018-04-11 04:42:39 +08:00
|
|
|
// Collect incoming constants and initialize possible common value.
|
|
|
|
SmallVector<std::pair<Constant *, unsigned>, 4> IncomingConstants;
|
|
|
|
Value *CommonValue = nullptr;
|
|
|
|
for (unsigned i = 0, e = P->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
Value *Incoming = P->getIncomingValue(i);
|
|
|
|
if (auto *IncomingConstant = dyn_cast<Constant>(Incoming)) {
|
|
|
|
IncomingConstants.push_back(std::make_pair(IncomingConstant, i));
|
|
|
|
} else if (!CommonValue) {
|
|
|
|
// The potential common value is initialized to the first non-constant.
|
|
|
|
CommonValue = Incoming;
|
|
|
|
} else if (Incoming != CommonValue) {
|
|
|
|
// There can be only one non-constant common value.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CommonValue || IncomingConstants.empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// The common value must be valid in all incoming blocks.
|
|
|
|
BasicBlock *ToBB = P->getParent();
|
|
|
|
if (auto *CommonInst = dyn_cast<Instruction>(CommonValue))
|
2018-05-21 19:06:28 +08:00
|
|
|
if (!DT->dominates(CommonInst, ToBB))
|
2018-04-11 04:42:39 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// We have a phi with exactly 1 variable incoming value and 1 or more constant
|
|
|
|
// incoming values. See if all constant incoming values can be mapped back to
|
|
|
|
// the same incoming variable value.
|
|
|
|
for (auto &IncomingConstant : IncomingConstants) {
|
|
|
|
Constant *C = IncomingConstant.first;
|
|
|
|
BasicBlock *IncomingBB = P->getIncomingBlock(IncomingConstant.second);
|
|
|
|
if (C != LVI->getConstantOnEdge(CommonValue, IncomingBB, ToBB, P))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// All constant incoming values map to the same variable along the incoming
|
|
|
|
// edges of the phi. The phi is unnecessary.
|
|
|
|
P->replaceAllUsesWith(CommonValue);
|
|
|
|
P->eraseFromParent();
|
|
|
|
++NumPhiCommon;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-05-21 19:06:28 +08:00
|
|
|
static bool processPHI(PHINode *P, LazyValueInfo *LVI, DominatorTree *DT,
|
2018-01-29 13:59:55 +08:00
|
|
|
const SimplifyQuery &SQ) {
|
2010-08-31 07:34:17 +08:00
|
|
|
bool Changed = false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-08-28 07:31:36 +08:00
|
|
|
BasicBlock *BB = P->getParent();
|
2010-08-31 07:34:17 +08:00
|
|
|
for (unsigned i = 0, e = P->getNumIncomingValues(); i < e; ++i) {
|
|
|
|
Value *Incoming = P->getIncomingValue(i);
|
|
|
|
if (isa<Constant>(Incoming)) continue;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2018-01-29 13:59:55 +08:00
|
|
|
Value *V = LVI->getConstantOnEdge(Incoming, P->getIncomingBlock(i), BB, P);
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2015-05-13 06:31:47 +08:00
|
|
|
// Look if the incoming value is a select with a scalar condition for which
|
|
|
|
// LVI can tells us the value. In that case replace the incoming value with
|
|
|
|
// the appropriate value of the select. This often allows us to remove the
|
|
|
|
// select later.
|
2013-02-24 23:34:43 +08:00
|
|
|
if (!V) {
|
|
|
|
SelectInst *SI = dyn_cast<SelectInst>(Incoming);
|
|
|
|
if (!SI) continue;
|
|
|
|
|
2015-05-13 06:31:47 +08:00
|
|
|
Value *Condition = SI->getCondition();
|
|
|
|
if (!Condition->getType()->isVectorTy()) {
|
2015-06-06 12:56:51 +08:00
|
|
|
if (Constant *C = LVI->getConstantOnEdge(
|
|
|
|
Condition, P->getIncomingBlock(i), BB, P)) {
|
|
|
|
if (C->isOneValue()) {
|
2015-05-13 06:31:47 +08:00
|
|
|
V = SI->getTrueValue();
|
2015-06-06 12:56:51 +08:00
|
|
|
} else if (C->isZeroValue()) {
|
2015-05-13 06:31:47 +08:00
|
|
|
V = SI->getFalseValue();
|
|
|
|
}
|
|
|
|
// Once LVI learns to handle vector types, we could also add support
|
|
|
|
// for vector type constants that are not all zeroes or all ones.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look if the select has a constant but LVI tells us that the incoming
|
|
|
|
// value can never be that constant. In that case replace the incoming
|
|
|
|
// value with the other value of the select. This often allows us to
|
|
|
|
// remove the select later.
|
|
|
|
if (!V) {
|
|
|
|
Constant *C = dyn_cast<Constant>(SI->getFalseValue());
|
|
|
|
if (!C) continue;
|
|
|
|
|
|
|
|
if (LVI->getPredicateOnEdge(ICmpInst::ICMP_EQ, SI, C,
|
|
|
|
P->getIncomingBlock(i), BB, P) !=
|
|
|
|
LazyValueInfo::False)
|
|
|
|
continue;
|
|
|
|
V = SI->getTrueValue();
|
|
|
|
}
|
2013-02-24 23:34:43 +08:00
|
|
|
|
2018-05-14 20:53:11 +08:00
|
|
|
LLVM_DEBUG(dbgs() << "CVP: Threading PHI over " << *SI << '\n');
|
2013-02-24 23:34:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
P->setIncomingValue(i, V);
|
2010-08-31 07:34:17 +08:00
|
|
|
Changed = true;
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
2010-11-17 01:41:24 +08:00
|
|
|
|
2017-04-29 03:55:38 +08:00
|
|
|
if (Value *V = SimplifyInstruction(P, SQ)) {
|
2010-11-17 01:41:24 +08:00
|
|
|
P->replaceAllUsesWith(V);
|
2010-08-28 07:31:36 +08:00
|
|
|
P->eraseFromParent();
|
2010-08-31 07:34:17 +08:00
|
|
|
Changed = true;
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
2010-11-17 01:41:24 +08:00
|
|
|
|
2018-04-11 04:42:39 +08:00
|
|
|
if (!Changed)
|
2018-05-21 19:06:28 +08:00
|
|
|
Changed = simplifyCommonValuePhi(P, LVI, DT);
|
2018-04-11 04:42:39 +08:00
|
|
|
|
2012-03-10 03:21:15 +08:00
|
|
|
if (Changed)
|
|
|
|
++NumPhis;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-08-31 07:34:17 +08:00
|
|
|
return Changed;
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
|
|
|
|
2016-05-26 01:39:54 +08:00
|
|
|
static bool processMemAccess(Instruction *I, LazyValueInfo *LVI) {
|
2014-04-25 13:29:35 +08:00
|
|
|
Value *Pointer = nullptr;
|
2010-09-04 03:08:37 +08:00
|
|
|
if (LoadInst *L = dyn_cast<LoadInst>(I))
|
|
|
|
Pointer = L->getPointerOperand();
|
|
|
|
else
|
|
|
|
Pointer = cast<StoreInst>(I)->getPointerOperand();
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-09-04 03:08:37 +08:00
|
|
|
if (isa<Constant>(Pointer)) return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2014-09-08 04:29:59 +08:00
|
|
|
Constant *C = LVI->getConstant(Pointer, I->getParent(), I);
|
2010-09-04 03:08:37 +08:00
|
|
|
if (!C) return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-09-04 03:08:37 +08:00
|
|
|
++NumMemAccess;
|
|
|
|
I->replaceUsesOfWith(Pointer, C);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-02 00:41:59 +08:00
|
|
|
/// See if LazyValueInfo's ability to exploit edge conditions or range
|
|
|
|
/// information is sufficient to prove this comparison. Even for local
|
|
|
|
/// conditions, this can sometimes prove conditions instcombine can't by
|
[LVI/CVP] Teach LVI about range metadata
Somewhat shockingly for an analysis pass which is computing constant ranges, LVI did not understand the ranges provided by range metadata.
As part of this change, I included a change to CVP primarily because doing so made it much easier to write small self contained test cases. CVP was previously only handling the non-local operand case, but given that LVI can sometimes figure out information about instructions standalone, I don't see any reason to restrict this. There could possibly be a compile time impact from this, but I suspect it should be minimal. If anyone has an example which substaintially regresses, please let me know. I could restrict the block local handling to ICmps feeding Terminator instructions if needed.
Note that this patch continues a somewhat bad practice in LVI. In many cases, we know facts about values, and separate context sensitive facts about values. LVI makes no effort to distinguish and will frequently cache the same value fact repeatedly for different contexts. I would like to change this, but that's a large enough change that I want it to go in separately with clear documentation of what's changing. Other examples of this include the non-null handling, and arguments.
As a meta comment: the entire motivation of this change was being able to write smaller (aka reasonable sized) test cases for a future patch teaching LVI about select instructions.
Differential Revision: http://reviews.llvm.org/D13543
llvm-svn: 251606
2015-10-29 11:57:17 +08:00
|
|
|
/// exploiting range information.
|
2018-11-29 22:41:21 +08:00
|
|
|
static bool processCmp(CmpInst *Cmp, LazyValueInfo *LVI) {
|
|
|
|
Value *Op0 = Cmp->getOperand(0);
|
|
|
|
auto *C = dyn_cast<Constant>(Cmp->getOperand(1));
|
|
|
|
if (!C)
|
|
|
|
return false;
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2015-11-04 09:43:54 +08:00
|
|
|
// As a policy choice, we choose not to waste compile time on anything where
|
|
|
|
// the comparison is testing local values. While LVI can sometimes reason
|
|
|
|
// about such cases, it's not its primary purpose. We do make sure to do
|
|
|
|
// the block local query for uses from terminator instructions, but that's
|
|
|
|
// handled in the code for each terminator.
|
|
|
|
auto *I = dyn_cast<Instruction>(Op0);
|
2018-11-29 22:41:21 +08:00
|
|
|
if (I && I->getParent() == Cmp->getParent())
|
2015-11-04 09:43:54 +08:00
|
|
|
return false;
|
|
|
|
|
[LVI/CVP] Teach LVI about range metadata
Somewhat shockingly for an analysis pass which is computing constant ranges, LVI did not understand the ranges provided by range metadata.
As part of this change, I included a change to CVP primarily because doing so made it much easier to write small self contained test cases. CVP was previously only handling the non-local operand case, but given that LVI can sometimes figure out information about instructions standalone, I don't see any reason to restrict this. There could possibly be a compile time impact from this, but I suspect it should be minimal. If anyone has an example which substaintially regresses, please let me know. I could restrict the block local handling to ICmps feeding Terminator instructions if needed.
Note that this patch continues a somewhat bad practice in LVI. In many cases, we know facts about values, and separate context sensitive facts about values. LVI makes no effort to distinguish and will frequently cache the same value fact repeatedly for different contexts. I would like to change this, but that's a large enough change that I want it to go in separately with clear documentation of what's changing. Other examples of this include the non-null handling, and arguments.
As a meta comment: the entire motivation of this change was being able to write smaller (aka reasonable sized) test cases for a future patch teaching LVI about select instructions.
Differential Revision: http://reviews.llvm.org/D13543
llvm-svn: 251606
2015-10-29 11:57:17 +08:00
|
|
|
LazyValueInfo::Tristate Result =
|
2018-11-29 22:41:21 +08:00
|
|
|
LVI->getPredicateAt(Cmp->getPredicate(), Op0, C, Cmp);
|
|
|
|
if (Result == LazyValueInfo::Unknown)
|
|
|
|
return false;
|
2010-09-04 06:47:08 +08:00
|
|
|
|
|
|
|
++NumCmps;
|
2018-11-29 22:41:21 +08:00
|
|
|
Constant *TorF = ConstantInt::get(Type::getInt1Ty(Cmp->getContext()), Result);
|
|
|
|
Cmp->replaceAllUsesWith(TorF);
|
|
|
|
Cmp->eraseFromParent();
|
2010-09-04 06:47:08 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-02 00:41:59 +08:00
|
|
|
/// Simplify a switch instruction by removing cases which can never fire. If the
|
|
|
|
/// uselessness of a case could be determined locally then constant propagation
|
|
|
|
/// would already have figured it out. Instead, walk the predecessors and
|
|
|
|
/// statically evaluate cases based on information available on that edge. Cases
|
|
|
|
/// that cannot fire no matter what the incoming edge can safely be removed. If
|
|
|
|
/// a case fires on every incoming edge then the entire switch can be removed
|
|
|
|
/// and replaced with a branch to the case destination.
|
2019-06-05 13:46:40 +08:00
|
|
|
static bool processSwitch(SwitchInst *I, LazyValueInfo *LVI,
|
2018-11-29 22:41:21 +08:00
|
|
|
DominatorTree *DT) {
|
2018-08-03 13:08:17 +08:00
|
|
|
DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Lazy);
|
2019-06-05 13:46:40 +08:00
|
|
|
Value *Cond = I->getCondition();
|
|
|
|
BasicBlock *BB = I->getParent();
|
2012-03-09 21:45:18 +08:00
|
|
|
|
|
|
|
// If the condition was defined in same block as the switch then LazyValueInfo
|
|
|
|
// currently won't say anything useful about it, though in theory it could.
|
|
|
|
if (isa<Instruction>(Cond) && cast<Instruction>(Cond)->getParent() == BB)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the switch is unreachable then trying to improve it is a waste of time.
|
|
|
|
pred_iterator PB = pred_begin(BB), PE = pred_end(BB);
|
|
|
|
if (PB == PE) return false;
|
|
|
|
|
2017-06-24 04:28:35 +08:00
|
|
|
// Analyse each switch case in turn.
|
2012-03-09 21:45:18 +08:00
|
|
|
bool Changed = false;
|
2018-06-17 02:57:31 +08:00
|
|
|
DenseMap<BasicBlock*, int> SuccessorsCount;
|
|
|
|
for (auto *Succ : successors(BB))
|
|
|
|
SuccessorsCount[Succ]++;
|
|
|
|
|
2019-06-05 13:46:40 +08:00
|
|
|
{ // Scope for SwitchInstProfUpdateWrapper. It must not live during
|
|
|
|
// ConstantFoldTerminator() as the underlying SwitchInst can be changed.
|
|
|
|
SwitchInstProfUpdateWrapper SI(*I);
|
|
|
|
|
|
|
|
for (auto CI = SI->case_begin(), CE = SI->case_end(); CI != CE;) {
|
|
|
|
ConstantInt *Case = CI->getCaseValue();
|
|
|
|
|
|
|
|
// Check to see if the switch condition is equal to/not equal to the case
|
|
|
|
// value on every incoming edge, equal/not equal being the same each time.
|
|
|
|
LazyValueInfo::Tristate State = LazyValueInfo::Unknown;
|
|
|
|
for (pred_iterator PI = PB; PI != PE; ++PI) {
|
|
|
|
// Is the switch condition equal to the case value?
|
|
|
|
LazyValueInfo::Tristate Value = LVI->getPredicateOnEdge(CmpInst::ICMP_EQ,
|
|
|
|
Cond, Case, *PI,
|
|
|
|
BB, SI);
|
|
|
|
// Give up on this case if nothing is known.
|
|
|
|
if (Value == LazyValueInfo::Unknown) {
|
|
|
|
State = LazyValueInfo::Unknown;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this was the first edge to be visited, record that all other edges
|
|
|
|
// need to give the same result.
|
|
|
|
if (PI == PB) {
|
|
|
|
State = Value;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this case is known to fire for some edges and known not to fire for
|
|
|
|
// others then there is nothing we can do - give up.
|
|
|
|
if (Value != State) {
|
|
|
|
State = LazyValueInfo::Unknown;
|
|
|
|
break;
|
|
|
|
}
|
2012-03-09 21:45:18 +08:00
|
|
|
}
|
|
|
|
|
2019-06-05 13:46:40 +08:00
|
|
|
if (State == LazyValueInfo::False) {
|
|
|
|
// This case never fires - remove it.
|
|
|
|
BasicBlock *Succ = CI->getCaseSuccessor();
|
|
|
|
Succ->removePredecessor(BB);
|
|
|
|
CI = SI.removeCase(CI);
|
|
|
|
CE = SI->case_end();
|
|
|
|
|
|
|
|
// The condition can be modified by removePredecessor's PHI simplification
|
|
|
|
// logic.
|
|
|
|
Cond = SI->getCondition();
|
|
|
|
|
|
|
|
++NumDeadCases;
|
|
|
|
Changed = true;
|
|
|
|
if (--SuccessorsCount[Succ] == 0)
|
|
|
|
DTU.applyUpdatesPermissive({{DominatorTree::Delete, BB, Succ}});
|
2012-03-09 21:45:18 +08:00
|
|
|
continue;
|
|
|
|
}
|
2019-06-05 13:46:40 +08:00
|
|
|
if (State == LazyValueInfo::True) {
|
|
|
|
// This case always fires. Arrange for the switch to be turned into an
|
|
|
|
// unconditional branch by replacing the switch condition with the case
|
|
|
|
// value.
|
|
|
|
SI->setCondition(Case);
|
|
|
|
NumDeadCases += SI->getNumCases();
|
|
|
|
Changed = true;
|
2012-03-09 21:45:18 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-06-05 13:46:40 +08:00
|
|
|
// Increment the case iterator since we didn't delete it.
|
|
|
|
++CI;
|
2017-03-26 10:49:23 +08:00
|
|
|
}
|
2012-03-09 21:45:18 +08:00
|
|
|
}
|
|
|
|
|
2018-08-03 13:08:17 +08:00
|
|
|
if (Changed)
|
2012-03-09 21:45:18 +08:00
|
|
|
// If the switch has been simplified to the point where it can be replaced
|
|
|
|
// by a branch then do so now.
|
2018-06-17 02:57:31 +08:00
|
|
|
ConstantFoldTerminator(BB, /*DeleteDeadConditions = */ false,
|
2018-08-03 13:08:17 +08:00
|
|
|
/*TLI = */ nullptr, &DTU);
|
2012-03-09 21:45:18 +08:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2019-05-31 05:03:10 +08:00
|
|
|
// See if we can prove that the given binary op intrinsic will not overflow.
|
|
|
|
static bool willNotOverflow(BinaryOpIntrinsic *BO, LazyValueInfo *LVI) {
|
2019-05-25 22:11:55 +08:00
|
|
|
ConstantRange LRange = LVI->getConstantRange(
|
2019-05-31 05:03:10 +08:00
|
|
|
BO->getLHS(), BO->getParent(), BO);
|
2019-05-25 22:11:55 +08:00
|
|
|
ConstantRange RRange = LVI->getConstantRange(
|
2019-05-31 05:03:10 +08:00
|
|
|
BO->getRHS(), BO->getParent(), BO);
|
2019-04-22 17:01:38 +08:00
|
|
|
ConstantRange NWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
|
2019-05-31 05:03:10 +08:00
|
|
|
BO->getBinaryOp(), RRange, BO->getNoWrapKind());
|
2019-04-17 02:55:16 +08:00
|
|
|
return NWRegion.contains(LRange);
|
2017-11-11 03:13:35 +08:00
|
|
|
}
|
|
|
|
|
2019-10-18 21:20:16 +08:00
|
|
|
static void setDeducedOverflowingFlags(Value *V, Instruction::BinaryOps Opcode,
|
|
|
|
bool NewNSW, bool NewNUW) {
|
|
|
|
Statistic *OpcNW, *OpcNSW, *OpcNUW;
|
|
|
|
switch (Opcode) {
|
|
|
|
case Instruction::Add:
|
|
|
|
OpcNW = &NumAddNW;
|
|
|
|
OpcNSW = &NumAddNSW;
|
|
|
|
OpcNUW = &NumAddNUW;
|
|
|
|
break;
|
|
|
|
case Instruction::Sub:
|
|
|
|
OpcNW = &NumSubNW;
|
|
|
|
OpcNSW = &NumSubNSW;
|
|
|
|
OpcNUW = &NumSubNUW;
|
|
|
|
break;
|
|
|
|
case Instruction::Mul:
|
|
|
|
OpcNW = &NumMulNW;
|
|
|
|
OpcNSW = &NumMulNSW;
|
|
|
|
OpcNUW = &NumMulNUW;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Will not be called with other binops");
|
|
|
|
}
|
|
|
|
|
|
|
|
auto *Inst = dyn_cast<Instruction>(V);
|
|
|
|
if (NewNSW) {
|
|
|
|
++NumNW;
|
2019-10-19 05:19:26 +08:00
|
|
|
++*OpcNW;
|
2019-10-18 21:20:16 +08:00
|
|
|
++NumNSW;
|
2019-10-19 05:19:26 +08:00
|
|
|
++*OpcNSW;
|
2019-10-18 21:20:16 +08:00
|
|
|
if (Inst)
|
2019-04-17 14:35:07 +08:00
|
|
|
Inst->setHasNoSignedWrap();
|
2019-10-18 21:20:16 +08:00
|
|
|
}
|
|
|
|
if (NewNUW) {
|
|
|
|
++NumNW;
|
2019-10-19 05:19:26 +08:00
|
|
|
++*OpcNW;
|
2019-10-18 21:20:16 +08:00
|
|
|
++NumNUW;
|
2019-10-19 05:19:26 +08:00
|
|
|
++*OpcNUW;
|
2019-10-18 21:20:16 +08:00
|
|
|
if (Inst)
|
2019-04-17 14:35:07 +08:00
|
|
|
Inst->setHasNoUnsignedWrap();
|
|
|
|
}
|
2019-10-18 21:20:16 +08:00
|
|
|
}
|
|
|
|
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
static bool processBinOp(BinaryOperator *BinOp, LazyValueInfo *LVI);
|
|
|
|
|
2019-10-18 21:20:16 +08:00
|
|
|
// Rewrite this with.overflow intrinsic as non-overflowing.
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
static void processOverflowIntrinsic(WithOverflowInst *WO, LazyValueInfo *LVI) {
|
2019-10-18 21:20:16 +08:00
|
|
|
IRBuilder<> B(WO);
|
|
|
|
Instruction::BinaryOps Opcode = WO->getBinaryOp();
|
|
|
|
bool NSW = WO->isSigned();
|
|
|
|
bool NUW = !WO->isSigned();
|
|
|
|
|
|
|
|
Value *NewOp =
|
|
|
|
B.CreateBinOp(Opcode, WO->getLHS(), WO->getRHS(), WO->getName());
|
|
|
|
setDeducedOverflowingFlags(NewOp, Opcode, NSW, NUW);
|
2019-04-17 02:55:16 +08:00
|
|
|
|
2019-08-31 17:58:37 +08:00
|
|
|
StructType *ST = cast<StructType>(WO->getType());
|
|
|
|
Constant *Struct = ConstantStruct::get(ST,
|
|
|
|
{ UndefValue::get(ST->getElementType(0)),
|
|
|
|
ConstantInt::getFalse(ST->getElementType(1)) });
|
|
|
|
Value *NewI = B.CreateInsertValue(Struct, NewOp, 0);
|
2019-04-17 02:55:16 +08:00
|
|
|
WO->replaceAllUsesWith(NewI);
|
|
|
|
WO->eraseFromParent();
|
2017-11-11 03:13:35 +08:00
|
|
|
++NumOverflows;
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
|
|
|
|
// See if we can infer the other no-wrap too.
|
|
|
|
if (auto *BO = dyn_cast<BinaryOperator>(NewOp))
|
|
|
|
processBinOp(BO, LVI);
|
2017-11-11 03:13:35 +08:00
|
|
|
}
|
|
|
|
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
static void processSaturatingInst(SaturatingInst *SI, LazyValueInfo *LVI) {
|
2019-10-18 21:20:16 +08:00
|
|
|
Instruction::BinaryOps Opcode = SI->getBinaryOp();
|
|
|
|
bool NSW = SI->isSigned();
|
|
|
|
bool NUW = !SI->isSigned();
|
2019-06-01 04:48:26 +08:00
|
|
|
BinaryOperator *BinOp = BinaryOperator::Create(
|
2019-10-18 21:20:16 +08:00
|
|
|
Opcode, SI->getLHS(), SI->getRHS(), SI->getName(), SI);
|
2019-06-01 04:48:26 +08:00
|
|
|
BinOp->setDebugLoc(SI->getDebugLoc());
|
2019-10-18 21:20:16 +08:00
|
|
|
setDeducedOverflowingFlags(BinOp, Opcode, NSW, NUW);
|
2019-06-01 04:48:26 +08:00
|
|
|
|
|
|
|
SI->replaceAllUsesWith(BinOp);
|
|
|
|
SI->eraseFromParent();
|
|
|
|
++NumSaturating;
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
|
|
|
|
// See if we can infer the other no-wrap too.
|
|
|
|
if (auto *BO = dyn_cast<BinaryOperator>(BinOp))
|
|
|
|
processBinOp(BO, LVI);
|
2019-06-01 04:48:26 +08:00
|
|
|
}
|
|
|
|
|
2016-07-02 00:41:59 +08:00
|
|
|
/// Infer nonnull attributes for the arguments at the specified callsite.
|
2016-05-26 01:39:54 +08:00
|
|
|
static bool processCallSite(CallSite CS, LazyValueInfo *LVI) {
|
2017-06-01 03:23:09 +08:00
|
|
|
SmallVector<unsigned, 4> ArgNos;
|
2015-09-16 01:51:50 +08:00
|
|
|
unsigned ArgNo = 0;
|
2015-12-02 14:58:49 +08:00
|
|
|
|
2019-04-17 02:55:16 +08:00
|
|
|
if (auto *WO = dyn_cast<WithOverflowInst>(CS.getInstruction())) {
|
2019-06-01 04:42:07 +08:00
|
|
|
if (WO->getLHS()->getType()->isIntegerTy() && willNotOverflow(WO, LVI)) {
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
processOverflowIntrinsic(WO, LVI);
|
2017-11-11 03:13:35 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-01 04:48:26 +08:00
|
|
|
if (auto *SI = dyn_cast<SaturatingInst>(CS.getInstruction())) {
|
|
|
|
if (SI->getType()->isIntegerTy() && willNotOverflow(SI, LVI)) {
|
[CVP] After proving that @llvm.with.overflow()/@llvm.sat() don't overflow, also try to prove other no-wrap
Summary:
CVP, unlike InstCombine, does not run till exaustion.
It only does a single pass.
When dealing with those special binops, if we prove that they can
safely be demoted into their usual binop form,
we do set the no-wrap we deduced. But when dealing with usual binops,
we try to deduce both no-wraps.
So if we convert e.g. @llvm.uadd.with.overflow() to `add nuw`,
we won't attempt to check whether it can be `add nuw nsw`.
This patch proposes to call `processBinOp()` on newly-created binop,
which is identical to what we do for div/rem already.
Reviewers: nikic, spatel, reames
Reviewed By: nikic
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D69183
llvm-svn: 375273
2019-10-19 03:32:47 +08:00
|
|
|
processSaturatingInst(SI, LVI);
|
2019-06-01 04:48:26 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-22 09:34:33 +08:00
|
|
|
// Deopt bundle operands are intended to capture state with minimal
|
|
|
|
// perturbance of the code otherwise. If we can find a constant value for
|
|
|
|
// any such operand and remove a use of the original value, that's
|
|
|
|
// desireable since it may allow further optimization of that value (e.g. via
|
|
|
|
// single use rules in instcombine). Since deopt uses tend to,
|
|
|
|
// idiomatically, appear along rare conditional paths, it's reasonable likely
|
|
|
|
// we may have a conditional fact with which LVI can fold.
|
|
|
|
if (auto DeoptBundle = CS.getOperandBundle(LLVMContext::OB_deopt)) {
|
|
|
|
bool Progress = false;
|
|
|
|
for (const Use &ConstU : DeoptBundle->Inputs) {
|
|
|
|
Use &U = const_cast<Use&>(ConstU);
|
|
|
|
Value *V = U.get();
|
|
|
|
if (V->getType()->isVectorTy()) continue;
|
|
|
|
if (isa<Constant>(V)) continue;
|
|
|
|
|
|
|
|
Constant *C = LVI->getConstant(V, CS.getParent(), CS.getInstruction());
|
|
|
|
if (!C) continue;
|
|
|
|
U.set(C);
|
|
|
|
Progress = true;
|
|
|
|
}
|
|
|
|
if (Progress)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-09-16 01:51:50 +08:00
|
|
|
for (Value *V : CS.args()) {
|
|
|
|
PointerType *Type = dyn_cast<PointerType>(V->getType());
|
2016-02-11 06:22:41 +08:00
|
|
|
// Try to mark pointer typed parameters as non-null. We skip the
|
|
|
|
// relatively expensive analysis for constants which are obviously either
|
|
|
|
// null or non-null to start with.
|
2017-04-15 04:19:02 +08:00
|
|
|
if (Type && !CS.paramHasAttr(ArgNo, Attribute::NonNull) &&
|
2018-07-31 03:41:25 +08:00
|
|
|
!isa<Constant>(V) &&
|
2015-09-16 01:51:50 +08:00
|
|
|
LVI->getPredicateAt(ICmpInst::ICMP_EQ, V,
|
|
|
|
ConstantPointerNull::get(Type),
|
2015-12-02 14:58:49 +08:00
|
|
|
CS.getInstruction()) == LazyValueInfo::False)
|
2017-06-01 03:23:09 +08:00
|
|
|
ArgNos.push_back(ArgNo);
|
2015-09-16 01:51:50 +08:00
|
|
|
ArgNo++;
|
|
|
|
}
|
2015-12-02 14:58:49 +08:00
|
|
|
|
2015-09-16 01:51:50 +08:00
|
|
|
assert(ArgNo == CS.arg_size() && "sanity check");
|
|
|
|
|
2017-06-01 03:23:09 +08:00
|
|
|
if (ArgNos.empty())
|
2015-12-02 14:58:49 +08:00
|
|
|
return false;
|
|
|
|
|
Rename AttributeSet to AttributeList
Summary:
This class is a list of AttributeSetNodes corresponding the function
prototype of a call or function declaration. This class used to be
called ParamAttrListPtr, then AttrListPtr, then AttributeSet. It is
typically accessed by parameter and return value index, so
"AttributeList" seems like a more intuitive name.
Rename AttributeSetImpl to AttributeListImpl to follow suit.
It's useful to rename this class so that we can rename AttributeSetNode
to AttributeSet later. AttributeSet is the set of attributes that apply
to a single function, argument, or return value.
Reviewers: sanjoy, javed.absar, chandlerc, pete
Reviewed By: pete
Subscribers: pete, jholewinski, arsenm, dschuff, mehdi_amini, jfb, nhaehnle, sbc100, void, llvm-commits
Differential Revision: https://reviews.llvm.org/D31102
llvm-svn: 298393
2017-03-22 00:57:19 +08:00
|
|
|
AttributeList AS = CS.getAttributes();
|
2015-12-02 14:58:49 +08:00
|
|
|
LLVMContext &Ctx = CS.getInstruction()->getContext();
|
2017-06-01 03:23:09 +08:00
|
|
|
AS = AS.addParamAttribute(Ctx, ArgNos,
|
|
|
|
Attribute::get(Ctx, Attribute::NonNull));
|
2015-12-02 14:58:49 +08:00
|
|
|
CS.setAttributes(AS);
|
|
|
|
|
|
|
|
return true;
|
2015-09-16 01:51:50 +08:00
|
|
|
}
|
|
|
|
|
2016-07-14 20:23:48 +08:00
|
|
|
static bool hasPositiveOperands(BinaryOperator *SDI, LazyValueInfo *LVI) {
|
2016-03-14 11:24:28 +08:00
|
|
|
Constant *Zero = ConstantInt::get(SDI->getType(), 0);
|
|
|
|
for (Value *O : SDI->operands()) {
|
2016-07-14 20:23:48 +08:00
|
|
|
auto Result = LVI->getPredicateAt(ICmpInst::ICMP_SGE, O, Zero, SDI);
|
2016-03-14 11:24:28 +08:00
|
|
|
if (Result != LazyValueInfo::True)
|
|
|
|
return false;
|
|
|
|
}
|
2016-07-14 20:23:48 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-03-21 22:08:21 +08:00
|
|
|
/// Try to shrink a udiv/urem's width down to the smallest power of two that's
|
|
|
|
/// sufficient to contain its operands.
|
|
|
|
static bool processUDivOrURem(BinaryOperator *Instr, LazyValueInfo *LVI) {
|
|
|
|
assert(Instr->getOpcode() == Instruction::UDiv ||
|
|
|
|
Instr->getOpcode() == Instruction::URem);
|
|
|
|
if (Instr->getType()->isVectorTy())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Find the smallest power of two bitwidth that's sufficient to hold Instr's
|
|
|
|
// operands.
|
|
|
|
auto OrigWidth = Instr->getType()->getIntegerBitWidth();
|
2019-07-16 12:46:31 +08:00
|
|
|
ConstantRange OperandRange(OrigWidth, /*isFullSet=*/false);
|
2018-03-21 22:08:21 +08:00
|
|
|
for (Value *Operand : Instr->operands()) {
|
|
|
|
OperandRange = OperandRange.unionWith(
|
|
|
|
LVI->getConstantRange(Operand, Instr->getParent()));
|
|
|
|
}
|
|
|
|
// Don't shrink below 8 bits wide.
|
|
|
|
unsigned NewWidth = std::max<unsigned>(
|
|
|
|
PowerOf2Ceil(OperandRange.getUnsignedMax().getActiveBits()), 8);
|
|
|
|
// NewWidth might be greater than OrigWidth if OrigWidth is not a power of
|
|
|
|
// two.
|
|
|
|
if (NewWidth >= OrigWidth)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
++NumUDivs;
|
2018-11-18 08:29:58 +08:00
|
|
|
IRBuilder<> B{Instr};
|
2018-03-21 22:08:21 +08:00
|
|
|
auto *TruncTy = Type::getIntNTy(Instr->getContext(), NewWidth);
|
2018-11-18 08:29:58 +08:00
|
|
|
auto *LHS = B.CreateTruncOrBitCast(Instr->getOperand(0), TruncTy,
|
|
|
|
Instr->getName() + ".lhs.trunc");
|
|
|
|
auto *RHS = B.CreateTruncOrBitCast(Instr->getOperand(1), TruncTy,
|
|
|
|
Instr->getName() + ".rhs.trunc");
|
|
|
|
auto *BO = B.CreateBinOp(Instr->getOpcode(), LHS, RHS, Instr->getName());
|
|
|
|
auto *Zext = B.CreateZExt(BO, Instr->getType(), Instr->getName() + ".zext");
|
|
|
|
if (auto *BinOp = dyn_cast<BinaryOperator>(BO))
|
|
|
|
if (BinOp->getOpcode() == Instruction::UDiv)
|
|
|
|
BinOp->setIsExact(Instr->isExact());
|
2018-03-21 22:08:21 +08:00
|
|
|
|
|
|
|
Instr->replaceAllUsesWith(Zext);
|
|
|
|
Instr->eraseFromParent();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-07-14 20:23:48 +08:00
|
|
|
static bool processSRem(BinaryOperator *SDI, LazyValueInfo *LVI) {
|
2018-03-06 00:08:34 +08:00
|
|
|
if (SDI->getType()->isVectorTy() || !hasPositiveOperands(SDI, LVI))
|
2016-07-14 20:23:48 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
++NumSRems;
|
|
|
|
auto *BO = BinaryOperator::CreateURem(SDI->getOperand(0), SDI->getOperand(1),
|
|
|
|
SDI->getName(), SDI);
|
2018-11-18 08:29:58 +08:00
|
|
|
BO->setDebugLoc(SDI->getDebugLoc());
|
2016-07-14 20:23:48 +08:00
|
|
|
SDI->replaceAllUsesWith(BO);
|
|
|
|
SDI->eraseFromParent();
|
2018-03-21 22:08:21 +08:00
|
|
|
|
|
|
|
// Try to process our new urem.
|
|
|
|
processUDivOrURem(BO, LVI);
|
|
|
|
|
2016-07-14 20:23:48 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// See if LazyValueInfo's ability to exploit edge conditions or range
|
|
|
|
/// information is sufficient to prove the both operands of this SDiv are
|
|
|
|
/// positive. If this is the case, replace the SDiv with a UDiv. Even for local
|
|
|
|
/// conditions, this can sometimes prove conditions instcombine can't by
|
|
|
|
/// exploiting range information.
|
|
|
|
static bool processSDiv(BinaryOperator *SDI, LazyValueInfo *LVI) {
|
2018-03-06 00:08:34 +08:00
|
|
|
if (SDI->getType()->isVectorTy() || !hasPositiveOperands(SDI, LVI))
|
2016-07-14 20:23:48 +08:00
|
|
|
return false;
|
2016-03-14 11:24:28 +08:00
|
|
|
|
|
|
|
++NumSDivs;
|
|
|
|
auto *BO = BinaryOperator::CreateUDiv(SDI->getOperand(0), SDI->getOperand(1),
|
|
|
|
SDI->getName(), SDI);
|
2018-11-18 08:29:58 +08:00
|
|
|
BO->setDebugLoc(SDI->getDebugLoc());
|
2016-03-14 11:24:28 +08:00
|
|
|
BO->setIsExact(SDI->isExact());
|
|
|
|
SDI->replaceAllUsesWith(BO);
|
|
|
|
SDI->eraseFromParent();
|
|
|
|
|
2018-03-21 22:08:21 +08:00
|
|
|
// Try to simplify our new udiv.
|
|
|
|
processUDivOrURem(BO, LVI);
|
|
|
|
|
2016-03-14 11:24:28 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-10-12 21:41:38 +08:00
|
|
|
static bool processAShr(BinaryOperator *SDI, LazyValueInfo *LVI) {
|
2017-10-13 06:39:52 +08:00
|
|
|
if (SDI->getType()->isVectorTy())
|
2016-10-12 21:41:38 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
Constant *Zero = ConstantInt::get(SDI->getType(), 0);
|
|
|
|
if (LVI->getPredicateAt(ICmpInst::ICMP_SGE, SDI->getOperand(0), Zero, SDI) !=
|
|
|
|
LazyValueInfo::True)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
++NumAShrs;
|
|
|
|
auto *BO = BinaryOperator::CreateLShr(SDI->getOperand(0), SDI->getOperand(1),
|
|
|
|
SDI->getName(), SDI);
|
2018-11-18 08:29:58 +08:00
|
|
|
BO->setDebugLoc(SDI->getDebugLoc());
|
2016-10-12 21:41:38 +08:00
|
|
|
BO->setIsExact(SDI->isExact());
|
|
|
|
SDI->replaceAllUsesWith(BO);
|
|
|
|
SDI->eraseFromParent();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
[CVP} Replace SExt with ZExt if the input is known-non-negative
Summary:
zero-extension is far more friendly for further analysis.
While this doesn't directly help with the shift-by-signext problem, this is not unrelated.
This has the following effect on test-suite (numbers collected after the finish of middle-end module pass manager):
| Statistic | old | new | delta | percent change |
| correlated-value-propagation.NumSExt | 0 | 6026 | 6026 | +100.00% |
| instcount.NumAddInst | 272860 | 271283 | -1577 | -0.58% |
| instcount.NumAllocaInst | 27227 | 27226 | -1 | 0.00% |
| instcount.NumAndInst | 63502 | 63320 | -182 | -0.29% |
| instcount.NumAShrInst | 13498 | 13407 | -91 | -0.67% |
| instcount.NumAtomicCmpXchgInst | 1159 | 1159 | 0 | 0.00% |
| instcount.NumAtomicRMWInst | 5036 | 5036 | 0 | 0.00% |
| instcount.NumBitCastInst | 672482 | 672353 | -129 | -0.02% |
| instcount.NumBrInst | 702768 | 702195 | -573 | -0.08% |
| instcount.NumCallInst | 518285 | 518205 | -80 | -0.02% |
| instcount.NumExtractElementInst | 18481 | 18482 | 1 | 0.01% |
| instcount.NumExtractValueInst | 18290 | 18288 | -2 | -0.01% |
| instcount.NumFAddInst | 139035 | 138963 | -72 | -0.05% |
| instcount.NumFCmpInst | 10358 | 10348 | -10 | -0.10% |
| instcount.NumFDivInst | 30310 | 30302 | -8 | -0.03% |
| instcount.NumFenceInst | 387 | 387 | 0 | 0.00% |
| instcount.NumFMulInst | 93873 | 93806 | -67 | -0.07% |
| instcount.NumFPExtInst | 7148 | 7144 | -4 | -0.06% |
| instcount.NumFPToSIInst | 2823 | 2838 | 15 | 0.53% |
| instcount.NumFPToUIInst | 1251 | 1251 | 0 | 0.00% |
| instcount.NumFPTruncInst | 2195 | 2191 | -4 | -0.18% |
| instcount.NumFSubInst | 92109 | 92103 | -6 | -0.01% |
| instcount.NumGetElementPtrInst | 1221423 | 1219157 | -2266 | -0.19% |
| instcount.NumICmpInst | 479140 | 478929 | -211 | -0.04% |
| instcount.NumIndirectBrInst | 2 | 2 | 0 | 0.00% |
| instcount.NumInsertElementInst | 66089 | 66094 | 5 | 0.01% |
| instcount.NumInsertValueInst | 2032 | 2030 | -2 | -0.10% |
| instcount.NumIntToPtrInst | 19641 | 19641 | 0 | 0.00% |
| instcount.NumInvokeInst | 21789 | 21788 | -1 | 0.00% |
| instcount.NumLandingPadInst | 12051 | 12051 | 0 | 0.00% |
| instcount.NumLoadInst | 880079 | 878673 | -1406 | -0.16% |
| instcount.NumLShrInst | 25919 | 25921 | 2 | 0.01% |
| instcount.NumMulInst | 42416 | 42417 | 1 | 0.00% |
| instcount.NumOrInst | 100826 | 100576 | -250 | -0.25% |
| instcount.NumPHIInst | 315118 | 314092 | -1026 | -0.33% |
| instcount.NumPtrToIntInst | 15933 | 15939 | 6 | 0.04% |
| instcount.NumResumeInst | 2156 | 2156 | 0 | 0.00% |
| instcount.NumRetInst | 84485 | 84484 | -1 | 0.00% |
| instcount.NumSDivInst | 8599 | 8597 | -2 | -0.02% |
| instcount.NumSelectInst | 45577 | 45913 | 336 | 0.74% |
| instcount.NumSExtInst | 84026 | 78278 | -5748 | -6.84% |
| instcount.NumShlInst | 39796 | 39726 | -70 | -0.18% |
| instcount.NumShuffleVectorInst | 100272 | 100292 | 20 | 0.02% |
| instcount.NumSIToFPInst | 29131 | 29113 | -18 | -0.06% |
| instcount.NumSRemInst | 1543 | 1543 | 0 | 0.00% |
| instcount.NumStoreInst | 805394 | 804351 | -1043 | -0.13% |
| instcount.NumSubInst | 61337 | 61414 | 77 | 0.13% |
| instcount.NumSwitchInst | 8527 | 8524 | -3 | -0.04% |
| instcount.NumTruncInst | 60523 | 60484 | -39 | -0.06% |
| instcount.NumUDivInst | 2381 | 2381 | 0 | 0.00% |
| instcount.NumUIToFPInst | 5549 | 5549 | 0 | 0.00% |
| instcount.NumUnreachableInst | 9855 | 9855 | 0 | 0.00% |
| instcount.NumURemInst | 1305 | 1305 | 0 | 0.00% |
| instcount.NumXorInst | 10230 | 10081 | -149 | -1.46% |
| instcount.NumZExtInst | 60353 | 66840 | 6487 | 10.75% |
| instcount.TotalBlocks | 829582 | 829004 | -578 | -0.07% |
| instcount.TotalFuncs | 83818 | 83817 | -1 | 0.00% |
| instcount.TotalInsts | 7316574 | 7308483 | -8091 | -0.11% |
TLDR: we produce -0.11% less instructions, -6.84% less `sext`, +10.75% more `zext`.
To be noted, clearly, not all new `zext`'s are produced by this fold.
(And now i guess it might have been interesting to measure this for D68103 :S)
Reviewers: nikic, spatel, reames, dberlin
Reviewed By: nikic
Subscribers: hiraditya, jfb, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D68654
llvm-svn: 374112
2019-10-09 04:29:48 +08:00
|
|
|
static bool processSExt(SExtInst *SDI, LazyValueInfo *LVI) {
|
|
|
|
if (SDI->getType()->isVectorTy())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Value *Base = SDI->getOperand(0);
|
|
|
|
|
|
|
|
Constant *Zero = ConstantInt::get(Base->getType(), 0);
|
|
|
|
if (LVI->getPredicateAt(ICmpInst::ICMP_SGE, Base, Zero, SDI) !=
|
|
|
|
LazyValueInfo::True)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
++NumSExt;
|
|
|
|
auto *ZExt =
|
|
|
|
CastInst::CreateZExtOrBitCast(Base, SDI->getType(), SDI->getName(), SDI);
|
|
|
|
ZExt->setDebugLoc(SDI->getDebugLoc());
|
|
|
|
SDI->replaceAllUsesWith(ZExt);
|
|
|
|
SDI->eraseFromParent();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-04-20 21:14:18 +08:00
|
|
|
static bool processBinOp(BinaryOperator *BinOp, LazyValueInfo *LVI) {
|
2017-10-14 05:17:07 +08:00
|
|
|
using OBO = OverflowingBinaryOperator;
|
2016-08-10 21:08:34 +08:00
|
|
|
|
2019-04-20 21:14:18 +08:00
|
|
|
if (DontAddNoWrapFlags)
|
2017-02-24 06:29:00 +08:00
|
|
|
return false;
|
|
|
|
|
2019-04-20 21:14:18 +08:00
|
|
|
if (BinOp->getType()->isVectorTy())
|
2016-08-10 21:08:34 +08:00
|
|
|
return false;
|
|
|
|
|
2019-04-20 21:14:18 +08:00
|
|
|
bool NSW = BinOp->hasNoSignedWrap();
|
|
|
|
bool NUW = BinOp->hasNoUnsignedWrap();
|
2016-08-10 21:08:34 +08:00
|
|
|
if (NSW && NUW)
|
|
|
|
return false;
|
|
|
|
|
2019-04-20 21:14:18 +08:00
|
|
|
BasicBlock *BB = BinOp->getParent();
|
2016-08-10 21:08:34 +08:00
|
|
|
|
2019-10-18 21:20:16 +08:00
|
|
|
Instruction::BinaryOps Opcode = BinOp->getOpcode();
|
2019-04-20 21:14:18 +08:00
|
|
|
Value *LHS = BinOp->getOperand(0);
|
|
|
|
Value *RHS = BinOp->getOperand(1);
|
2016-08-10 21:08:34 +08:00
|
|
|
|
2019-05-25 22:11:55 +08:00
|
|
|
ConstantRange LRange = LVI->getConstantRange(LHS, BB, BinOp);
|
2019-04-20 21:14:18 +08:00
|
|
|
ConstantRange RRange = LVI->getConstantRange(RHS, BB, BinOp);
|
2016-08-10 21:08:34 +08:00
|
|
|
|
|
|
|
bool Changed = false;
|
2019-10-18 21:20:16 +08:00
|
|
|
bool NewNUW = false, NewNSW = false;
|
2016-08-10 21:08:34 +08:00
|
|
|
if (!NUW) {
|
2019-04-22 17:01:38 +08:00
|
|
|
ConstantRange NUWRange = ConstantRange::makeGuaranteedNoWrapRegion(
|
2019-10-18 21:20:16 +08:00
|
|
|
Opcode, RRange, OBO::NoUnsignedWrap);
|
|
|
|
NewNUW = NUWRange.contains(LRange);
|
2019-05-25 22:11:55 +08:00
|
|
|
Changed |= NewNUW;
|
2016-08-10 21:08:34 +08:00
|
|
|
}
|
|
|
|
if (!NSW) {
|
2019-04-22 17:01:38 +08:00
|
|
|
ConstantRange NSWRange = ConstantRange::makeGuaranteedNoWrapRegion(
|
2019-10-18 21:20:16 +08:00
|
|
|
Opcode, RRange, OBO::NoSignedWrap);
|
|
|
|
NewNSW = NSWRange.contains(LRange);
|
2019-05-25 22:11:55 +08:00
|
|
|
Changed |= NewNSW;
|
2016-08-10 21:08:34 +08:00
|
|
|
}
|
|
|
|
|
2019-10-18 21:20:16 +08:00
|
|
|
setDeducedOverflowingFlags(BinOp, Opcode, NewNSW, NewNUW);
|
|
|
|
|
2016-08-10 21:08:34 +08:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2019-10-11 11:48:56 +08:00
|
|
|
static bool processAnd(BinaryOperator *BinOp, LazyValueInfo *LVI) {
|
|
|
|
if (BinOp->getType()->isVectorTy())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Pattern match (and lhs, C) where C includes a superset of bits which might
|
|
|
|
// be set in lhs. This is a common truncation idiom created by instcombine.
|
|
|
|
BasicBlock *BB = BinOp->getParent();
|
|
|
|
Value *LHS = BinOp->getOperand(0);
|
|
|
|
ConstantInt *RHS = dyn_cast<ConstantInt>(BinOp->getOperand(1));
|
|
|
|
if (!RHS || !RHS->getValue().isMask())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ConstantRange LRange = LVI->getConstantRange(LHS, BB, BinOp);
|
|
|
|
if (!LRange.getUnsignedMax().ule(RHS->getValue()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
BinOp->replaceAllUsesWith(LHS);
|
|
|
|
BinOp->eraseFromParent();
|
|
|
|
NumAnd++;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-05-26 01:39:54 +08:00
|
|
|
static Constant *getConstantAt(Value *V, Instruction *At, LazyValueInfo *LVI) {
|
2015-11-04 09:43:54 +08:00
|
|
|
if (Constant *C = LVI->getConstant(V, At->getParent(), At))
|
|
|
|
return C;
|
|
|
|
|
|
|
|
// TODO: The following really should be sunk inside LVI's core algorithm, or
|
|
|
|
// at least the outer shims around such.
|
|
|
|
auto *C = dyn_cast<CmpInst>(V);
|
|
|
|
if (!C) return nullptr;
|
|
|
|
|
|
|
|
Value *Op0 = C->getOperand(0);
|
|
|
|
Constant *Op1 = dyn_cast<Constant>(C->getOperand(1));
|
|
|
|
if (!Op1) return nullptr;
|
2018-07-31 03:41:25 +08:00
|
|
|
|
2015-11-04 09:43:54 +08:00
|
|
|
LazyValueInfo::Tristate Result =
|
|
|
|
LVI->getPredicateAt(C->getPredicate(), Op0, Op1, At);
|
|
|
|
if (Result == LazyValueInfo::Unknown)
|
|
|
|
return nullptr;
|
2018-07-31 03:41:25 +08:00
|
|
|
|
2015-11-04 09:43:54 +08:00
|
|
|
return (Result == LazyValueInfo::True) ?
|
|
|
|
ConstantInt::getTrue(C->getContext()) :
|
|
|
|
ConstantInt::getFalse(C->getContext());
|
|
|
|
}
|
|
|
|
|
2018-05-21 19:06:28 +08:00
|
|
|
static bool runImpl(Function &F, LazyValueInfo *LVI, DominatorTree *DT,
|
|
|
|
const SimplifyQuery &SQ) {
|
2010-09-01 02:55:52 +08:00
|
|
|
bool FnChanged = false;
|
2017-02-08 10:48:25 +08:00
|
|
|
// Visiting in a pre-order depth-first traversal causes us to simplify early
|
|
|
|
// blocks before querying later blocks (which require us to analyze early
|
|
|
|
// blocks). Eagerly simplifying shallow blocks means there is strictly less
|
|
|
|
// work to do for deep blocks. This also means we don't visit unreachable
|
2017-12-06 01:59:07 +08:00
|
|
|
// blocks.
|
2017-02-08 10:48:25 +08:00
|
|
|
for (BasicBlock *BB : depth_first(&F.getEntryBlock())) {
|
2010-09-01 02:55:52 +08:00
|
|
|
bool BBChanged = false;
|
2016-12-31 02:00:55 +08:00
|
|
|
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
|
2015-10-14 02:26:00 +08:00
|
|
|
Instruction *II = &*BI++;
|
2010-09-04 03:08:37 +08:00
|
|
|
switch (II->getOpcode()) {
|
|
|
|
case Instruction::Select:
|
2016-05-26 01:39:54 +08:00
|
|
|
BBChanged |= processSelect(cast<SelectInst>(II), LVI);
|
2010-09-04 03:08:37 +08:00
|
|
|
break;
|
|
|
|
case Instruction::PHI:
|
2018-05-21 19:06:28 +08:00
|
|
|
BBChanged |= processPHI(cast<PHINode>(II), LVI, DT, SQ);
|
2010-09-04 03:08:37 +08:00
|
|
|
break;
|
2010-09-04 06:47:08 +08:00
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
2016-05-26 01:39:54 +08:00
|
|
|
BBChanged |= processCmp(cast<CmpInst>(II), LVI);
|
2010-09-04 06:47:08 +08:00
|
|
|
break;
|
2010-09-04 03:08:37 +08:00
|
|
|
case Instruction::Load:
|
|
|
|
case Instruction::Store:
|
2016-05-26 01:39:54 +08:00
|
|
|
BBChanged |= processMemAccess(II, LVI);
|
2010-09-04 03:08:37 +08:00
|
|
|
break;
|
2015-09-16 01:51:50 +08:00
|
|
|
case Instruction::Call:
|
|
|
|
case Instruction::Invoke:
|
2016-05-26 01:39:54 +08:00
|
|
|
BBChanged |= processCallSite(CallSite(II), LVI);
|
2015-09-16 01:51:50 +08:00
|
|
|
break;
|
2016-07-14 20:23:48 +08:00
|
|
|
case Instruction::SRem:
|
|
|
|
BBChanged |= processSRem(cast<BinaryOperator>(II), LVI);
|
|
|
|
break;
|
2016-03-14 11:24:28 +08:00
|
|
|
case Instruction::SDiv:
|
2016-05-26 01:39:54 +08:00
|
|
|
BBChanged |= processSDiv(cast<BinaryOperator>(II), LVI);
|
2016-03-14 11:24:28 +08:00
|
|
|
break;
|
2018-03-21 22:08:21 +08:00
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::URem:
|
|
|
|
BBChanged |= processUDivOrURem(cast<BinaryOperator>(II), LVI);
|
|
|
|
break;
|
2016-10-12 21:41:38 +08:00
|
|
|
case Instruction::AShr:
|
|
|
|
BBChanged |= processAShr(cast<BinaryOperator>(II), LVI);
|
|
|
|
break;
|
[CVP} Replace SExt with ZExt if the input is known-non-negative
Summary:
zero-extension is far more friendly for further analysis.
While this doesn't directly help with the shift-by-signext problem, this is not unrelated.
This has the following effect on test-suite (numbers collected after the finish of middle-end module pass manager):
| Statistic | old | new | delta | percent change |
| correlated-value-propagation.NumSExt | 0 | 6026 | 6026 | +100.00% |
| instcount.NumAddInst | 272860 | 271283 | -1577 | -0.58% |
| instcount.NumAllocaInst | 27227 | 27226 | -1 | 0.00% |
| instcount.NumAndInst | 63502 | 63320 | -182 | -0.29% |
| instcount.NumAShrInst | 13498 | 13407 | -91 | -0.67% |
| instcount.NumAtomicCmpXchgInst | 1159 | 1159 | 0 | 0.00% |
| instcount.NumAtomicRMWInst | 5036 | 5036 | 0 | 0.00% |
| instcount.NumBitCastInst | 672482 | 672353 | -129 | -0.02% |
| instcount.NumBrInst | 702768 | 702195 | -573 | -0.08% |
| instcount.NumCallInst | 518285 | 518205 | -80 | -0.02% |
| instcount.NumExtractElementInst | 18481 | 18482 | 1 | 0.01% |
| instcount.NumExtractValueInst | 18290 | 18288 | -2 | -0.01% |
| instcount.NumFAddInst | 139035 | 138963 | -72 | -0.05% |
| instcount.NumFCmpInst | 10358 | 10348 | -10 | -0.10% |
| instcount.NumFDivInst | 30310 | 30302 | -8 | -0.03% |
| instcount.NumFenceInst | 387 | 387 | 0 | 0.00% |
| instcount.NumFMulInst | 93873 | 93806 | -67 | -0.07% |
| instcount.NumFPExtInst | 7148 | 7144 | -4 | -0.06% |
| instcount.NumFPToSIInst | 2823 | 2838 | 15 | 0.53% |
| instcount.NumFPToUIInst | 1251 | 1251 | 0 | 0.00% |
| instcount.NumFPTruncInst | 2195 | 2191 | -4 | -0.18% |
| instcount.NumFSubInst | 92109 | 92103 | -6 | -0.01% |
| instcount.NumGetElementPtrInst | 1221423 | 1219157 | -2266 | -0.19% |
| instcount.NumICmpInst | 479140 | 478929 | -211 | -0.04% |
| instcount.NumIndirectBrInst | 2 | 2 | 0 | 0.00% |
| instcount.NumInsertElementInst | 66089 | 66094 | 5 | 0.01% |
| instcount.NumInsertValueInst | 2032 | 2030 | -2 | -0.10% |
| instcount.NumIntToPtrInst | 19641 | 19641 | 0 | 0.00% |
| instcount.NumInvokeInst | 21789 | 21788 | -1 | 0.00% |
| instcount.NumLandingPadInst | 12051 | 12051 | 0 | 0.00% |
| instcount.NumLoadInst | 880079 | 878673 | -1406 | -0.16% |
| instcount.NumLShrInst | 25919 | 25921 | 2 | 0.01% |
| instcount.NumMulInst | 42416 | 42417 | 1 | 0.00% |
| instcount.NumOrInst | 100826 | 100576 | -250 | -0.25% |
| instcount.NumPHIInst | 315118 | 314092 | -1026 | -0.33% |
| instcount.NumPtrToIntInst | 15933 | 15939 | 6 | 0.04% |
| instcount.NumResumeInst | 2156 | 2156 | 0 | 0.00% |
| instcount.NumRetInst | 84485 | 84484 | -1 | 0.00% |
| instcount.NumSDivInst | 8599 | 8597 | -2 | -0.02% |
| instcount.NumSelectInst | 45577 | 45913 | 336 | 0.74% |
| instcount.NumSExtInst | 84026 | 78278 | -5748 | -6.84% |
| instcount.NumShlInst | 39796 | 39726 | -70 | -0.18% |
| instcount.NumShuffleVectorInst | 100272 | 100292 | 20 | 0.02% |
| instcount.NumSIToFPInst | 29131 | 29113 | -18 | -0.06% |
| instcount.NumSRemInst | 1543 | 1543 | 0 | 0.00% |
| instcount.NumStoreInst | 805394 | 804351 | -1043 | -0.13% |
| instcount.NumSubInst | 61337 | 61414 | 77 | 0.13% |
| instcount.NumSwitchInst | 8527 | 8524 | -3 | -0.04% |
| instcount.NumTruncInst | 60523 | 60484 | -39 | -0.06% |
| instcount.NumUDivInst | 2381 | 2381 | 0 | 0.00% |
| instcount.NumUIToFPInst | 5549 | 5549 | 0 | 0.00% |
| instcount.NumUnreachableInst | 9855 | 9855 | 0 | 0.00% |
| instcount.NumURemInst | 1305 | 1305 | 0 | 0.00% |
| instcount.NumXorInst | 10230 | 10081 | -149 | -1.46% |
| instcount.NumZExtInst | 60353 | 66840 | 6487 | 10.75% |
| instcount.TotalBlocks | 829582 | 829004 | -578 | -0.07% |
| instcount.TotalFuncs | 83818 | 83817 | -1 | 0.00% |
| instcount.TotalInsts | 7316574 | 7308483 | -8091 | -0.11% |
TLDR: we produce -0.11% less instructions, -6.84% less `sext`, +10.75% more `zext`.
To be noted, clearly, not all new `zext`'s are produced by this fold.
(And now i guess it might have been interesting to measure this for D68103 :S)
Reviewers: nikic, spatel, reames, dberlin
Reviewed By: nikic
Subscribers: hiraditya, jfb, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D68654
llvm-svn: 374112
2019-10-09 04:29:48 +08:00
|
|
|
case Instruction::SExt:
|
|
|
|
BBChanged |= processSExt(cast<SExtInst>(II), LVI);
|
|
|
|
break;
|
2016-08-10 21:08:34 +08:00
|
|
|
case Instruction::Add:
|
2019-04-20 21:14:18 +08:00
|
|
|
case Instruction::Sub:
|
|
|
|
BBChanged |= processBinOp(cast<BinaryOperator>(II), LVI);
|
2016-08-10 21:08:34 +08:00
|
|
|
break;
|
2019-10-11 11:48:56 +08:00
|
|
|
case Instruction::And:
|
|
|
|
BBChanged |= processAnd(cast<BinaryOperator>(II), LVI);
|
|
|
|
break;
|
2010-09-04 03:08:37 +08:00
|
|
|
}
|
2010-08-28 07:31:36 +08:00
|
|
|
}
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2016-12-31 02:00:55 +08:00
|
|
|
Instruction *Term = BB->getTerminator();
|
2012-03-09 21:45:18 +08:00
|
|
|
switch (Term->getOpcode()) {
|
|
|
|
case Instruction::Switch:
|
2018-06-17 02:57:31 +08:00
|
|
|
BBChanged |= processSwitch(cast<SwitchInst>(Term), LVI, DT);
|
2012-03-09 21:45:18 +08:00
|
|
|
break;
|
2015-11-04 09:43:54 +08:00
|
|
|
case Instruction::Ret: {
|
|
|
|
auto *RI = cast<ReturnInst>(Term);
|
|
|
|
// Try to determine the return value if we can. This is mainly here to
|
|
|
|
// simplify the writing of unit tests, but also helps to enable IPO by
|
|
|
|
// constant folding the return values of callees.
|
|
|
|
auto *RetVal = RI->getReturnValue();
|
|
|
|
if (!RetVal) break; // handle "ret void"
|
|
|
|
if (isa<Constant>(RetVal)) break; // nothing to do
|
2016-05-26 01:39:54 +08:00
|
|
|
if (auto *C = getConstantAt(RetVal, RI, LVI)) {
|
2015-11-04 09:43:54 +08:00
|
|
|
++NumReturns;
|
|
|
|
RI->replaceUsesOfWith(RetVal, C);
|
2018-07-31 03:41:25 +08:00
|
|
|
BBChanged = true;
|
2015-11-04 09:43:54 +08:00
|
|
|
}
|
2012-03-09 21:45:18 +08:00
|
|
|
}
|
2017-06-16 09:53:20 +08:00
|
|
|
}
|
2012-03-09 21:45:18 +08:00
|
|
|
|
2010-09-01 02:55:52 +08:00
|
|
|
FnChanged |= BBChanged;
|
2010-08-31 15:55:56 +08:00
|
|
|
}
|
2010-12-15 08:52:44 +08:00
|
|
|
|
2010-09-01 02:55:52 +08:00
|
|
|
return FnChanged;
|
2010-08-28 08:11:12 +08:00
|
|
|
}
|
2016-07-07 07:26:29 +08:00
|
|
|
|
|
|
|
bool CorrelatedValuePropagation::runOnFunction(Function &F) {
|
|
|
|
if (skipFunction(F))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
LazyValueInfo *LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
|
2018-05-21 19:06:28 +08:00
|
|
|
DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
|
|
|
|
|
|
|
|
return runImpl(F, LVI, DT, getBestSimplifyQuery(*this, F));
|
2016-07-07 07:26:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
PreservedAnalyses
|
|
|
|
CorrelatedValuePropagationPass::run(Function &F, FunctionAnalysisManager &AM) {
|
|
|
|
LazyValueInfo *LVI = &AM.getResult<LazyValueAnalysis>(F);
|
2018-05-21 19:06:28 +08:00
|
|
|
DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
|
|
|
|
|
|
|
|
bool Changed = runImpl(F, LVI, DT, getBestSimplifyQuery(AM, F));
|
2016-07-07 07:26:29 +08:00
|
|
|
|
|
|
|
if (!Changed)
|
|
|
|
return PreservedAnalyses::all();
|
|
|
|
PreservedAnalyses PA;
|
|
|
|
PA.preserve<GlobalsAA>();
|
2018-06-17 02:57:31 +08:00
|
|
|
PA.preserve<DominatorTreeAnalysis>();
|
2019-07-25 04:27:32 +08:00
|
|
|
PA.preserve<LazyValueAnalysis>();
|
2016-07-07 07:26:29 +08:00
|
|
|
return PA;
|
|
|
|
}
|