PPCCTRLoops.cpp revision ebe69fe11e48d322045d5949c83283927a0d790b
199f823f94374917174f96a7689955b8463db6816Hal Finkel//===-- PPCCTRLoops.cpp - Identify and generate CTR loops -----------------===// 299f823f94374917174f96a7689955b8463db6816Hal Finkel// 399f823f94374917174f96a7689955b8463db6816Hal Finkel// The LLVM Compiler Infrastructure 499f823f94374917174f96a7689955b8463db6816Hal Finkel// 599f823f94374917174f96a7689955b8463db6816Hal Finkel// This file is distributed under the University of Illinois Open Source 699f823f94374917174f96a7689955b8463db6816Hal Finkel// License. See LICENSE.TXT for details. 799f823f94374917174f96a7689955b8463db6816Hal Finkel// 899f823f94374917174f96a7689955b8463db6816Hal Finkel//===----------------------------------------------------------------------===// 999f823f94374917174f96a7689955b8463db6816Hal Finkel// 1099f823f94374917174f96a7689955b8463db6816Hal Finkel// This pass identifies loops where we can generate the PPC branch instructions 1199f823f94374917174f96a7689955b8463db6816Hal Finkel// that decrement and test the count register (CTR) (bdnz and friends). 1299f823f94374917174f96a7689955b8463db6816Hal Finkel// 1399f823f94374917174f96a7689955b8463db6816Hal Finkel// The pattern that defines the induction variable can changed depending on 1499f823f94374917174f96a7689955b8463db6816Hal Finkel// prior optimizations. For example, the IndVarSimplify phase run by 'opt' 1599f823f94374917174f96a7689955b8463db6816Hal Finkel// normalizes induction variables, and the Loop Strength Reduction pass 1699f823f94374917174f96a7689955b8463db6816Hal Finkel// run by 'llc' may also make changes to the induction variable. 1799f823f94374917174f96a7689955b8463db6816Hal Finkel// 1899f823f94374917174f96a7689955b8463db6816Hal Finkel// Criteria for CTR loops: 1999f823f94374917174f96a7689955b8463db6816Hal Finkel// - Countable loops (w/ ind. var for a trip count) 2099f823f94374917174f96a7689955b8463db6816Hal Finkel// - Try inner-most loops first 2199f823f94374917174f96a7689955b8463db6816Hal Finkel// - No nested CTR loops. 2299f823f94374917174f96a7689955b8463db6816Hal Finkel// - No function calls in loops. 2399f823f94374917174f96a7689955b8463db6816Hal Finkel// 2499f823f94374917174f96a7689955b8463db6816Hal Finkel//===----------------------------------------------------------------------===// 2599f823f94374917174f96a7689955b8463db6816Hal Finkel 26b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Transforms/Scalar.h" 2736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "PPC.h" 2836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "PPCTargetMachine.h" 29b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/ADT/STLExtras.h" 3036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/ADT/Statistic.h" 31b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Analysis/LoopInfo.h" 32b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Analysis/ScalarEvolutionExpander.h" 33ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines#include "llvm/Analysis/TargetLibraryInfo.h" 340b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 35b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/IR/DerivedTypes.h" 3636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/Dominators.h" 37bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel#include "llvm/IR/InlineAsm.h" 38b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/IR/Instructions.h" 39b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/IR/IntrinsicInst.h" 40b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/IR/Module.h" 4136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ValueHandle.h" 42d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/PassSupport.h" 43b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Support/CommandLine.h" 4499f823f94374917174f96a7689955b8463db6816Hal Finkel#include "llvm/Support/Debug.h" 4599f823f94374917174f96a7689955b8463db6816Hal Finkel#include "llvm/Support/raw_ostream.h" 46b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Transforms/Utils/BasicBlockUtils.h" 47b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include "llvm/Transforms/Utils/Local.h" 484e6b24ffcfafbc0c5eda1bb89163ccd56f394fdfHal Finkel#include "llvm/Transforms/Utils/LoopUtils.h" 49b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 50e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 51e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#include "llvm/CodeGen/MachineDominators.h" 52e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#include "llvm/CodeGen/MachineFunction.h" 53e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#include "llvm/CodeGen/MachineFunctionPass.h" 54e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#include "llvm/CodeGen/MachineRegisterInfo.h" 55e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif 56e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 5799f823f94374917174f96a7689955b8463db6816Hal Finkel#include <algorithm> 58b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#include <vector> 5999f823f94374917174f96a7689955b8463db6816Hal Finkel 6099f823f94374917174f96a7689955b8463db6816Hal Finkelusing namespace llvm; 6199f823f94374917174f96a7689955b8463db6816Hal Finkel 62dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "ctrloops" 63dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 64b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 65b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelstatic cl::opt<int> CTRLoopLimit("ppc-max-ctrloop", cl::Hidden, cl::init(-1)); 66b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 67b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 6899f823f94374917174f96a7689955b8463db6816Hal FinkelSTATISTIC(NumCTRLoops, "Number of loops converted to CTR loops"); 6999f823f94374917174f96a7689955b8463db6816Hal Finkel 7096848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszeknamespace llvm { 7196848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek void initializePPCCTRLoopsPass(PassRegistry&); 72e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 73e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel void initializePPCCTRLoopsVerifyPass(PassRegistry&); 74e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif 7596848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek} 7696848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek 7799f823f94374917174f96a7689955b8463db6816Hal Finkelnamespace { 78b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel struct PPCCTRLoops : public FunctionPass { 79b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 80b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 81b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel static int Counter; 82b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 8399f823f94374917174f96a7689955b8463db6816Hal Finkel 8499f823f94374917174f96a7689955b8463db6816Hal Finkel public: 85b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel static char ID; 8699f823f94374917174f96a7689955b8463db6816Hal Finkel 87dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PPCCTRLoops() : FunctionPass(ID), TM(nullptr) { 88b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry()); 89b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 90b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PPCCTRLoops(PPCTargetMachine &TM) : FunctionPass(ID), TM(&TM) { 9196848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry()); 9296848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek } 9399f823f94374917174f96a7689955b8463db6816Hal Finkel 94dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool runOnFunction(Function &F) override; 9599f823f94374917174f96a7689955b8463db6816Hal Finkel 96dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 97ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AU.addRequired<LoopInfoWrapperPass>(); 98ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AU.addPreserved<LoopInfoWrapperPass>(); 9936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AU.addRequired<DominatorTreeWrapperPass>(); 10036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AU.addPreserved<DominatorTreeWrapperPass>(); 101b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel AU.addRequired<ScalarEvolution>(); 10299f823f94374917174f96a7689955b8463db6816Hal Finkel } 10399f823f94374917174f96a7689955b8463db6816Hal Finkel 10499f823f94374917174f96a7689955b8463db6816Hal Finkel private: 105c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel bool mightUseCTR(const Triple &TT, BasicBlock *BB); 106b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool convertToCTRLoop(Loop *L); 10708f92c98ac1cdb43ec35653536c89964401d936cHal Finkel 10899f823f94374917174f96a7689955b8463db6816Hal Finkel private: 109b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PPCTargetMachine *TM; 110b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel LoopInfo *LI; 111b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ScalarEvolution *SE; 11236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL; 113b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DominatorTree *DT; 114b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel const TargetLibraryInfo *LibInfo; 11599f823f94374917174f96a7689955b8463db6816Hal Finkel }; 116b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 117b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel char PPCCTRLoops::ID = 0; 118b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 119b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel int PPCCTRLoops::Counter = 0; 120b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 121e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 122e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 123e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel struct PPCCTRLoopsVerify : public MachineFunctionPass { 124e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel public: 125e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel static char ID; 126e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 127e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel PPCCTRLoopsVerify() : MachineFunctionPass(ID) { 128e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel initializePPCCTRLoopsVerifyPass(*PassRegistry::getPassRegistry()); 129e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 130e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 131dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 132e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel AU.addRequired<MachineDominatorTree>(); 133e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineFunctionPass::getAnalysisUsage(AU); 134e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 135e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 136dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool runOnMachineFunction(MachineFunction &MF) override; 137e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 138e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel private: 139e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineDominatorTree *MDT; 140e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel }; 141e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 142e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel char PPCCTRLoopsVerify::ID = 0; 143e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 14499f823f94374917174f96a7689955b8463db6816Hal Finkel} // end anonymous namespace 14599f823f94374917174f96a7689955b8463db6816Hal Finkel 14696848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof ParzyszekINITIALIZE_PASS_BEGIN(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops", 14796848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek false, false) 14836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesINITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) 149ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesINITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) 150b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal FinkelINITIALIZE_PASS_DEPENDENCY(ScalarEvolution) 15196848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof ParzyszekINITIALIZE_PASS_END(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops", 15296848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek false, false) 15399f823f94374917174f96a7689955b8463db6816Hal Finkel 154b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal FinkelFunctionPass *llvm::createPPCCTRLoops(PPCTargetMachine &TM) { 155b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return new PPCCTRLoops(TM); 15699f823f94374917174f96a7689955b8463db6816Hal Finkel} 15799f823f94374917174f96a7689955b8463db6816Hal Finkel 158e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 159e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_BEGIN(PPCCTRLoopsVerify, "ppc-ctr-loops-verify", 160e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel "PowerPC CTR Loops Verify", false, false) 161e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_DEPENDENCY(MachineDominatorTree) 162e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_END(PPCCTRLoopsVerify, "ppc-ctr-loops-verify", 163e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel "PowerPC CTR Loops Verify", false, false) 164e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 165e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelFunctionPass *llvm::createPPCCTRLoopsVerify() { 166e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return new PPCCTRLoopsVerify(); 167e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 168e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 169e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 170b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelbool PPCCTRLoops::runOnFunction(Function &F) { 171ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); 172b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel SE = &getAnalysis<ScalarEvolution>(); 17336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 17436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>(); 175dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines DL = DLP ? &DLP->getDataLayout() : nullptr; 176ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); 177ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LibInfo = TLIP ? &TLIP->getTLI() : nullptr; 17899f823f94374917174f96a7689955b8463db6816Hal Finkel 179b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool MadeChange = false; 18099f823f94374917174f96a7689955b8463db6816Hal Finkel 181b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (LoopInfo::iterator I = LI->begin(), E = LI->end(); 18299f823f94374917174f96a7689955b8463db6816Hal Finkel I != E; ++I) { 183b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Loop *L = *I; 184b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->getParentLoop()) 185b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange |= convertToCTRLoop(L); 18699f823f94374917174f96a7689955b8463db6816Hal Finkel } 18799f823f94374917174f96a7689955b8463db6816Hal Finkel 188b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 18999f823f94374917174f96a7689955b8463db6816Hal Finkel} 19099f823f94374917174f96a7689955b8463db6816Hal Finkel 19136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic bool isLargeIntegerTy(bool Is32Bit, Type *Ty) { 19236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 19336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ITy->getBitWidth() > (Is32Bit ? 32U : 64U); 19436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 19536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 19636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 19736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 198ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// Determining the address of a TLS variable results in a function call in 199ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// certain TLS models. 200ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic bool memAddrUsesCTR(const PPCTargetMachine *TM, 201ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const llvm::Value *MemAddr) { 202ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const auto *GV = dyn_cast<GlobalValue>(MemAddr); 203ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!GV) 204ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return false; 205ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!GV->isThreadLocal()) 206ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return false; 207ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!TM) 208ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return true; 209ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLSModel::Model Model = TM->getTLSModel(GV); 210ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Model == TLSModel::GeneralDynamic || Model == TLSModel::LocalDynamic; 211ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 212ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 213c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkelbool PPCCTRLoops::mightUseCTR(const Triple &TT, BasicBlock *BB) { 214c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel for (BasicBlock::iterator J = BB->begin(), JE = BB->end(); 215c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel J != JE; ++J) { 216c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (CallInst *CI = dyn_cast<CallInst>(J)) { 217bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue())) { 218bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel // Inline ASM is okay, unless it clobbers the ctr register. 219bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel InlineAsm::ConstraintInfoVector CIV = IA->ParseConstraints(); 220bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) { 221bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel InlineAsm::ConstraintInfo &C = CIV[i]; 222bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (C.Type != InlineAsm::isInput) 223bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel for (unsigned j = 0, je = C.Codes.size(); j < je; ++j) 224bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (StringRef(C.Codes[j]).equals_lower("{ctr}")) 225bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel return true; 226bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel } 227bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel 228bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel continue; 229bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel } 230bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel 231c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!TM) 232c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 233ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLowering *TLI = 234ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TM->getSubtargetImpl(*BB->getParent())->getTargetLowering(); 235c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 236c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (Function *F = CI->getCalledFunction()) { 237c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Most intrinsics don't become function calls, but some might. 238c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // sin, cos, exp and log are always calls. 239c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel unsigned Opcode; 240c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (F->getIntrinsicID() != Intrinsic::not_intrinsic) { 241c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel switch (F->getIntrinsicID()) { 242c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel default: continue; 243c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 244c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel// VisualStudio defines setjmp as _setjmp 245c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#if defined(_MSC_VER) && defined(setjmp) && \ 246c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel !defined(setjmp_undefined_for_msvc) 247c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# pragma push_macro("setjmp") 248c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# undef setjmp 249c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# define setjmp_undefined_for_msvc 250c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#endif 251c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 252c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::setjmp: 253c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 254c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc) 255c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // let's return it to _setjmp state 256c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# pragma pop_macro("setjmp") 257c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# undef setjmp_undefined_for_msvc 258c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#endif 259c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 260c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::longjmp: 2618d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel 2628d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // Exclude eh_sjlj_setjmp; we don't need to exclude eh_sjlj_longjmp 2638d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // because, although it does clobber the counter register, the 2648d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // control can't then return to inside the loop unless there is also 2658d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // an eh_sjlj_setjmp. 2668d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel case Intrinsic::eh_sjlj_setjmp: 2678d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel 268c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memcpy: 269c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memmove: 270c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memset: 271c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::powi: 272c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log: 273c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log2: 274c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log10: 275c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::exp: 276c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::exp2: 277c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::pow: 278c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::sin: 279c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::cos: 280c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 28166d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel case Intrinsic::copysign: 28266d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel if (CI->getArgOperand(0)->getType()->getScalarType()-> 28366d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel isPPC_FP128Ty()) 28466d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel return true; 28566d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel else 28666d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel continue; // ISD::FCOPYSIGN is never a library call. 287c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::sqrt: Opcode = ISD::FSQRT; break; 288c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::floor: Opcode = ISD::FFLOOR; break; 289c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::ceil: Opcode = ISD::FCEIL; break; 290c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::trunc: Opcode = ISD::FTRUNC; break; 291c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::rint: Opcode = ISD::FRINT; break; 292c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::nearbyint: Opcode = ISD::FNEARBYINT; break; 29341418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case Intrinsic::round: Opcode = ISD::FROUND; break; 294c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 295c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 296c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 297c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // PowerPC does not use [US]DIVREM or other library calls for 298c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // operations on regular types which are not otherwise library calls 299c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // (i.e. soft float or atomics). If adapting for targets that do, 300c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // additional care is required here. 301c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 302c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibFunc::Func Func; 303c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!F->hasLocalLinkage() && F->hasName() && LibInfo && 304c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibInfo->getLibFunc(F->getName(), Func) && 305c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibInfo->hasOptimizedCodeGen(Func)) { 306c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Non-read-only functions are never treated as intrinsics. 307c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!CI->onlyReadsMemory()) 308c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 309c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 310c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Conversion happens only for FP calls. 311c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!CI->getArgOperand(0)->getType()->isFloatingPointTy()) 312c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 313c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 314c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel switch (Func) { 315c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel default: return true; 316c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::copysign: 317c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::copysignf: 318c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; // ISD::FCOPYSIGN is never a library call. 31930cbccb029b01738202bd04341b1cbf68a7814c9Hal Finkel case LibFunc::copysignl: 32030cbccb029b01738202bd04341b1cbf68a7814c9Hal Finkel return true; 321c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabs: 322c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabsf: 323c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabsl: 324c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; // ISD::FABS is never a library call. 325c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrt: 326c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrtf: 327c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrtl: 328c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FSQRT; break; 329c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floor: 330c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floorf: 331c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floorl: 332c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FFLOOR; break; 333c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyint: 334c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyintf: 335c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyintl: 336c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FNEARBYINT; break; 337c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceil: 338c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceilf: 339c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceill: 340c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FCEIL; break; 341c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rint: 342c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rintf: 343c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rintl: 344c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FRINT; break; 34541418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::round: 34641418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::roundf: 34741418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::roundl: 34841418d17cced656f91038b2482bc9d173b4974b0Hal Finkel Opcode = ISD::FROUND; break; 349c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::trunc: 350c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::truncf: 351c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::truncl: 352c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FTRUNC; break; 353c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 354c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 355c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel MVT VTy = 356c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel TLI->getSimpleValueType(CI->getArgOperand(0)->getType(), true); 357c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (VTy == MVT::Other) 358c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 359c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 360c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (TLI->isOperationLegalOrCustom(Opcode, VTy)) 361c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; 362c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel else if (VTy.isVector() && 363c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel TLI->isOperationLegalOrCustom(Opcode, VTy.getScalarType())) 364c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; 365c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 366c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 367c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 368c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 369c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 370c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 371c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<BinaryOperator>(J) && 372c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel J->getType()->getScalarType()->isPPC_FP128Ty()) { 373c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Most operations on ppc_f128 values become calls. 374c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 375c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<UIToFPInst>(J) || isa<SIToFPInst>(J) || 376c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel isa<FPToUIInst>(J) || isa<FPToSIInst>(J)) { 377c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel CastInst *CI = cast<CastInst>(J); 378c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() || 379c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel CI->getDestTy()->getScalarType()->isPPC_FP128Ty() || 38036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isLargeIntegerTy(TT.isArch32Bit(), CI->getSrcTy()->getScalarType()) || 38136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isLargeIntegerTy(TT.isArch32Bit(), CI->getDestTy()->getScalarType())) 382c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 38336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else if (isLargeIntegerTy(TT.isArch32Bit(), 38436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines J->getType()->getScalarType()) && 38540be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel (J->getOpcode() == Instruction::UDiv || 38640be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::SDiv || 38740be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::URem || 38840be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::SRem)) { 38940be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel return true; 390dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (TT.isArch32Bit() && 391dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines isLargeIntegerTy(false, J->getType()->getScalarType()) && 392dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (J->getOpcode() == Instruction::Shl || 393dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines J->getOpcode() == Instruction::AShr || 394dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines J->getOpcode() == Instruction::LShr)) { 395dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Only on PPC32, for 128-bit integers (specifically not 64-bit 396dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // integers), these might be runtime calls. 397dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return true; 398c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<IndirectBrInst>(J) || isa<InvokeInst>(J)) { 399c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // On PowerPC, indirect jumps use the counter register. 400c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 401c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (SwitchInst *SI = dyn_cast<SwitchInst>(J)) { 402c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!TM) 403c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 404ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLowering *TLI = 405ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TM->getSubtargetImpl(*BB->getParent())->getTargetLowering(); 406c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 40737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (SI->getNumCases() + 1 >= (unsigned)TLI->getMinimumJumpTableEntries()) 408c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 409c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 410ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (Value *Operand : J->operands()) 411ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (memAddrUsesCTR(TM, Operand)) 412ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return true; 413c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 414c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 415c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return false; 416c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel} 417c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 418b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelbool PPCCTRLoops::convertToCTRLoop(Loop *L) { 419b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool MadeChange = false; 42099f823f94374917174f96a7689955b8463db6816Hal Finkel 421b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Triple TT = Triple(L->getHeader()->getParent()->getParent()-> 422b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel getTargetTriple()); 423b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!TT.isArch32Bit() && !TT.isArch64Bit()) 424b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; // Unknown arch. type. 4251448d06156728712f47e5a71fac8e8edc0aba73bHal Finkel 426b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Process nested loops first. 427b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) { 428b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange |= convertToCTRLoop(*I); 429b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 4301448d06156728712f47e5a71fac8e8edc0aba73bHal Finkel 431b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // If a nested loop has been converted, then we can't convert this loop. 432b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (MadeChange) 433b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 434b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 435b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 436b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Stop trying after reaching the limit (if any). 437b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel int Limit = CTRLoopLimit; 438b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (Limit >= 0) { 439b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (Counter >= CTRLoopLimit) 440b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return false; 441b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Counter++; 442b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 443b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 444b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 445b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We don't want to spill/restore the counter register, and so we don't 446b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // want to use the counter register if the loop contains calls. 447b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (Loop::block_iterator I = L->block_begin(), IE = L->block_end(); 448c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel I != IE; ++I) 449c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (mightUseCTR(TT, *I)) 450c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return MadeChange; 45199f823f94374917174f96a7689955b8463db6816Hal Finkel 452b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel SmallVector<BasicBlock*, 4> ExitingBlocks; 453b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel L->getExitingBlocks(ExitingBlocks); 454b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 455dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BasicBlock *CountedExitBlock = nullptr; 456dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const SCEV *ExitCount = nullptr; 457dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BranchInst *CountedExitBranch = nullptr; 4586227d5c690504c7ada5780c00a635b282c46e275Craig Topper for (SmallVectorImpl<BasicBlock *>::iterator I = ExitingBlocks.begin(), 459b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IE = ExitingBlocks.end(); I != IE; ++I) { 460b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel const SCEV *EC = SE->getExitCount(L, *I); 461b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DEBUG(dbgs() << "Exit Count for " << *L << " from block " << 462b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel (*I)->getName() << ": " << *EC << "\n"); 463b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (isa<SCEVCouldNotCompute>(EC)) 464b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 465b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) { 466b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (ConstEC->getValue()->isZero()) 467b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 468b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } else if (!SE->isLoopInvariant(EC, L)) 469b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 470b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 471b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel if (SE->getTypeSizeInBits(EC->getType()) > (TT.isArch64Bit() ? 64 : 32)) 472b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel continue; 473b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel 474b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We now have a loop-invariant count of loop iterations (which is not the 475b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // constant zero) for which we know that this loop will not exit via this 476b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // exisiting block. 477b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 478b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We need to make sure that this block will run on every loop iteration. 479b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // For this to be true, we must dominate all blocks with backedges. Such 480b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // blocks are in-loop predecessors to the header block. 481b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool NotAlways = false; 482b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (pred_iterator PI = pred_begin(L->getHeader()), 483b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PIE = pred_end(L->getHeader()); PI != PIE; ++PI) { 484b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->contains(*PI)) 485b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 48699f823f94374917174f96a7689955b8463db6816Hal Finkel 487b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!DT->dominates(*I, *PI)) { 488b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel NotAlways = true; 489b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel break; 49099f823f94374917174f96a7689955b8463db6816Hal Finkel } 49199f823f94374917174f96a7689955b8463db6816Hal Finkel } 49299f823f94374917174f96a7689955b8463db6816Hal Finkel 493b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (NotAlways) 494b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 49599f823f94374917174f96a7689955b8463db6816Hal Finkel 496b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Make sure this blocks ends with a conditional branch. 497b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Instruction *TI = (*I)->getTerminator(); 498b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!TI) 499b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 50099f823f94374917174f96a7689955b8463db6816Hal Finkel 501b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 502b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!BI->isConditional()) 50399f823f94374917174f96a7689955b8463db6816Hal Finkel continue; 50499f823f94374917174f96a7689955b8463db6816Hal Finkel 505b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch = BI; 506b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } else 507b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 50899f823f94374917174f96a7689955b8463db6816Hal Finkel 509b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Note that this block may not be the loop latch block, even if the loop 510b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // has a latch block. 511b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBlock = *I; 512b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount = EC; 513b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel break; 51499f823f94374917174f96a7689955b8463db6816Hal Finkel } 51599f823f94374917174f96a7689955b8463db6816Hal Finkel 516b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!CountedExitBlock) 517b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 518b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 519b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel BasicBlock *Preheader = L->getLoopPreheader(); 520c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 521c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // If we don't have a preheader, then insert one. If we already have a 522c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // preheader, then we can use it (except if the preheader contains a use of 523c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // the CTR register because some such uses might be reordered by the 524c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // selection DAG after the mtctr instruction). 525c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!Preheader || mightUseCTR(TT, Preheader)) 52608f92c98ac1cdb43ec35653536c89964401d936cHal Finkel Preheader = InsertPreheaderForLoop(L, this); 527b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!Preheader) 528b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 529b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 530b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DEBUG(dbgs() << "Preheader for exit count: " << Preheader->getName() << "\n"); 531b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 532b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Insert the count into the preheader and replace the condition used by the 533b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // selected branch. 534b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange = true; 535b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 536b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel SCEVExpander SCEVE(*SE, "loopcnt"); 537b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel LLVMContext &C = SE->getContext(); 538b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) : 539b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Type::getInt32Ty(C); 540b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!ExitCount->getType()->isPointerTy() && 541b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount->getType() != CountType) 542b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount = SE->getZeroExtendExpr(ExitCount, CountType); 543b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount = SE->getAddExpr(ExitCount, 544b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel SE->getConstant(CountType, 1)); 545b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *ECValue = SCEVE.expandCodeFor(ExitCount, CountType, 546b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Preheader->getTerminator()); 547b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 548b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IRBuilder<> CountBuilder(Preheader->getTerminator()); 549b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Module *M = Preheader->getParent()->getParent(); 550b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *MTCTRFunc = Intrinsic::getDeclaration(M, Intrinsic::ppc_mtctr, 551b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountType); 552b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountBuilder.CreateCall(MTCTRFunc, ECValue); 553b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 554b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IRBuilder<> CondBuilder(CountedExitBranch); 555b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *DecFunc = 556b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Intrinsic::getDeclaration(M, Intrinsic::ppc_is_decremented_ctr_nonzero); 557b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *NewCond = CondBuilder.CreateCall(DecFunc); 558b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *OldCond = CountedExitBranch->getCondition(); 559b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch->setCondition(NewCond); 560b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 561b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // The false branch must exit the loop. 562b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->contains(CountedExitBranch->getSuccessor(0))) 563b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch->swapSuccessors(); 564b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 565b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // The old condition may be dead now, and may have even created a dead PHI 566b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // (the original induction variable). 567b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel RecursivelyDeleteTriviallyDeadInstructions(OldCond); 568b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DeleteDeadPHIs(CountedExitBlock); 5699887ec31e630ede8541dee1d90c44a1efb63c417Hal Finkel 570b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ++NumCTRLoops; 571b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 572b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel} 5739887ec31e630ede8541dee1d90c44a1efb63c417Hal Finkel 574e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 575e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelstatic bool clobbersCTR(const MachineInstr *MI) { 576e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 577e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel const MachineOperand &MO = MI->getOperand(i); 578e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.isReg()) { 579e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.isDef() && (MO.getReg() == PPC::CTR || MO.getReg() == PPC::CTR8)) 580e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 581e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } else if (MO.isRegMask()) { 582e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.clobbersPhysReg(PPC::CTR) || MO.clobbersPhysReg(PPC::CTR8)) 583e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 584e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 585e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 586e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 587e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 588e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 589e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 590e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelstatic bool verifyCTRBranch(MachineBasicBlock *MBB, 591e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineBasicBlock::iterator I) { 592e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineBasicBlock::iterator BI = I; 593e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel SmallSet<MachineBasicBlock *, 16> Visited; 594e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel SmallVector<MachineBasicBlock *, 8> Preds; 595e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel bool CheckPreds; 596e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 597e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == MBB->begin()) { 598e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Visited.insert(MBB); 599e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto queue_preds; 600e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } else 601e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel --I; 602e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 603e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelcheck_block: 604e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Visited.insert(MBB); 605e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == MBB->end()) 606e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto queue_preds; 607e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 608e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel CheckPreds = true; 609e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::iterator IE = MBB->begin();; --I) { 610e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel unsigned Opc = I->getOpcode(); 61185c08b059ce4248ee739e756cf717a9b429e2ec2Hal Finkel if (Opc == PPC::MTCTRloop || Opc == PPC::MTCTR8loop) { 612e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel CheckPreds = false; 613e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel break; 614e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 615e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 616e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I != BI && clobbersCTR(I)) { 617e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel DEBUG(dbgs() << "BB#" << MBB->getNumber() << " (" << 618e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MBB->getFullName() << ") instruction " << *I << 619e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel " clobbers CTR, invalidating " << "BB#" << 620e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getNumber() << " (" << 621e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getFullName() << ") instruction " << 622e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel *BI << "\n"); 623e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 624e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 625e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 626e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == IE) 627e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel break; 628e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 629e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 630e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!CheckPreds && Preds.empty()) 631e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 632e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 633e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (CheckPreds) { 634e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelqueue_preds: 635e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MachineFunction::iterator(MBB) == MBB->getParent()->begin()) { 636e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel DEBUG(dbgs() << "Unable to find a MTCTR instruction for BB#" << 637e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getNumber() << " (" << 638e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getFullName() << ") instruction " << 639e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel *BI << "\n"); 640e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 641e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 642e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 643e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(), 644e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel PIE = MBB->pred_end(); PI != PIE; ++PI) 645e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Preds.push_back(*PI); 646e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 647e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 648e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel do { 649e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MBB = Preds.pop_back_val(); 650e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!Visited.count(MBB)) { 651e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel I = MBB->getLastNonDebugInstr(); 652e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto check_block; 653e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 654e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } while (!Preds.empty()); 655e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 656e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 657e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 658e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 659e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelbool PPCCTRLoopsVerify::runOnMachineFunction(MachineFunction &MF) { 660e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MDT = &getAnalysis<MachineDominatorTree>(); 661e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 662e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel // Verify that all bdnz/bdz instructions are dominated by a loop mtctr before 663e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel // any other instructions that might clobber the ctr register. 664e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineFunction::iterator I = MF.begin(), IE = MF.end(); 665e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel I != IE; ++I) { 666e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineBasicBlock *MBB = I; 667e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!MDT->isReachableFromEntry(MBB)) 668e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel continue; 669e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 670e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::iterator MII = MBB->getFirstTerminator(), 671e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MIIE = MBB->end(); MII != MIIE; ++MII) { 672e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel unsigned Opc = MII->getOpcode(); 673e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (Opc == PPC::BDNZ8 || Opc == PPC::BDNZ || 674e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Opc == PPC::BDZ8 || Opc == PPC::BDZ) 675e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!verifyCTRBranch(MBB, MII)) 676e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel llvm_unreachable("Invalid PPC CTR loop!"); 677e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 678e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 679e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 680e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 681e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 682e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 683e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 684