mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-17 18:31:04 +00:00
bd64447bf3
Determining the address of a TLS variable results in a function call in certain TLS models. This means that a simple ICmpInst might actually result in invalidating the CTR register. In such cases, do not attempt to rely on the CTR register for loop optimization purposes. This fixes PR22034. Differential Revision: http://reviews.llvm.org/D6786 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@224890 91177308-0d34-0410-b5e6-96231b3b80d8
681 lines
22 KiB
C++
681 lines
22 KiB
C++
//===-- PPCCTRLoops.cpp - Identify and generate CTR loops -----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This pass identifies loops where we can generate the PPC branch instructions
|
|
// that decrement and test the count register (CTR) (bdnz and friends).
|
|
//
|
|
// The pattern that defines the induction variable can changed depending on
|
|
// prior optimizations. For example, the IndVarSimplify phase run by 'opt'
|
|
// normalizes induction variables, and the Loop Strength Reduction pass
|
|
// run by 'llc' may also make changes to the induction variable.
|
|
//
|
|
// Criteria for CTR loops:
|
|
// - Countable loops (w/ ind. var for a trip count)
|
|
// - Try inner-most loops first
|
|
// - No nested CTR loops.
|
|
// - No function calls in loops.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
#include "PPC.h"
|
|
#include "PPCTargetMachine.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/Analysis/LoopInfo.h"
|
|
#include "llvm/Analysis/ScalarEvolutionExpander.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
#include "llvm/IR/Dominators.h"
|
|
#include "llvm/IR/InlineAsm.h"
|
|
#include "llvm/IR/Instructions.h"
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/ValueHandle.h"
|
|
#include "llvm/PassSupport.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/Target/TargetLibraryInfo.h"
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
#include "llvm/Transforms/Utils/Local.h"
|
|
#include "llvm/Transforms/Utils/LoopUtils.h"
|
|
|
|
#ifndef NDEBUG
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "ctrloops"
|
|
|
|
#ifndef NDEBUG
|
|
static cl::opt<int> CTRLoopLimit("ppc-max-ctrloop", cl::Hidden, cl::init(-1));
|
|
#endif
|
|
|
|
STATISTIC(NumCTRLoops, "Number of loops converted to CTR loops");
|
|
|
|
namespace llvm {
|
|
void initializePPCCTRLoopsPass(PassRegistry&);
|
|
#ifndef NDEBUG
|
|
void initializePPCCTRLoopsVerifyPass(PassRegistry&);
|
|
#endif
|
|
}
|
|
|
|
namespace {
|
|
struct PPCCTRLoops : public FunctionPass {
|
|
|
|
#ifndef NDEBUG
|
|
static int Counter;
|
|
#endif
|
|
|
|
public:
|
|
static char ID;
|
|
|
|
PPCCTRLoops() : FunctionPass(ID), TM(nullptr) {
|
|
initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
PPCCTRLoops(PPCTargetMachine &TM) : FunctionPass(ID), TM(&TM) {
|
|
initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
bool runOnFunction(Function &F) override;
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.addRequired<LoopInfo>();
|
|
AU.addPreserved<LoopInfo>();
|
|
AU.addRequired<DominatorTreeWrapperPass>();
|
|
AU.addPreserved<DominatorTreeWrapperPass>();
|
|
AU.addRequired<ScalarEvolution>();
|
|
}
|
|
|
|
private:
|
|
bool mightUseCTR(const Triple &TT, BasicBlock *BB);
|
|
bool convertToCTRLoop(Loop *L);
|
|
|
|
private:
|
|
PPCTargetMachine *TM;
|
|
LoopInfo *LI;
|
|
ScalarEvolution *SE;
|
|
const DataLayout *DL;
|
|
DominatorTree *DT;
|
|
const TargetLibraryInfo *LibInfo;
|
|
};
|
|
|
|
char PPCCTRLoops::ID = 0;
|
|
#ifndef NDEBUG
|
|
int PPCCTRLoops::Counter = 0;
|
|
#endif
|
|
|
|
#ifndef NDEBUG
|
|
struct PPCCTRLoopsVerify : public MachineFunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
PPCCTRLoopsVerify() : MachineFunctionPass(ID) {
|
|
initializePPCCTRLoopsVerifyPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.addRequired<MachineDominatorTree>();
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
}
|
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
|
|
|
private:
|
|
MachineDominatorTree *MDT;
|
|
};
|
|
|
|
char PPCCTRLoopsVerify::ID = 0;
|
|
#endif // NDEBUG
|
|
} // end anonymous namespace
|
|
|
|
INITIALIZE_PASS_BEGIN(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops",
|
|
false, false)
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
|
|
INITIALIZE_PASS_DEPENDENCY(LoopInfo)
|
|
INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
|
|
INITIALIZE_PASS_END(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops",
|
|
false, false)
|
|
|
|
FunctionPass *llvm::createPPCCTRLoops(PPCTargetMachine &TM) {
|
|
return new PPCCTRLoops(TM);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
INITIALIZE_PASS_BEGIN(PPCCTRLoopsVerify, "ppc-ctr-loops-verify",
|
|
"PowerPC CTR Loops Verify", false, false)
|
|
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
|
|
INITIALIZE_PASS_END(PPCCTRLoopsVerify, "ppc-ctr-loops-verify",
|
|
"PowerPC CTR Loops Verify", false, false)
|
|
|
|
FunctionPass *llvm::createPPCCTRLoopsVerify() {
|
|
return new PPCCTRLoopsVerify();
|
|
}
|
|
#endif // NDEBUG
|
|
|
|
bool PPCCTRLoops::runOnFunction(Function &F) {
|
|
LI = &getAnalysis<LoopInfo>();
|
|
SE = &getAnalysis<ScalarEvolution>();
|
|
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
|
|
DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
|
|
DL = DLP ? &DLP->getDataLayout() : nullptr;
|
|
LibInfo = getAnalysisIfAvailable<TargetLibraryInfo>();
|
|
|
|
bool MadeChange = false;
|
|
|
|
for (LoopInfo::iterator I = LI->begin(), E = LI->end();
|
|
I != E; ++I) {
|
|
Loop *L = *I;
|
|
if (!L->getParentLoop())
|
|
MadeChange |= convertToCTRLoop(L);
|
|
}
|
|
|
|
return MadeChange;
|
|
}
|
|
|
|
static bool isLargeIntegerTy(bool Is32Bit, Type *Ty) {
|
|
if (IntegerType *ITy = dyn_cast<IntegerType>(Ty))
|
|
return ITy->getBitWidth() > (Is32Bit ? 32U : 64U);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Determining the address of a TLS variable results in a function call in
|
|
// certain TLS models.
|
|
static bool memAddrUsesCTR(const PPCTargetMachine *TM,
|
|
const llvm::Value *MemAddr) {
|
|
const auto *GV = dyn_cast<GlobalValue>(MemAddr);
|
|
if (!GV)
|
|
return false;
|
|
if (!GV->isThreadLocal())
|
|
return false;
|
|
if (!TM)
|
|
return true;
|
|
TLSModel::Model Model = TM->getTLSModel(GV);
|
|
return Model == TLSModel::GeneralDynamic || Model == TLSModel::LocalDynamic;
|
|
}
|
|
|
|
bool PPCCTRLoops::mightUseCTR(const Triple &TT, BasicBlock *BB) {
|
|
for (BasicBlock::iterator J = BB->begin(), JE = BB->end();
|
|
J != JE; ++J) {
|
|
if (CallInst *CI = dyn_cast<CallInst>(J)) {
|
|
if (InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue())) {
|
|
// Inline ASM is okay, unless it clobbers the ctr register.
|
|
InlineAsm::ConstraintInfoVector CIV = IA->ParseConstraints();
|
|
for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) {
|
|
InlineAsm::ConstraintInfo &C = CIV[i];
|
|
if (C.Type != InlineAsm::isInput)
|
|
for (unsigned j = 0, je = C.Codes.size(); j < je; ++j)
|
|
if (StringRef(C.Codes[j]).equals_lower("{ctr}"))
|
|
return true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (!TM)
|
|
return true;
|
|
const TargetLowering *TLI = TM->getSubtargetImpl()->getTargetLowering();
|
|
|
|
if (Function *F = CI->getCalledFunction()) {
|
|
// Most intrinsics don't become function calls, but some might.
|
|
// sin, cos, exp and log are always calls.
|
|
unsigned Opcode;
|
|
if (F->getIntrinsicID() != Intrinsic::not_intrinsic) {
|
|
switch (F->getIntrinsicID()) {
|
|
default: continue;
|
|
|
|
// VisualStudio defines setjmp as _setjmp
|
|
#if defined(_MSC_VER) && defined(setjmp) && \
|
|
!defined(setjmp_undefined_for_msvc)
|
|
# pragma push_macro("setjmp")
|
|
# undef setjmp
|
|
# define setjmp_undefined_for_msvc
|
|
#endif
|
|
|
|
case Intrinsic::setjmp:
|
|
|
|
#if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc)
|
|
// let's return it to _setjmp state
|
|
# pragma pop_macro("setjmp")
|
|
# undef setjmp_undefined_for_msvc
|
|
#endif
|
|
|
|
case Intrinsic::longjmp:
|
|
|
|
// Exclude eh_sjlj_setjmp; we don't need to exclude eh_sjlj_longjmp
|
|
// because, although it does clobber the counter register, the
|
|
// control can't then return to inside the loop unless there is also
|
|
// an eh_sjlj_setjmp.
|
|
case Intrinsic::eh_sjlj_setjmp:
|
|
|
|
case Intrinsic::memcpy:
|
|
case Intrinsic::memmove:
|
|
case Intrinsic::memset:
|
|
case Intrinsic::powi:
|
|
case Intrinsic::log:
|
|
case Intrinsic::log2:
|
|
case Intrinsic::log10:
|
|
case Intrinsic::exp:
|
|
case Intrinsic::exp2:
|
|
case Intrinsic::pow:
|
|
case Intrinsic::sin:
|
|
case Intrinsic::cos:
|
|
return true;
|
|
case Intrinsic::copysign:
|
|
if (CI->getArgOperand(0)->getType()->getScalarType()->
|
|
isPPC_FP128Ty())
|
|
return true;
|
|
else
|
|
continue; // ISD::FCOPYSIGN is never a library call.
|
|
case Intrinsic::sqrt: Opcode = ISD::FSQRT; break;
|
|
case Intrinsic::floor: Opcode = ISD::FFLOOR; break;
|
|
case Intrinsic::ceil: Opcode = ISD::FCEIL; break;
|
|
case Intrinsic::trunc: Opcode = ISD::FTRUNC; break;
|
|
case Intrinsic::rint: Opcode = ISD::FRINT; break;
|
|
case Intrinsic::nearbyint: Opcode = ISD::FNEARBYINT; break;
|
|
case Intrinsic::round: Opcode = ISD::FROUND; break;
|
|
}
|
|
}
|
|
|
|
// PowerPC does not use [US]DIVREM or other library calls for
|
|
// operations on regular types which are not otherwise library calls
|
|
// (i.e. soft float or atomics). If adapting for targets that do,
|
|
// additional care is required here.
|
|
|
|
LibFunc::Func Func;
|
|
if (!F->hasLocalLinkage() && F->hasName() && LibInfo &&
|
|
LibInfo->getLibFunc(F->getName(), Func) &&
|
|
LibInfo->hasOptimizedCodeGen(Func)) {
|
|
// Non-read-only functions are never treated as intrinsics.
|
|
if (!CI->onlyReadsMemory())
|
|
return true;
|
|
|
|
// Conversion happens only for FP calls.
|
|
if (!CI->getArgOperand(0)->getType()->isFloatingPointTy())
|
|
return true;
|
|
|
|
switch (Func) {
|
|
default: return true;
|
|
case LibFunc::copysign:
|
|
case LibFunc::copysignf:
|
|
continue; // ISD::FCOPYSIGN is never a library call.
|
|
case LibFunc::copysignl:
|
|
return true;
|
|
case LibFunc::fabs:
|
|
case LibFunc::fabsf:
|
|
case LibFunc::fabsl:
|
|
continue; // ISD::FABS is never a library call.
|
|
case LibFunc::sqrt:
|
|
case LibFunc::sqrtf:
|
|
case LibFunc::sqrtl:
|
|
Opcode = ISD::FSQRT; break;
|
|
case LibFunc::floor:
|
|
case LibFunc::floorf:
|
|
case LibFunc::floorl:
|
|
Opcode = ISD::FFLOOR; break;
|
|
case LibFunc::nearbyint:
|
|
case LibFunc::nearbyintf:
|
|
case LibFunc::nearbyintl:
|
|
Opcode = ISD::FNEARBYINT; break;
|
|
case LibFunc::ceil:
|
|
case LibFunc::ceilf:
|
|
case LibFunc::ceill:
|
|
Opcode = ISD::FCEIL; break;
|
|
case LibFunc::rint:
|
|
case LibFunc::rintf:
|
|
case LibFunc::rintl:
|
|
Opcode = ISD::FRINT; break;
|
|
case LibFunc::round:
|
|
case LibFunc::roundf:
|
|
case LibFunc::roundl:
|
|
Opcode = ISD::FROUND; break;
|
|
case LibFunc::trunc:
|
|
case LibFunc::truncf:
|
|
case LibFunc::truncl:
|
|
Opcode = ISD::FTRUNC; break;
|
|
}
|
|
|
|
MVT VTy =
|
|
TLI->getSimpleValueType(CI->getArgOperand(0)->getType(), true);
|
|
if (VTy == MVT::Other)
|
|
return true;
|
|
|
|
if (TLI->isOperationLegalOrCustom(Opcode, VTy))
|
|
continue;
|
|
else if (VTy.isVector() &&
|
|
TLI->isOperationLegalOrCustom(Opcode, VTy.getScalarType()))
|
|
continue;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
} else if (isa<BinaryOperator>(J) &&
|
|
J->getType()->getScalarType()->isPPC_FP128Ty()) {
|
|
// Most operations on ppc_f128 values become calls.
|
|
return true;
|
|
} else if (isa<UIToFPInst>(J) || isa<SIToFPInst>(J) ||
|
|
isa<FPToUIInst>(J) || isa<FPToSIInst>(J)) {
|
|
CastInst *CI = cast<CastInst>(J);
|
|
if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() ||
|
|
CI->getDestTy()->getScalarType()->isPPC_FP128Ty() ||
|
|
isLargeIntegerTy(TT.isArch32Bit(), CI->getSrcTy()->getScalarType()) ||
|
|
isLargeIntegerTy(TT.isArch32Bit(), CI->getDestTy()->getScalarType()))
|
|
return true;
|
|
} else if (isLargeIntegerTy(TT.isArch32Bit(),
|
|
J->getType()->getScalarType()) &&
|
|
(J->getOpcode() == Instruction::UDiv ||
|
|
J->getOpcode() == Instruction::SDiv ||
|
|
J->getOpcode() == Instruction::URem ||
|
|
J->getOpcode() == Instruction::SRem)) {
|
|
return true;
|
|
} else if (TT.isArch32Bit() &&
|
|
isLargeIntegerTy(false, J->getType()->getScalarType()) &&
|
|
(J->getOpcode() == Instruction::Shl ||
|
|
J->getOpcode() == Instruction::AShr ||
|
|
J->getOpcode() == Instruction::LShr)) {
|
|
// Only on PPC32, for 128-bit integers (specifically not 64-bit
|
|
// integers), these might be runtime calls.
|
|
return true;
|
|
} else if (isa<IndirectBrInst>(J) || isa<InvokeInst>(J)) {
|
|
// On PowerPC, indirect jumps use the counter register.
|
|
return true;
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(J)) {
|
|
if (!TM)
|
|
return true;
|
|
const TargetLowering *TLI = TM->getSubtargetImpl()->getTargetLowering();
|
|
|
|
if (SI->getNumCases() + 1 >= (unsigned)TLI->getMinimumJumpTableEntries())
|
|
return true;
|
|
}
|
|
for (Value *Operand : J->operands())
|
|
if (memAddrUsesCTR(TM, Operand))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool PPCCTRLoops::convertToCTRLoop(Loop *L) {
|
|
bool MadeChange = false;
|
|
|
|
Triple TT = Triple(L->getHeader()->getParent()->getParent()->
|
|
getTargetTriple());
|
|
if (!TT.isArch32Bit() && !TT.isArch64Bit())
|
|
return MadeChange; // Unknown arch. type.
|
|
|
|
// Process nested loops first.
|
|
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
|
|
MadeChange |= convertToCTRLoop(*I);
|
|
}
|
|
|
|
// If a nested loop has been converted, then we can't convert this loop.
|
|
if (MadeChange)
|
|
return MadeChange;
|
|
|
|
#ifndef NDEBUG
|
|
// Stop trying after reaching the limit (if any).
|
|
int Limit = CTRLoopLimit;
|
|
if (Limit >= 0) {
|
|
if (Counter >= CTRLoopLimit)
|
|
return false;
|
|
Counter++;
|
|
}
|
|
#endif
|
|
|
|
// We don't want to spill/restore the counter register, and so we don't
|
|
// want to use the counter register if the loop contains calls.
|
|
for (Loop::block_iterator I = L->block_begin(), IE = L->block_end();
|
|
I != IE; ++I)
|
|
if (mightUseCTR(TT, *I))
|
|
return MadeChange;
|
|
|
|
SmallVector<BasicBlock*, 4> ExitingBlocks;
|
|
L->getExitingBlocks(ExitingBlocks);
|
|
|
|
BasicBlock *CountedExitBlock = nullptr;
|
|
const SCEV *ExitCount = nullptr;
|
|
BranchInst *CountedExitBranch = nullptr;
|
|
for (SmallVectorImpl<BasicBlock *>::iterator I = ExitingBlocks.begin(),
|
|
IE = ExitingBlocks.end(); I != IE; ++I) {
|
|
const SCEV *EC = SE->getExitCount(L, *I);
|
|
DEBUG(dbgs() << "Exit Count for " << *L << " from block " <<
|
|
(*I)->getName() << ": " << *EC << "\n");
|
|
if (isa<SCEVCouldNotCompute>(EC))
|
|
continue;
|
|
if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) {
|
|
if (ConstEC->getValue()->isZero())
|
|
continue;
|
|
} else if (!SE->isLoopInvariant(EC, L))
|
|
continue;
|
|
|
|
if (SE->getTypeSizeInBits(EC->getType()) > (TT.isArch64Bit() ? 64 : 32))
|
|
continue;
|
|
|
|
// We now have a loop-invariant count of loop iterations (which is not the
|
|
// constant zero) for which we know that this loop will not exit via this
|
|
// exisiting block.
|
|
|
|
// We need to make sure that this block will run on every loop iteration.
|
|
// For this to be true, we must dominate all blocks with backedges. Such
|
|
// blocks are in-loop predecessors to the header block.
|
|
bool NotAlways = false;
|
|
for (pred_iterator PI = pred_begin(L->getHeader()),
|
|
PIE = pred_end(L->getHeader()); PI != PIE; ++PI) {
|
|
if (!L->contains(*PI))
|
|
continue;
|
|
|
|
if (!DT->dominates(*I, *PI)) {
|
|
NotAlways = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (NotAlways)
|
|
continue;
|
|
|
|
// Make sure this blocks ends with a conditional branch.
|
|
Instruction *TI = (*I)->getTerminator();
|
|
if (!TI)
|
|
continue;
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
|
if (!BI->isConditional())
|
|
continue;
|
|
|
|
CountedExitBranch = BI;
|
|
} else
|
|
continue;
|
|
|
|
// Note that this block may not be the loop latch block, even if the loop
|
|
// has a latch block.
|
|
CountedExitBlock = *I;
|
|
ExitCount = EC;
|
|
break;
|
|
}
|
|
|
|
if (!CountedExitBlock)
|
|
return MadeChange;
|
|
|
|
BasicBlock *Preheader = L->getLoopPreheader();
|
|
|
|
// If we don't have a preheader, then insert one. If we already have a
|
|
// preheader, then we can use it (except if the preheader contains a use of
|
|
// the CTR register because some such uses might be reordered by the
|
|
// selection DAG after the mtctr instruction).
|
|
if (!Preheader || mightUseCTR(TT, Preheader))
|
|
Preheader = InsertPreheaderForLoop(L, this);
|
|
if (!Preheader)
|
|
return MadeChange;
|
|
|
|
DEBUG(dbgs() << "Preheader for exit count: " << Preheader->getName() << "\n");
|
|
|
|
// Insert the count into the preheader and replace the condition used by the
|
|
// selected branch.
|
|
MadeChange = true;
|
|
|
|
SCEVExpander SCEVE(*SE, "loopcnt");
|
|
LLVMContext &C = SE->getContext();
|
|
Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) :
|
|
Type::getInt32Ty(C);
|
|
if (!ExitCount->getType()->isPointerTy() &&
|
|
ExitCount->getType() != CountType)
|
|
ExitCount = SE->getZeroExtendExpr(ExitCount, CountType);
|
|
ExitCount = SE->getAddExpr(ExitCount,
|
|
SE->getConstant(CountType, 1));
|
|
Value *ECValue = SCEVE.expandCodeFor(ExitCount, CountType,
|
|
Preheader->getTerminator());
|
|
|
|
IRBuilder<> CountBuilder(Preheader->getTerminator());
|
|
Module *M = Preheader->getParent()->getParent();
|
|
Value *MTCTRFunc = Intrinsic::getDeclaration(M, Intrinsic::ppc_mtctr,
|
|
CountType);
|
|
CountBuilder.CreateCall(MTCTRFunc, ECValue);
|
|
|
|
IRBuilder<> CondBuilder(CountedExitBranch);
|
|
Value *DecFunc =
|
|
Intrinsic::getDeclaration(M, Intrinsic::ppc_is_decremented_ctr_nonzero);
|
|
Value *NewCond = CondBuilder.CreateCall(DecFunc);
|
|
Value *OldCond = CountedExitBranch->getCondition();
|
|
CountedExitBranch->setCondition(NewCond);
|
|
|
|
// The false branch must exit the loop.
|
|
if (!L->contains(CountedExitBranch->getSuccessor(0)))
|
|
CountedExitBranch->swapSuccessors();
|
|
|
|
// The old condition may be dead now, and may have even created a dead PHI
|
|
// (the original induction variable).
|
|
RecursivelyDeleteTriviallyDeadInstructions(OldCond);
|
|
DeleteDeadPHIs(CountedExitBlock);
|
|
|
|
++NumCTRLoops;
|
|
return MadeChange;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
static bool clobbersCTR(const MachineInstr *MI) {
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
const MachineOperand &MO = MI->getOperand(i);
|
|
if (MO.isReg()) {
|
|
if (MO.isDef() && (MO.getReg() == PPC::CTR || MO.getReg() == PPC::CTR8))
|
|
return true;
|
|
} else if (MO.isRegMask()) {
|
|
if (MO.clobbersPhysReg(PPC::CTR) || MO.clobbersPhysReg(PPC::CTR8))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool verifyCTRBranch(MachineBasicBlock *MBB,
|
|
MachineBasicBlock::iterator I) {
|
|
MachineBasicBlock::iterator BI = I;
|
|
SmallSet<MachineBasicBlock *, 16> Visited;
|
|
SmallVector<MachineBasicBlock *, 8> Preds;
|
|
bool CheckPreds;
|
|
|
|
if (I == MBB->begin()) {
|
|
Visited.insert(MBB);
|
|
goto queue_preds;
|
|
} else
|
|
--I;
|
|
|
|
check_block:
|
|
Visited.insert(MBB);
|
|
if (I == MBB->end())
|
|
goto queue_preds;
|
|
|
|
CheckPreds = true;
|
|
for (MachineBasicBlock::iterator IE = MBB->begin();; --I) {
|
|
unsigned Opc = I->getOpcode();
|
|
if (Opc == PPC::MTCTRloop || Opc == PPC::MTCTR8loop) {
|
|
CheckPreds = false;
|
|
break;
|
|
}
|
|
|
|
if (I != BI && clobbersCTR(I)) {
|
|
DEBUG(dbgs() << "BB#" << MBB->getNumber() << " (" <<
|
|
MBB->getFullName() << ") instruction " << *I <<
|
|
" clobbers CTR, invalidating " << "BB#" <<
|
|
BI->getParent()->getNumber() << " (" <<
|
|
BI->getParent()->getFullName() << ") instruction " <<
|
|
*BI << "\n");
|
|
return false;
|
|
}
|
|
|
|
if (I == IE)
|
|
break;
|
|
}
|
|
|
|
if (!CheckPreds && Preds.empty())
|
|
return true;
|
|
|
|
if (CheckPreds) {
|
|
queue_preds:
|
|
if (MachineFunction::iterator(MBB) == MBB->getParent()->begin()) {
|
|
DEBUG(dbgs() << "Unable to find a MTCTR instruction for BB#" <<
|
|
BI->getParent()->getNumber() << " (" <<
|
|
BI->getParent()->getFullName() << ") instruction " <<
|
|
*BI << "\n");
|
|
return false;
|
|
}
|
|
|
|
for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
|
|
PIE = MBB->pred_end(); PI != PIE; ++PI)
|
|
Preds.push_back(*PI);
|
|
}
|
|
|
|
do {
|
|
MBB = Preds.pop_back_val();
|
|
if (!Visited.count(MBB)) {
|
|
I = MBB->getLastNonDebugInstr();
|
|
goto check_block;
|
|
}
|
|
} while (!Preds.empty());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PPCCTRLoopsVerify::runOnMachineFunction(MachineFunction &MF) {
|
|
MDT = &getAnalysis<MachineDominatorTree>();
|
|
|
|
// Verify that all bdnz/bdz instructions are dominated by a loop mtctr before
|
|
// any other instructions that might clobber the ctr register.
|
|
for (MachineFunction::iterator I = MF.begin(), IE = MF.end();
|
|
I != IE; ++I) {
|
|
MachineBasicBlock *MBB = I;
|
|
if (!MDT->isReachableFromEntry(MBB))
|
|
continue;
|
|
|
|
for (MachineBasicBlock::iterator MII = MBB->getFirstTerminator(),
|
|
MIIE = MBB->end(); MII != MIIE; ++MII) {
|
|
unsigned Opc = MII->getOpcode();
|
|
if (Opc == PPC::BDNZ8 || Opc == PPC::BDNZ ||
|
|
Opc == PPC::BDZ8 || Opc == PPC::BDZ)
|
|
if (!verifyCTRBranch(MBB, MII))
|
|
llvm_unreachable("Invalid PPC CTR loop!");
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif // NDEBUG
|
|
|