Skip to content
This repository has been archived by the owner. It is now read-only.
Permalink
master
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
//===- LoopIdiomRecognize.cpp - Loop idiom recognition --------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This pass implements an idiom recognizer that transforms simple loops into a
// non-loop form. In cases that this kicks in, it can be a significant
// performance win.
//
// If compiling for code size we avoid idiom recognition if the resulting
// code could be larger than the code for the original loop. One way this could
// happen is if the loop is not removable after idiom recognition due to the
// presence of non-idiom instructions. The initial implementation of the
// heuristics applies to idioms in multi-block loops.
//
//===----------------------------------------------------------------------===//
//
// TODO List:
//
// Future loop memory idioms to recognize:
// memcmp, memmove, strlen, etc.
// Future floating point idioms to recognize in -ffast-math mode:
// fpowi
// Future integer operation idioms to recognize:
// ctpop
//
// Beware that isel's default lowering for ctpop is highly inefficient for
// i64 and larger types when i64 is legal and the value has few bits set. It
// would be good to enhance isel to emit a loop for ctpop in this case.
//
// This could recognize common matrix multiplies and dot product idioms and
// replace them with calls to BLAS (if linked in??).
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/LoopAccessAnalysis.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Analysis/MemoryLocation.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionExpander.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Scalar/LoopPassManager.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/BuildLibCalls.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/LoopUtils.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <utility>
#include <vector>
using namespace llvm;
#define DEBUG_TYPE "loop-idiom"
STATISTIC(NumMemSet, "Number of memset's formed from loop stores");
STATISTIC(NumMemCpy, "Number of memcpy's formed from loop load+stores");
STATISTIC(NumBCmp, "Number of memcmp's formed from loop 2xload+eq-compare");
static cl::opt<bool> UseLIRCodeSizeHeurs(
"use-lir-code-size-heurs",
cl::desc("Use loop idiom recognition code size heuristics when compiling"
"with -Os/-Oz"),
cl::init(true), cl::Hidden);
namespace {
// FIXME: reinventing the wheel much? Is there a cleaner solution?
struct PMAbstraction {
virtual void markLoopAsDeleted(Loop *L) = 0;
virtual ~PMAbstraction() = default;
};
struct LegacyPMAbstraction : PMAbstraction {
LPPassManager &LPM;
LegacyPMAbstraction(LPPassManager &LPM) : LPM(LPM) {}
virtual ~LegacyPMAbstraction() = default;
void markLoopAsDeleted(Loop *L) override { LPM.markLoopAsDeleted(*L); }
};
struct NewPMAbstraction : PMAbstraction {
LPMUpdater &Updater;
NewPMAbstraction(LPMUpdater &Updater) : Updater(Updater) {}
virtual ~NewPMAbstraction() = default;
void markLoopAsDeleted(Loop *L) override {
Updater.markLoopAsDeleted(*L, L->getName());
}
};
class LoopIdiomRecognize {
Loop *CurLoop = nullptr;
AliasAnalysis *AA;
DominatorTree *DT;
LoopInfo *LI;
ScalarEvolution *SE;
TargetLibraryInfo *TLI;
const TargetTransformInfo *TTI;
const DataLayout *DL;
PMAbstraction &LoopDeleter;
OptimizationRemarkEmitter &ORE;
bool ApplyCodeSizeHeuristics;
public:
explicit LoopIdiomRecognize(AliasAnalysis *AA, DominatorTree *DT,
LoopInfo *LI, ScalarEvolution *SE,
TargetLibraryInfo *TLI,
const TargetTransformInfo *TTI,
const DataLayout *DL, PMAbstraction &LoopDeleter,
OptimizationRemarkEmitter &ORE)
: AA(AA), DT(DT), LI(LI), SE(SE), TLI(TLI), TTI(TTI), DL(DL),
LoopDeleter(LoopDeleter), ORE(ORE) {}
bool runOnLoop(Loop *L);
private:
using StoreList = SmallVector<StoreInst *, 8>;
using StoreListMap = MapVector<Value *, StoreList>;
StoreListMap StoreRefsForMemset;
StoreListMap StoreRefsForMemsetPattern;
StoreList StoreRefsForMemcpy;
bool HasMemset;
bool HasMemsetPattern;
bool HasMemcpy;
bool HasMemCmp;
bool HasBCmp;
/// Return code for isLegalStore()
enum LegalStoreKind {
None = 0,
Memset,
MemsetPattern,
Memcpy,
UnorderedAtomicMemcpy,
DontUse // Dummy retval never to be used. Allows catching errors in retval
// handling.
};
/// \name Countable Loop Idiom Handling
/// @{
bool runOnCountableLoop();
bool runOnLoopBlock(BasicBlock *BB, const SCEV *BECount,
SmallVectorImpl<BasicBlock *> &ExitBlocks);
void collectStores(BasicBlock *BB);
LegalStoreKind isLegalStore(StoreInst *SI);
enum class ForMemset { No, Yes };
bool processLoopStores(SmallVectorImpl<StoreInst *> &SL, const SCEV *BECount,
ForMemset For);
bool processLoopMemSet(MemSetInst *MSI, const SCEV *BECount);
bool processLoopStridedStore(Value *DestPtr, unsigned StoreSize,
unsigned StoreAlignment, Value *StoredVal,
Instruction *TheStore,
SmallPtrSetImpl<Instruction *> &Stores,
const SCEVAddRecExpr *Ev, const SCEV *BECount,
bool NegStride, bool IsLoopMemset = false);
bool processLoopStoreOfLoopLoad(StoreInst *SI, const SCEV *BECount);
bool avoidLIRForMultiBlockLoop(bool IsMemset = false,
bool IsLoopMemset = false);
/// @}
/// \name Noncountable Loop Idiom Handling
/// @{
bool runOnNoncountableLoop();
struct CmpLoopStructure {
Value *BCmpValue, *LatchCmpValue;
BasicBlock *HeaderBrEqualBB, *HeaderBrUnequalBB;
BasicBlock *LatchBrFinishBB, *LatchBrContinueBB;
};
bool matchBCmpLoopStructure(CmpLoopStructure &CmpLoop) const;
struct CmpOfLoads {
ICmpInst::Predicate BCmpPred;
Value *LoadSrcA, *LoadSrcB;
Value *LoadA, *LoadB;
};
bool matchBCmpOfLoads(Value *BCmpValue, CmpOfLoads &CmpOfLoads) const;
bool recognizeBCmpLoopControlFlow(const CmpOfLoads &CmpOfLoads,
CmpLoopStructure &CmpLoop) const;
bool recognizeBCmpLoopSCEV(uint64_t BCmpTyBytes, CmpOfLoads &CmpOfLoads,
const SCEV *&SrcA, const SCEV *&SrcB,
const SCEV *&Iterations) const;
bool detectBCmpIdiom(ICmpInst *&BCmpInst, CmpInst *&LatchCmpInst,
LoadInst *&LoadA, LoadInst *&LoadB, const SCEV *&SrcA,
const SCEV *&SrcB, const SCEV *&NBytes) const;
BasicBlock *transformBCmpControlFlow(ICmpInst *ComparedEqual);
void transformLoopToBCmp(ICmpInst *BCmpInst, CmpInst *LatchCmpInst,
LoadInst *LoadA, LoadInst *LoadB, const SCEV *SrcA,
const SCEV *SrcB, const SCEV *NBytes);
bool recognizeBCmp();
bool recognizePopcount();
void transformLoopToPopcount(BasicBlock *PreCondBB, Instruction *CntInst,
PHINode *CntPhi, Value *Var);
bool recognizeAndInsertFFS(); /// Find First Set: ctlz or cttz
void transformLoopToCountable(Intrinsic::ID IntrinID, BasicBlock *PreCondBB,
Instruction *CntInst, PHINode *CntPhi,
Value *Var, Instruction *DefX,
const DebugLoc &DL, bool ZeroCheck,
bool IsCntPhiUsedOutsideLoop);
/// @}
};
class LoopIdiomRecognizeLegacyPass : public LoopPass {
public:
static char ID;
explicit LoopIdiomRecognizeLegacyPass() : LoopPass(ID) {
initializeLoopIdiomRecognizeLegacyPassPass(
*PassRegistry::getPassRegistry());
}
bool runOnLoop(Loop *L, LPPassManager &LPM) override {
if (skipLoop(L))
return false;
AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
ScalarEvolution *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
TargetLibraryInfo *TLI =
&getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
*L->getHeader()->getParent());
const TargetTransformInfo *TTI =
&getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
*L->getHeader()->getParent());
const DataLayout *DL = &L->getHeader()->getModule()->getDataLayout();
LegacyPMAbstraction LoopDeleter(LPM);
// For the old PM, we can't use OptimizationRemarkEmitter as an analysis
// pass. Function analyses need to be preserved across loop transformations
// but ORE cannot be preserved (see comment before the pass definition).
OptimizationRemarkEmitter ORE(L->getHeader()->getParent());
LoopIdiomRecognize LIR(AA, DT, LI, SE, TLI, TTI, DL, LoopDeleter, ORE);
return LIR.runOnLoop(L);
}
/// This transformation requires natural loop information & requires that
/// loop preheaders be inserted into the CFG.
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>();
AU.addRequired<TargetTransformInfoWrapperPass>();
getLoopAnalysisUsage(AU);
}
};
} // end anonymous namespace
char LoopIdiomRecognizeLegacyPass::ID = 0;
PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L, LoopAnalysisManager &AM,
LoopStandardAnalysisResults &AR,
LPMUpdater &Updater) {
const auto *DL = &L.getHeader()->getModule()->getDataLayout();
const auto &FAM =
AM.getResult<FunctionAnalysisManagerLoopProxy>(L, AR).getManager();
Function *F = L.getHeader()->getParent();
auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F);
// FIXME: This should probably be optional rather than required.
if (!ORE)
report_fatal_error(
"LoopIdiomRecognizePass: OptimizationRemarkEmitterAnalysis not cached "
"at a higher level");
NewPMAbstraction LoopDeleter(Updater);
LoopIdiomRecognize LIR(&AR.AA, &AR.DT, &AR.LI, &AR.SE, &AR.TLI, &AR.TTI, DL,
LoopDeleter, *ORE);
if (!LIR.runOnLoop(&L))
return PreservedAnalyses::all();
return getLoopPassPreservedAnalyses();
}
INITIALIZE_PASS_BEGIN(LoopIdiomRecognizeLegacyPass, "loop-idiom",
"Recognize loop idioms", false, false)
INITIALIZE_PASS_DEPENDENCY(LoopPass)
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
INITIALIZE_PASS_END(LoopIdiomRecognizeLegacyPass, "loop-idiom",
"Recognize loop idioms", false, false)
Pass *llvm::createLoopIdiomPass() { return new LoopIdiomRecognizeLegacyPass(); }
static void deleteDeadInstruction(Instruction *I) {
I->replaceAllUsesWith(UndefValue::get(I->getType()));
I->eraseFromParent();
}
//===----------------------------------------------------------------------===//
//
// Implementation of LoopIdiomRecognize
//
//===----------------------------------------------------------------------===//
bool LoopIdiomRecognize::runOnLoop(Loop *L) {
CurLoop = L;
// If the loop could not be converted to canonical form, it must have an
// indirectbr in it, just give up.
if (!L->getLoopPreheader())
return false;
// Disable loop idiom recognition if the function's name is a common idiom.
StringRef Name = L->getHeader()->getParent()->getName();
if (Name == "memset" || Name == "memcpy" || Name == "memcmp" ||
Name == "bcmp")
return false;
// Determine if code size heuristics need to be applied.
ApplyCodeSizeHeuristics =
L->getHeader()->getParent()->hasOptSize() && UseLIRCodeSizeHeurs;
HasMemset = TLI->has(LibFunc_memset);
HasMemsetPattern = TLI->has(LibFunc_memset_pattern16);
HasMemcpy = TLI->has(LibFunc_memcpy);
HasMemCmp = TLI->has(LibFunc_memcmp);
HasBCmp = TLI->has(LibFunc_bcmp);
if (HasMemset || HasMemsetPattern || HasMemcpy || HasMemCmp || HasBCmp)
if (SE->hasLoopInvariantBackedgeTakenCount(L))
return runOnCountableLoop();
return runOnNoncountableLoop();
}
bool LoopIdiomRecognize::runOnCountableLoop() {
const SCEV *BECount = SE->getBackedgeTakenCount(CurLoop);
assert(!isa<SCEVCouldNotCompute>(BECount) &&
"runOnCountableLoop() called on a loop without a predictable"
"backedge-taken count");
// If this loop executes exactly one time, then it should be peeled, not
// optimized by this pass.
if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
if (BECst->getAPInt() == 0)
return false;
SmallVector<BasicBlock *, 8> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
LLVM_DEBUG(dbgs() << DEBUG_TYPE " Scanning: F["
<< CurLoop->getHeader()->getParent()->getName()
<< "] Countable Loop %" << CurLoop->getHeader()->getName()
<< "\n");
bool MadeChange = false;
// The following transforms hoist stores/memsets into the loop pre-header.
// Give up if the loop has instructions may throw.
SimpleLoopSafetyInfo SafetyInfo;
SafetyInfo.computeLoopSafetyInfo(CurLoop);
if (SafetyInfo.anyBlockMayThrow())
return MadeChange;
// Scan all the blocks in the loop that are not in subloops.
for (auto *BB : CurLoop->getBlocks()) {
// Ignore blocks in subloops.
if (LI->getLoopFor(BB) != CurLoop)
continue;
MadeChange |= runOnLoopBlock(BB, BECount, ExitBlocks);
}
return MadeChange;
}
static APInt getStoreStride(const SCEVAddRecExpr *StoreEv) {
const SCEVConstant *ConstStride = cast<SCEVConstant>(StoreEv->getOperand(1));
return ConstStride->getAPInt();
}
/// getMemSetPatternValue - If a strided store of the specified value is safe to
/// turn into a memset_pattern16, return a ConstantArray of 16 bytes that should
/// be passed in. Otherwise, return null.
///
/// Note that we don't ever attempt to use memset_pattern8 or 4, because these
/// just replicate their input array and then pass on to memset_pattern16.
static Constant *getMemSetPatternValue(Value *V, const DataLayout *DL) {
// FIXME: This could check for UndefValue because it can be merged into any
// other valid pattern.
// If the value isn't a constant, we can't promote it to being in a constant
// array. We could theoretically do a store to an alloca or something, but
// that doesn't seem worthwhile.
Constant *C = dyn_cast<Constant>(V);
if (!C)
return nullptr;
// Only handle simple values that are a power of two bytes in size.
uint64_t Size = DL->getTypeSizeInBits(V->getType());
if (Size == 0 || (Size & 7) || (Size & (Size - 1)))
return nullptr;
// Don't care enough about darwin/ppc to implement this.
if (DL->isBigEndian())
return nullptr;
// Convert to size in bytes.
Size /= 8;
// TODO: If CI is larger than 16-bytes, we can try slicing it in half to see
// if the top and bottom are the same (e.g. for vectors and large integers).
if (Size > 16)
return nullptr;
// If the constant is exactly 16 bytes, just use it.
if (Size == 16)
return C;
// Otherwise, we'll use an array of the constants.
unsigned ArraySize = 16 / Size;
ArrayType *AT = ArrayType::get(V->getType(), ArraySize);
return ConstantArray::get(AT, std::vector<Constant *>(ArraySize, C));
}
LoopIdiomRecognize::LegalStoreKind
LoopIdiomRecognize::isLegalStore(StoreInst *SI) {
// Don't touch volatile stores.
if (SI->isVolatile())
return LegalStoreKind::None;
// We only want simple or unordered-atomic stores.
if (!SI->isUnordered())
return LegalStoreKind::None;
// Don't convert stores of non-integral pointer types to memsets (which stores
// integers).
if (DL->isNonIntegralPointerType(SI->getValueOperand()->getType()))
return LegalStoreKind::None;
// Avoid merging nontemporal stores.
if (SI->getMetadata(LLVMContext::MD_nontemporal))
return LegalStoreKind::None;
Value *StoredVal = SI->getValueOperand();
Value *StorePtr = SI->getPointerOperand();
// Reject stores that are so large that they overflow an unsigned.
uint64_t SizeInBits = DL->getTypeSizeInBits(StoredVal->getType());
if ((SizeInBits & 7) || (SizeInBits >> 32) != 0)
return LegalStoreKind::None;
// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided store. If we have something else, it's a
// random store we can't handle.
const SCEVAddRecExpr *StoreEv =
dyn_cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
if (!StoreEv || StoreEv->getLoop() != CurLoop || !StoreEv->isAffine())
return LegalStoreKind::None;
// Check to see if we have a constant stride.
if (!isa<SCEVConstant>(StoreEv->getOperand(1)))
return LegalStoreKind::None;
// See if the store can be turned into a memset.
// If the stored value is a byte-wise value (like i32 -1), then it may be
// turned into a memset of i8 -1, assuming that all the consecutive bytes
// are stored. A store of i32 0x01020304 can never be turned into a memset,
// but it can be turned into memset_pattern if the target supports it.
Value *SplatValue = isBytewiseValue(StoredVal, *DL);
Constant *PatternValue = nullptr;
// Note: memset and memset_pattern on unordered-atomic is yet not supported
bool UnorderedAtomic = SI->isUnordered() && !SI->isSimple();
// If we're allowed to form a memset, and the stored value would be
// acceptable for memset, use it.
if (!UnorderedAtomic && HasMemset && SplatValue &&
// Verify that the stored value is loop invariant. If not, we can't
// promote the memset.
CurLoop->isLoopInvariant(SplatValue)) {
// It looks like we can use SplatValue.
return LegalStoreKind::Memset;
} else if (!UnorderedAtomic && HasMemsetPattern &&
// Don't create memset_pattern16s with address spaces.
StorePtr->getType()->getPointerAddressSpace() == 0 &&
(PatternValue = getMemSetPatternValue(StoredVal, DL))) {
// It looks like we can use PatternValue!
return LegalStoreKind::MemsetPattern;
}
// Otherwise, see if the store can be turned into a memcpy.
if (HasMemcpy) {
// Check to see if the stride matches the size of the store. If so, then we
// know that every byte is touched in the loop.
APInt Stride = getStoreStride(StoreEv);
unsigned StoreSize = DL->getTypeStoreSize(SI->getValueOperand()->getType());
if (StoreSize != Stride && StoreSize != -Stride)
return LegalStoreKind::None;
// The store must be feeding a non-volatile load.
LoadInst *LI = dyn_cast<LoadInst>(SI->getValueOperand());
// Only allow non-volatile loads
if (!LI || LI->isVolatile())
return LegalStoreKind::None;
// Only allow simple or unordered-atomic loads
if (!LI->isUnordered())
return LegalStoreKind::None;
// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided load. If we have something else, it's a
// random load we can't handle.
const SCEVAddRecExpr *LoadEv =
dyn_cast<SCEVAddRecExpr>(SE->getSCEV(LI->getPointerOperand()));
if (!LoadEv || LoadEv->getLoop() != CurLoop || !LoadEv->isAffine())
return LegalStoreKind::None;
// The store and load must share the same stride.
if (StoreEv->getOperand(1) != LoadEv->getOperand(1))
return LegalStoreKind::None;
// Success. This store can be converted into a memcpy.
UnorderedAtomic = UnorderedAtomic || LI->isAtomic();
return UnorderedAtomic ? LegalStoreKind::UnorderedAtomicMemcpy
: LegalStoreKind::Memcpy;
}
// This store can't be transformed into a memset/memcpy.
return LegalStoreKind::None;
}
void LoopIdiomRecognize::collectStores(BasicBlock *BB) {
StoreRefsForMemset.clear();
StoreRefsForMemsetPattern.clear();
StoreRefsForMemcpy.clear();
for (Instruction &I : *BB) {
StoreInst *SI = dyn_cast<StoreInst>(&I);
if (!SI)
continue;
// Make sure this is a strided store with a constant stride.
switch (isLegalStore(SI)) {
case LegalStoreKind::None:
// Nothing to do
break;
case LegalStoreKind::Memset: {
// Find the base pointer.
Value *Ptr = GetUnderlyingObject(SI->getPointerOperand(), *DL);
StoreRefsForMemset[Ptr].push_back(SI);
} break;
case LegalStoreKind::MemsetPattern: {
// Find the base pointer.
Value *Ptr = GetUnderlyingObject(SI->getPointerOperand(), *DL);
StoreRefsForMemsetPattern[Ptr].push_back(SI);
} break;
case LegalStoreKind::Memcpy:
case LegalStoreKind::UnorderedAtomicMemcpy:
StoreRefsForMemcpy.push_back(SI);
break;
default:
assert(false && "unhandled return value");
break;
}
}
}
/// runOnLoopBlock - Process the specified block, which lives in a counted loop
/// with the specified backedge count. This block is known to be in the current
/// loop and not in any subloops.
bool LoopIdiomRecognize::runOnLoopBlock(
BasicBlock *BB, const SCEV *BECount,
SmallVectorImpl<BasicBlock *> &ExitBlocks) {
// We can only promote stores in this block if they are unconditionally
// executed in the loop. For a block to be unconditionally executed, it has
// to dominate all the exit blocks of the loop. Verify this now.
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
if (!DT->dominates(BB, ExitBlocks[i]))
return false;
bool MadeChange = false;
// Look for store instructions, which may be optimized to memset/memcpy.
collectStores(BB);
// Look for a single store or sets of stores with a common base, which can be
// optimized into a memset (memset_pattern). The latter most commonly happens
// with structs and handunrolled loops.
for (auto &SL : StoreRefsForMemset)
MadeChange |= processLoopStores(SL.second, BECount, ForMemset::Yes);
for (auto &SL : StoreRefsForMemsetPattern)
MadeChange |= processLoopStores(SL.second, BECount, ForMemset::No);
// Optimize the store into a memcpy, if it feeds an similarly strided load.
for (auto &SI : StoreRefsForMemcpy)
MadeChange |= processLoopStoreOfLoopLoad(SI, BECount);
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) {
Instruction *Inst = &*I++;
// Look for memset instructions, which may be optimized to a larger memset.
if (MemSetInst *MSI = dyn_cast<MemSetInst>(Inst)) {
WeakTrackingVH InstPtr(&*I);
if (!processLoopMemSet(MSI, BECount))
continue;
MadeChange = true;
// If processing the memset invalidated our iterator, start over from the
// top of the block.
if (!InstPtr)
I = BB->begin();
continue;
}
}
return MadeChange;
}
/// See if this store(s) can be promoted to a memset.
bool LoopIdiomRecognize::processLoopStores(SmallVectorImpl<StoreInst *> &SL,
const SCEV *BECount, ForMemset For) {
// Try to find consecutive stores that can be transformed into memsets.
SetVector<StoreInst *> Heads, Tails;
SmallDenseMap<StoreInst *, StoreInst *> ConsecutiveChain;
// Do a quadratic search on all of the given stores and find
// all of the pairs of stores that follow each other.
SmallVector<unsigned, 16> IndexQueue;
for (unsigned i = 0, e = SL.size(); i < e; ++i) {
assert(SL[i]->isSimple() && "Expected only non-volatile stores.");
Value *FirstStoredVal = SL[i]->getValueOperand();
Value *FirstStorePtr = SL[i]->getPointerOperand();
const SCEVAddRecExpr *FirstStoreEv =
cast<SCEVAddRecExpr>(SE->getSCEV(FirstStorePtr));
APInt FirstStride = getStoreStride(FirstStoreEv);
unsigned FirstStoreSize = DL->getTypeStoreSize(SL[i]->getValueOperand()->getType());
// See if we can optimize just this store in isolation.
if (FirstStride == FirstStoreSize || -FirstStride == FirstStoreSize) {
Heads.insert(SL[i]);
continue;
}
Value *FirstSplatValue = nullptr;
Constant *FirstPatternValue = nullptr;
if (For == ForMemset::Yes)
FirstSplatValue = isBytewiseValue(FirstStoredVal, *DL);
else
FirstPatternValue = getMemSetPatternValue(FirstStoredVal, DL);
assert((FirstSplatValue || FirstPatternValue) &&
"Expected either splat value or pattern value.");
IndexQueue.clear();
// If a store has multiple consecutive store candidates, search Stores
// array according to the sequence: from i+1 to e, then from i-1 to 0.
// This is because usually pairing with immediate succeeding or preceding
// candidate create the best chance to find memset opportunity.
unsigned j = 0;
for (j = i + 1; j < e; ++j)
IndexQueue.push_back(j);
for (j = i; j > 0; --j)
IndexQueue.push_back(j - 1);
for (auto &k : IndexQueue) {
assert(SL[k]->isSimple() && "Expected only non-volatile stores.");
Value *SecondStorePtr = SL[k]->getPointerOperand();
const SCEVAddRecExpr *SecondStoreEv =
cast<SCEVAddRecExpr>(SE->getSCEV(SecondStorePtr));
APInt SecondStride = getStoreStride(SecondStoreEv);
if (FirstStride != SecondStride)
continue;
Value *SecondStoredVal = SL[k]->getValueOperand();
Value *SecondSplatValue = nullptr;
Constant *SecondPatternValue = nullptr;
if (For == ForMemset::Yes)
SecondSplatValue = isBytewiseValue(SecondStoredVal, *DL);
else
SecondPatternValue = getMemSetPatternValue(SecondStoredVal, DL);
assert((SecondSplatValue || SecondPatternValue) &&
"Expected either splat value or pattern value.");
if (isConsecutiveAccess(SL[i], SL[k], *DL, *SE, false)) {
if (For == ForMemset::Yes) {
if (isa<UndefValue>(FirstSplatValue))
FirstSplatValue = SecondSplatValue;
if (FirstSplatValue != SecondSplatValue)
continue;
} else {
if (isa<UndefValue>(FirstPatternValue))
FirstPatternValue = SecondPatternValue;
if (FirstPatternValue != SecondPatternValue)
continue;
}
Tails.insert(SL[k]);
Heads.insert(SL[i]);
ConsecutiveChain[SL[i]] = SL[k];
break;
}
}
}
// We may run into multiple chains that merge into a single chain. We mark the
// stores that we transformed so that we don't visit the same store twice.
SmallPtrSet<Value *, 16> TransformedStores;
bool Changed = false;
// For stores that start but don't end a link in the chain:
for (SetVector<StoreInst *>::iterator it = Heads.begin(), e = Heads.end();
it != e; ++it) {
if (Tails.count(*it))
continue;
// We found a store instr that starts a chain. Now follow the chain and try
// to transform it.
SmallPtrSet<Instruction *, 8> AdjacentStores;
StoreInst *I = *it;
StoreInst *HeadStore = I;
unsigned StoreSize = 0;
// Collect the chain into a list.
while (Tails.count(I) || Heads.count(I)) {
if (TransformedStores.count(I))
break;
AdjacentStores.insert(I);
StoreSize += DL->getTypeStoreSize(I->getValueOperand()->getType());
// Move to the next value in the chain.
I = ConsecutiveChain[I];
}
Value *StoredVal = HeadStore->getValueOperand();
Value *StorePtr = HeadStore->getPointerOperand();
const SCEVAddRecExpr *StoreEv = cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
APInt Stride = getStoreStride(StoreEv);
// Check to see if the stride matches the size of the stores. If so, then
// we know that every byte is touched in the loop.
if (StoreSize != Stride && StoreSize != -Stride)
continue;
bool NegStride = StoreSize == -Stride;
if (processLoopStridedStore(StorePtr, StoreSize, HeadStore->getAlignment(),
StoredVal, HeadStore, AdjacentStores, StoreEv,
BECount, NegStride)) {
TransformedStores.insert(AdjacentStores.begin(), AdjacentStores.end());
Changed = true;
}
}
return Changed;
}
/// processLoopMemSet - See if this memset can be promoted to a large memset.
bool LoopIdiomRecognize::processLoopMemSet(MemSetInst *MSI,
const SCEV *BECount) {
// We can only handle non-volatile memsets with a constant size.
if (MSI->isVolatile() || !isa<ConstantInt>(MSI->getLength()))
return false;
// If we're not allowed to hack on memset, we fail.
if (!HasMemset)
return false;
Value *Pointer = MSI->getDest();
// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided store. If we have something else, it's a
// random store we can't handle.
const SCEVAddRecExpr *Ev = dyn_cast<SCEVAddRecExpr>(SE->getSCEV(Pointer));
if (!Ev || Ev->getLoop() != CurLoop || !Ev->isAffine())
return false;
// Reject memsets that are so large that they overflow an unsigned.
uint64_t SizeInBytes = cast<ConstantInt>(MSI->getLength())->getZExtValue();
if ((SizeInBytes >> 32) != 0)
return false;
// Check to see if the stride matches the size of the memset. If so, then we
// know that every byte is touched in the loop.
const SCEVConstant *ConstStride = dyn_cast<SCEVConstant>(Ev->getOperand(1));
if (!ConstStride)
return false;
APInt Stride = ConstStride->getAPInt();
if (SizeInBytes != Stride && SizeInBytes != -Stride)
return false;
// Verify that the memset value is loop invariant. If not, we can't promote
// the memset.
Value *SplatValue = MSI->getValue();
if (!SplatValue || !CurLoop->isLoopInvariant(SplatValue))
return false;
SmallPtrSet<Instruction *, 1> MSIs;
MSIs.insert(MSI);
bool NegStride = SizeInBytes == -Stride;
return processLoopStridedStore(Pointer, (unsigned)SizeInBytes,
MSI->getDestAlignment(), SplatValue, MSI, MSIs,
Ev, BECount, NegStride, /*IsLoopMemset=*/true);
}
/// mayLoopAccessLocation - Return true if the specified loop might access the
/// specified pointer location, which is a loop-strided access. The 'Access'
/// argument specifies what the verboten forms of access are (read or write).
static bool
mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
const SCEV *BECount, unsigned StoreSize,
AliasAnalysis &AA,
SmallPtrSetImpl<Instruction *> &IgnoredStores) {
// Get the location that may be stored across the loop. Since the access is
// strided positively through memory, we say that the modified location starts
// at the pointer and has infinite size.
LocationSize AccessSize = LocationSize::unknown();
// If the loop iterates a fixed number of times, we can refine the access size
// to be exactly the size of the memset, which is (BECount+1)*StoreSize
if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
AccessSize = LocationSize::precise((BECst->getValue()->getZExtValue() + 1) *
StoreSize);
// TODO: For this to be really effective, we have to dive into the pointer
// operand in the store. Store to &A[i] of 100 will always return may alias
// with store of &A[100], we need to StoreLoc to be "A" with size of 100,
// which will then no-alias a store to &A[100].
MemoryLocation StoreLoc(Ptr, AccessSize);
for (Loop::block_iterator BI = L->block_begin(), E = L->block_end(); BI != E;
++BI)
for (Instruction &I : **BI)
if (IgnoredStores.count(&I) == 0 &&
isModOrRefSet(
intersectModRef(AA.getModRefInfo(&I, StoreLoc), Access)))
return true;
return false;
}
// If we have a negative stride, Start refers to the end of the memory location
// we're trying to memset. Therefore, we need to recompute the base pointer,
// which is just Start - BECount*Size.
static const SCEV *getStartForNegStride(const SCEV *Start, const SCEV *BECount,
Type *IntPtr, unsigned StoreSize,
ScalarEvolution *SE) {
const SCEV *Index = SE->getTruncateOrZeroExtend(BECount, IntPtr);
if (StoreSize != 1)
Index = SE->getMulExpr(Index, SE->getConstant(IntPtr, StoreSize),
SCEV::FlagNUW);
return SE->getMinusSCEV(Start, Index);
}
/// Compute the number of bytes as a SCEV from the backedge taken count.
///
/// This also maps the SCEV into the provided type and tries to handle the
/// computation in a way that will fold cleanly.
static const SCEV *getNumBytes(const SCEV *BECount, Type *IntPtr,
unsigned StoreSize, Loop *CurLoop,
const DataLayout *DL, ScalarEvolution *SE) {
const SCEV *NumBytesS;
// The # stored bytes is (BECount+1)*Size. Expand the trip count out to
// pointer size if it isn't already.
//
// If we're going to need to zero extend the BE count, check if we can add
// one to it prior to zero extending without overflow. Provided this is safe,
// it allows better simplification of the +1.
if (DL->getTypeSizeInBits(BECount->getType()) <
DL->getTypeSizeInBits(IntPtr) &&
SE->isLoopEntryGuardedByCond(
CurLoop, ICmpInst::ICMP_NE, BECount,
SE->getNegativeSCEV(SE->getOne(BECount->getType())))) {
NumBytesS = SE->getZeroExtendExpr(
SE->getAddExpr(BECount, SE->getOne(BECount->getType()), SCEV::FlagNUW),
IntPtr);
} else {
NumBytesS = SE->getAddExpr(SE->getTruncateOrZeroExtend(BECount, IntPtr),
SE->getOne(IntPtr), SCEV::FlagNUW);
}
// And scale it based on the store size.
if (StoreSize != 1) {
NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtr, StoreSize),
SCEV::FlagNUW);
}
return NumBytesS;
}
/// processLoopStridedStore - We see a strided store of some value. If we can
/// transform this into a memset or memset_pattern in the loop preheader, do so.
bool LoopIdiomRecognize::processLoopStridedStore(
Value *DestPtr, unsigned StoreSize, unsigned StoreAlignment,
Value *StoredVal, Instruction *TheStore,
SmallPtrSetImpl<Instruction *> &Stores, const SCEVAddRecExpr *Ev,
const SCEV *BECount, bool NegStride, bool IsLoopMemset) {
Value *SplatValue = isBytewiseValue(StoredVal, *DL);
Constant *PatternValue = nullptr;
if (!SplatValue)
PatternValue = getMemSetPatternValue(StoredVal, DL);
assert((SplatValue || PatternValue) &&
"Expected either splat value or pattern value.");
// The trip count of the loop and the base pointer of the addrec SCEV is
// guaranteed to be loop invariant, which means that it should dominate the
// header. This allows us to insert code for it in the preheader.
unsigned DestAS = DestPtr->getType()->getPointerAddressSpace();
BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, *DL, "loop-idiom");
Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS);
Type *IntPtr = Builder.getIntPtrTy(*DL, DestAS);
const SCEV *Start = Ev->getStart();
// Handle negative strided loops.
if (NegStride)
Start = getStartForNegStride(Start, BECount, IntPtr, StoreSize, SE);
// TODO: ideally we should still be able to generate memset if SCEV expander
// is taught to generate the dependencies at the latest point.
if (!isSafeToExpand(Start, *SE))
return false;
// Okay, we have a strided store "p[i]" of a splattable value. We can turn
// this into a memset in the loop preheader now if we want. However, this
// would be unsafe to do if there is anything else in the loop that may read
// or write to the aliased location. Check for any overlap by generating the
// base pointer and checking the region.
Value *BasePtr =
Expander.expandCodeFor(Start, DestInt8PtrTy, Preheader->getTerminator());
if (mayLoopAccessLocation(BasePtr, ModRefInfo::ModRef, CurLoop, BECount,
StoreSize, *AA, Stores)) {
Expander.clear();
// If we generated new code for the base pointer, clean up.
RecursivelyDeleteTriviallyDeadInstructions(BasePtr, TLI);
return false;
}
if (avoidLIRForMultiBlockLoop(/*IsMemset=*/true, IsLoopMemset))
return false;
// Okay, everything looks good, insert the memset.
const SCEV *NumBytesS =
getNumBytes(BECount, IntPtr, StoreSize, CurLoop, DL, SE);
// TODO: ideally we should still be able to generate memset if SCEV expander
// is taught to generate the dependencies at the latest point.
if (!isSafeToExpand(NumBytesS, *SE))
return false;
Value *NumBytes =
Expander.expandCodeFor(NumBytesS, IntPtr, Preheader->getTerminator());
CallInst *NewCall;
if (SplatValue) {
NewCall =
Builder.CreateMemSet(BasePtr, SplatValue, NumBytes, StoreAlignment);
} else {
// Everything is emitted in default address space
Type *Int8PtrTy = DestInt8PtrTy;
Module *M = TheStore->getModule();
StringRef FuncName = "memset_pattern16";
FunctionCallee MSP = M->getOrInsertFunction(FuncName, Builder.getVoidTy(),
Int8PtrTy, Int8PtrTy, IntPtr);
inferLibFuncAttributes(M, FuncName, *TLI);
// Otherwise we should form a memset_pattern16. PatternValue is known to be
// an constant array of 16-bytes. Plop the value into a mergable global.
GlobalVariable *GV = new GlobalVariable(*M, PatternValue->getType(), true,
GlobalValue::PrivateLinkage,
PatternValue, ".memset_pattern");
GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); // Ok to merge these.
GV->setAlignment(Align(16));
Value *PatternPtr = ConstantExpr::getBitCast(GV, Int8PtrTy);
NewCall = Builder.CreateCall(MSP, {BasePtr, PatternPtr, NumBytes});
}
LLVM_DEBUG(dbgs() << " Formed memset: " << *NewCall << "\n"
<< " from store to: " << *Ev << " at: " << *TheStore
<< "\n");
NewCall->setDebugLoc(TheStore->getDebugLoc());
ORE.emit([&]() {
return OptimizationRemark(DEBUG_TYPE, "ProcessLoopStridedStore",
NewCall->getDebugLoc(), Preheader)
<< "Transformed loop-strided store into a call to "
<< ore::NV("NewFunction", NewCall->getCalledFunction())
<< "() function";
});
// Okay, the memset has been formed. Zap the original store and anything that
// feeds into it.
for (auto *I : Stores)
deleteDeadInstruction(I);
++NumMemSet;
return true;
}
/// If the stored value is a strided load in the same loop with the same stride
/// this may be transformable into a memcpy. This kicks in for stuff like
/// for (i) A[i] = B[i];
bool LoopIdiomRecognize::processLoopStoreOfLoopLoad(StoreInst *SI,
const SCEV *BECount) {
assert(SI->isUnordered() && "Expected only non-volatile non-ordered stores.");
Value *StorePtr = SI->getPointerOperand();
const SCEVAddRecExpr *StoreEv = cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
APInt Stride = getStoreStride(StoreEv);
unsigned StoreSize = DL->getTypeStoreSize(SI->getValueOperand()->getType());
bool NegStride = StoreSize == -Stride;
// The store must be feeding a non-volatile load.
LoadInst *LI = cast<LoadInst>(SI->getValueOperand());
assert(LI->isUnordered() && "Expected only non-volatile non-ordered loads.");
// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided load. If we have something else, it's a
// random load we can't handle.
const SCEVAddRecExpr *LoadEv =
cast<SCEVAddRecExpr>(SE->getSCEV(LI->getPointerOperand()));
// The trip count of the loop and the base pointer of the addrec SCEV is
// guaranteed to be loop invariant, which means that it should dominate the
// header. This allows us to insert code for it in the preheader.
BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, *DL, "loop-idiom");
const SCEV *StrStart = StoreEv->getStart();
unsigned StrAS = SI->getPointerAddressSpace();
Type *IntPtrTy = Builder.getIntPtrTy(*DL, StrAS);
// Handle negative strided loops.
if (NegStride)
StrStart = getStartForNegStride(StrStart, BECount, IntPtrTy, StoreSize, SE);
// Okay, we have a strided store "p[i]" of a loaded value. We can turn
// this into a memcpy in the loop preheader now if we want. However, this
// would be unsafe to do if there is anything else in the loop that may read
// or write the memory region we're storing to. This includes the load that
// feeds the stores. Check for an alias by generating the base address and
// checking everything.
Value *StoreBasePtr = Expander.expandCodeFor(
StrStart, Builder.getInt8PtrTy(StrAS), Preheader->getTerminator());
SmallPtrSet<Instruction *, 1> Stores;
Stores.insert(SI);
if (mayLoopAccessLocation(StoreBasePtr, ModRefInfo::ModRef, CurLoop, BECount,
StoreSize, *AA, Stores)) {
Expander.clear();
// If we generated new code for the base pointer, clean up.
RecursivelyDeleteTriviallyDeadInstructions(StoreBasePtr, TLI);
return false;
}
const SCEV *LdStart = LoadEv->getStart();
unsigned LdAS = LI->getPointerAddressSpace();
// Handle negative strided loops.
if (NegStride)
LdStart = getStartForNegStride(LdStart, BECount, IntPtrTy, StoreSize, SE);
// For a memcpy, we have to make sure that the input array is not being
// mutated by the loop.
Value *LoadBasePtr = Expander.expandCodeFor(
LdStart, Builder.getInt8PtrTy(LdAS), Preheader->getTerminator());
if (mayLoopAccessLocation(LoadBasePtr, ModRefInfo::Mod, CurLoop, BECount,
StoreSize, *AA, Stores)) {
Expander.clear();
// If we generated new code for the base pointer, clean up.
RecursivelyDeleteTriviallyDeadInstructions(LoadBasePtr, TLI);
RecursivelyDeleteTriviallyDeadInstructions(StoreBasePtr, TLI);
return false;
}
if (avoidLIRForMultiBlockLoop())
return false;
// Okay, everything is safe, we can transform this!
const SCEV *NumBytesS =
getNumBytes(BECount, IntPtrTy, StoreSize, CurLoop, DL, SE);
Value *NumBytes =
Expander.expandCodeFor(NumBytesS, IntPtrTy, Preheader->getTerminator());
CallInst *NewCall = nullptr;
// Check whether to generate an unordered atomic memcpy:
// If the load or store are atomic, then they must necessarily be unordered
// by previous checks.
if (!SI->isAtomic() && !LI->isAtomic())
NewCall = Builder.CreateMemCpy(StoreBasePtr, SI->getAlignment(),
LoadBasePtr, LI->getAlignment(), NumBytes);
else {
// We cannot allow unaligned ops for unordered load/store, so reject
// anything where the alignment isn't at least the element size.
unsigned Align = std::min(SI->getAlignment(), LI->getAlignment());
if (Align < StoreSize)
return false;
// If the element.atomic memcpy is not lowered into explicit
// loads/stores later, then it will be lowered into an element-size
// specific lib call. If the lib call doesn't exist for our store size, then
// we shouldn't generate the memcpy.
if (StoreSize > TTI->getAtomicMemIntrinsicMaxElementSize())
return false;
// Create the call.
// Note that unordered atomic loads/stores are *required* by the spec to
// have an alignment but non-atomic loads/stores may not.
NewCall = Builder.CreateElementUnorderedAtomicMemCpy(
StoreBasePtr, SI->getAlignment(), LoadBasePtr, LI->getAlignment(),
NumBytes, StoreSize);
}
NewCall->setDebugLoc(SI->getDebugLoc());
LLVM_DEBUG(dbgs() << " Formed memcpy: " << *NewCall << "\n"
<< " from load ptr=" << *LoadEv << " at: " << *LI << "\n"
<< " from store ptr=" << *StoreEv << " at: " << *SI
<< "\n");
ORE.emit([&]() {
return OptimizationRemark(DEBUG_TYPE, "ProcessLoopStoreOfLoopLoad",
NewCall->getDebugLoc(), Preheader)
<< "Formed a call to "
<< ore::NV("NewFunction", NewCall->getCalledFunction())
<< "() function";
});
// Okay, the memcpy has been formed. Zap the original store and anything that
// feeds into it.
deleteDeadInstruction(SI);
++NumMemCpy;
return true;
}
// When compiling for codesize we avoid idiom recognition for a multi-block loop
// unless it is a loop_memset idiom or a memset/memcpy idiom in a nested loop.
//
bool LoopIdiomRecognize::avoidLIRForMultiBlockLoop(bool IsMemset,
bool IsLoopMemset) {
if (ApplyCodeSizeHeuristics && CurLoop->getNumBlocks() > 1) {
if (!CurLoop->getParentLoop() && (!IsMemset || !IsLoopMemset)) {
LLVM_DEBUG(dbgs() << " " << CurLoop->getHeader()->getParent()->getName()
<< " : LIR " << (IsMemset ? "Memset" : "Memcpy")
<< " avoided: multi-block top-level loop\n");
return true;
}
}
return false;
}
bool LoopIdiomRecognize::runOnNoncountableLoop() {
LLVM_DEBUG(dbgs() << DEBUG_TYPE " Scanning: F["
<< CurLoop->getHeader()->getParent()->getName()
<< "] Noncountable Loop %"
<< CurLoop->getHeader()->getName() << "\n");
return recognizeBCmp() || recognizePopcount() || recognizeAndInsertFFS();
}
/// Check if the given conditional branch is based on the comparison between
/// a variable and zero, and if the variable is non-zero or zero (JmpOnZero is
/// true), the control yields to the loop entry. If the branch matches the
/// behavior, the variable involved in the comparison is returned. This function
/// will be called to see if the precondition and postcondition of the loop are
/// in desirable form.
static Value *matchCondition(BranchInst *BI, BasicBlock *LoopEntry,
bool JmpOnZero = false) {
if (!BI || !BI->isConditional())
return nullptr;
ICmpInst *Cond = dyn_cast<ICmpInst>(BI->getCondition());
if (!Cond)
return nullptr;
ConstantInt *CmpZero = dyn_cast<ConstantInt>(Cond->getOperand(1));
if (!CmpZero || !CmpZero->isZero())
return nullptr;
BasicBlock *TrueSucc = BI->getSuccessor(0);
BasicBlock *FalseSucc = BI->getSuccessor(1);
if (JmpOnZero)
std::swap(TrueSucc, FalseSucc);
ICmpInst::Predicate Pred = Cond->getPredicate();
if ((Pred == ICmpInst::ICMP_NE && TrueSucc == LoopEntry) ||
(Pred == ICmpInst::ICMP_EQ && FalseSucc == LoopEntry))
return Cond->getOperand(0);
return nullptr;
}
// Check if the recurrence variable `VarX` is in the right form to create
// the idiom. Returns the value coerced to a PHINode if so.
static PHINode *getRecurrenceVar(Value *VarX, Instruction *DefX,
BasicBlock *LoopEntry) {
auto *PhiX = dyn_cast<PHINode>(VarX);
if (PhiX && PhiX->getParent() == LoopEntry &&
(PhiX->getOperand(0) == DefX || PhiX->getOperand(1) == DefX))
return PhiX;
return nullptr;
}
/// Return true iff the idiom is detected in the loop.
///
/// Additionally:
/// 1) \p CntInst is set to the instruction counting the population bit.
/// 2) \p CntPhi is set to the corresponding phi node.
/// 3) \p Var is set to the value whose population bits are being counted.
///
/// The core idiom we are trying to detect is:
/// \code
/// if (x0 != 0)
/// goto loop-exit // the precondition of the loop
/// cnt0 = init-val;
/// do {
/// x1 = phi (x0, x2);
/// cnt1 = phi(cnt0, cnt2);
///
/// cnt2 = cnt1 + 1;
/// ...
/// x2 = x1 & (x1 - 1);
/// ...
/// } while(x != 0);
///
/// loop-exit:
/// \endcode
static bool detectPopcountIdiom(Loop *CurLoop, BasicBlock *PreCondBB,
Instruction *&CntInst, PHINode *&CntPhi,
Value *&Var) {
// step 1: Check to see if the look-back branch match this pattern:
// "if (a!=0) goto loop-entry".
BasicBlock *LoopEntry;
Instruction *DefX2, *CountInst;
Value *VarX1, *VarX0;
PHINode *PhiX, *CountPhi;
DefX2 = CountInst = nullptr;
VarX1 = VarX0 = nullptr;
PhiX = CountPhi = nullptr;
LoopEntry = *(CurLoop->block_begin());
// step 1: Check if the loop-back branch is in desirable form.
{
if (Value *T = matchCondition(
dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
DefX2 = dyn_cast<Instruction>(T);
else
return false;
}
// step 2: detect instructions corresponding to "x2 = x1 & (x1 - 1)"
{
if (!DefX2 || DefX2->getOpcode() != Instruction::And)
return false;
BinaryOperator *SubOneOp;
if ((SubOneOp = dyn_cast<BinaryOperator>(DefX2->getOperand(0))))
VarX1 = DefX2->getOperand(1);
else {
VarX1 = DefX2->getOperand(0);
SubOneOp = dyn_cast<BinaryOperator>(DefX2->getOperand(1));
}
if (!SubOneOp || SubOneOp->getOperand(0) != VarX1)
return false;
ConstantInt *Dec = dyn_cast<ConstantInt>(SubOneOp->getOperand(1));
if (!Dec ||
!((SubOneOp->getOpcode() == Instruction::Sub && Dec->isOne()) ||
(SubOneOp->getOpcode() == Instruction::Add &&
Dec->isMinusOne()))) {
return false;
}
}
// step 3: Check the recurrence of variable X
PhiX = getRecurrenceVar(VarX1, DefX2, LoopEntry);
if (!PhiX)
return false;
// step 4: Find the instruction which count the population: cnt2 = cnt1 + 1
{
CountInst = nullptr;
for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),
IterE = LoopEntry->end();
Iter != IterE; Iter++) {
Instruction *Inst = &*Iter;
if (Inst->getOpcode() != Instruction::Add)
continue;
ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
if (!Inc || !Inc->isOne())
continue;
PHINode *Phi = getRecurrenceVar(Inst->getOperand(0), Inst, LoopEntry);
if (!Phi)
continue;
// Check if the result of the instruction is live of the loop.
bool LiveOutLoop = false;
for (User *U : Inst->users()) {
if ((cast<Instruction>(U))->getParent() != LoopEntry) {
LiveOutLoop = true;
break;
}
}
if (LiveOutLoop) {
CountInst = Inst;
CountPhi = Phi;
break;
}
}
if (!CountInst)
return false;
}
// step 5: check if the precondition is in this form:
// "if (x != 0) goto loop-head ; else goto somewhere-we-don't-care;"
{
auto *PreCondBr = dyn_cast<BranchInst>(PreCondBB->getTerminator());
Value *T = matchCondition(PreCondBr, CurLoop->getLoopPreheader());
if (T != PhiX->getOperand(0) && T != PhiX->getOperand(1))
return false;
CntInst = CountInst;
CntPhi = CountPhi;
Var = T;
}
return true;
}
/// Return true if the idiom is detected in the loop.
///
/// Additionally:
/// 1) \p CntInst is set to the instruction Counting Leading Zeros (CTLZ)
/// or nullptr if there is no such.
/// 2) \p CntPhi is set to the corresponding phi node
/// or nullptr if there is no such.
/// 3) \p Var is set to the value whose CTLZ could be used.
/// 4) \p DefX is set to the instruction calculating Loop exit condition.
///
/// The core idiom we are trying to detect is:
/// \code
/// if (x0 == 0)
/// goto loop-exit // the precondition of the loop
/// cnt0 = init-val;
/// do {
/// x = phi (x0, x.next); //PhiX
/// cnt = phi(cnt0, cnt.next);
///
/// cnt.next = cnt + 1;
/// ...
/// x.next = x >> 1; // DefX
/// ...
/// } while(x.next != 0);
///
/// loop-exit:
/// \endcode
static bool detectShiftUntilZeroIdiom(Loop *CurLoop, const DataLayout &DL,
Intrinsic::ID &IntrinID, Value *&InitX,
Instruction *&CntInst, PHINode *&CntPhi,
Instruction *&DefX) {
BasicBlock *LoopEntry;
Value *VarX = nullptr;
DefX = nullptr;
CntInst = nullptr;
CntPhi = nullptr;
LoopEntry = *(CurLoop->block_begin());
// step 1: Check if the loop-back branch is in desirable form.
if (Value *T = matchCondition(
dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
DefX = dyn_cast<Instruction>(T);
else
return false;
// step 2: detect instructions corresponding to "x.next = x >> 1 or x << 1"
if (!DefX || !DefX->isShift())
return false;
IntrinID = DefX->getOpcode() == Instruction::Shl ? Intrinsic::cttz :
Intrinsic::ctlz;
ConstantInt *Shft = dyn_cast<ConstantInt>(DefX->getOperand(1));
if (!Shft || !Shft->isOne())
return false;
VarX = DefX->getOperand(0);
// step 3: Check the recurrence of variable X
PHINode *PhiX = getRecurrenceVar(VarX, DefX, LoopEntry);
if (!PhiX)
return false;
InitX = PhiX->getIncomingValueForBlock(CurLoop->getLoopPreheader());
// Make sure the initial value can't be negative otherwise the ashr in the
// loop might never reach zero which would make the loop infinite.
if (DefX->getOpcode() == Instruction::AShr && !isKnownNonNegative(InitX, DL))
return false;
// step 4: Find the instruction which count the CTLZ: cnt.next = cnt + 1
// TODO: We can skip the step. If loop trip count is known (CTLZ),
// then all uses of "cnt.next" could be optimized to the trip count
// plus "cnt0". Currently it is not optimized.
// This step could be used to detect POPCNT instruction:
// cnt.next = cnt + (x.next & 1)
for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),
IterE = LoopEntry->end();
Iter != IterE; Iter++) {
Instruction *Inst = &*Iter;
if (Inst->getOpcode() != Instruction::Add)
continue;
ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
if (!Inc || !Inc->isOne())
continue;
PHINode *Phi = getRecurrenceVar(Inst->getOperand(0), Inst, LoopEntry);
if (!Phi)
continue;
CntInst = Inst;
CntPhi = Phi;
break;
}
if (!CntInst)
return false;
return true;
}
/// Recognize CTLZ or CTTZ idiom in a non-countable loop and convert the loop
/// to countable (with CTLZ / CTTZ trip count). If CTLZ / CTTZ inserted as a new
/// trip count returns true; otherwise, returns false.
bool LoopIdiomRecognize::recognizeAndInsertFFS() {
// Give up if the loop has multiple blocks or multiple backedges.
if (CurLoop->getNumBackEdges() != 1 || CurLoop->getNumBlocks() != 1)
return false;
Intrinsic::ID IntrinID;
Value *InitX;
Instruction *DefX = nullptr;
PHINode *CntPhi = nullptr;
Instruction *CntInst = nullptr;
// Help decide if transformation is profitable. For ShiftUntilZero idiom,
// this is always 6.
size_t IdiomCanonicalSize = 6;
if (!detectShiftUntilZeroIdiom(CurLoop, *DL, IntrinID, InitX,
CntInst, CntPhi, DefX))
return false;
bool IsCntPhiUsedOutsideLoop = false;
for (User *U : CntPhi->users())
if (!CurLoop->contains(cast<Instruction>(U))) {
IsCntPhiUsedOutsideLoop = true;
break;
}
bool IsCntInstUsedOutsideLoop = false;
for (User *U : CntInst->users())
if (!CurLoop->contains(cast<Instruction>(U))) {
IsCntInstUsedOutsideLoop = true;
break;
}
// If both CntInst and CntPhi are used outside the loop the profitability
// is questionable.
if (IsCntInstUsedOutsideLoop && IsCntPhiUsedOutsideLoop)
return false;
// For some CPUs result of CTLZ(X) intrinsic is undefined
// when X is 0. If we can not guarantee X != 0, we need to check this
// when expand.
bool ZeroCheck = false;
// It is safe to assume Preheader exist as it was checked in
// parent function RunOnLoop.
BasicBlock *PH = CurLoop->getLoopPreheader();
// If we are using the count instruction outside the loop, make sure we
// have a zero check as a precondition. Without the check the loop would run
// one iteration for before any check of the input value. This means 0 and 1
// would have identical behavior in the original loop and thus
if (!IsCntPhiUsedOutsideLoop) {
auto *PreCondBB = PH->getSinglePredecessor();
if (!PreCondBB)
return false;
auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
if (!PreCondBI)
return false;
if (matchCondition(PreCondBI, PH) != InitX)
return false;
ZeroCheck = true;
}
// Check if CTLZ / CTTZ intrinsic is profitable. Assume it is always
// profitable if we delete the loop.
// the loop has only 6 instructions:
// %n.addr.0 = phi [ %n, %entry ], [ %shr, %while.cond ]
// %i.0 = phi [ %i0, %entry ], [ %inc, %while.cond ]
// %shr = ashr %n.addr.0, 1
// %tobool = icmp eq %shr, 0
// %inc = add nsw %i.0, 1
// br i1 %tobool
const Value *Args[] =
{InitX, ZeroCheck ? ConstantInt::getTrue(InitX->getContext())
: ConstantInt::getFalse(InitX->getContext())};
// @llvm.dbg doesn't count as they have no semantic effect.
auto InstWithoutDebugIt = CurLoop->getHeader()->instructionsWithoutDebug();
uint32_t HeaderSize =
std::distance(InstWithoutDebugIt.begin(), InstWithoutDebugIt.end());
if (HeaderSize != IdiomCanonicalSize &&
TTI->getIntrinsicCost(IntrinID, InitX->getType(), Args) >
TargetTransformInfo::TCC_Basic)
return false;
transformLoopToCountable(IntrinID, PH, CntInst, CntPhi, InitX, DefX,
DefX->getDebugLoc(), ZeroCheck,
IsCntPhiUsedOutsideLoop);
return true;
}
/// Recognizes a population count idiom in a non-countable loop.
///
/// If detected, transforms the relevant code to issue the popcount intrinsic
/// function call, and returns true; otherwise, returns false.
bool LoopIdiomRecognize::recognizePopcount() {
if (TTI->getPopcntSupport(32) != TargetTransformInfo::PSK_FastHardware)
return false;
// Counting population are usually conducted by few arithmetic instructions.
// Such instructions can be easily "absorbed" by vacant slots in a
// non-compact loop. Therefore, recognizing popcount idiom only makes sense
// in a compact loop.
// Give up if the loop has multiple blocks or multiple backedges.
if (CurLoop->getNumBackEdges() != 1 || CurLoop->getNumBlocks() != 1)
return false;
BasicBlock *LoopBody = *(CurLoop->block_begin());
if (LoopBody->size() >= 20) {
// The loop is too big, bail out.
return false;
}
// It should have a preheader containing nothing but an unconditional branch.
BasicBlock *PH = CurLoop->getLoopPreheader();
if (!PH || &PH->front() != PH->getTerminator())
return false;
auto *EntryBI = dyn_cast<BranchInst>(PH->getTerminator());
if (!EntryBI || EntryBI->isConditional())
return false;
// It should have a precondition block where the generated popcount intrinsic
// function can be inserted.
auto *PreCondBB = PH->getSinglePredecessor();
if (!PreCondBB)
return false;
auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
if (!PreCondBI || PreCondBI->isUnconditional())
return false;
Instruction *CntInst;
PHINode *CntPhi;
Value *Val;
if (!detectPopcountIdiom(CurLoop, PreCondBB, CntInst, CntPhi, Val))
return false;
transformLoopToPopcount(PreCondBB, CntInst, CntPhi, Val);
return true;
}
static CallInst *createPopcntIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
const DebugLoc &DL) {
Value *Ops[] = {Val};
Type *Tys[] = {Val->getType()};
Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
Function *Func = Intrinsic::getDeclaration(M, Intrinsic::ctpop, Tys);
CallInst *CI = IRBuilder.CreateCall(Func, Ops);
CI->setDebugLoc(DL);
return CI;
}
static CallInst *createFFSIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
const DebugLoc &DL, bool ZeroCheck,
Intrinsic::ID IID) {
Value *Ops[] = {Val, ZeroCheck ? IRBuilder.getTrue() : IRBuilder.getFalse()};
Type *Tys[] = {Val->getType()};
Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
Function *Func = Intrinsic::getDeclaration(M, IID, Tys);
CallInst *CI = IRBuilder.CreateCall(Func, Ops);
CI->setDebugLoc(DL);
return CI;
}
/// Transform the following loop (Using CTLZ, CTTZ is similar):
/// loop:
/// CntPhi = PHI [Cnt0, CntInst]
/// PhiX = PHI [InitX, DefX]
/// CntInst = CntPhi + 1
/// DefX = PhiX >> 1
/// LOOP_BODY
/// Br: loop if (DefX != 0)
/// Use(CntPhi) or Use(CntInst)
///
/// Into:
/// If CntPhi used outside the loop:
/// CountPrev = BitWidth(InitX) - CTLZ(InitX >> 1)
/// Count = CountPrev + 1
/// else
/// Count = BitWidth(InitX) - CTLZ(InitX)
/// loop:
/// CntPhi = PHI [Cnt0, CntInst]
/// PhiX = PHI [InitX, DefX]
/// PhiCount = PHI [Count, Dec]
/// CntInst = CntPhi + 1
/// DefX = PhiX >> 1
/// Dec = PhiCount - 1
/// LOOP_BODY
/// Br: loop if (Dec != 0)
/// Use(CountPrev + Cnt0) // Use(CntPhi)
/// or
/// Use(Count + Cnt0) // Use(CntInst)
///
/// If LOOP_BODY is empty the loop will be deleted.
/// If CntInst and DefX are not used in LOOP_BODY they will be removed.
void LoopIdiomRecognize::transformLoopToCountable(
Intrinsic::ID IntrinID, BasicBlock *Preheader, Instruction *CntInst,
PHINode *CntPhi, Value *InitX, Instruction *DefX, const DebugLoc &DL,
bool ZeroCheck, bool IsCntPhiUsedOutsideLoop) {
BranchInst *PreheaderBr = cast<BranchInst>(Preheader->getTerminator());
// Step 1: Insert the CTLZ/CTTZ instruction at the end of the preheader block
IRBuilder<> Builder(PreheaderBr);
Builder.SetCurrentDebugLocation(DL);
Value *FFS, *Count, *CountPrev, *NewCount, *InitXNext;
// Count = BitWidth - CTLZ(InitX);
// If there are uses of CntPhi create:
// CountPrev = BitWidth - CTLZ(InitX >> 1);
if (IsCntPhiUsedOutsideLoop) {
if (DefX->getOpcode() == Instruction::AShr)
InitXNext =
Builder.CreateAShr(InitX, ConstantInt::get(InitX->getType(), 1));
else if (DefX->getOpcode() == Instruction::LShr)
InitXNext =
Builder.CreateLShr(InitX, ConstantInt::get(InitX->getType(), 1));
else if (DefX->getOpcode() == Instruction::Shl) // cttz
InitXNext =
Builder.CreateShl(InitX, ConstantInt::get(InitX->getType(), 1));
else
llvm_unreachable("Unexpected opcode!");
} else
InitXNext = InitX;
FFS = createFFSIntrinsic(Builder, InitXNext, DL, ZeroCheck, IntrinID);
Count = Builder.CreateSub(
ConstantInt::get(FFS->getType(),
FFS->getType()->getIntegerBitWidth()),
FFS);
if (IsCntPhiUsedOutsideLoop) {
CountPrev = Count;
Count = Builder.CreateAdd(
CountPrev,
ConstantInt::get(CountPrev->getType(), 1));
}
NewCount = Builder.CreateZExtOrTrunc(
IsCntPhiUsedOutsideLoop ? CountPrev : Count,
cast<IntegerType>(CntInst->getType()));
// If the counter's initial value is not zero, insert Add Inst.
Value *CntInitVal = CntPhi->getIncomingValueForBlock(Preheader);
ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
if (!InitConst || !InitConst->isZero())
NewCount = Builder.CreateAdd(NewCount, CntInitVal);
// Step 2: Insert new IV and loop condition:
// loop:
// ...
// PhiCount = PHI [Count, Dec]
// ...
// Dec = PhiCount - 1
// ...
// Br: loop if (Dec != 0)
BasicBlock *Body = *(CurLoop->block_begin());
auto *LbBr = cast<BranchInst>(Body->getTerminator());
ICmpInst *LbCond = cast<ICmpInst>(LbBr->getCondition());
Type *Ty = Count->getType();
PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi", &Body->front());
Builder.SetInsertPoint(LbCond);
Instruction *TcDec = cast<Instruction>(
Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
"tcdec", false, true));
TcPhi->addIncoming(Count, Preheader);
TcPhi->addIncoming(TcDec, Body);
CmpInst::Predicate Pred =
(LbBr->getSuccessor(0) == Body) ? CmpInst::ICMP_NE : CmpInst::ICMP_EQ;
LbCond->setPredicate(Pred);
LbCond->setOperand(0, TcDec);
LbCond->setOperand(1, ConstantInt::get(Ty, 0));
// Step 3: All the references to the original counter outside
// the loop are replaced with the NewCount
if (IsCntPhiUsedOutsideLoop)
CntPhi->replaceUsesOutsideBlock(NewCount, Body);
else
CntInst->replaceUsesOutsideBlock(NewCount, Body);
// step 4: Forget the "non-computable" trip-count SCEV associated with the
// loop. The loop would otherwise not be deleted even if it becomes empty.
SE->forgetLoop(CurLoop);
}
void LoopIdiomRecognize::transformLoopToPopcount(BasicBlock *PreCondBB,
Instruction *CntInst,
PHINode *CntPhi, Value *Var) {
BasicBlock *PreHead = CurLoop->getLoopPreheader();
auto *PreCondBr = cast<BranchInst>(PreCondBB->getTerminator());
const DebugLoc &DL = CntInst->getDebugLoc();
// Assuming before transformation, the loop is following:
// if (x) // the precondition
// do { cnt++; x &= x - 1; } while(x);
// Step 1: Insert the ctpop instruction at the end of the precondition block
IRBuilder<> Builder(PreCondBr);
Value *PopCnt, *PopCntZext, *NewCount, *TripCnt;
{
PopCnt = createPopcntIntrinsic(Builder, Var, DL);
NewCount = PopCntZext =
Builder.CreateZExtOrTrunc(PopCnt, cast<IntegerType>(CntPhi->getType()));
if (NewCount != PopCnt)
(cast<Instruction>(NewCount))->setDebugLoc(DL);
// TripCnt is exactly the number of iterations the loop has
TripCnt = NewCount;
// If the population counter's initial value is not zero, insert Add Inst.
Value *CntInitVal = CntPhi->getIncomingValueForBlock(PreHead);
ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
if (!InitConst || !InitConst->isZero()) {
NewCount = Builder.CreateAdd(NewCount, CntInitVal);
(cast<Instruction>(NewCount))->setDebugLoc(DL);
}
}
// Step 2: Replace the precondition from "if (x == 0) goto loop-exit" to
// "if (NewCount == 0) loop-exit". Without this change, the intrinsic
// function would be partial dead code, and downstream passes will drag
// it back from the precondition block to the preheader.
{
ICmpInst *PreCond = cast<ICmpInst>(PreCondBr->getCondition());
Value *Opnd0 = PopCntZext;
Value *Opnd1 = ConstantInt::get(PopCntZext->getType(), 0);
if (PreCond->getOperand(0) != Var)
std::swap(Opnd0, Opnd1);
ICmpInst *NewPreCond = cast<ICmpInst>(
Builder.CreateICmp(PreCond->getPredicate(), Opnd0, Opnd1));
PreCondBr->setCondition(NewPreCond);
RecursivelyDeleteTriviallyDeadInstructions(PreCond, TLI);
}
// Step 3: Note that the population count is exactly the trip count of the
// loop in question, which enable us to convert the loop from noncountable
// loop into a countable one. The benefit is twofold:
//
// - If the loop only counts population, the entire loop becomes dead after
// the transformation. It is a lot easier to prove a countable loop dead
// than to prove a noncountable one. (In some C dialects, an infinite loop
// isn't dead even if it computes nothing useful. In general, DCE needs
// to prove a noncountable loop finite before safely delete it.)
//
// - If the loop also performs something else, it remains alive.
// Since it is transformed to countable form, it can be aggressively
// optimized by some optimizations which are in general not applicable
// to a noncountable loop.
//
// After this step, this loop (conceptually) would look like following:
// newcnt = __builtin_ctpop(x);
// t = newcnt;
// if (x)
// do { cnt++; x &= x-1; t--) } while (t > 0);
BasicBlock *Body = *(CurLoop->block_begin());
{
auto *LbBr = cast<BranchInst>(Body->getTerminator());
ICmpInst *LbCond = cast<ICmpInst>(LbBr->getCondition());
Type *Ty = TripCnt->getType();
PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi", &Body->front());
Builder.SetInsertPoint(LbCond);
Instruction *TcDec = cast<Instruction>(
Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
"tcdec", false, true));
TcPhi->addIncoming(TripCnt, PreHead);
TcPhi->addIncoming(TcDec, Body);
CmpInst::Predicate Pred =
(LbBr->getSuccessor(0) == Body) ? CmpInst::ICMP_UGT : CmpInst::ICMP_SLE;
LbCond->setPredicate(Pred);
LbCond->setOperand(0, TcDec);
LbCond->setOperand(1, ConstantInt::get(Ty, 0));
}
// Step 4: All the references to the original population counter outside
// the loop are replaced with the NewCount -- the value returned from
// __builtin_ctpop().
CntInst->replaceUsesOutsideBlock(NewCount, Body);
// step 5: Forget the "non-computable" trip-count SCEV associated with the
// loop. The loop would otherwise not be deleted even if it becomes empty.
SE->forgetLoop(CurLoop);
}
bool LoopIdiomRecognize::matchBCmpLoopStructure(
CmpLoopStructure &CmpLoop) const {
ICmpInst::Predicate BCmpPred;
// We are looking for the following basic layout:
// PreheaderBB: <preheader> ; preds = ???
// <...>
// br label %LoopHeaderBB
// LoopHeaderBB: <header,exiting> ; preds = %PreheaderBB,%LoopLatchBB
// <...>
// %BCmpValue = icmp <...>
// br i1 %BCmpValue, label %LoopLatchBB, label %Successor0
// LoopLatchBB: <latch,exiting> ; preds = %LoopHeaderBB
// <...>
// %LatchCmpValue = <are we done, or do next iteration?>
// br i1 %LatchCmpValue, label %Successor1, label %LoopHeaderBB
// Successor0: <exit> ; preds = %LoopHeaderBB
// <...>
// Successor1: <exit> ; preds = %LoopLatchBB
// <...>
//
// Successor0 and Successor1 may or may not be the same basic block.
// Match basic frame-work of this supposedly-comparison loop.
using namespace PatternMatch;
if (!match(CurLoop->getHeader()->getTerminator(),
m_Br(m_CombineAnd(m_ICmp(BCmpPred, m_Value(), m_Value()),
m_Value(CmpLoop.BCmpValue)),
CmpLoop.HeaderBrEqualBB, CmpLoop.HeaderBrUnequalBB)) ||
!match(CurLoop->getLoopLatch()->getTerminator(),
m_Br(m_CombineAnd(m_Cmp(), m_Value(CmpLoop.LatchCmpValue)),
CmpLoop.LatchBrFinishBB, CmpLoop.LatchBrContinueBB))) {
LLVM_DEBUG(dbgs() << "Basic control-flow layout unrecognized.\n");
return false;
}
LLVM_DEBUG(dbgs() << "Recognized basic control-flow layout.\n");
return true;
}
bool LoopIdiomRecognize::matchBCmpOfLoads(Value *BCmpValue,
CmpOfLoads &CmpOfLoads) const {
using namespace PatternMatch;
LLVM_DEBUG(dbgs() << "Analyzing header icmp " << *BCmpValue
<< " as bcmp pattern.\n");
// Match bcmp-style loop header cmp. It must be an eq-icmp of loads. Example:
// %v0 = load <...>, <...>* %LoadSrcA
// %v1 = load <...>, <...>* %LoadSrcB
// %CmpLoop.BCmpValue = icmp eq <...> %v0, %v1
// There won't be any no-op bitcasts between load and icmp,
// they would have been transformed into a load of bitcast.
// FIXME: {b,mem}cmp() calls have the same semantics as icmp. Match them too.
if (!match(BCmpValue,
m_ICmp(CmpOfLoads.BCmpPred,
m_CombineAnd(m_Load(m_Value(CmpOfLoads.LoadSrcA)),
m_Value(CmpOfLoads.LoadA)),
m_CombineAnd(m_Load(m_Value(CmpOfLoads.LoadSrcB)),
m_Value(CmpOfLoads.LoadB)))) ||
!ICmpInst::isEquality(CmpOfLoads.BCmpPred)) {
LLVM_DEBUG(dbgs() << "Loop header icmp did not match bcmp pattern.\n");
return false;
}
LLVM_DEBUG(dbgs() << "Recognized header icmp as bcmp pattern with loads:\n\t"
<< *CmpOfLoads.LoadA << "\n\t" << *CmpOfLoads.LoadB
<< "\n");
// FIXME: handle memcmp pattern?
return true;
}
bool LoopIdiomRecognize::recognizeBCmpLoopControlFlow(
const CmpOfLoads &CmpOfLoads, CmpLoopStructure &CmpLoop) const {
BasicBlock *LoopHeaderBB = CurLoop->getHeader();
BasicBlock *LoopLatchBB = CurLoop->getLoopLatch();
// Be wary, comparisons can be inverted, canonicalize order.
// If this 'element' comparison passed, we expect to proceed to the next elt.
if (CmpOfLoads.BCmpPred != ICmpInst::Predicate::ICMP_EQ)
std::swap(CmpLoop.HeaderBrEqualBB, CmpLoop.HeaderBrUnequalBB);
// The predicate on loop latch does not matter, just canonicalize some order.
if (CmpLoop.LatchBrContinueBB != LoopHeaderBB)
std::swap(CmpLoop.LatchBrFinishBB, CmpLoop.LatchBrContinueBB);
SmallVector<BasicBlock *, 2> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
assert(ExitBlocks.size() <= 2U && "Can't have more than two exit blocks.");
// Check that control-flow between blocks is as expected.
if (CmpLoop.HeaderBrEqualBB != LoopLatchBB ||
CmpLoop.LatchBrContinueBB != LoopHeaderBB ||
!is_contained(ExitBlocks, CmpLoop.HeaderBrUnequalBB) ||
!is_contained(ExitBlocks, CmpLoop.LatchBrFinishBB)) {
LLVM_DEBUG(dbgs() << "Loop control-flow not recognized.\n");
return false;
}
assert(!is_contained(ExitBlocks, CmpLoop.HeaderBrEqualBB) &&
!is_contained(ExitBlocks, CmpLoop.LatchBrContinueBB) &&
"Unexpected exit edges.");
LLVM_DEBUG(dbgs() << "Recognized loop control-flow.\n");
LLVM_DEBUG(dbgs() << "Performing side-effect analysis on the loop.\n");
assert(CurLoop->isLCSSAForm(*DT) && "Should only get LCSSA-form loops here.");
// No loop instructions must be used outside of the loop. Since we are in
// LCSSA form, we only need to check successor block's PHI nodes's incoming
// values for incoming blocks that are the loop basic blocks.
for (const BasicBlock *ExitBB : ExitBlocks) {
for (const PHINode &PHI : ExitBB->phis()) {
for (const BasicBlock *LoopBB :
make_filter_range(PHI.blocks(), [this](BasicBlock *PredecessorBB) {
return CurLoop->contains(PredecessorBB);
})) {
const auto *I =
dyn_cast<Instruction>(PHI.getIncomingValueForBlock(LoopBB));
if (I && CurLoop->contains(I)) {
LLVM_DEBUG(dbgs()
<< "Loop contains instruction " << *I
<< " which is used outside of the loop in basic block "
<< ExitBB->getName() << " in phi node " << PHI << "\n");
return false;
}
}
}
}
// Similarly, the loop should not have any other observable side-effects
// other than the final comparison result.
for (BasicBlock *LoopBB : CurLoop->blocks()) {
for (Instruction &I : *LoopBB) {
if (isa<DbgInfoIntrinsic>(I)) // Ignore dbginfo.
continue; // FIXME: anything else? lifetime info?
if ((I.mayHaveSideEffects() || I.isAtomic() || I.isFenceLike()) &&
&I != CmpOfLoads.LoadA && &I != CmpOfLoads.LoadB) {
LLVM_DEBUG(
dbgs() << "Loop contains instruction with potential side-effects: "
<< I << "\n");
return false;
}
}
}
LLVM_DEBUG(dbgs() << "No loop instructions deemed to have side-effects.\n");
return true;
}
bool LoopIdiomRecognize::recognizeBCmpLoopSCEV(uint64_t BCmpTyBytes,
CmpOfLoads &CmpOfLoads,
const SCEV *&SrcA,
const SCEV *&SrcB,
const SCEV *&Iterations) const {
// Try to compute SCEV of the loads, for this loop's scope.
const auto *ScevForSrcA = dyn_cast<SCEVAddRecExpr>(
SE->getSCEVAtScope(CmpOfLoads.LoadSrcA, CurLoop));
const auto *ScevForSrcB = dyn_cast<SCEVAddRecExpr>(
SE->getSCEVAtScope(CmpOfLoads.LoadSrcB, CurLoop));
if (!ScevForSrcA || !ScevForSrcB) {
LLVM_DEBUG(dbgs() << "Failed to get SCEV expressions for load sources.\n");
return false;
}
LLVM_DEBUG(dbgs() << "Got SCEV expressions (at loop scope) for loads:\n\t"
<< *ScevForSrcA << "\n\t" << *ScevForSrcB << "\n");
// Loads must have folloving SCEV exprs: {%ptr,+,BCmpTyBytes}<%LoopHeaderBB>
const SCEV *RecStepForA = ScevForSrcA->getStepRecurrence(*SE);
const SCEV *RecStepForB = ScevForSrcB->getStepRecurrence(*SE);
if (!ScevForSrcA->isAffine() || !ScevForSrcB->isAffine() ||
ScevForSrcA->getLoop() != CurLoop || ScevForSrcB->getLoop() != CurLoop ||
RecStepForA != RecStepForB || !isa<SCEVConstant>(RecStepForA) ||
cast<SCEVConstant>(RecStepForA)->getAPInt() != BCmpTyBytes) {
LLVM_DEBUG(dbgs() << "Unsupported SCEV expressions for loads. Only support "
"affine SCEV expressions originating in the loop we "
"are analysing with identical constant positive step, "
"equal to the count of bytes compared. Got:\n\t"
<< *RecStepForA << "\n\t" << *RecStepForB << "\n");
return false;
// FIXME: can support BCmpTyBytes > Step.
// But will need to account for the extra bytes compared at the end.
}
SrcA = ScevForSrcA->getStart();
SrcB = ScevForSrcB->getStart();
LLVM_DEBUG(dbgs() << "Got SCEV expressions for load sources:\n\t" << *SrcA
<< "\n\t" << *SrcB << "\n");
// The load sources must be loop-invants that dominate the loop header.
if (SrcA == SE->getCouldNotCompute() || SrcB == SE->getCouldNotCompute() ||
!SE->isAvailableAtLoopEntry(SrcA, CurLoop) ||
!SE->isAvailableAtLoopEntry(SrcB, CurLoop)) {
LLVM_DEBUG(dbgs() << "Unsupported SCEV expressions for loads, unavaliable "
"prior to loop header.\n");
return false;
}
LLVM_DEBUG(dbgs() << "SCEV expressions for loads are acceptable.\n");
// bcmp / memcmp take length argument as size_t, so let's conservatively
// assume that the iteration count should be not wider than that.
Type *CmpFuncSizeTy = DL->getIntPtrType(SE->getContext());
// For how many iterations is loop guaranteed not to exit via LoopLatch?
// This is one less than the maximal number of comparisons,and is: n + -1
const SCEV *LoopExitCount =
SE->getExitCount(CurLoop, CurLoop->getLoopLatch());
LLVM_DEBUG(dbgs() << "Got SCEV expression for loop latch exit count: "
<< *LoopExitCount << "\n");
// Exit count, similarly, must be loop-invant that dominates the loop header.
if (LoopExitCount == SE->getCouldNotCompute() ||
!LoopExitCount->getType()->isIntOrPtrTy() ||
LoopExitCount->getType()->getScalarSizeInBits() >
CmpFuncSizeTy->getScalarSizeInBits() ||
!SE->isAvailableAtLoopEntry(LoopExitCount, CurLoop)) {
LLVM_DEBUG(dbgs() << "Unsupported SCEV expression for loop latch exit.\n");
return false;
}
// LoopExitCount is always one less than the actual count of iterations.
// Do this before cast, else we will be stuck with 1 + zext(-1 + n)
Iterations = SE->getAddExpr(
LoopExitCount, SE->getOne(LoopExitCount->getType()), SCEV::FlagNUW);
assert(Iterations != SE->getCouldNotCompute() &&
"Shouldn't fail to increment by one.");
LLVM_DEBUG(dbgs() << "Computed iteration count: " << *Iterations << "\n");
return true;
}
/// Return true iff the bcmp idiom is detected in the loop.
///
/// Additionally:
/// 1) \p BCmpInst is set to the root byte-comparison instruction.
/// 2) \p LatchCmpInst is set to the comparison that controls the latch.
/// 3) \p LoadA is set to the first LoadInst.
/// 4) \p LoadB is set to the second LoadInst.
/// 5) \p SrcA is set to the first source location that is being compared.
/// 6) \p SrcB is set to the second source location that is being compared.
/// 7) \p NBytes is set to the number of bytes to compare.
bool LoopIdiomRecognize::detectBCmpIdiom(ICmpInst *&BCmpInst,
CmpInst *&LatchCmpInst,
LoadInst *&LoadA, LoadInst *&LoadB,
const SCEV *&SrcA, const SCEV *&SrcB,
const SCEV *&NBytes) const {
LLVM_DEBUG(dbgs() << "Recognizing bcmp idiom\n");
// Give up if the loop is not in normal form, or has more than 2 blocks.
if (!CurLoop->isLoopSimplifyForm() || CurLoop->getNumBlocks() > 2) {
LLVM_DEBUG(dbgs() << "Basic loop structure unrecognized.\n");
return false;
}
LLVM_DEBUG(dbgs() << "Recognized basic loop structure.\n");
CmpLoopStructure CmpLoop;
if (!matchBCmpLoopStructure(CmpLoop))
return false;
CmpOfLoads CmpOfLoads;
if (!matchBCmpOfLoads(CmpLoop.BCmpValue, CmpOfLoads))
return false;
if (!recognizeBCmpLoopControlFlow(CmpOfLoads, CmpLoop))
return false;
BCmpInst = cast<ICmpInst>(CmpLoop.BCmpValue); // FIXME: is there no
LatchCmpInst = cast<CmpInst>(CmpLoop.LatchCmpValue); // way to combine
LoadA = cast<LoadInst>(CmpOfLoads.LoadA); // these cast with
LoadB = cast<LoadInst>(CmpOfLoads.LoadB); // m_Value() matcher?
Type *BCmpValTy = BCmpInst->getOperand(0)->getType();
LLVMContext &Context = BCmpValTy->getContext();
uint64_t BCmpTyBits = DL->getTypeSizeInBits(BCmpValTy);
static constexpr uint64_t ByteTyBits = 8;
LLVM_DEBUG(dbgs() << "Got comparison between values of type " << *BCmpValTy
<< " of size " << BCmpTyBits
<< " bits (while byte = " << ByteTyBits << " bits).\n");
// bcmp()/memcmp() minimal unit of work is a byte. Therefore we must check
// that we are dealing with a multiple of a byte here.
if (BCmpTyBits % ByteTyBits != 0) {
LLVM_DEBUG(dbgs() << "Value size is not a multiple of byte.\n");
return false;
// FIXME: could still be done under a run-time check that the total bit
// count is a multiple of a byte i guess? Or handle remainder separately?
}
// Each comparison is done on this many bytes.
uint64_t BCmpTyBytes = BCmpTyBits / ByteTyBits;
LLVM_DEBUG(dbgs() << "Size is exactly " << BCmpTyBytes
<< " bytes, eligible for bcmp conversion.\n");
const SCEV *Iterations;
if (!recognizeBCmpLoopSCEV(BCmpTyBytes, CmpOfLoads, SrcA, SrcB, Iterations))
return false;
// bcmp / memcmp take length argument as size_t, do promotion now.
Type *CmpFuncSizeTy = DL->getIntPtrType(Context);
Iterations = SE->getNoopOrZeroExtend(Iterations, CmpFuncSizeTy);
assert(Iterations != SE->getCouldNotCompute() && "Promotion failed.");
// Note that it didn't do ptrtoint cast, we will need to do it manually.
// We will be comparing *bytes*, not BCmpTy, we need to recalculate size.
// It's a multiplication, and it *could* overflow. But for it to overflow
// we'd want to compare more bytes than could be represented by size_t, But
// allocation functions also take size_t. So how'd you produce such buffer?
// FIXME: we likely need to actually check that we know this won't overflow,
// via llvm::computeOverflowForUnsignedMul().
NBytes = SE->getMulExpr(
Iterations, SE->getConstant(CmpFuncSizeTy, BCmpTyBytes), SCEV::FlagNUW);
assert(NBytes != SE->getCouldNotCompute() &&
"Shouldn't fail to increment by one.");
LLVM_DEBUG(dbgs() << "Computed total byte count: " << *NBytes << "\n");
if (LoadA->getPointerAddressSpace() != LoadB->getPointerAddressSpace() ||
LoadA->getPointerAddressSpace() != 0 || !LoadA->isSimple() ||
!LoadB->isSimple()) {
StringLiteral L("Unsupported loads in idiom - only support identical, "
"simple loads from address space 0.\n");
LLVM_DEBUG(dbgs() << L);
ORE.emit([&]() {
return OptimizationRemarkMissed(DEBUG_TYPE, "BCmpIdiomUnsupportedLoads",
BCmpInst->getDebugLoc(),
CurLoop->getHeader())
<< L;
});
return false; // FIXME: support non-simple loads.
}
LLVM_DEBUG(dbgs() << "Recognized bcmp idiom\n");
ORE.emit([&]() {
return OptimizationRemarkAnalysis(DEBUG_TYPE, "RecognizedBCmpIdiom",
CurLoop->getStartLoc(),
CurLoop->getHeader())
<< "Loop recognized as a bcmp idiom";
});
return true;
}
BasicBlock *
LoopIdiomRecognize::transformBCmpControlFlow(ICmpInst *ComparedEqual) {
LLVM_DEBUG(dbgs() << "Transforming control-flow.\n");
SmallVector<DominatorTree::UpdateType, 8> DTUpdates;
BasicBlock *PreheaderBB = CurLoop->getLoopPreheader();
BasicBlock *HeaderBB = CurLoop->getHeader();
BasicBlock *LoopLatchBB = CurLoop->getLoopLatch();
SmallString<32> LoopName = CurLoop->getName();
Function *Func = PreheaderBB->getParent();
LLVMContext &Context = Func->getContext();
// Before doing anything, drop SCEV info.
SE->forgetLoop(CurLoop);
// Here we start with: (0/6)
// PreheaderBB: <preheader> ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// br label %LoopHeaderBB
// LoopHeaderBB: <header,exiting> ; preds = %PreheaderBB,%LoopLatchBB
// <...>
// br i1 %<...>, label %LoopLatchBB, label %Successor0BB
// LoopLatchBB: <latch,exiting> ; preds = %LoopHeaderBB
// <...>
// br i1 %<...>, label %Successor1BB, label %LoopHeaderBB
// Successor0BB: <exit> ; preds = %LoopHeaderBB
// %S0PHI = phi <...> [ <...>, %LoopHeaderBB ]
// <...>
// Successor1BB: <exit> ; preds = %LoopLatchBB
// %S1PHI = phi <...> [ <...>, %LoopLatchBB ]
// <...>
//
// Successor0 and Successor1 may or may not be the same basic block.
// Decouple the edge between loop preheader basic block and loop header basic
// block. Thus the loop has become unreachable.
assert(cast<BranchInst>(PreheaderBB->getTerminator())->isUnconditional() &&
PreheaderBB->getTerminator()->getSuccessor(0) == HeaderBB &&
"Preheader bb must end with an unconditional branch to header bb.");
PreheaderBB->getTerminator()->eraseFromParent();
DTUpdates.push_back({DominatorTree::Delete, PreheaderBB, HeaderBB});
// Create a new preheader basic block before loop header basic block.
auto *PhonyPreheaderBB = BasicBlock::Create(
Context, LoopName + ".phonypreheaderbb", Func, HeaderBB);
// And insert an unconditional branch from phony preheader basic block to
// loop header basic block.
IRBuilder<>(PhonyPreheaderBB).CreateBr(HeaderBB);
DTUpdates.push_back({DominatorTree::Insert, PhonyPreheaderBB, HeaderBB});
// Create a *single* new empty block that we will substitute as a
// successor basic block for the loop's exits. This one is temporary.
// Much like phony preheader basic block, it is not connected.
auto *PhonySuccessorBB =
BasicBlock::Create(Context, LoopName + ".phonysuccessorbb", Func,
LoopLatchBB->getNextNode());
// That block must have *some* non-PHI instruction, or else deleteDeadLoop()
// will mess up cleanup of dbginfo, and verifier will complain.
IRBuilder<>(PhonySuccessorBB).CreateUnreachable();
// Create two new empty blocks that we will use to preserve the original
// loop exit control-flow, and preserve the incoming values in the PHI nodes
// in loop's successor exit blocks. These will live one.
auto *ComparedUnequalBB =
BasicBlock::Create(Context, ComparedEqual->getName() + ".unequalbb", Func,
PhonySuccessorBB->getNextNode());
auto *ComparedEqualBB =
BasicBlock::Create(Context, ComparedEqual->getName() + ".equalbb", Func,
PhonySuccessorBB->getNextNode());
// By now we have: (1/6)
// PreheaderBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// [no terminator instruction!]
// PhonyPreheaderBB: <preheader> ; No preds, UNREACHABLE!
// br label %LoopHeaderBB
// LoopHeaderBB: <header,exiting> ; preds = %PhonyPreheaderBB, %LoopLatchBB
// <...>
// br i1 %<...>, label %LoopLatchBB, label %Successor0BB
// LoopLatchBB: <latch,exiting> ; preds = %LoopHeaderBB
// <...>
// br i1 %<...>, label %Successor1BB, label %LoopHeaderBB
// PhonySuccessorBB: ; No preds, UNREACHABLE!
// unreachable
// EqualBB: ; No preds, UNREACHABLE!
// [no terminator instruction!]
// UnequalBB: ; No preds, UNREACHABLE!
// [no terminator instruction!]
// Successor0BB: <exit> ; preds = %LoopHeaderBB
// %S0PHI = phi <...> [ <...>, %LoopHeaderBB ]
// <...>
// Successor1BB: <exit> ; preds = %LoopLatchBB
// %S1PHI = phi <...> [ <...>, %LoopLatchBB ]
// <...>
// What is the mapping/replacement basic block for exiting out of the loop
// from either of old's loop basic blocks?
auto GetReplacementBB = [this, ComparedEqualBB,
ComparedUnequalBB](const BasicBlock *OldBB) {
assert(CurLoop->contains(OldBB) && "Only for loop's basic blocks.");
if (OldBB == CurLoop->getLoopLatch()) // "all elements compared equal".
return ComparedEqualBB;
if (OldBB == CurLoop->getHeader()) // "element compared unequal".
return ComparedUnequalBB;
llvm_unreachable("Only had two basic blocks in loop.");
};
// What are the exits out of this loop?
SmallVector<Loop::Edge, 2> LoopExitEdges;
CurLoop->getExitEdges(LoopExitEdges);
assert(LoopExitEdges.size() == 2 && "Should have only to two exit edges.");
// Populate new basic blocks, update the exiting control-flow, PHI nodes.
for (const Loop::Edge &Edge : LoopExitEdges) {
auto *OldLoopBB = const_cast<BasicBlock *>(Edge.first);
auto *SuccessorBB = const_cast<BasicBlock *>(Edge.second);
assert(CurLoop->contains(OldLoopBB) && !CurLoop->contains(SuccessorBB) &&
"Unexpected edge.");
// If we would exit the loop from this loop's basic block,
// what semantically would that mean? Did comparison succeed or fail?
BasicBlock *NewBB = GetReplacementBB(OldLoopBB);
assert(NewBB->empty() && "Should not get same new basic block here twice.");
IRBuilder<> Builder(NewBB);
Builder.SetCurrentDebugLocation(OldLoopBB->getTerminator()->getDebugLoc());
Builder.CreateBr(SuccessorBB);
DTUpdates.push_back({DominatorTree::Insert, NewBB, SuccessorBB});
// Also, be *REALLY* careful with PHI nodes in successor basic block,
// update them to recieve the same input value, but not from current loop's
// basic block, but from new basic block instead.
SuccessorBB->replacePhiUsesWith(OldLoopBB, NewBB);
// Also, change loop control-flow. This loop's basic block shall no longer
// exit from the loop to it's original successor basic block, but to our new
// phony successor basic block. Note that new successor will be unique exit.
OldLoopBB->getTerminator()->replaceSuccessorWith(SuccessorBB,
PhonySuccessorBB);
DTUpdates.push_back({DominatorTree::Delete, OldLoopBB, SuccessorBB});
DTUpdates.push_back({DominatorTree::Insert, OldLoopBB, PhonySuccessorBB});
}
// Inform DomTree about edge changes. Note that LoopInfo is still out-of-date.
assert(DTUpdates.size() == 8 && "Update count prediction failed.");
DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
DTU.applyUpdates(DTUpdates);
DTUpdates.clear();
// By now we have: (2/6)
// PreheaderBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// [no terminator instruction!]
// PhonyPreheaderBB: <preheader> ; No preds, UNREACHABLE!
// br label %LoopHeaderBB
// LoopHeaderBB: <header,exiting> ; preds = %PhonyPreheaderBB, %LoopLatchBB
// <...>
// br i1 %<...>, label %LoopLatchBB, label %PhonySuccessorBB
// LoopLatchBB: <latch,exiting> ; preds = %LoopHeaderBB
// <...>
// br i1 %<...>, label %PhonySuccessorBB, label %LoopHeaderBB
// PhonySuccessorBB: <uniq. exit> ; preds = %LoopHeaderBB, %LoopLatchBB
// unreachable
// EqualBB: ; No preds, UNREACHABLE!
// br label %Successor1BB
// UnequalBB: ; No preds, UNREACHABLE!
// br label %Successor0BB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
// *Finally*, zap the original loop. Record it's parent loop though.
Loop *ParentLoop = CurLoop->getParentLoop();
LLVM_DEBUG(dbgs() << "Deleting old loop.\n");
LoopDeleter.markLoopAsDeleted(CurLoop); // Mark as deleted *BEFORE* deleting!
deleteDeadLoop(CurLoop, DT, SE, LI); // And actually delete the loop.
CurLoop = nullptr;
// By now we have: (3/6)
// PreheaderBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// [no terminator instruction!]
// PhonyPreheaderBB: ; No preds, UNREACHABLE!
// br label %PhonySuccessorBB
// PhonySuccessorBB: ; preds = %PhonyPreheaderBB
// unreachable
// EqualBB: ; No preds, UNREACHABLE!
// br label %Successor1BB
// UnequalBB: ; No preds, UNREACHABLE!
// br label %Successor0BB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
// Now, actually restore the CFG.
// Insert an unconditional branch from an actual preheader basic block to
// phony preheader basic block.
IRBuilder<>(PreheaderBB).CreateBr(PhonyPreheaderBB);
DTUpdates.push_back({DominatorTree::Insert, PhonyPreheaderBB, HeaderBB});
// Insert proper conditional branch from phony successor basic block to the
// "dispatch" basic blocks, which were used to preserve incoming values in
// original loop's successor basic blocks.
assert(isa<UnreachableInst>(PhonySuccessorBB->getTerminator()) &&
"Yep, that's the one we created to keep deleteDeadLoop() happy.");
PhonySuccessorBB->getTerminator()->eraseFromParent();
{
IRBuilder<> Builder(PhonySuccessorBB);
Builder.SetCurrentDebugLocation(ComparedEqual->getDebugLoc());
Builder.CreateCondBr(ComparedEqual, ComparedEqualBB, ComparedUnequalBB);
}
DTUpdates.push_back(
{DominatorTree::Insert, PhonySuccessorBB, ComparedEqualBB});
DTUpdates.push_back(
{DominatorTree::Insert, PhonySuccessorBB, ComparedUnequalBB});
BasicBlock *DispatchBB = PhonySuccessorBB;
DispatchBB->setName(LoopName + ".bcmpdispatchbb");
assert(DTUpdates.size() == 3 && "Update count prediction failed.");
DTU.applyUpdates(DTUpdates);
DTUpdates.clear();
// By now we have: (4/6)
// PreheaderBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// br label %PhonyPreheaderBB
// PhonyPreheaderBB: ; preds = %PreheaderBB
// br label %DispatchBB
// DispatchBB: ; preds = %PhonyPreheaderBB
// br i1 %ComparedEqual, label %EqualBB, label %UnequalBB
// EqualBB: ; preds = %DispatchBB
// br label %Successor1BB
// UnequalBB: ; preds = %DispatchBB
// br label %Successor0BB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
// The basic CFG has been restored! Now let's merge redundant basic blocks.
// Merge phony successor basic block into it's only predecessor,
// phony preheader basic block. It is fully pointlessly redundant.
MergeBasicBlockIntoOnlyPred(DispatchBB, &DTU);
// By now we have: (5/6)
// PreheaderBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// br label %DispatchBB
// DispatchBB: ; preds = %PreheaderBB
// br i1 %ComparedEqual, label %EqualBB, label %UnequalBB
// EqualBB: ; preds = %DispatchBB
// br label %Successor1BB
// UnequalBB: ; preds = %DispatchBB
// br label %Successor0BB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
// Was this loop nested?
if (!ParentLoop) {
// If the loop was *NOT* nested, then let's also merge phony successor
// basic block into it's only predecessor, preheader basic block.
// Also, here we need to update LoopInfo.
LI->removeBlock(PreheaderBB);
MergeBasicBlockIntoOnlyPred(DispatchBB, &DTU);
// By now we have: (6/6)
// DispatchBB: ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// br i1 %ComparedEqual, label %EqualBB, label %UnequalBB
// EqualBB: ; preds = %DispatchBB
// br label %Successor1BB
// UnequalBB: ; preds = %DispatchBB
// br label %Successor0BB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
return DispatchBB;
}
// Otherwise, we need to "preserve" the LoopSimplify form of the deleted loop.
// To achieve that, we shall keep the preheader basic block (mainly so that
// the loop header block will be guaranteed to have a predecessor outside of
// the loop), and create a phony loop with all these new three basic blocks.
Loop *PhonyLoop = LI->AllocateLoop();
ParentLoop->addChildLoop(PhonyLoop);
PhonyLoop->addBasicBlockToLoop(DispatchBB, *LI);
PhonyLoop->addBasicBlockToLoop(ComparedEqualBB, *LI);
PhonyLoop->addBasicBlockToLoop(ComparedUnequalBB, *LI);
// But we only have a preheader basic block, a header basic block block and
// two exiting basic blocks. For a proper loop we also need a backedge from
// non-header basic block to header bb.
// Let's just add a never-taken branch from both of the exiting basic blocks.
for (BasicBlock *BB : {ComparedEqualBB, ComparedUnequalBB}) {
BranchInst *OldTerminator = cast<BranchInst>(BB->getTerminator());
assert(OldTerminator->isUnconditional() && "That's the one we created.");
BasicBlock *SuccessorBB = OldTerminator->getSuccessor(0);
IRBuilder<> Builder(OldTerminator);
Builder.SetCurrentDebugLocation(OldTerminator->getDebugLoc());
Builder.CreateCondBr(ConstantInt::getTrue(Context), SuccessorBB,
DispatchBB);
OldTerminator->eraseFromParent();
// Yes, the backedge will never be taken. The control-flow is redundant.
// If it can be simplified further, other passes will take care.
DTUpdates.push_back({DominatorTree::Delete, BB, SuccessorBB});
DTUpdates.push_back({DominatorTree::Insert, BB, SuccessorBB});
DTUpdates.push_back({DominatorTree::Insert, BB, DispatchBB});
}
assert(DTUpdates.size() == 6 && "Update count prediction failed.");
DTU.applyUpdates(DTUpdates);
DTUpdates.clear();
// By now we have: (6/6)
// PreheaderBB: <preheader> ; preds = ???
// <...>
// %memcmp = call i32 @memcmp(i8* %LoadSrcA, i8* %LoadSrcB, i64 %Nbytes)
// %ComparedEqual = icmp eq <...> %memcmp, 0
// br label %BCmpDispatchBB
// BCmpDispatchBB: <header> ; preds = %PreheaderBB
// br i1 %ComparedEqual, label %EqualBB, label %UnequalBB
// EqualBB: <latch,exiting> ; preds = %BCmpDispatchBB
// br i1 %true, label %Successor1BB, label %BCmpDispatchBB
// UnequalBB: <latch,exiting> ; preds = %BCmpDispatchBB
// br i1 %true, label %Successor0BB, label %BCmpDispatchBB
// Successor0BB: ; preds = %UnequalBB
// %S0PHI = phi <...> [ <...>, %UnequalBB ]
// <...>
// Successor1BB: ; preds = %EqualBB
// %S0PHI = phi <...> [ <...>, %EqualBB ]
// <...>
// Finally fully DONE!
return DispatchBB;
}
void LoopIdiomRecognize::transformLoopToBCmp(ICmpInst *BCmpInst,
CmpInst *LatchCmpInst,
LoadInst *LoadA, LoadInst *LoadB,
const SCEV *SrcA, const SCEV *SrcB,
const SCEV *NBytes) {
// We will be inserting before the terminator instruction of preheader block.
IRBuilder<> Builder(CurLoop->getLoopPreheader()->getTerminator());
LLVM_DEBUG(dbgs() << "Transforming bcmp loop idiom into a call.\n");
LLVM_DEBUG(dbgs() << "Emitting new instructions.\n");
// Expand the SCEV expressions for both sources to compare, and produce value
// for the byte len (beware of Iterations potentially being a pointer, and
// account for element size being BCmpTyBytes bytes, which may be not 1 byte)
Value *PtrA, *PtrB, *Len;
{
SCEVExpander SExp(*SE, *DL, "LoopToBCmp");
SExp.setInsertPoint(&*Builder.GetInsertPoint());
auto HandlePtr = [&SExp](LoadInst *Load, const SCEV *Src) {
SExp.SetCurrentDebugLocation(DebugLoc());
// If the pointer operand of original load had dbgloc - use it.
if (const auto *I = dyn_cast<Instruction>(Load->getPointerOperand()))
SExp.SetCurrentDebugLocation(I->getDebugLoc());
return SExp.expandCodeFor(Src);
};
PtrA = HandlePtr(LoadA, SrcA);
PtrB = HandlePtr(LoadB, SrcB);
// For len calculation let's use dbgloc for the loop's latch condition.
Builder.SetCurrentDebugLocation(LatchCmpInst->getDebugLoc());
SExp.SetCurrentDebugLocation(LatchCmpInst->getDebugLoc());
Len = SExp.expandCodeFor(NBytes);
Type *CmpFuncSizeTy = DL->getIntPtrType(Builder.getContext());
assert(SE->getTypeSizeInBits(Len->getType()) ==
DL->getTypeSizeInBits(CmpFuncSizeTy) &&
"Len should already have the correct size.");
// Make sure that iteration count is a number, insert ptrtoint cast if not.
if (Len->getType()->isPointerTy())
Len = Builder.CreatePtrToInt(Len, CmpFuncSizeTy);
assert(Len->getType() == CmpFuncSizeTy && "Should have correct type now.");
Len->setName(Len->getName() + ".bytecount");
// There is no legality check needed. We want to compare that the memory
// regions [PtrA, PtrA+Len) and [PtrB, PtrB+Len) are fully identical, equal.
// For them to be fully equal, they must match bit-by-bit. And likewise,
// for them to *NOT* be fully equal, they have to differ just by one bit.
// The step of comparison (bits compared at once) simply does not matter.
}
// For the rest of new instructions, dbgloc should point at the value cmp.
Builder.SetCurrentDebugLocation(BCmpInst->getDebugLoc());
// Emit the comparison itself.
auto *CmpCall =
cast<CallInst>(HasBCmp ? emitBCmp(PtrA, PtrB, Len, Builder, *DL, TLI)
: emitMemCmp(PtrA, PtrB, Len, Builder, *DL, TLI));
// FIXME: add {B,Mem}CmpInst with MemoryCompareInst
// (based on MemIntrinsicBase) as base?
// FIXME: propagate metadata from loads? (alignments, AS, TBAA, ...)
// {b,mem}cmp returned 0 if they were equal, or non-zero if not equal.
auto *ComparedEqual = cast<ICmpInst>(Builder.CreateICmpEQ(
CmpCall, ConstantInt::get(CmpCall->getType(), 0),
PtrA->getName() + ".vs." + PtrB->getName() + ".eqcmp"));
BasicBlock *BB = transformBCmpControlFlow(ComparedEqual);
Builder.ClearInsertionPoint();
// We're done.
LLVM_DEBUG(dbgs() << "Transformed loop bcmp idiom into a call.\n");
ORE.emit([&]() {
return OptimizationRemark(DEBUG_TYPE, "TransformedBCmpIdiomToCall",
CmpCall->getDebugLoc(), BB)
<< "Transformed bcmp idiom into a call to "
<< ore::NV("NewFunction", CmpCall->getCalledFunction())
<< "() function";
});
++NumBCmp;
}
/// Recognizes a bcmp idiom in a non-countable loop.
///
/// If detected, transforms the relevant code to issue the bcmp (or memcmp)
/// intrinsic function call, and returns true; otherwise, returns false.
bool LoopIdiomRecognize::recognizeBCmp() {
if (!HasMemCmp && !HasBCmp)
return false;
ICmpInst *BCmpInst;
CmpInst *LatchCmpInst;
LoadInst *LoadA, *LoadB;
const SCEV *SrcA, *SrcB, *NBytes;
if (!detectBCmpIdiom(BCmpInst, LatchCmpInst, LoadA, LoadB, SrcA, SrcB,
NBytes)) {
LLVM_DEBUG(dbgs() << "bcmp idiom recognition failed.\n");
return false;
}
transformLoopToBCmp(BCmpInst, LatchCmpInst, LoadA, LoadB, SrcA, SrcB, NBytes);
return true;
}