2015-06-27 00:57:30 +08:00
|
|
|
//===----------- VectorUtils.cpp - Vectorizer utility functions -----------===//
|
|
|
|
//
|
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
|
2015-06-27 00:57:30 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines vectorizer utilities.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/Analysis/VectorUtils.h"
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
#include "llvm/ADT/EquivalenceClasses.h"
|
|
|
|
#include "llvm/Analysis/DemandedBits.h"
|
2015-07-11 18:52:42 +08:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2018-09-12 16:01:57 +08:00
|
|
|
#include "llvm/Analysis/LoopIterator.h"
|
2015-07-11 18:52:42 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolution.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
2016-04-20 03:10:21 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
2015-07-11 18:52:42 +08:00
|
|
|
#include "llvm/IR/GetElementPtrTypeIterator.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2015-07-11 18:52:42 +08:00
|
|
|
#include "llvm/IR/PatternMatch.h"
|
|
|
|
#include "llvm/IR/Value.h"
|
2015-08-30 18:49:04 +08:00
|
|
|
|
2018-09-12 16:01:57 +08:00
|
|
|
#define DEBUG_TYPE "vectorutils"
|
|
|
|
|
2015-08-19 06:07:20 +08:00
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::PatternMatch;
|
2015-06-27 00:57:30 +08:00
|
|
|
|
2018-09-12 16:01:57 +08:00
|
|
|
/// Maximum factor for an interleaved memory access.
|
|
|
|
static cl::opt<unsigned> MaxInterleaveGroupFactor(
|
|
|
|
"max-interleave-group-factor", cl::Hidden,
|
|
|
|
cl::desc("Maximum factor for an interleaved access group (default = 8)"),
|
|
|
|
cl::init(8));
|
|
|
|
|
2018-11-12 23:10:30 +08:00
|
|
|
/// Return true if all of the intrinsic's arguments and return type are scalars
|
|
|
|
/// for the scalar form of the intrinsic and vectors for the vector form of the
|
|
|
|
/// intrinsic.
|
2015-06-27 00:57:30 +08:00
|
|
|
bool llvm::isTriviallyVectorizable(Intrinsic::ID ID) {
|
|
|
|
switch (ID) {
|
2018-11-12 23:10:30 +08:00
|
|
|
case Intrinsic::bswap: // Begin integer bit-manipulation.
|
|
|
|
case Intrinsic::bitreverse:
|
|
|
|
case Intrinsic::ctpop:
|
|
|
|
case Intrinsic::ctlz:
|
|
|
|
case Intrinsic::cttz:
|
2018-11-12 23:20:14 +08:00
|
|
|
case Intrinsic::fshl:
|
|
|
|
case Intrinsic::fshr:
|
2019-01-23 21:49:10 +08:00
|
|
|
case Intrinsic::sadd_sat:
|
|
|
|
case Intrinsic::ssub_sat:
|
|
|
|
case Intrinsic::uadd_sat:
|
|
|
|
case Intrinsic::usub_sat:
|
2019-02-25 23:42:02 +08:00
|
|
|
case Intrinsic::smul_fix:
|
|
|
|
case Intrinsic::umul_fix:
|
2018-11-12 23:10:30 +08:00
|
|
|
case Intrinsic::sqrt: // Begin floating-point.
|
2015-06-27 00:57:30 +08:00
|
|
|
case Intrinsic::sin:
|
|
|
|
case Intrinsic::cos:
|
|
|
|
case Intrinsic::exp:
|
|
|
|
case Intrinsic::exp2:
|
|
|
|
case Intrinsic::log:
|
|
|
|
case Intrinsic::log10:
|
|
|
|
case Intrinsic::log2:
|
|
|
|
case Intrinsic::fabs:
|
|
|
|
case Intrinsic::minnum:
|
|
|
|
case Intrinsic::maxnum:
|
2018-10-20 05:11:43 +08:00
|
|
|
case Intrinsic::minimum:
|
|
|
|
case Intrinsic::maximum:
|
2015-06-27 00:57:30 +08:00
|
|
|
case Intrinsic::copysign:
|
|
|
|
case Intrinsic::floor:
|
|
|
|
case Intrinsic::ceil:
|
|
|
|
case Intrinsic::trunc:
|
|
|
|
case Intrinsic::rint:
|
|
|
|
case Intrinsic::nearbyint:
|
|
|
|
case Intrinsic::round:
|
|
|
|
case Intrinsic::pow:
|
|
|
|
case Intrinsic::fma:
|
|
|
|
case Intrinsic::fmuladd:
|
|
|
|
case Intrinsic::powi:
|
2018-09-17 21:24:30 +08:00
|
|
|
case Intrinsic::canonicalize:
|
2015-06-27 00:57:30 +08:00
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Identifies if the intrinsic has a scalar operand. It check for
|
2015-06-27 00:57:30 +08:00
|
|
|
/// ctlz,cttz and powi special intrinsics whose argument is scalar.
|
|
|
|
bool llvm::hasVectorInstrinsicScalarOpd(Intrinsic::ID ID,
|
|
|
|
unsigned ScalarOpdIdx) {
|
|
|
|
switch (ID) {
|
|
|
|
case Intrinsic::ctlz:
|
|
|
|
case Intrinsic::cttz:
|
|
|
|
case Intrinsic::powi:
|
|
|
|
return (ScalarOpdIdx == 1);
|
2019-02-25 23:42:02 +08:00
|
|
|
case Intrinsic::smul_fix:
|
|
|
|
case Intrinsic::umul_fix:
|
|
|
|
return (ScalarOpdIdx == 2);
|
2015-06-27 00:57:30 +08:00
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Returns intrinsic ID for call.
|
2015-06-27 00:57:30 +08:00
|
|
|
/// For the input call instruction it finds mapping intrinsic and returns
|
|
|
|
/// its ID, in case it does not found it return not_intrinsic.
|
2016-04-20 03:10:21 +08:00
|
|
|
Intrinsic::ID llvm::getVectorIntrinsicIDForCall(const CallInst *CI,
|
|
|
|
const TargetLibraryInfo *TLI) {
|
|
|
|
Intrinsic::ID ID = getIntrinsicForCallSite(CI, TLI);
|
|
|
|
if (ID == Intrinsic::not_intrinsic)
|
2015-06-27 00:57:30 +08:00
|
|
|
return Intrinsic::not_intrinsic;
|
|
|
|
|
2016-04-20 03:10:21 +08:00
|
|
|
if (isTriviallyVectorizable(ID) || ID == Intrinsic::lifetime_start ||
|
Add an @llvm.sideeffect intrinsic
This patch implements Chandler's idea [0] for supporting languages that
require support for infinite loops with side effects, such as Rust, providing
part of a solution to bug 965 [1].
Specifically, it adds an `llvm.sideeffect()` intrinsic, which has no actual
effect, but which appears to optimization passes to have obscure side effects,
such that they don't optimize away loops containing it. It also teaches
several optimization passes to ignore this intrinsic, so that it doesn't
significantly impact optimization in most cases.
As discussed on llvm-dev [2], this patch is the first of two major parts.
The second part, to change LLVM's semantics to have defined behavior
on infinite loops by default, with a function attribute for opting into
potential-undefined-behavior, will be implemented and posted for review in
a separate patch.
[0] http://lists.llvm.org/pipermail/llvm-dev/2015-July/088103.html
[1] https://bugs.llvm.org/show_bug.cgi?id=965
[2] http://lists.llvm.org/pipermail/llvm-dev/2017-October/118632.html
Differential Revision: https://reviews.llvm.org/D38336
llvm-svn: 317729
2017-11-09 05:59:51 +08:00
|
|
|
ID == Intrinsic::lifetime_end || ID == Intrinsic::assume ||
|
|
|
|
ID == Intrinsic::sideeffect)
|
2016-04-20 03:10:21 +08:00
|
|
|
return ID;
|
2015-06-27 00:57:30 +08:00
|
|
|
return Intrinsic::not_intrinsic;
|
|
|
|
}
|
2015-07-11 18:52:42 +08:00
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Find the operand of the GEP that should be checked for consecutive
|
2015-07-11 18:52:42 +08:00
|
|
|
/// stores. This ignores trailing indices that have no effect on the final
|
|
|
|
/// pointer.
|
|
|
|
unsigned llvm::getGEPInductionOperand(const GetElementPtrInst *Gep) {
|
|
|
|
const DataLayout &DL = Gep->getModule()->getDataLayout();
|
|
|
|
unsigned LastOperand = Gep->getNumOperands() - 1;
|
2016-01-20 01:28:00 +08:00
|
|
|
unsigned GEPAllocSize = DL.getTypeAllocSize(Gep->getResultElementType());
|
2015-07-11 18:52:42 +08:00
|
|
|
|
|
|
|
// Walk backwards and try to peel off zeros.
|
2015-08-19 06:07:20 +08:00
|
|
|
while (LastOperand > 1 && match(Gep->getOperand(LastOperand), m_Zero())) {
|
2015-07-11 18:52:42 +08:00
|
|
|
// Find the type we're currently indexing into.
|
|
|
|
gep_type_iterator GEPTI = gep_type_begin(Gep);
|
2016-12-02 10:24:42 +08:00
|
|
|
std::advance(GEPTI, LastOperand - 2);
|
2015-07-11 18:52:42 +08:00
|
|
|
|
|
|
|
// If it's a type with the same allocation size as the result of the GEP we
|
|
|
|
// can peel off the zero index.
|
2016-12-02 10:24:42 +08:00
|
|
|
if (DL.getTypeAllocSize(GEPTI.getIndexedType()) != GEPAllocSize)
|
2015-07-11 18:52:42 +08:00
|
|
|
break;
|
|
|
|
--LastOperand;
|
|
|
|
}
|
|
|
|
|
|
|
|
return LastOperand;
|
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// If the argument is a GEP, then returns the operand identified by
|
2015-07-11 18:52:42 +08:00
|
|
|
/// getGEPInductionOperand. However, if there is some other non-loop-invariant
|
|
|
|
/// operand, it returns that instead.
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *llvm::stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
|
2015-07-11 18:52:42 +08:00
|
|
|
GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr);
|
|
|
|
if (!GEP)
|
|
|
|
return Ptr;
|
|
|
|
|
|
|
|
unsigned InductionOperand = getGEPInductionOperand(GEP);
|
|
|
|
|
|
|
|
// Check that all of the gep indices are uniform except for our induction
|
|
|
|
// operand.
|
|
|
|
for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
|
|
|
|
if (i != InductionOperand &&
|
|
|
|
!SE->isLoopInvariant(SE->getSCEV(GEP->getOperand(i)), Lp))
|
|
|
|
return Ptr;
|
|
|
|
return GEP->getOperand(InductionOperand);
|
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// If a value has only one user that is a CastInst, return it.
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *llvm::getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty) {
|
|
|
|
Value *UniqueCast = nullptr;
|
2015-07-11 18:52:42 +08:00
|
|
|
for (User *U : Ptr->users()) {
|
|
|
|
CastInst *CI = dyn_cast<CastInst>(U);
|
|
|
|
if (CI && CI->getType() == Ty) {
|
|
|
|
if (!UniqueCast)
|
|
|
|
UniqueCast = CI;
|
|
|
|
else
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return UniqueCast;
|
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Get the stride of a pointer access in a loop. Looks for symbolic
|
2015-07-11 18:52:42 +08:00
|
|
|
/// strides "a[i*stride]". Returns the symbolic stride, or null otherwise.
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *llvm::getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
|
2015-08-02 06:20:21 +08:00
|
|
|
auto *PtrTy = dyn_cast<PointerType>(Ptr->getType());
|
2015-07-11 18:52:42 +08:00
|
|
|
if (!PtrTy || PtrTy->isAggregateType())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Try to remove a gep instruction to make the pointer (actually index at this
|
2018-03-01 03:08:52 +08:00
|
|
|
// point) easier analyzable. If OrigPtr is equal to Ptr we are analyzing the
|
2015-07-11 18:52:42 +08:00
|
|
|
// pointer, otherwise, we are analyzing the index.
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *OrigPtr = Ptr;
|
2015-07-11 18:52:42 +08:00
|
|
|
|
|
|
|
// The size of the pointer access.
|
|
|
|
int64_t PtrAccessSize = 1;
|
|
|
|
|
|
|
|
Ptr = stripGetElementPtr(Ptr, SE, Lp);
|
|
|
|
const SCEV *V = SE->getSCEV(Ptr);
|
|
|
|
|
|
|
|
if (Ptr != OrigPtr)
|
|
|
|
// Strip off casts.
|
|
|
|
while (const SCEVCastExpr *C = dyn_cast<SCEVCastExpr>(V))
|
|
|
|
V = C->getOperand();
|
|
|
|
|
|
|
|
const SCEVAddRecExpr *S = dyn_cast<SCEVAddRecExpr>(V);
|
|
|
|
if (!S)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
V = S->getStepRecurrence(*SE);
|
|
|
|
if (!V)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// Strip off the size of access multiplication if we are still analyzing the
|
|
|
|
// pointer.
|
|
|
|
if (OrigPtr == Ptr) {
|
|
|
|
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(V)) {
|
|
|
|
if (M->getOperand(0)->getSCEVType() != scConstant)
|
|
|
|
return nullptr;
|
|
|
|
|
2015-12-18 04:28:46 +08:00
|
|
|
const APInt &APStepVal = cast<SCEVConstant>(M->getOperand(0))->getAPInt();
|
2015-07-11 18:52:42 +08:00
|
|
|
|
|
|
|
// Huge step value - give up.
|
|
|
|
if (APStepVal.getBitWidth() > 64)
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
int64_t StepVal = APStepVal.getSExtValue();
|
|
|
|
if (PtrAccessSize != StepVal)
|
|
|
|
return nullptr;
|
|
|
|
V = M->getOperand(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Strip off casts.
|
|
|
|
Type *StripedOffRecurrenceCast = nullptr;
|
|
|
|
if (const SCEVCastExpr *C = dyn_cast<SCEVCastExpr>(V)) {
|
|
|
|
StripedOffRecurrenceCast = C->getType();
|
|
|
|
V = C->getOperand();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for the loop invariant symbolic value.
|
|
|
|
const SCEVUnknown *U = dyn_cast<SCEVUnknown>(V);
|
|
|
|
if (!U)
|
|
|
|
return nullptr;
|
|
|
|
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *Stride = U->getValue();
|
2015-07-11 18:52:42 +08:00
|
|
|
if (!Lp->isLoopInvariant(Stride))
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// If we have stripped off the recurrence cast we have to make sure that we
|
|
|
|
// return the value that is used in this loop so that we can replace it later.
|
|
|
|
if (StripedOffRecurrenceCast)
|
|
|
|
Stride = getUniqueCastUse(Stride, Lp, StripedOffRecurrenceCast);
|
|
|
|
|
|
|
|
return Stride;
|
|
|
|
}
|
2015-07-13 09:15:53 +08:00
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Given a vector and an element number, see if the scalar value is
|
2015-07-13 09:15:53 +08:00
|
|
|
/// already around as a register, for example if it were inserted then extracted
|
|
|
|
/// from the vector.
|
2015-08-19 06:07:20 +08:00
|
|
|
Value *llvm::findScalarElement(Value *V, unsigned EltNo) {
|
2015-07-13 09:15:53 +08:00
|
|
|
assert(V->getType()->isVectorTy() && "Not looking at a vector?");
|
|
|
|
VectorType *VTy = cast<VectorType>(V->getType());
|
|
|
|
unsigned Width = VTy->getNumElements();
|
|
|
|
if (EltNo >= Width) // Out of range access.
|
|
|
|
return UndefValue::get(VTy->getElementType());
|
|
|
|
|
|
|
|
if (Constant *C = dyn_cast<Constant>(V))
|
|
|
|
return C->getAggregateElement(EltNo);
|
|
|
|
|
|
|
|
if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) {
|
|
|
|
// If this is an insert to a variable element, we don't know what it is.
|
|
|
|
if (!isa<ConstantInt>(III->getOperand(2)))
|
|
|
|
return nullptr;
|
|
|
|
unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue();
|
|
|
|
|
|
|
|
// If this is an insert to the element we are looking for, return the
|
|
|
|
// inserted value.
|
|
|
|
if (EltNo == IIElt)
|
|
|
|
return III->getOperand(1);
|
|
|
|
|
|
|
|
// Otherwise, the insertelement doesn't modify the value, recurse on its
|
|
|
|
// vector input.
|
|
|
|
return findScalarElement(III->getOperand(0), EltNo);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) {
|
|
|
|
unsigned LHSWidth = SVI->getOperand(0)->getType()->getVectorNumElements();
|
|
|
|
int InEl = SVI->getMaskValue(EltNo);
|
|
|
|
if (InEl < 0)
|
|
|
|
return UndefValue::get(VTy->getElementType());
|
|
|
|
if (InEl < (int)LHSWidth)
|
|
|
|
return findScalarElement(SVI->getOperand(0), InEl);
|
|
|
|
return findScalarElement(SVI->getOperand(1), InEl - LHSWidth);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Extract a value from a vector add operation with a constant zero.
|
2018-09-25 01:18:32 +08:00
|
|
|
// TODO: Use getBinOpIdentity() to generalize this.
|
|
|
|
Value *Val; Constant *C;
|
|
|
|
if (match(V, m_Add(m_Value(Val), m_Constant(C))))
|
|
|
|
if (Constant *Elt = C->getAggregateElement(EltNo))
|
2015-08-19 06:07:25 +08:00
|
|
|
if (Elt->isNullValue())
|
|
|
|
return findScalarElement(Val, EltNo);
|
2015-07-13 09:15:53 +08:00
|
|
|
|
|
|
|
// Otherwise, we don't know.
|
|
|
|
return nullptr;
|
|
|
|
}
|
2015-08-30 18:49:04 +08:00
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Get splat value if the input is a splat vector or return nullptr.
|
2015-08-30 21:48:02 +08:00
|
|
|
/// This function is not fully general. It checks only 2 cases:
|
|
|
|
/// the input value is (1) a splat constants vector or (2) a sequence
|
|
|
|
/// of instructions that broadcast a single value into a vector.
|
|
|
|
///
|
2015-12-01 20:08:36 +08:00
|
|
|
const llvm::Value *llvm::getSplatValue(const Value *V) {
|
|
|
|
|
|
|
|
if (auto *C = dyn_cast<Constant>(V))
|
2015-12-01 20:30:40 +08:00
|
|
|
if (isa<VectorType>(V->getType()))
|
|
|
|
return C->getSplatValue();
|
2015-08-30 21:48:02 +08:00
|
|
|
|
|
|
|
auto *ShuffleInst = dyn_cast<ShuffleVectorInst>(V);
|
2015-08-30 18:49:04 +08:00
|
|
|
if (!ShuffleInst)
|
|
|
|
return nullptr;
|
2015-08-30 21:48:02 +08:00
|
|
|
// All-zero (or undef) shuffle mask elements.
|
|
|
|
for (int MaskElt : ShuffleInst->getShuffleMask())
|
|
|
|
if (MaskElt != 0 && MaskElt != -1)
|
2015-08-30 18:49:04 +08:00
|
|
|
return nullptr;
|
|
|
|
// The first shuffle source is 'insertelement' with index 0.
|
2015-08-30 21:48:02 +08:00
|
|
|
auto *InsertEltInst =
|
|
|
|
dyn_cast<InsertElementInst>(ShuffleInst->getOperand(0));
|
2015-08-30 18:49:04 +08:00
|
|
|
if (!InsertEltInst || !isa<ConstantInt>(InsertEltInst->getOperand(2)) ||
|
2017-07-07 02:39:47 +08:00
|
|
|
!cast<ConstantInt>(InsertEltInst->getOperand(2))->isZero())
|
2015-08-30 18:49:04 +08:00
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
return InsertEltInst->getOperand(1);
|
|
|
|
}
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
|
2015-11-27 04:39:51 +08:00
|
|
|
MapVector<Instruction *, uint64_t>
|
2015-11-09 22:32:05 +08:00
|
|
|
llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
|
|
|
|
const TargetTransformInfo *TTI) {
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
|
|
|
|
// DemandedBits will give us every value's live-out bits. But we want
|
|
|
|
// to ensure no extra casts would need to be inserted, so every DAG
|
|
|
|
// of connected values must have the same minimum bitwidth.
|
2015-11-09 22:32:05 +08:00
|
|
|
EquivalenceClasses<Value *> ECs;
|
|
|
|
SmallVector<Value *, 16> Worklist;
|
|
|
|
SmallPtrSet<Value *, 4> Roots;
|
|
|
|
SmallPtrSet<Value *, 16> Visited;
|
|
|
|
DenseMap<Value *, uint64_t> DBits;
|
|
|
|
SmallPtrSet<Instruction *, 4> InstructionSet;
|
2015-11-27 04:39:51 +08:00
|
|
|
MapVector<Instruction *, uint64_t> MinBWs;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
// Determine the roots. We work bottom-up, from truncs or icmps.
|
|
|
|
bool SeenExtFromIllegalType = false;
|
|
|
|
for (auto *BB : Blocks)
|
|
|
|
for (auto &I : *BB) {
|
|
|
|
InstructionSet.insert(&I);
|
|
|
|
|
|
|
|
if (TTI && (isa<ZExtInst>(&I) || isa<SExtInst>(&I)) &&
|
|
|
|
!TTI->isTypeLegal(I.getOperand(0)->getType()))
|
|
|
|
SeenExtFromIllegalType = true;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
// Only deal with non-vector integers up to 64-bits wide.
|
|
|
|
if ((isa<TruncInst>(&I) || isa<ICmpInst>(&I)) &&
|
|
|
|
!I.getType()->isVectorTy() &&
|
|
|
|
I.getOperand(0)->getType()->getScalarSizeInBits() <= 64) {
|
|
|
|
// Don't make work for ourselves. If we know the loaded type is legal,
|
|
|
|
// don't add it to the worklist.
|
|
|
|
if (TTI && isa<TruncInst>(&I) && TTI->isTypeLegal(I.getType()))
|
|
|
|
continue;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
Worklist.push_back(&I);
|
|
|
|
Roots.insert(&I);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Early exit.
|
|
|
|
if (Worklist.empty() || (TTI && !SeenExtFromIllegalType))
|
|
|
|
return MinBWs;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
// Now proceed breadth-first, unioning values together.
|
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Value *Val = Worklist.pop_back_val();
|
|
|
|
Value *Leader = ECs.getOrInsertLeaderValue(Val);
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
if (Visited.count(Val))
|
|
|
|
continue;
|
|
|
|
Visited.insert(Val);
|
|
|
|
|
|
|
|
// Non-instructions terminate a chain successfully.
|
|
|
|
if (!isa<Instruction>(Val))
|
|
|
|
continue;
|
|
|
|
Instruction *I = cast<Instruction>(Val);
|
|
|
|
|
|
|
|
// If we encounter a type that is larger than 64 bits, we can't represent
|
|
|
|
// it so bail out.
|
2016-05-10 20:27:23 +08:00
|
|
|
if (DB.getDemandedBits(I).getBitWidth() > 64)
|
2015-11-27 04:39:51 +08:00
|
|
|
return MapVector<Instruction *, uint64_t>();
|
2015-11-09 22:32:05 +08:00
|
|
|
|
2016-05-10 20:27:23 +08:00
|
|
|
uint64_t V = DB.getDemandedBits(I).getZExtValue();
|
|
|
|
DBits[Leader] |= V;
|
|
|
|
DBits[I] = V;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
// Casts, loads and instructions outside of our range terminate a chain
|
|
|
|
// successfully.
|
|
|
|
if (isa<SExtInst>(I) || isa<ZExtInst>(I) || isa<LoadInst>(I) ||
|
|
|
|
!InstructionSet.count(I))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Unsafe casts terminate a chain unsuccessfully. We can't do anything
|
|
|
|
// useful with bitcasts, ptrtoints or inttoptrs and it'd be unsafe to
|
|
|
|
// transform anything that relies on them.
|
|
|
|
if (isa<BitCastInst>(I) || isa<PtrToIntInst>(I) || isa<IntToPtrInst>(I) ||
|
|
|
|
!I->getType()->isIntegerTy()) {
|
|
|
|
DBits[Leader] |= ~0ULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We don't modify the types of PHIs. Reductions will already have been
|
|
|
|
// truncated if possible, and inductions' sizes will have been chosen by
|
|
|
|
// indvars.
|
|
|
|
if (isa<PHINode>(I))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (DBits[Leader] == ~0ULL)
|
|
|
|
// All bits demanded, no point continuing.
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (Value *O : cast<User>(I)->operands()) {
|
|
|
|
ECs.unionSets(Leader, O);
|
|
|
|
Worklist.push_back(O);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we've discovered all values, walk them to see if there are
|
|
|
|
// any users we didn't see. If there are, we can't optimize that
|
|
|
|
// chain.
|
|
|
|
for (auto &I : DBits)
|
|
|
|
for (auto *U : I.first->users())
|
|
|
|
if (U->getType()->isIntegerTy() && DBits.count(U) == 0)
|
|
|
|
DBits[ECs.getOrInsertLeaderValue(I.first)] |= ~0ULL;
|
2015-11-09 22:32:05 +08:00
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
for (auto I = ECs.begin(), E = ECs.end(); I != E; ++I) {
|
|
|
|
uint64_t LeaderDemandedBits = 0;
|
|
|
|
for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI)
|
|
|
|
LeaderDemandedBits |= DBits[*MI];
|
|
|
|
|
|
|
|
uint64_t MinBW = (sizeof(LeaderDemandedBits) * 8) -
|
|
|
|
llvm::countLeadingZeros(LeaderDemandedBits);
|
|
|
|
// Round up to a power of 2
|
|
|
|
if (!isPowerOf2_64((uint64_t)MinBW))
|
|
|
|
MinBW = NextPowerOf2(MinBW);
|
2016-03-30 18:11:43 +08:00
|
|
|
|
|
|
|
// We don't modify the types of PHIs. Reductions will already have been
|
|
|
|
// truncated if possible, and inductions' sizes will have been chosen by
|
|
|
|
// indvars.
|
|
|
|
// If we are required to shrink a PHI, abandon this entire equivalence class.
|
|
|
|
bool Abort = false;
|
|
|
|
for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI)
|
|
|
|
if (isa<PHINode>(*MI) && MinBW < (*MI)->getType()->getScalarSizeInBits()) {
|
|
|
|
Abort = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (Abort)
|
|
|
|
continue;
|
|
|
|
|
[LoopVectorize] Shrink integer operations into the smallest type possible
C semantics force sub-int-sized values (e.g. i8, i16) to be promoted to int
type (e.g. i32) whenever arithmetic is performed on them.
For targets with native i8 or i16 operations, usually InstCombine can shrink
the arithmetic type down again. However InstCombine refuses to create illegal
types, so for targets without i8 or i16 registers, the lengthening and
shrinking remains.
Most SIMD ISAs (e.g. NEON) however support vectors of i8 or i16 even when
their scalar equivalents do not, so during vectorization it is important to
remove these lengthens and truncates when deciding the profitability of
vectorization.
The algorithm this uses starts at truncs and icmps, trawling their use-def
chains until they terminate or instructions outside the loop are found (or
unsafe instructions like inttoptr casts are found). If the use-def chains
starting from different root instructions (truncs/icmps) meet, they are
unioned. The demanded bits of each node in the graph are ORed together to form
an overall mask of the demanded bits in the entire graph. The minimum bitwidth
that graph can be truncated to is the bitwidth minus the number of leading
zeroes in the overall mask.
The intention is that this algorithm should "first do no harm", so it will
never insert extra cast instructions. This is why the use-def graphs are
unioned, so that subgraphs with different minimum bitwidths do not need casts
inserted between them.
This algorithm works hard to reduce compile time impact. DemandedBits are only
queried if there are extends of illegal types and if a truncate to an illegal
type is seen. In the general case, this results in a simple linear scan of the
instructions in the loop.
No non-noise compile time impact was seen on a clang bootstrap build.
llvm-svn: 250032
2015-10-12 20:34:45 +08:00
|
|
|
for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI) {
|
|
|
|
if (!isa<Instruction>(*MI))
|
|
|
|
continue;
|
|
|
|
Type *Ty = (*MI)->getType();
|
|
|
|
if (Roots.count(*MI))
|
|
|
|
Ty = cast<Instruction>(*MI)->getOperand(0)->getType();
|
|
|
|
if (MinBW < Ty->getScalarSizeInBits())
|
|
|
|
MinBWs[cast<Instruction>(*MI)] = MinBW;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return MinBWs;
|
|
|
|
}
|
2016-07-01 05:17:59 +08:00
|
|
|
|
2018-12-20 12:58:07 +08:00
|
|
|
/// Add all access groups in @p AccGroups to @p List.
|
|
|
|
template <typename ListT>
|
|
|
|
static void addToAccessGroupList(ListT &List, MDNode *AccGroups) {
|
|
|
|
// Interpret an access group as a list containing itself.
|
|
|
|
if (AccGroups->getNumOperands() == 0) {
|
|
|
|
assert(isValidAsAccessGroup(AccGroups) && "Node must be an access group");
|
|
|
|
List.insert(AccGroups);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto &AccGroupListOp : AccGroups->operands()) {
|
|
|
|
auto *Item = cast<MDNode>(AccGroupListOp.get());
|
|
|
|
assert(isValidAsAccessGroup(Item) && "List item must be an access group");
|
|
|
|
List.insert(Item);
|
|
|
|
}
|
2018-12-20 17:20:07 +08:00
|
|
|
}
|
2018-12-20 12:58:07 +08:00
|
|
|
|
|
|
|
MDNode *llvm::uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2) {
|
|
|
|
if (!AccGroups1)
|
|
|
|
return AccGroups2;
|
|
|
|
if (!AccGroups2)
|
|
|
|
return AccGroups1;
|
|
|
|
if (AccGroups1 == AccGroups2)
|
|
|
|
return AccGroups1;
|
|
|
|
|
|
|
|
SmallSetVector<Metadata *, 4> Union;
|
|
|
|
addToAccessGroupList(Union, AccGroups1);
|
|
|
|
addToAccessGroupList(Union, AccGroups2);
|
|
|
|
|
|
|
|
if (Union.size() == 0)
|
|
|
|
return nullptr;
|
|
|
|
if (Union.size() == 1)
|
|
|
|
return cast<MDNode>(Union.front());
|
|
|
|
|
|
|
|
LLVMContext &Ctx = AccGroups1->getContext();
|
|
|
|
return MDNode::get(Ctx, Union.getArrayRef());
|
|
|
|
}
|
|
|
|
|
|
|
|
MDNode *llvm::intersectAccessGroups(const Instruction *Inst1,
|
|
|
|
const Instruction *Inst2) {
|
|
|
|
bool MayAccessMem1 = Inst1->mayReadOrWriteMemory();
|
|
|
|
bool MayAccessMem2 = Inst2->mayReadOrWriteMemory();
|
|
|
|
|
|
|
|
if (!MayAccessMem1 && !MayAccessMem2)
|
|
|
|
return nullptr;
|
|
|
|
if (!MayAccessMem1)
|
|
|
|
return Inst2->getMetadata(LLVMContext::MD_access_group);
|
|
|
|
if (!MayAccessMem2)
|
|
|
|
return Inst1->getMetadata(LLVMContext::MD_access_group);
|
|
|
|
|
|
|
|
MDNode *MD1 = Inst1->getMetadata(LLVMContext::MD_access_group);
|
|
|
|
MDNode *MD2 = Inst2->getMetadata(LLVMContext::MD_access_group);
|
|
|
|
if (!MD1 || !MD2)
|
|
|
|
return nullptr;
|
|
|
|
if (MD1 == MD2)
|
|
|
|
return MD1;
|
|
|
|
|
|
|
|
// Use set for scalable 'contains' check.
|
|
|
|
SmallPtrSet<Metadata *, 4> AccGroupSet2;
|
|
|
|
addToAccessGroupList(AccGroupSet2, MD2);
|
|
|
|
|
|
|
|
SmallVector<Metadata *, 4> Intersection;
|
|
|
|
if (MD1->getNumOperands() == 0) {
|
|
|
|
assert(isValidAsAccessGroup(MD1) && "Node must be an access group");
|
|
|
|
if (AccGroupSet2.count(MD1))
|
|
|
|
Intersection.push_back(MD1);
|
|
|
|
} else {
|
|
|
|
for (const MDOperand &Node : MD1->operands()) {
|
|
|
|
auto *Item = cast<MDNode>(Node.get());
|
|
|
|
assert(isValidAsAccessGroup(Item) && "List item must be an access group");
|
|
|
|
if (AccGroupSet2.count(Item))
|
|
|
|
Intersection.push_back(Item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Intersection.size() == 0)
|
|
|
|
return nullptr;
|
|
|
|
if (Intersection.size() == 1)
|
|
|
|
return cast<MDNode>(Intersection.front());
|
|
|
|
|
|
|
|
LLVMContext &Ctx = Inst1->getContext();
|
|
|
|
return MDNode::get(Ctx, Intersection);
|
|
|
|
}
|
|
|
|
|
2016-07-01 05:17:59 +08:00
|
|
|
/// \returns \p I after propagating metadata from \p VL.
|
|
|
|
Instruction *llvm::propagateMetadata(Instruction *Inst, ArrayRef<Value *> VL) {
|
|
|
|
Instruction *I0 = cast<Instruction>(VL[0]);
|
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
|
|
|
|
I0->getAllMetadataOtherThanDebugLoc(Metadata);
|
|
|
|
|
2018-12-20 12:58:07 +08:00
|
|
|
for (auto Kind : {LLVMContext::MD_tbaa, LLVMContext::MD_alias_scope,
|
|
|
|
LLVMContext::MD_noalias, LLVMContext::MD_fpmath,
|
|
|
|
LLVMContext::MD_nontemporal, LLVMContext::MD_invariant_load,
|
|
|
|
LLVMContext::MD_access_group}) {
|
2016-07-01 05:17:59 +08:00
|
|
|
MDNode *MD = I0->getMetadata(Kind);
|
|
|
|
|
|
|
|
for (int J = 1, E = VL.size(); MD && J != E; ++J) {
|
|
|
|
const Instruction *IJ = cast<Instruction>(VL[J]);
|
|
|
|
MDNode *IMD = IJ->getMetadata(Kind);
|
|
|
|
switch (Kind) {
|
|
|
|
case LLVMContext::MD_tbaa:
|
|
|
|
MD = MDNode::getMostGenericTBAA(MD, IMD);
|
|
|
|
break;
|
|
|
|
case LLVMContext::MD_alias_scope:
|
|
|
|
MD = MDNode::getMostGenericAliasScope(MD, IMD);
|
|
|
|
break;
|
|
|
|
case LLVMContext::MD_fpmath:
|
|
|
|
MD = MDNode::getMostGenericFPMath(MD, IMD);
|
|
|
|
break;
|
2016-09-11 09:39:08 +08:00
|
|
|
case LLVMContext::MD_noalias:
|
2016-07-01 05:17:59 +08:00
|
|
|
case LLVMContext::MD_nontemporal:
|
2016-09-11 09:39:08 +08:00
|
|
|
case LLVMContext::MD_invariant_load:
|
2016-07-01 05:17:59 +08:00
|
|
|
MD = MDNode::intersect(MD, IMD);
|
|
|
|
break;
|
2018-12-20 12:58:07 +08:00
|
|
|
case LLVMContext::MD_access_group:
|
|
|
|
MD = intersectAccessGroups(Inst, IJ);
|
|
|
|
break;
|
2016-07-01 05:17:59 +08:00
|
|
|
default:
|
|
|
|
llvm_unreachable("unhandled metadata");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Inst->setMetadata(Kind, MD);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Inst;
|
|
|
|
}
|
2017-02-02 01:45:46 +08:00
|
|
|
|
2018-11-13 23:58:18 +08:00
|
|
|
Constant *
|
|
|
|
llvm::createBitMaskForGaps(IRBuilder<> &Builder, unsigned VF,
|
|
|
|
const InterleaveGroup<Instruction> &Group) {
|
2018-10-31 17:57:56 +08:00
|
|
|
// All 1's means mask is not needed.
|
|
|
|
if (Group.getNumMembers() == Group.getFactor())
|
|
|
|
return nullptr;
|
|
|
|
|
|
|
|
// TODO: support reversed access.
|
|
|
|
assert(!Group.isReverse() && "Reversed group not supported.");
|
|
|
|
|
|
|
|
SmallVector<Constant *, 16> Mask;
|
|
|
|
for (unsigned i = 0; i < VF; i++)
|
|
|
|
for (unsigned j = 0; j < Group.getFactor(); ++j) {
|
|
|
|
unsigned HasMember = Group.getMember(j) ? 1 : 0;
|
|
|
|
Mask.push_back(Builder.getInt1(HasMember));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ConstantVector::get(Mask);
|
|
|
|
}
|
|
|
|
|
2018-10-14 16:50:06 +08:00
|
|
|
Constant *llvm::createReplicatedMask(IRBuilder<> &Builder,
|
|
|
|
unsigned ReplicationFactor, unsigned VF) {
|
|
|
|
SmallVector<Constant *, 16> MaskVec;
|
|
|
|
for (unsigned i = 0; i < VF; i++)
|
|
|
|
for (unsigned j = 0; j < ReplicationFactor; j++)
|
|
|
|
MaskVec.push_back(Builder.getInt32(i));
|
|
|
|
|
|
|
|
return ConstantVector::get(MaskVec);
|
|
|
|
}
|
|
|
|
|
2017-02-02 01:45:46 +08:00
|
|
|
Constant *llvm::createInterleaveMask(IRBuilder<> &Builder, unsigned VF,
|
|
|
|
unsigned NumVecs) {
|
|
|
|
SmallVector<Constant *, 16> Mask;
|
|
|
|
for (unsigned i = 0; i < VF; i++)
|
|
|
|
for (unsigned j = 0; j < NumVecs; j++)
|
|
|
|
Mask.push_back(Builder.getInt32(j * VF + i));
|
|
|
|
|
|
|
|
return ConstantVector::get(Mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *llvm::createStrideMask(IRBuilder<> &Builder, unsigned Start,
|
|
|
|
unsigned Stride, unsigned VF) {
|
|
|
|
SmallVector<Constant *, 16> Mask;
|
|
|
|
for (unsigned i = 0; i < VF; i++)
|
|
|
|
Mask.push_back(Builder.getInt32(Start + i * Stride));
|
|
|
|
|
|
|
|
return ConstantVector::get(Mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *llvm::createSequentialMask(IRBuilder<> &Builder, unsigned Start,
|
|
|
|
unsigned NumInts, unsigned NumUndefs) {
|
|
|
|
SmallVector<Constant *, 16> Mask;
|
|
|
|
for (unsigned i = 0; i < NumInts; i++)
|
|
|
|
Mask.push_back(Builder.getInt32(Start + i));
|
|
|
|
|
|
|
|
Constant *Undef = UndefValue::get(Builder.getInt32Ty());
|
|
|
|
for (unsigned i = 0; i < NumUndefs; i++)
|
|
|
|
Mask.push_back(Undef);
|
|
|
|
|
|
|
|
return ConstantVector::get(Mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// A helper function for concatenating vectors. This function concatenates two
|
|
|
|
/// vectors having the same element type. If the second vector has fewer
|
|
|
|
/// elements than the first, it is padded with undefs.
|
|
|
|
static Value *concatenateTwoVectors(IRBuilder<> &Builder, Value *V1,
|
|
|
|
Value *V2) {
|
|
|
|
VectorType *VecTy1 = dyn_cast<VectorType>(V1->getType());
|
|
|
|
VectorType *VecTy2 = dyn_cast<VectorType>(V2->getType());
|
|
|
|
assert(VecTy1 && VecTy2 &&
|
|
|
|
VecTy1->getScalarType() == VecTy2->getScalarType() &&
|
|
|
|
"Expect two vectors with the same element type");
|
|
|
|
|
|
|
|
unsigned NumElts1 = VecTy1->getNumElements();
|
|
|
|
unsigned NumElts2 = VecTy2->getNumElements();
|
|
|
|
assert(NumElts1 >= NumElts2 && "Unexpect the first vector has less elements");
|
|
|
|
|
|
|
|
if (NumElts1 > NumElts2) {
|
|
|
|
// Extend with UNDEFs.
|
|
|
|
Constant *ExtMask =
|
|
|
|
createSequentialMask(Builder, 0, NumElts2, NumElts1 - NumElts2);
|
|
|
|
V2 = Builder.CreateShuffleVector(V2, UndefValue::get(VecTy2), ExtMask);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *Mask = createSequentialMask(Builder, 0, NumElts1 + NumElts2, 0);
|
|
|
|
return Builder.CreateShuffleVector(V1, V2, Mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *llvm::concatenateVectors(IRBuilder<> &Builder, ArrayRef<Value *> Vecs) {
|
|
|
|
unsigned NumVecs = Vecs.size();
|
|
|
|
assert(NumVecs > 1 && "Should be at least two vectors");
|
|
|
|
|
|
|
|
SmallVector<Value *, 8> ResList;
|
|
|
|
ResList.append(Vecs.begin(), Vecs.end());
|
|
|
|
do {
|
|
|
|
SmallVector<Value *, 8> TmpList;
|
|
|
|
for (unsigned i = 0; i < NumVecs - 1; i += 2) {
|
|
|
|
Value *V0 = ResList[i], *V1 = ResList[i + 1];
|
|
|
|
assert((V0->getType() == V1->getType() || i == NumVecs - 2) &&
|
|
|
|
"Only the last vector may have a different type");
|
|
|
|
|
|
|
|
TmpList.push_back(concatenateTwoVectors(Builder, V0, V1));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Push the last vector if the total number of vectors is odd.
|
|
|
|
if (NumVecs % 2 != 0)
|
|
|
|
TmpList.push_back(ResList[NumVecs - 1]);
|
|
|
|
|
|
|
|
ResList = TmpList;
|
|
|
|
NumVecs = ResList.size();
|
|
|
|
} while (NumVecs > 1);
|
|
|
|
|
|
|
|
return ResList[0];
|
|
|
|
}
|
2018-09-12 16:01:57 +08:00
|
|
|
|
|
|
|
bool InterleavedAccessInfo::isStrided(int Stride) {
|
|
|
|
unsigned Factor = std::abs(Stride);
|
|
|
|
return Factor >= 2 && Factor <= MaxInterleaveGroupFactor;
|
|
|
|
}
|
|
|
|
|
|
|
|
void InterleavedAccessInfo::collectConstStrideAccesses(
|
|
|
|
MapVector<Instruction *, StrideDescriptor> &AccessStrideInfo,
|
|
|
|
const ValueToValueMap &Strides) {
|
|
|
|
auto &DL = TheLoop->getHeader()->getModule()->getDataLayout();
|
|
|
|
|
|
|
|
// Since it's desired that the load/store instructions be maintained in
|
|
|
|
// "program order" for the interleaved access analysis, we have to visit the
|
|
|
|
// blocks in the loop in reverse postorder (i.e., in a topological order).
|
|
|
|
// Such an ordering will ensure that any load/store that may be executed
|
|
|
|
// before a second load/store will precede the second load/store in
|
|
|
|
// AccessStrideInfo.
|
|
|
|
LoopBlocksDFS DFS(TheLoop);
|
|
|
|
DFS.perform(LI);
|
|
|
|
for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO()))
|
|
|
|
for (auto &I : *BB) {
|
|
|
|
auto *LI = dyn_cast<LoadInst>(&I);
|
|
|
|
auto *SI = dyn_cast<StoreInst>(&I);
|
|
|
|
if (!LI && !SI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Value *Ptr = getLoadStorePointerOperand(&I);
|
|
|
|
// We don't check wrapping here because we don't know yet if Ptr will be
|
|
|
|
// part of a full group or a group with gaps. Checking wrapping for all
|
|
|
|
// pointers (even those that end up in groups with no gaps) will be overly
|
|
|
|
// conservative. For full groups, wrapping should be ok since if we would
|
|
|
|
// wrap around the address space we would do a memory access at nullptr
|
|
|
|
// even without the transformation. The wrapping checks are therefore
|
|
|
|
// deferred until after we've formed the interleaved groups.
|
|
|
|
int64_t Stride = getPtrStride(PSE, Ptr, TheLoop, Strides,
|
|
|
|
/*Assume=*/true, /*ShouldCheckWrap=*/false);
|
|
|
|
|
|
|
|
const SCEV *Scev = replaceSymbolicStrideSCEV(PSE, Strides, Ptr);
|
|
|
|
PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType());
|
|
|
|
uint64_t Size = DL.getTypeAllocSize(PtrTy->getElementType());
|
|
|
|
|
|
|
|
// An alignment of 0 means target ABI alignment.
|
|
|
|
unsigned Align = getLoadStoreAlignment(&I);
|
|
|
|
if (!Align)
|
|
|
|
Align = DL.getABITypeAlignment(PtrTy->getElementType());
|
|
|
|
|
|
|
|
AccessStrideInfo[&I] = StrideDescriptor(Stride, Scev, Size, Align);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Analyze interleaved accesses and collect them into interleaved load and
|
|
|
|
// store groups.
|
|
|
|
//
|
|
|
|
// When generating code for an interleaved load group, we effectively hoist all
|
|
|
|
// loads in the group to the location of the first load in program order. When
|
|
|
|
// generating code for an interleaved store group, we sink all stores to the
|
|
|
|
// location of the last store. This code motion can change the order of load
|
|
|
|
// and store instructions and may break dependences.
|
|
|
|
//
|
|
|
|
// The code generation strategy mentioned above ensures that we won't violate
|
|
|
|
// any write-after-read (WAR) dependences.
|
|
|
|
//
|
|
|
|
// E.g., for the WAR dependence: a = A[i]; // (1)
|
|
|
|
// A[i] = b; // (2)
|
|
|
|
//
|
|
|
|
// The store group of (2) is always inserted at or below (2), and the load
|
|
|
|
// group of (1) is always inserted at or above (1). Thus, the instructions will
|
|
|
|
// never be reordered. All other dependences are checked to ensure the
|
|
|
|
// correctness of the instruction reordering.
|
|
|
|
//
|
|
|
|
// The algorithm visits all memory accesses in the loop in bottom-up program
|
|
|
|
// order. Program order is established by traversing the blocks in the loop in
|
|
|
|
// reverse postorder when collecting the accesses.
|
|
|
|
//
|
|
|
|
// We visit the memory accesses in bottom-up order because it can simplify the
|
|
|
|
// construction of store groups in the presence of write-after-write (WAW)
|
|
|
|
// dependences.
|
|
|
|
//
|
|
|
|
// E.g., for the WAW dependence: A[i] = a; // (1)
|
|
|
|
// A[i] = b; // (2)
|
|
|
|
// A[i + 1] = c; // (3)
|
|
|
|
//
|
|
|
|
// We will first create a store group with (3) and (2). (1) can't be added to
|
|
|
|
// this group because it and (2) are dependent. However, (1) can be grouped
|
|
|
|
// with other accesses that may precede it in program order. Note that a
|
|
|
|
// bottom-up order does not imply that WAW dependences should not be checked.
|
2018-10-14 16:50:06 +08:00
|
|
|
void InterleavedAccessInfo::analyzeInterleaving(
|
|
|
|
bool EnablePredicatedInterleavedMemAccesses) {
|
2018-09-12 16:01:57 +08:00
|
|
|
LLVM_DEBUG(dbgs() << "LV: Analyzing interleaved accesses...\n");
|
|
|
|
const ValueToValueMap &Strides = LAI->getSymbolicStrides();
|
|
|
|
|
|
|
|
// Holds all accesses with a constant stride.
|
|
|
|
MapVector<Instruction *, StrideDescriptor> AccessStrideInfo;
|
|
|
|
collectConstStrideAccesses(AccessStrideInfo, Strides);
|
|
|
|
|
|
|
|
if (AccessStrideInfo.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Collect the dependences in the loop.
|
|
|
|
collectDependences();
|
|
|
|
|
|
|
|
// Holds all interleaved store groups temporarily.
|
2018-11-13 23:58:18 +08:00
|
|
|
SmallSetVector<InterleaveGroup<Instruction> *, 4> StoreGroups;
|
2018-09-12 16:01:57 +08:00
|
|
|
// Holds all interleaved load groups temporarily.
|
2018-11-13 23:58:18 +08:00
|
|
|
SmallSetVector<InterleaveGroup<Instruction> *, 4> LoadGroups;
|
2018-09-12 16:01:57 +08:00
|
|
|
|
|
|
|
// Search in bottom-up program order for pairs of accesses (A and B) that can
|
|
|
|
// form interleaved load or store groups. In the algorithm below, access A
|
|
|
|
// precedes access B in program order. We initialize a group for B in the
|
|
|
|
// outer loop of the algorithm, and then in the inner loop, we attempt to
|
|
|
|
// insert each A into B's group if:
|
|
|
|
//
|
|
|
|
// 1. A and B have the same stride,
|
|
|
|
// 2. A and B have the same memory object size, and
|
|
|
|
// 3. A belongs in B's group according to its distance from B.
|
|
|
|
//
|
|
|
|
// Special care is taken to ensure group formation will not break any
|
|
|
|
// dependences.
|
|
|
|
for (auto BI = AccessStrideInfo.rbegin(), E = AccessStrideInfo.rend();
|
|
|
|
BI != E; ++BI) {
|
|
|
|
Instruction *B = BI->first;
|
|
|
|
StrideDescriptor DesB = BI->second;
|
|
|
|
|
|
|
|
// Initialize a group for B if it has an allowable stride. Even if we don't
|
|
|
|
// create a group for B, we continue with the bottom-up algorithm to ensure
|
|
|
|
// we don't break any of B's dependences.
|
2018-11-13 23:58:18 +08:00
|
|
|
InterleaveGroup<Instruction> *Group = nullptr;
|
2018-10-14 16:50:06 +08:00
|
|
|
if (isStrided(DesB.Stride) &&
|
|
|
|
(!isPredicated(B->getParent()) || EnablePredicatedInterleavedMemAccesses)) {
|
2018-09-12 16:01:57 +08:00
|
|
|
Group = getInterleaveGroup(B);
|
|
|
|
if (!Group) {
|
|
|
|
LLVM_DEBUG(dbgs() << "LV: Creating an interleave group with:" << *B
|
|
|
|
<< '\n');
|
|
|
|
Group = createInterleaveGroup(B, DesB.Stride, DesB.Align);
|
|
|
|
}
|
|
|
|
if (B->mayWriteToMemory())
|
|
|
|
StoreGroups.insert(Group);
|
|
|
|
else
|
|
|
|
LoadGroups.insert(Group);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto AI = std::next(BI); AI != E; ++AI) {
|
|
|
|
Instruction *A = AI->first;
|
|
|
|
StrideDescriptor DesA = AI->second;
|
|
|
|
|
|
|
|
// Our code motion strategy implies that we can't have dependences
|
|
|
|
// between accesses in an interleaved group and other accesses located
|
|
|
|
// between the first and last member of the group. Note that this also
|
|
|
|
// means that a group can't have more than one member at a given offset.
|
|
|
|
// The accesses in a group can have dependences with other accesses, but
|
|
|
|
// we must ensure we don't extend the boundaries of the group such that
|
|
|
|
// we encompass those dependent accesses.
|
|
|
|
//
|
|
|
|
// For example, assume we have the sequence of accesses shown below in a
|
|
|
|
// stride-2 loop:
|
|
|
|
//
|
|
|
|
// (1, 2) is a group | A[i] = a; // (1)
|
|
|
|
// | A[i-1] = b; // (2) |
|
|
|
|
// A[i-3] = c; // (3)
|
|
|
|
// A[i] = d; // (4) | (2, 4) is not a group
|
|
|
|
//
|
|
|
|
// Because accesses (2) and (3) are dependent, we can group (2) with (1)
|
|
|
|
// but not with (4). If we did, the dependent access (3) would be within
|
|
|
|
// the boundaries of the (2, 4) group.
|
|
|
|
if (!canReorderMemAccessesForInterleavedGroups(&*AI, &*BI)) {
|
|
|
|
// If a dependence exists and A is already in a group, we know that A
|
|
|
|
// must be a store since A precedes B and WAR dependences are allowed.
|
|
|
|
// Thus, A would be sunk below B. We release A's group to prevent this
|
|
|
|
// illegal code motion. A will then be free to form another group with
|
|
|
|
// instructions that precede it.
|
|
|
|
if (isInterleaved(A)) {
|
2018-11-13 23:58:18 +08:00
|
|
|
InterleaveGroup<Instruction> *StoreGroup = getInterleaveGroup(A);
|
2018-09-12 16:01:57 +08:00
|
|
|
StoreGroups.remove(StoreGroup);
|
|
|
|
releaseGroup(StoreGroup);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If a dependence exists and A is not already in a group (or it was
|
|
|
|
// and we just released it), B might be hoisted above A (if B is a
|
|
|
|
// load) or another store might be sunk below A (if B is a store). In
|
|
|
|
// either case, we can't add additional instructions to B's group. B
|
|
|
|
// will only form a group with instructions that it precedes.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point, we've checked for illegal code motion. If either A or B
|
|
|
|
// isn't strided, there's nothing left to do.
|
|
|
|
if (!isStrided(DesA.Stride) || !isStrided(DesB.Stride))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Ignore A if it's already in a group or isn't the same kind of memory
|
|
|
|
// operation as B.
|
|
|
|
// Note that mayReadFromMemory() isn't mutually exclusive to
|
|
|
|
// mayWriteToMemory in the case of atomic loads. We shouldn't see those
|
|
|
|
// here, canVectorizeMemory() should have returned false - except for the
|
|
|
|
// case we asked for optimization remarks.
|
|
|
|
if (isInterleaved(A) ||
|
|
|
|
(A->mayReadFromMemory() != B->mayReadFromMemory()) ||
|
|
|
|
(A->mayWriteToMemory() != B->mayWriteToMemory()))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Check rules 1 and 2. Ignore A if its stride or size is different from
|
|
|
|
// that of B.
|
|
|
|
if (DesA.Stride != DesB.Stride || DesA.Size != DesB.Size)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Ignore A if the memory object of A and B don't belong to the same
|
|
|
|
// address space
|
|
|
|
if (getLoadStoreAddressSpace(A) != getLoadStoreAddressSpace(B))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Calculate the distance from A to B.
|
|
|
|
const SCEVConstant *DistToB = dyn_cast<SCEVConstant>(
|
|
|
|
PSE.getSE()->getMinusSCEV(DesA.Scev, DesB.Scev));
|
|
|
|
if (!DistToB)
|
|
|
|
continue;
|
|
|
|
int64_t DistanceToB = DistToB->getAPInt().getSExtValue();
|
|
|
|
|
|
|
|
// Check rule 3. Ignore A if its distance to B is not a multiple of the
|
|
|
|
// size.
|
|
|
|
if (DistanceToB % static_cast<int64_t>(DesB.Size))
|
|
|
|
continue;
|
|
|
|
|
2018-10-14 16:50:06 +08:00
|
|
|
// All members of a predicated interleave-group must have the same predicate,
|
|
|
|
// and currently must reside in the same BB.
|
|
|
|
BasicBlock *BlockA = A->getParent();
|
|
|
|
BasicBlock *BlockB = B->getParent();
|
|
|
|
if ((isPredicated(BlockA) || isPredicated(BlockB)) &&
|
|
|
|
(!EnablePredicatedInterleavedMemAccesses || BlockA != BlockB))
|
2018-09-12 16:01:57 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// The index of A is the index of B plus A's distance to B in multiples
|
|
|
|
// of the size.
|
|
|
|
int IndexA =
|
|
|
|
Group->getIndex(B) + DistanceToB / static_cast<int64_t>(DesB.Size);
|
|
|
|
|
|
|
|
// Try to insert A into B's group.
|
|
|
|
if (Group->insertMember(A, IndexA, DesA.Align)) {
|
|
|
|
LLVM_DEBUG(dbgs() << "LV: Inserted:" << *A << '\n'
|
|
|
|
<< " into the interleave group with" << *B
|
|
|
|
<< '\n');
|
|
|
|
InterleaveGroupMap[A] = Group;
|
|
|
|
|
|
|
|
// Set the first load in program order as the insert position.
|
|
|
|
if (A->mayReadFromMemory())
|
|
|
|
Group->setInsertPos(A);
|
|
|
|
}
|
|
|
|
} // Iteration over A accesses.
|
|
|
|
} // Iteration over B accesses.
|
|
|
|
|
|
|
|
// Remove interleaved store groups with gaps.
|
2018-11-13 23:58:18 +08:00
|
|
|
for (auto *Group : StoreGroups)
|
2018-09-12 16:01:57 +08:00
|
|
|
if (Group->getNumMembers() != Group->getFactor()) {
|
|
|
|
LLVM_DEBUG(
|
|
|
|
dbgs() << "LV: Invalidate candidate interleaved store group due "
|
|
|
|
"to gaps.\n");
|
|
|
|
releaseGroup(Group);
|
|
|
|
}
|
|
|
|
// Remove interleaved groups with gaps (currently only loads) whose memory
|
|
|
|
// accesses may wrap around. We have to revisit the getPtrStride analysis,
|
|
|
|
// this time with ShouldCheckWrap=true, since collectConstStrideAccesses does
|
|
|
|
// not check wrapping (see documentation there).
|
|
|
|
// FORNOW we use Assume=false;
|
|
|
|
// TODO: Change to Assume=true but making sure we don't exceed the threshold
|
|
|
|
// of runtime SCEV assumptions checks (thereby potentially failing to
|
|
|
|
// vectorize altogether).
|
|
|
|
// Additional optional optimizations:
|
|
|
|
// TODO: If we are peeling the loop and we know that the first pointer doesn't
|
|
|
|
// wrap then we can deduce that all pointers in the group don't wrap.
|
|
|
|
// This means that we can forcefully peel the loop in order to only have to
|
|
|
|
// check the first pointer for no-wrap. When we'll change to use Assume=true
|
|
|
|
// we'll only need at most one runtime check per interleaved group.
|
2018-11-13 23:58:18 +08:00
|
|
|
for (auto *Group : LoadGroups) {
|
2018-09-12 16:01:57 +08:00
|
|
|
// Case 1: A full group. Can Skip the checks; For full groups, if the wide
|
|
|
|
// load would wrap around the address space we would do a memory access at
|
|
|
|
// nullptr even without the transformation.
|
|
|
|
if (Group->getNumMembers() == Group->getFactor())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Case 2: If first and last members of the group don't wrap this implies
|
|
|
|
// that all the pointers in the group don't wrap.
|
|
|
|
// So we check only group member 0 (which is always guaranteed to exist),
|
|
|
|
// and group member Factor - 1; If the latter doesn't exist we rely on
|
2019-02-05 16:30:48 +08:00
|
|
|
// peeling (if it is a non-reversed accsess -- see Case 3).
|
2018-09-12 16:01:57 +08:00
|
|
|
Value *FirstMemberPtr = getLoadStorePointerOperand(Group->getMember(0));
|
|
|
|
if (!getPtrStride(PSE, FirstMemberPtr, TheLoop, Strides, /*Assume=*/false,
|
|
|
|
/*ShouldCheckWrap=*/true)) {
|
|
|
|
LLVM_DEBUG(
|
|
|
|
dbgs() << "LV: Invalidate candidate interleaved group due to "
|
|
|
|
"first group member potentially pointer-wrapping.\n");
|
|
|
|
releaseGroup(Group);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Instruction *LastMember = Group->getMember(Group->getFactor() - 1);
|
|
|
|
if (LastMember) {
|
|
|
|
Value *LastMemberPtr = getLoadStorePointerOperand(LastMember);
|
|
|
|
if (!getPtrStride(PSE, LastMemberPtr, TheLoop, Strides, /*Assume=*/false,
|
|
|
|
/*ShouldCheckWrap=*/true)) {
|
|
|
|
LLVM_DEBUG(
|
|
|
|
dbgs() << "LV: Invalidate candidate interleaved group due to "
|
|
|
|
"last group member potentially pointer-wrapping.\n");
|
|
|
|
releaseGroup(Group);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Case 3: A non-reversed interleaved load group with gaps: We need
|
|
|
|
// to execute at least one scalar epilogue iteration. This will ensure
|
|
|
|
// we don't speculatively access memory out-of-bounds. We only need
|
|
|
|
// to look for a member at index factor - 1, since every group must have
|
|
|
|
// a member at index zero.
|
|
|
|
if (Group->isReverse()) {
|
|
|
|
LLVM_DEBUG(
|
|
|
|
dbgs() << "LV: Invalidate candidate interleaved group due to "
|
|
|
|
"a reverse access with gaps.\n");
|
|
|
|
releaseGroup(Group);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
LLVM_DEBUG(
|
|
|
|
dbgs() << "LV: Interleaved group requires epilogue iteration.\n");
|
|
|
|
RequiresScalarEpilogue = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-10-22 14:17:09 +08:00
|
|
|
|
|
|
|
void InterleavedAccessInfo::invalidateGroupsRequiringScalarEpilogue() {
|
|
|
|
// If no group had triggered the requirement to create an epilogue loop,
|
|
|
|
// there is nothing to do.
|
|
|
|
if (!requiresScalarEpilogue())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Avoid releasing a Group twice.
|
2018-11-13 23:58:18 +08:00
|
|
|
SmallPtrSet<InterleaveGroup<Instruction> *, 4> DelSet;
|
2018-10-22 14:17:09 +08:00
|
|
|
for (auto &I : InterleaveGroupMap) {
|
2018-11-13 23:58:18 +08:00
|
|
|
InterleaveGroup<Instruction> *Group = I.second;
|
2018-10-22 14:17:09 +08:00
|
|
|
if (Group->requiresScalarEpilogue())
|
|
|
|
DelSet.insert(Group);
|
|
|
|
}
|
|
|
|
for (auto *Ptr : DelSet) {
|
|
|
|
LLVM_DEBUG(
|
2018-10-31 17:57:56 +08:00
|
|
|
dbgs()
|
2018-10-22 14:17:09 +08:00
|
|
|
<< "LV: Invalidate candidate interleaved group due to gaps that "
|
2018-10-31 17:57:56 +08:00
|
|
|
"require a scalar epilogue (not allowed under optsize) and cannot "
|
|
|
|
"be masked (not enabled). \n");
|
2018-10-22 14:17:09 +08:00
|
|
|
releaseGroup(Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
RequiresScalarEpilogue = false;
|
|
|
|
}
|
2018-11-13 23:58:18 +08:00
|
|
|
|
2018-11-14 00:26:34 +08:00
|
|
|
template <typename InstT>
|
|
|
|
void InterleaveGroup<InstT>::addMetadata(InstT *NewInst) const {
|
|
|
|
llvm_unreachable("addMetadata can only be used for Instruction");
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace llvm {
|
2018-11-13 23:58:18 +08:00
|
|
|
template <>
|
|
|
|
void InterleaveGroup<Instruction>::addMetadata(Instruction *NewInst) const {
|
|
|
|
SmallVector<Value *, 4> VL;
|
|
|
|
std::transform(Members.begin(), Members.end(), std::back_inserter(VL),
|
|
|
|
[](std::pair<int, Instruction *> p) { return p.second; });
|
|
|
|
propagateMetadata(NewInst, VL);
|
|
|
|
}
|
|
|
|
}
|