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 Finkelusing namespace llvm; 5899f823f94374917174f96a7689955b8463db6816Hal Finkel 59dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "ctrloops" 60dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 61b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 62b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelstatic cl::opt<int> CTRLoopLimit("ppc-max-ctrloop", cl::Hidden, cl::init(-1)); 63b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 64b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 6599f823f94374917174f96a7689955b8463db6816Hal FinkelSTATISTIC(NumCTRLoops, "Number of loops converted to CTR loops"); 6699f823f94374917174f96a7689955b8463db6816Hal Finkel 6796848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszeknamespace llvm { 6896848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek void initializePPCCTRLoopsPass(PassRegistry&); 69e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 70e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel void initializePPCCTRLoopsVerifyPass(PassRegistry&); 71e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif 7296848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek} 7396848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek 7499f823f94374917174f96a7689955b8463db6816Hal Finkelnamespace { 75b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel struct PPCCTRLoops : public FunctionPass { 76b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 77b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 78b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel static int Counter; 79b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 8099f823f94374917174f96a7689955b8463db6816Hal Finkel 8199f823f94374917174f96a7689955b8463db6816Hal Finkel public: 82b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel static char ID; 8399f823f94374917174f96a7689955b8463db6816Hal Finkel 84dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PPCCTRLoops() : FunctionPass(ID), TM(nullptr) { 85b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry()); 86b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 87b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PPCCTRLoops(PPCTargetMachine &TM) : FunctionPass(ID), TM(&TM) { 8896848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek initializePPCCTRLoopsPass(*PassRegistry::getPassRegistry()); 8996848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek } 9099f823f94374917174f96a7689955b8463db6816Hal Finkel 91dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool runOnFunction(Function &F) override; 9299f823f94374917174f96a7689955b8463db6816Hal Finkel 93dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 94ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AU.addRequired<LoopInfoWrapperPass>(); 95ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AU.addPreserved<LoopInfoWrapperPass>(); 9636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AU.addRequired<DominatorTreeWrapperPass>(); 9736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines AU.addPreserved<DominatorTreeWrapperPass>(); 98f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar AU.addRequired<ScalarEvolutionWrapperPass>(); 9999f823f94374917174f96a7689955b8463db6816Hal Finkel } 10099f823f94374917174f96a7689955b8463db6816Hal Finkel 10199f823f94374917174f96a7689955b8463db6816Hal Finkel private: 102c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel bool mightUseCTR(const Triple &TT, BasicBlock *BB); 103b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool convertToCTRLoop(Loop *L); 10408f92c98ac1cdb43ec35653536c89964401d936cHal Finkel 10599f823f94374917174f96a7689955b8463db6816Hal Finkel private: 106b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PPCTargetMachine *TM; 107b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel LoopInfo *LI; 108b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ScalarEvolution *SE; 10936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL; 110b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DominatorTree *DT; 111b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel const TargetLibraryInfo *LibInfo; 112f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar bool PreserveLCSSA; 11399f823f94374917174f96a7689955b8463db6816Hal Finkel }; 114b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 115b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel char PPCCTRLoops::ID = 0; 116b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 117b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel int PPCCTRLoops::Counter = 0; 118b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 119e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 120e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 121e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel struct PPCCTRLoopsVerify : public MachineFunctionPass { 122e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel public: 123e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel static char ID; 124e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 125e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel PPCCTRLoopsVerify() : MachineFunctionPass(ID) { 126e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel initializePPCCTRLoopsVerifyPass(*PassRegistry::getPassRegistry()); 127e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 128e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 129dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines void getAnalysisUsage(AnalysisUsage &AU) const override { 130e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel AU.addRequired<MachineDominatorTree>(); 131e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineFunctionPass::getAnalysisUsage(AU); 132e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 133e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 134dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool runOnMachineFunction(MachineFunction &MF) override; 135e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 136e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel private: 137e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineDominatorTree *MDT; 138e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel }; 139e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 140e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel char PPCCTRLoopsVerify::ID = 0; 141e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 14299f823f94374917174f96a7689955b8463db6816Hal Finkel} // end anonymous namespace 14399f823f94374917174f96a7689955b8463db6816Hal Finkel 14496848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof ParzyszekINITIALIZE_PASS_BEGIN(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops", 14596848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek false, false) 14636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesINITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) 147ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesINITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) 148f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga NainarINITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) 14996848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof ParzyszekINITIALIZE_PASS_END(PPCCTRLoops, "ppc-ctr-loops", "PowerPC CTR Loops", 15096848dfc465c8c7f156a562c246803ebefcf21cfKrzysztof Parzyszek false, false) 15199f823f94374917174f96a7689955b8463db6816Hal Finkel 152b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal FinkelFunctionPass *llvm::createPPCCTRLoops(PPCTargetMachine &TM) { 153b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return new PPCCTRLoops(TM); 15499f823f94374917174f96a7689955b8463db6816Hal Finkel} 15599f823f94374917174f96a7689955b8463db6816Hal Finkel 156e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 157e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_BEGIN(PPCCTRLoopsVerify, "ppc-ctr-loops-verify", 158e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel "PowerPC CTR Loops Verify", false, false) 159e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_DEPENDENCY(MachineDominatorTree) 160e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelINITIALIZE_PASS_END(PPCCTRLoopsVerify, "ppc-ctr-loops-verify", 161e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel "PowerPC CTR Loops Verify", false, false) 162e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 163e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal FinkelFunctionPass *llvm::createPPCCTRLoopsVerify() { 164e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return new PPCCTRLoopsVerify(); 165e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 166e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 167e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 168b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelbool PPCCTRLoops::runOnFunction(Function &F) { 169de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (skipFunction(F)) 170de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return false; 171de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 172ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); 173f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE(); 17436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 1754c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar DL = &F.getParent()->getDataLayout(); 176ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); 177ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LibInfo = TLIP ? &TLIP->getTLI() : nullptr; 178f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar PreserveLCSSA = mustPreserveAnalysisID(LCSSAID); 17999f823f94374917174f96a7689955b8463db6816Hal Finkel 180b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool MadeChange = false; 18199f823f94374917174f96a7689955b8463db6816Hal Finkel 182b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (LoopInfo::iterator I = LI->begin(), E = LI->end(); 18399f823f94374917174f96a7689955b8463db6816Hal Finkel I != E; ++I) { 184b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Loop *L = *I; 185b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->getParentLoop()) 186b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange |= convertToCTRLoop(L); 18799f823f94374917174f96a7689955b8463db6816Hal Finkel } 18899f823f94374917174f96a7689955b8463db6816Hal Finkel 189b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 19099f823f94374917174f96a7689955b8463db6816Hal Finkel} 19199f823f94374917174f96a7689955b8463db6816Hal Finkel 19236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic bool isLargeIntegerTy(bool Is32Bit, Type *Ty) { 19336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 19436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ITy->getBitWidth() > (Is32Bit ? 32U : 64U); 19536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 19636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 19736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 19836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 199ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// Determining the address of a TLS variable results in a function call in 200ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines// certain TLS models. 201ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic bool memAddrUsesCTR(const PPCTargetMachine *TM, 202f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const Value *MemAddr) { 203ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const auto *GV = dyn_cast<GlobalValue>(MemAddr); 204f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!GV) { 205f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // Recurse to check for constants that refer to TLS global variables. 206f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (const auto *CV = dyn_cast<Constant>(MemAddr)) 207f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (const auto &CO : CV->operands()) 208f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (memAddrUsesCTR(TM, CO)) 209f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return true; 210f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 211ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return false; 212f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 213f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 214ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!GV->isThreadLocal()) 215ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return false; 216ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!TM) 217ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return true; 218ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLSModel::Model Model = TM->getTLSModel(GV); 219ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Model == TLSModel::GeneralDynamic || Model == TLSModel::LocalDynamic; 220ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 221ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 222c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkelbool PPCCTRLoops::mightUseCTR(const Triple &TT, BasicBlock *BB) { 223c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel for (BasicBlock::iterator J = BB->begin(), JE = BB->end(); 224c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel J != JE; ++J) { 225c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (CallInst *CI = dyn_cast<CallInst>(J)) { 226bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue())) { 227bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel // Inline ASM is okay, unless it clobbers the ctr register. 228bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel InlineAsm::ConstraintInfoVector CIV = IA->ParseConstraints(); 229bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) { 230bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel InlineAsm::ConstraintInfo &C = CIV[i]; 231bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (C.Type != InlineAsm::isInput) 232bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel for (unsigned j = 0, je = C.Codes.size(); j < je; ++j) 233bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel if (StringRef(C.Codes[j]).equals_lower("{ctr}")) 234bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel return true; 235bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel } 236bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel 237bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel continue; 238bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel } 239bf0bc3b2a2e11ff7e79b881ca82324fe17919a97Hal Finkel 240c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!TM) 241c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 242ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLowering *TLI = 243ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TM->getSubtargetImpl(*BB->getParent())->getTargetLowering(); 244c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 245c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (Function *F = CI->getCalledFunction()) { 246c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Most intrinsics don't become function calls, but some might. 247c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // sin, cos, exp and log are always calls. 248de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned Opcode = 0; 249c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (F->getIntrinsicID() != Intrinsic::not_intrinsic) { 250c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel switch (F->getIntrinsicID()) { 251c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel default: continue; 252f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // If we have a call to ppc_is_decremented_ctr_nonzero, or ppc_mtctr 253f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // we're definitely using CTR. 254f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case Intrinsic::ppc_is_decremented_ctr_nonzero: 255f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case Intrinsic::ppc_mtctr: 256f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return true; 257c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 258c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel// VisualStudio defines setjmp as _setjmp 259c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#if defined(_MSC_VER) && defined(setjmp) && \ 260c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel !defined(setjmp_undefined_for_msvc) 261c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# pragma push_macro("setjmp") 262c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# undef setjmp 263c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# define setjmp_undefined_for_msvc 264c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#endif 265c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 266c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::setjmp: 267c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 268c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#if defined(_MSC_VER) && defined(setjmp_undefined_for_msvc) 269c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // let's return it to _setjmp state 270c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# pragma pop_macro("setjmp") 271c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel# undef setjmp_undefined_for_msvc 272c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel#endif 273c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 274c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::longjmp: 2758d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel 2768d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // Exclude eh_sjlj_setjmp; we don't need to exclude eh_sjlj_longjmp 2778d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // because, although it does clobber the counter register, the 2788d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // control can't then return to inside the loop unless there is also 2798d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel // an eh_sjlj_setjmp. 2808d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel case Intrinsic::eh_sjlj_setjmp: 2818d7435e9b1319c6e748a06c0b41a4c3de82ec750Hal Finkel 282c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memcpy: 283c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memmove: 284c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::memset: 285c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::powi: 286c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log: 287c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log2: 288c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::log10: 289c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::exp: 290c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::exp2: 291c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::pow: 292c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::sin: 293c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::cos: 294c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 29566d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel case Intrinsic::copysign: 29666d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel if (CI->getArgOperand(0)->getType()->getScalarType()-> 29766d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel isPPC_FP128Ty()) 29866d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel return true; 29966d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel else 30066d1fa6f4b443ac9f8bcea5d1f71a73ada733a42Hal Finkel continue; // ISD::FCOPYSIGN is never a library call. 301c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::sqrt: Opcode = ISD::FSQRT; break; 302c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::floor: Opcode = ISD::FFLOOR; break; 303c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::ceil: Opcode = ISD::FCEIL; break; 304c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::trunc: Opcode = ISD::FTRUNC; break; 305c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::rint: Opcode = ISD::FRINT; break; 306c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case Intrinsic::nearbyint: Opcode = ISD::FNEARBYINT; break; 30741418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case Intrinsic::round: Opcode = ISD::FROUND; break; 308de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Intrinsic::minnum: Opcode = ISD::FMINNUM; break; 309de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Intrinsic::maxnum: Opcode = ISD::FMAXNUM; break; 310c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 311c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 312c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 313c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // PowerPC does not use [US]DIVREM or other library calls for 314c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // operations on regular types which are not otherwise library calls 315c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // (i.e. soft float or atomics). If adapting for targets that do, 316c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // additional care is required here. 317c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 318c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibFunc::Func Func; 319c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!F->hasLocalLinkage() && F->hasName() && LibInfo && 320c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibInfo->getLibFunc(F->getName(), Func) && 321c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel LibInfo->hasOptimizedCodeGen(Func)) { 322c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Non-read-only functions are never treated as intrinsics. 323c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!CI->onlyReadsMemory()) 324c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 325c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 326c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Conversion happens only for FP calls. 327c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!CI->getArgOperand(0)->getType()->isFloatingPointTy()) 328c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 329c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 330c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel switch (Func) { 331c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel default: return true; 332c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::copysign: 333c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::copysignf: 334c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; // ISD::FCOPYSIGN is never a library call. 33530cbccb029b01738202bd04341b1cbf68a7814c9Hal Finkel case LibFunc::copysignl: 33630cbccb029b01738202bd04341b1cbf68a7814c9Hal Finkel return true; 337c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabs: 338c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabsf: 339c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::fabsl: 340c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; // ISD::FABS is never a library call. 341c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrt: 342c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrtf: 343c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::sqrtl: 344c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FSQRT; break; 345c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floor: 346c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floorf: 347c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::floorl: 348c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FFLOOR; break; 349c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyint: 350c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyintf: 351c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::nearbyintl: 352c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FNEARBYINT; break; 353c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceil: 354c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceilf: 355c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::ceill: 356c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FCEIL; break; 357c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rint: 358c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rintf: 359c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::rintl: 360c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FRINT; break; 36141418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::round: 36241418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::roundf: 36341418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case LibFunc::roundl: 36441418d17cced656f91038b2482bc9d173b4974b0Hal Finkel Opcode = ISD::FROUND; break; 365c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::trunc: 366c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::truncf: 367c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel case LibFunc::truncl: 368c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel Opcode = ISD::FTRUNC; break; 369de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fmin: 370de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fminf: 371de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fminl: 372de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Opcode = ISD::FMINNUM; break; 373de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fmax: 374de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fmaxf: 375de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case LibFunc::fmaxl: 376de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Opcode = ISD::FMAXNUM; break; 377c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 378de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 379c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 380de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Opcode) { 381f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto &DL = CI->getModule()->getDataLayout(); 382f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar MVT VTy = TLI->getSimpleValueType(DL, CI->getArgOperand(0)->getType(), 383f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar true); 384c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (VTy == MVT::Other) 385c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 386f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 387c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (TLI->isOperationLegalOrCustom(Opcode, VTy)) 388c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; 389c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel else if (VTy.isVector() && 390c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel TLI->isOperationLegalOrCustom(Opcode, VTy.getScalarType())) 391c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel continue; 392c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 393c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 394c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 395c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 396c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 397c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 398c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<BinaryOperator>(J) && 399c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel J->getType()->getScalarType()->isPPC_FP128Ty()) { 400c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // Most operations on ppc_f128 values become calls. 401c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 402c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<UIToFPInst>(J) || isa<SIToFPInst>(J) || 403c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel isa<FPToUIInst>(J) || isa<FPToSIInst>(J)) { 404c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel CastInst *CI = cast<CastInst>(J); 405c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() || 406c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel CI->getDestTy()->getScalarType()->isPPC_FP128Ty() || 40736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isLargeIntegerTy(TT.isArch32Bit(), CI->getSrcTy()->getScalarType()) || 40836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isLargeIntegerTy(TT.isArch32Bit(), CI->getDestTy()->getScalarType())) 409c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 41036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } else if (isLargeIntegerTy(TT.isArch32Bit(), 41136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines J->getType()->getScalarType()) && 41240be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel (J->getOpcode() == Instruction::UDiv || 41340be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::SDiv || 41440be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::URem || 41540be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel J->getOpcode() == Instruction::SRem)) { 41640be73bed71a69853720a7f0609cb1f2f77dc3bdHal Finkel return true; 417dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (TT.isArch32Bit() && 418dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines isLargeIntegerTy(false, J->getType()->getScalarType()) && 419dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (J->getOpcode() == Instruction::Shl || 420dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines J->getOpcode() == Instruction::AShr || 421dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines J->getOpcode() == Instruction::LShr)) { 422dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Only on PPC32, for 128-bit integers (specifically not 64-bit 423dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // integers), these might be runtime calls. 424dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return true; 425c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (isa<IndirectBrInst>(J) || isa<InvokeInst>(J)) { 426c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // On PowerPC, indirect jumps use the counter register. 427c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 428c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } else if (SwitchInst *SI = dyn_cast<SwitchInst>(J)) { 429c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!TM) 430c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 431ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLowering *TLI = 432ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TM->getSubtargetImpl(*BB->getParent())->getTargetLowering(); 433c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 43437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (SI->getNumCases() + 1 >= (unsigned)TLI->getMinimumJumpTableEntries()) 435c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return true; 436c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 437de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 438de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (TM->getSubtargetImpl(*BB->getParent())->getTargetLowering()->useSoftFloat()) { 439de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar switch(J->getOpcode()) { 440de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FAdd: 441de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FSub: 442de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FMul: 443de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FDiv: 444de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FRem: 445de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FPTrunc: 446de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FPExt: 447de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FPToUI: 448de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FPToSI: 449de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::UIToFP: 450de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::SIToFP: 451de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case Instruction::FCmp: 452de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return true; 453de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 454de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 455de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 456ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines for (Value *Operand : J->operands()) 457ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (memAddrUsesCTR(TM, Operand)) 458ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return true; 459c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel } 460c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 461c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return false; 462c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel} 463c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 464b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkelbool PPCCTRLoops::convertToCTRLoop(Loop *L) { 465b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool MadeChange = false; 46699f823f94374917174f96a7689955b8463db6816Hal Finkel 467f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const Triple TT = 468f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Triple(L->getHeader()->getParent()->getParent()->getTargetTriple()); 469b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!TT.isArch32Bit() && !TT.isArch64Bit()) 470b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; // Unknown arch. type. 4711448d06156728712f47e5a71fac8e8edc0aba73bHal Finkel 472b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Process nested loops first. 473b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I) { 474b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange |= convertToCTRLoop(*I); 475f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar DEBUG(dbgs() << "Nested loop converted\n"); 476b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 4771448d06156728712f47e5a71fac8e8edc0aba73bHal Finkel 478b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // If a nested loop has been converted, then we can't convert this loop. 479b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (MadeChange) 480b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 481b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 482b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#ifndef NDEBUG 483b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Stop trying after reaching the limit (if any). 484b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel int Limit = CTRLoopLimit; 485b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (Limit >= 0) { 486b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (Counter >= CTRLoopLimit) 487b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return false; 488b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Counter++; 489b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } 490b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel#endif 491b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 492b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We don't want to spill/restore the counter register, and so we don't 493b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // want to use the counter register if the loop contains calls. 494b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (Loop::block_iterator I = L->block_begin(), IE = L->block_end(); 495c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel I != IE; ++I) 496c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (mightUseCTR(TT, *I)) 497c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel return MadeChange; 49899f823f94374917174f96a7689955b8463db6816Hal Finkel 499b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel SmallVector<BasicBlock*, 4> ExitingBlocks; 500b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel L->getExitingBlocks(ExitingBlocks); 501b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 502dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BasicBlock *CountedExitBlock = nullptr; 503dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const SCEV *ExitCount = nullptr; 504dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BranchInst *CountedExitBranch = nullptr; 5056227d5c690504c7ada5780c00a635b282c46e275Craig Topper for (SmallVectorImpl<BasicBlock *>::iterator I = ExitingBlocks.begin(), 506b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IE = ExitingBlocks.end(); I != IE; ++I) { 507b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel const SCEV *EC = SE->getExitCount(L, *I); 508b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DEBUG(dbgs() << "Exit Count for " << *L << " from block " << 509b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel (*I)->getName() << ": " << *EC << "\n"); 510b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (isa<SCEVCouldNotCompute>(EC)) 511b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 512b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(EC)) { 513b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (ConstEC->getValue()->isZero()) 514b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 515b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } else if (!SE->isLoopInvariant(EC, L)) 516b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 517b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 518b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel if (SE->getTypeSizeInBits(EC->getType()) > (TT.isArch64Bit() ? 64 : 32)) 519b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel continue; 520b5f7b0f9780cd1bc6f948b194adfc57176d41711Hal Finkel 521b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We now have a loop-invariant count of loop iterations (which is not the 522b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // constant zero) for which we know that this loop will not exit via this 523b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // exisiting block. 524b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 525b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // We need to make sure that this block will run on every loop iteration. 526b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // For this to be true, we must dominate all blocks with backedges. Such 527b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // blocks are in-loop predecessors to the header block. 528b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel bool NotAlways = false; 529b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel for (pred_iterator PI = pred_begin(L->getHeader()), 530b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel PIE = pred_end(L->getHeader()); PI != PIE; ++PI) { 531b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->contains(*PI)) 532b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 53399f823f94374917174f96a7689955b8463db6816Hal Finkel 534b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!DT->dominates(*I, *PI)) { 535b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel NotAlways = true; 536b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel break; 53799f823f94374917174f96a7689955b8463db6816Hal Finkel } 53899f823f94374917174f96a7689955b8463db6816Hal Finkel } 53999f823f94374917174f96a7689955b8463db6816Hal Finkel 540b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (NotAlways) 541b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 54299f823f94374917174f96a7689955b8463db6816Hal Finkel 543b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Make sure this blocks ends with a conditional branch. 544b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Instruction *TI = (*I)->getTerminator(); 545b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!TI) 546b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 54799f823f94374917174f96a7689955b8463db6816Hal Finkel 548b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 549b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!BI->isConditional()) 55099f823f94374917174f96a7689955b8463db6816Hal Finkel continue; 55199f823f94374917174f96a7689955b8463db6816Hal Finkel 552b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch = BI; 553b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel } else 554b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel continue; 55599f823f94374917174f96a7689955b8463db6816Hal Finkel 556b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Note that this block may not be the loop latch block, even if the loop 557b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // has a latch block. 558b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBlock = *I; 559b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount = EC; 560b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel break; 56199f823f94374917174f96a7689955b8463db6816Hal Finkel } 56299f823f94374917174f96a7689955b8463db6816Hal Finkel 563b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!CountedExitBlock) 564b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 565b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 566b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel BasicBlock *Preheader = L->getLoopPreheader(); 567c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel 568c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // If we don't have a preheader, then insert one. If we already have a 569c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // preheader, then we can use it (except if the preheader contains a use of 570c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // the CTR register because some such uses might be reordered by the 571c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel // selection DAG after the mtctr instruction). 572c482454e3cc2a33a2cf2d1cf0881c7c5e2641c80Hal Finkel if (!Preheader || mightUseCTR(TT, Preheader)) 573f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Preheader = InsertPreheaderForLoop(L, DT, LI, PreserveLCSSA); 574b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!Preheader) 575b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 576b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 577b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DEBUG(dbgs() << "Preheader for exit count: " << Preheader->getName() << "\n"); 578b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 579b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // Insert the count into the preheader and replace the condition used by the 580b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // selected branch. 581b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel MadeChange = true; 582b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 5834c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar SCEVExpander SCEVE(*SE, Preheader->getModule()->getDataLayout(), "loopcnt"); 584b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel LLVMContext &C = SE->getContext(); 585b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) : 586b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Type::getInt32Ty(C); 587b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!ExitCount->getType()->isPointerTy() && 588b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount->getType() != CountType) 589b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ExitCount = SE->getZeroExtendExpr(ExitCount, CountType); 590f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ExitCount = SE->getAddExpr(ExitCount, SE->getOne(CountType)); 591f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Value *ECValue = 592f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar SCEVE.expandCodeFor(ExitCount, CountType, Preheader->getTerminator()); 593b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 594b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IRBuilder<> CountBuilder(Preheader->getTerminator()); 595b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Module *M = Preheader->getParent()->getParent(); 596b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *MTCTRFunc = Intrinsic::getDeclaration(M, Intrinsic::ppc_mtctr, 597b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountType); 598b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountBuilder.CreateCall(MTCTRFunc, ECValue); 599b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 600b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel IRBuilder<> CondBuilder(CountedExitBranch); 601b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *DecFunc = 602b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Intrinsic::getDeclaration(M, Intrinsic::ppc_is_decremented_ctr_nonzero); 6036948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Value *NewCond = CondBuilder.CreateCall(DecFunc, {}); 604b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel Value *OldCond = CountedExitBranch->getCondition(); 605b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch->setCondition(NewCond); 606b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 607b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // The false branch must exit the loop. 608b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel if (!L->contains(CountedExitBranch->getSuccessor(0))) 609b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel CountedExitBranch->swapSuccessors(); 610b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel 611b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // The old condition may be dead now, and may have even created a dead PHI 612b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel // (the original induction variable). 613b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel RecursivelyDeleteTriviallyDeadInstructions(OldCond); 614b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel DeleteDeadPHIs(CountedExitBlock); 6159887ec31e630ede8541dee1d90c44a1efb63c417Hal Finkel 616b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel ++NumCTRLoops; 617b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel return MadeChange; 618b1fd3cd78f8acd21dbf514b75fef991827c343b6Hal Finkel} 6199887ec31e630ede8541dee1d90c44a1efb63c417Hal Finkel 620e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#ifndef NDEBUG 621e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelstatic bool clobbersCTR(const MachineInstr *MI) { 622e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 623e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel const MachineOperand &MO = MI->getOperand(i); 624e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.isReg()) { 625e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.isDef() && (MO.getReg() == PPC::CTR || MO.getReg() == PPC::CTR8)) 626e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 627e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } else if (MO.isRegMask()) { 628e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MO.clobbersPhysReg(PPC::CTR) || MO.clobbersPhysReg(PPC::CTR8)) 629e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 630e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 631e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 632e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 633e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 634e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 635e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 636e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelstatic bool verifyCTRBranch(MachineBasicBlock *MBB, 637e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineBasicBlock::iterator I) { 638e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MachineBasicBlock::iterator BI = I; 639e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel SmallSet<MachineBasicBlock *, 16> Visited; 640e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel SmallVector<MachineBasicBlock *, 8> Preds; 641e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel bool CheckPreds; 642e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 643e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == MBB->begin()) { 644e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Visited.insert(MBB); 645e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto queue_preds; 646e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } else 647e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel --I; 648e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 649e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelcheck_block: 650e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Visited.insert(MBB); 651e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == MBB->end()) 652e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto queue_preds; 653e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 654e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel CheckPreds = true; 655e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::iterator IE = MBB->begin();; --I) { 656e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel unsigned Opc = I->getOpcode(); 65785c08b059ce4248ee739e756cf717a9b429e2ec2Hal Finkel if (Opc == PPC::MTCTRloop || Opc == PPC::MTCTR8loop) { 658e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel CheckPreds = false; 659e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel break; 660e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 661e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 662e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I != BI && clobbersCTR(I)) { 663e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel DEBUG(dbgs() << "BB#" << MBB->getNumber() << " (" << 664e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MBB->getFullName() << ") instruction " << *I << 665e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel " clobbers CTR, invalidating " << "BB#" << 666e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getNumber() << " (" << 667e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getFullName() << ") instruction " << 668e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel *BI << "\n"); 669e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 670e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 671e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 672e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (I == IE) 673e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel break; 674e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 675e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 676e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!CheckPreds && Preds.empty()) 677e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 678e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 679e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (CheckPreds) { 680e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelqueue_preds: 681e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (MachineFunction::iterator(MBB) == MBB->getParent()->begin()) { 682e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel DEBUG(dbgs() << "Unable to find a MTCTR instruction for BB#" << 683e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getNumber() << " (" << 684e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel BI->getParent()->getFullName() << ") instruction " << 685e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel *BI << "\n"); 686e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 687e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 688e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 689e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(), 690e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel PIE = MBB->pred_end(); PI != PIE; ++PI) 691e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Preds.push_back(*PI); 692e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 693e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 694e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel do { 695e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MBB = Preds.pop_back_val(); 696e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!Visited.count(MBB)) { 697e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel I = MBB->getLastNonDebugInstr(); 698e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel goto check_block; 699e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 700e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } while (!Preds.empty()); 701e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 702e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return true; 703e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 704e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 705e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkelbool PPCCTRLoopsVerify::runOnMachineFunction(MachineFunction &MF) { 706e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MDT = &getAnalysis<MachineDominatorTree>(); 707e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 708e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel // Verify that all bdnz/bdz instructions are dominated by a loop mtctr before 709e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel // any other instructions that might clobber the ctr register. 710e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineFunction::iterator I = MF.begin(), IE = MF.end(); 711e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel I != IE; ++I) { 712f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar MachineBasicBlock *MBB = &*I; 713e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!MDT->isReachableFromEntry(MBB)) 714e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel continue; 715e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 716e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel for (MachineBasicBlock::iterator MII = MBB->getFirstTerminator(), 717e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel MIIE = MBB->end(); MII != MIIE; ++MII) { 718e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel unsigned Opc = MII->getOpcode(); 719e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (Opc == PPC::BDNZ8 || Opc == PPC::BDNZ || 720e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel Opc == PPC::BDZ8 || Opc == PPC::BDZ) 721e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel if (!verifyCTRBranch(MBB, MII)) 722e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel llvm_unreachable("Invalid PPC CTR loop!"); 723e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 724e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel } 725e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel 726e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel return false; 727e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel} 728e50c8c1f81a38f0ecebafa5dc60a163814a9713aHal Finkel#endif // NDEBUG 729