IfConversion.cpp revision 321369
1//===-- IfConversion.cpp - Machine code if conversion pass. ---------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the machine instruction level if-conversion pass, which
11// tries to convert conditional branches into predicated instructions.
12//
13//===----------------------------------------------------------------------===//
14
15#include "BranchFolding.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/ADT/ScopeExit.h"
18#include "llvm/ADT/SmallSet.h"
19#include "llvm/ADT/Statistic.h"
20#include "llvm/CodeGen/LivePhysRegs.h"
21#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
22#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
23#include "llvm/CodeGen/MachineFunctionPass.h"
24#include "llvm/CodeGen/MachineInstrBuilder.h"
25#include "llvm/CodeGen/MachineModuleInfo.h"
26#include "llvm/CodeGen/MachineRegisterInfo.h"
27#include "llvm/CodeGen/Passes.h"
28#include "llvm/CodeGen/TargetSchedule.h"
29#include "llvm/Support/CommandLine.h"
30#include "llvm/Support/Debug.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/raw_ostream.h"
33#include "llvm/Target/TargetInstrInfo.h"
34#include "llvm/Target/TargetLowering.h"
35#include "llvm/Target/TargetRegisterInfo.h"
36#include "llvm/Target/TargetSubtargetInfo.h"
37#include <algorithm>
38#include <utility>
39
40using namespace llvm;
41
42#define DEBUG_TYPE "if-converter"
43
44// Hidden options for help debugging.
45static cl::opt<int> IfCvtFnStart("ifcvt-fn-start", cl::init(-1), cl::Hidden);
46static cl::opt<int> IfCvtFnStop("ifcvt-fn-stop", cl::init(-1), cl::Hidden);
47static cl::opt<int> IfCvtLimit("ifcvt-limit", cl::init(-1), cl::Hidden);
48static cl::opt<bool> DisableSimple("disable-ifcvt-simple",
49                                   cl::init(false), cl::Hidden);
50static cl::opt<bool> DisableSimpleF("disable-ifcvt-simple-false",
51                                    cl::init(false), cl::Hidden);
52static cl::opt<bool> DisableTriangle("disable-ifcvt-triangle",
53                                     cl::init(false), cl::Hidden);
54static cl::opt<bool> DisableTriangleR("disable-ifcvt-triangle-rev",
55                                      cl::init(false), cl::Hidden);
56static cl::opt<bool> DisableTriangleF("disable-ifcvt-triangle-false",
57                                      cl::init(false), cl::Hidden);
58static cl::opt<bool> DisableTriangleFR("disable-ifcvt-triangle-false-rev",
59                                       cl::init(false), cl::Hidden);
60static cl::opt<bool> DisableDiamond("disable-ifcvt-diamond",
61                                    cl::init(false), cl::Hidden);
62static cl::opt<bool> DisableForkedDiamond("disable-ifcvt-forked-diamond",
63                                        cl::init(false), cl::Hidden);
64static cl::opt<bool> IfCvtBranchFold("ifcvt-branch-fold",
65                                     cl::init(true), cl::Hidden);
66
67STATISTIC(NumSimple,       "Number of simple if-conversions performed");
68STATISTIC(NumSimpleFalse,  "Number of simple (F) if-conversions performed");
69STATISTIC(NumTriangle,     "Number of triangle if-conversions performed");
70STATISTIC(NumTriangleRev,  "Number of triangle (R) if-conversions performed");
71STATISTIC(NumTriangleFalse,"Number of triangle (F) if-conversions performed");
72STATISTIC(NumTriangleFRev, "Number of triangle (F/R) if-conversions performed");
73STATISTIC(NumDiamonds,     "Number of diamond if-conversions performed");
74STATISTIC(NumForkedDiamonds, "Number of forked-diamond if-conversions performed");
75STATISTIC(NumIfConvBBs,    "Number of if-converted blocks");
76STATISTIC(NumDupBBs,       "Number of duplicated blocks");
77STATISTIC(NumUnpred,       "Number of true blocks of diamonds unpredicated");
78
79namespace {
80  class IfConverter : public MachineFunctionPass {
81    enum IfcvtKind {
82      ICNotClassfied,  // BB data valid, but not classified.
83      ICSimpleFalse,   // Same as ICSimple, but on the false path.
84      ICSimple,        // BB is entry of an one split, no rejoin sub-CFG.
85      ICTriangleFRev,  // Same as ICTriangleFalse, but false path rev condition.
86      ICTriangleRev,   // Same as ICTriangle, but true path rev condition.
87      ICTriangleFalse, // Same as ICTriangle, but on the false path.
88      ICTriangle,      // BB is entry of a triangle sub-CFG.
89      ICDiamond,       // BB is entry of a diamond sub-CFG.
90      ICForkedDiamond  // BB is entry of an almost diamond sub-CFG, with a
91                       // common tail that can be shared.
92    };
93
94    /// One per MachineBasicBlock, this is used to cache the result
95    /// if-conversion feasibility analysis. This includes results from
96    /// TargetInstrInfo::analyzeBranch() (i.e. TBB, FBB, and Cond), and its
97    /// classification, and common tail block of its successors (if it's a
98    /// diamond shape), its size, whether it's predicable, and whether any
99    /// instruction can clobber the 'would-be' predicate.
100    ///
101    /// IsDone          - True if BB is not to be considered for ifcvt.
102    /// IsBeingAnalyzed - True if BB is currently being analyzed.
103    /// IsAnalyzed      - True if BB has been analyzed (info is still valid).
104    /// IsEnqueued      - True if BB has been enqueued to be ifcvt'ed.
105    /// IsBrAnalyzable  - True if analyzeBranch() returns false.
106    /// HasFallThrough  - True if BB may fallthrough to the following BB.
107    /// IsUnpredicable  - True if BB is known to be unpredicable.
108    /// ClobbersPred    - True if BB could modify predicates (e.g. has
109    ///                   cmp, call, etc.)
110    /// NonPredSize     - Number of non-predicated instructions.
111    /// ExtraCost       - Extra cost for multi-cycle instructions.
112    /// ExtraCost2      - Some instructions are slower when predicated
113    /// BB              - Corresponding MachineBasicBlock.
114    /// TrueBB / FalseBB- See analyzeBranch().
115    /// BrCond          - Conditions for end of block conditional branches.
116    /// Predicate       - Predicate used in the BB.
117    struct BBInfo {
118      bool IsDone          : 1;
119      bool IsBeingAnalyzed : 1;
120      bool IsAnalyzed      : 1;
121      bool IsEnqueued      : 1;
122      bool IsBrAnalyzable  : 1;
123      bool IsBrReversible  : 1;
124      bool HasFallThrough  : 1;
125      bool IsUnpredicable  : 1;
126      bool CannotBeCopied  : 1;
127      bool ClobbersPred    : 1;
128      unsigned NonPredSize;
129      unsigned ExtraCost;
130      unsigned ExtraCost2;
131      MachineBasicBlock *BB;
132      MachineBasicBlock *TrueBB;
133      MachineBasicBlock *FalseBB;
134      SmallVector<MachineOperand, 4> BrCond;
135      SmallVector<MachineOperand, 4> Predicate;
136      BBInfo() : IsDone(false), IsBeingAnalyzed(false),
137                 IsAnalyzed(false), IsEnqueued(false), IsBrAnalyzable(false),
138                 IsBrReversible(false), HasFallThrough(false),
139                 IsUnpredicable(false), CannotBeCopied(false),
140                 ClobbersPred(false), NonPredSize(0), ExtraCost(0),
141                 ExtraCost2(0), BB(nullptr), TrueBB(nullptr),
142                 FalseBB(nullptr) {}
143    };
144
145    /// Record information about pending if-conversions to attempt:
146    /// BBI             - Corresponding BBInfo.
147    /// Kind            - Type of block. See IfcvtKind.
148    /// NeedSubsumption - True if the to-be-predicated BB has already been
149    ///                   predicated.
150    /// NumDups      - Number of instructions that would be duplicated due
151    ///                   to this if-conversion. (For diamonds, the number of
152    ///                   identical instructions at the beginnings of both
153    ///                   paths).
154    /// NumDups2     - For diamonds, the number of identical instructions
155    ///                   at the ends of both paths.
156    struct IfcvtToken {
157      BBInfo &BBI;
158      IfcvtKind Kind;
159      unsigned NumDups;
160      unsigned NumDups2;
161      bool NeedSubsumption : 1;
162      bool TClobbersPred : 1;
163      bool FClobbersPred : 1;
164      IfcvtToken(BBInfo &b, IfcvtKind k, bool s, unsigned d, unsigned d2 = 0,
165                 bool tc = false, bool fc = false)
166        : BBI(b), Kind(k), NumDups(d), NumDups2(d2), NeedSubsumption(s),
167          TClobbersPred(tc), FClobbersPred(fc) {}
168    };
169
170    /// Results of if-conversion feasibility analysis indexed by basic block
171    /// number.
172    std::vector<BBInfo> BBAnalysis;
173    TargetSchedModel SchedModel;
174
175    const TargetLoweringBase *TLI;
176    const TargetInstrInfo *TII;
177    const TargetRegisterInfo *TRI;
178    const MachineBranchProbabilityInfo *MBPI;
179    MachineRegisterInfo *MRI;
180
181    LivePhysRegs Redefs;
182    LivePhysRegs DontKill;
183
184    bool PreRegAlloc;
185    bool MadeChange;
186    int FnNum;
187    std::function<bool(const MachineFunction &)> PredicateFtor;
188
189  public:
190    static char ID;
191    IfConverter(std::function<bool(const MachineFunction &)> Ftor = nullptr)
192        : MachineFunctionPass(ID), FnNum(-1), PredicateFtor(std::move(Ftor)) {
193      initializeIfConverterPass(*PassRegistry::getPassRegistry());
194    }
195
196    void getAnalysisUsage(AnalysisUsage &AU) const override {
197      AU.addRequired<MachineBlockFrequencyInfo>();
198      AU.addRequired<MachineBranchProbabilityInfo>();
199      MachineFunctionPass::getAnalysisUsage(AU);
200    }
201
202    bool runOnMachineFunction(MachineFunction &MF) override;
203
204    MachineFunctionProperties getRequiredProperties() const override {
205      return MachineFunctionProperties().set(
206          MachineFunctionProperties::Property::NoVRegs);
207    }
208
209  private:
210    bool reverseBranchCondition(BBInfo &BBI) const;
211    bool ValidSimple(BBInfo &TrueBBI, unsigned &Dups,
212                     BranchProbability Prediction) const;
213    bool ValidTriangle(BBInfo &TrueBBI, BBInfo &FalseBBI,
214                       bool FalseBranch, unsigned &Dups,
215                       BranchProbability Prediction) const;
216    bool CountDuplicatedInstructions(
217        MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
218        MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE,
219        unsigned &Dups1, unsigned &Dups2,
220        MachineBasicBlock &TBB, MachineBasicBlock &FBB,
221        bool SkipUnconditionalBranches) const;
222    bool ValidDiamond(BBInfo &TrueBBI, BBInfo &FalseBBI,
223                      unsigned &Dups1, unsigned &Dups2,
224                      BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const;
225    bool ValidForkedDiamond(BBInfo &TrueBBI, BBInfo &FalseBBI,
226                            unsigned &Dups1, unsigned &Dups2,
227                            BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const;
228    void AnalyzeBranches(BBInfo &BBI);
229    void ScanInstructions(BBInfo &BBI,
230                          MachineBasicBlock::iterator &Begin,
231                          MachineBasicBlock::iterator &End,
232                          bool BranchUnpredicable = false) const;
233    bool RescanInstructions(
234        MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
235        MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE,
236        BBInfo &TrueBBI, BBInfo &FalseBBI) const;
237    void AnalyzeBlock(MachineBasicBlock &MBB,
238                      std::vector<std::unique_ptr<IfcvtToken>> &Tokens);
239    bool FeasibilityAnalysis(BBInfo &BBI, SmallVectorImpl<MachineOperand> &Cond,
240                             bool isTriangle = false, bool RevBranch = false,
241                             bool hasCommonTail = false);
242    void AnalyzeBlocks(MachineFunction &MF,
243                       std::vector<std::unique_ptr<IfcvtToken>> &Tokens);
244    void InvalidatePreds(MachineBasicBlock &MBB);
245    void RemoveExtraEdges(BBInfo &BBI);
246    bool IfConvertSimple(BBInfo &BBI, IfcvtKind Kind);
247    bool IfConvertTriangle(BBInfo &BBI, IfcvtKind Kind);
248    bool IfConvertDiamondCommon(BBInfo &BBI, BBInfo &TrueBBI, BBInfo &FalseBBI,
249                                unsigned NumDups1, unsigned NumDups2,
250                                bool TClobbersPred, bool FClobbersPred,
251                                bool RemoveBranch, bool MergeAddEdges);
252    bool IfConvertDiamond(BBInfo &BBI, IfcvtKind Kind,
253                          unsigned NumDups1, unsigned NumDups2,
254                          bool TClobbers, bool FClobbers);
255    bool IfConvertForkedDiamond(BBInfo &BBI, IfcvtKind Kind,
256                              unsigned NumDups1, unsigned NumDups2,
257                              bool TClobbers, bool FClobbers);
258    void PredicateBlock(BBInfo &BBI,
259                        MachineBasicBlock::iterator E,
260                        SmallVectorImpl<MachineOperand> &Cond,
261                        SmallSet<unsigned, 4> *LaterRedefs = nullptr);
262    void CopyAndPredicateBlock(BBInfo &ToBBI, BBInfo &FromBBI,
263                               SmallVectorImpl<MachineOperand> &Cond,
264                               bool IgnoreBr = false);
265    void MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges = true);
266
267    bool MeetIfcvtSizeLimit(MachineBasicBlock &BB,
268                            unsigned Cycle, unsigned Extra,
269                            BranchProbability Prediction) const {
270      return Cycle > 0 && TII->isProfitableToIfCvt(BB, Cycle, Extra,
271                                                   Prediction);
272    }
273
274    bool MeetIfcvtSizeLimit(MachineBasicBlock &TBB,
275                            unsigned TCycle, unsigned TExtra,
276                            MachineBasicBlock &FBB,
277                            unsigned FCycle, unsigned FExtra,
278                            BranchProbability Prediction) const {
279      return TCycle > 0 && FCycle > 0 &&
280        TII->isProfitableToIfCvt(TBB, TCycle, TExtra, FBB, FCycle, FExtra,
281                                 Prediction);
282    }
283
284    /// Returns true if Block ends without a terminator.
285    bool blockAlwaysFallThrough(BBInfo &BBI) const {
286      return BBI.IsBrAnalyzable && BBI.TrueBB == nullptr;
287    }
288
289    /// Used to sort if-conversion candidates.
290    static bool IfcvtTokenCmp(const std::unique_ptr<IfcvtToken> &C1,
291                              const std::unique_ptr<IfcvtToken> &C2) {
292      int Incr1 = (C1->Kind == ICDiamond)
293        ? -(int)(C1->NumDups + C1->NumDups2) : (int)C1->NumDups;
294      int Incr2 = (C2->Kind == ICDiamond)
295        ? -(int)(C2->NumDups + C2->NumDups2) : (int)C2->NumDups;
296      if (Incr1 > Incr2)
297        return true;
298      else if (Incr1 == Incr2) {
299        // Favors subsumption.
300        if (!C1->NeedSubsumption && C2->NeedSubsumption)
301          return true;
302        else if (C1->NeedSubsumption == C2->NeedSubsumption) {
303          // Favors diamond over triangle, etc.
304          if ((unsigned)C1->Kind < (unsigned)C2->Kind)
305            return true;
306          else if (C1->Kind == C2->Kind)
307            return C1->BBI.BB->getNumber() < C2->BBI.BB->getNumber();
308        }
309      }
310      return false;
311    }
312  };
313
314  char IfConverter::ID = 0;
315}
316
317char &llvm::IfConverterID = IfConverter::ID;
318
319INITIALIZE_PASS_BEGIN(IfConverter, DEBUG_TYPE, "If Converter", false, false)
320INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
321INITIALIZE_PASS_END(IfConverter, DEBUG_TYPE, "If Converter", false, false)
322
323bool IfConverter::runOnMachineFunction(MachineFunction &MF) {
324  if (skipFunction(*MF.getFunction()) || (PredicateFtor && !PredicateFtor(MF)))
325    return false;
326
327  const TargetSubtargetInfo &ST = MF.getSubtarget();
328  TLI = ST.getTargetLowering();
329  TII = ST.getInstrInfo();
330  TRI = ST.getRegisterInfo();
331  BranchFolder::MBFIWrapper MBFI(getAnalysis<MachineBlockFrequencyInfo>());
332  MBPI = &getAnalysis<MachineBranchProbabilityInfo>();
333  MRI = &MF.getRegInfo();
334  SchedModel.init(ST.getSchedModel(), &ST, TII);
335
336  if (!TII) return false;
337
338  PreRegAlloc = MRI->isSSA();
339
340  bool BFChange = false;
341  if (!PreRegAlloc) {
342    // Tail merge tend to expose more if-conversion opportunities.
343    BranchFolder BF(true, false, MBFI, *MBPI);
344    BFChange = BF.OptimizeFunction(MF, TII, ST.getRegisterInfo(),
345                                   getAnalysisIfAvailable<MachineModuleInfo>());
346  }
347
348  DEBUG(dbgs() << "\nIfcvt: function (" << ++FnNum <<  ") \'"
349               << MF.getName() << "\'");
350
351  if (FnNum < IfCvtFnStart || (IfCvtFnStop != -1 && FnNum > IfCvtFnStop)) {
352    DEBUG(dbgs() << " skipped\n");
353    return false;
354  }
355  DEBUG(dbgs() << "\n");
356
357  MF.RenumberBlocks();
358  BBAnalysis.resize(MF.getNumBlockIDs());
359
360  std::vector<std::unique_ptr<IfcvtToken>> Tokens;
361  MadeChange = false;
362  unsigned NumIfCvts = NumSimple + NumSimpleFalse + NumTriangle +
363    NumTriangleRev + NumTriangleFalse + NumTriangleFRev + NumDiamonds;
364  while (IfCvtLimit == -1 || (int)NumIfCvts < IfCvtLimit) {
365    // Do an initial analysis for each basic block and find all the potential
366    // candidates to perform if-conversion.
367    bool Change = false;
368    AnalyzeBlocks(MF, Tokens);
369    while (!Tokens.empty()) {
370      std::unique_ptr<IfcvtToken> Token = std::move(Tokens.back());
371      Tokens.pop_back();
372      BBInfo &BBI = Token->BBI;
373      IfcvtKind Kind = Token->Kind;
374      unsigned NumDups = Token->NumDups;
375      unsigned NumDups2 = Token->NumDups2;
376
377      // If the block has been evicted out of the queue or it has already been
378      // marked dead (due to it being predicated), then skip it.
379      if (BBI.IsDone)
380        BBI.IsEnqueued = false;
381      if (!BBI.IsEnqueued)
382        continue;
383
384      BBI.IsEnqueued = false;
385
386      bool RetVal = false;
387      switch (Kind) {
388      default: llvm_unreachable("Unexpected!");
389      case ICSimple:
390      case ICSimpleFalse: {
391        bool isFalse = Kind == ICSimpleFalse;
392        if ((isFalse && DisableSimpleF) || (!isFalse && DisableSimple)) break;
393        DEBUG(dbgs() << "Ifcvt (Simple" << (Kind == ICSimpleFalse ?
394                                            " false" : "")
395                     << "): BB#" << BBI.BB->getNumber() << " ("
396                     << ((Kind == ICSimpleFalse)
397                         ? BBI.FalseBB->getNumber()
398                         : BBI.TrueBB->getNumber()) << ") ");
399        RetVal = IfConvertSimple(BBI, Kind);
400        DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n");
401        if (RetVal) {
402          if (isFalse) ++NumSimpleFalse;
403          else         ++NumSimple;
404        }
405       break;
406      }
407      case ICTriangle:
408      case ICTriangleRev:
409      case ICTriangleFalse:
410      case ICTriangleFRev: {
411        bool isFalse = Kind == ICTriangleFalse;
412        bool isRev   = (Kind == ICTriangleRev || Kind == ICTriangleFRev);
413        if (DisableTriangle && !isFalse && !isRev) break;
414        if (DisableTriangleR && !isFalse && isRev) break;
415        if (DisableTriangleF && isFalse && !isRev) break;
416        if (DisableTriangleFR && isFalse && isRev) break;
417        DEBUG(dbgs() << "Ifcvt (Triangle");
418        if (isFalse)
419          DEBUG(dbgs() << " false");
420        if (isRev)
421          DEBUG(dbgs() << " rev");
422        DEBUG(dbgs() << "): BB#" << BBI.BB->getNumber() << " (T:"
423                     << BBI.TrueBB->getNumber() << ",F:"
424                     << BBI.FalseBB->getNumber() << ") ");
425        RetVal = IfConvertTriangle(BBI, Kind);
426        DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n");
427        if (RetVal) {
428          if (isFalse) {
429            if (isRev) ++NumTriangleFRev;
430            else       ++NumTriangleFalse;
431          } else {
432            if (isRev) ++NumTriangleRev;
433            else       ++NumTriangle;
434          }
435        }
436        break;
437      }
438      case ICDiamond: {
439        if (DisableDiamond) break;
440        DEBUG(dbgs() << "Ifcvt (Diamond): BB#" << BBI.BB->getNumber() << " (T:"
441                     << BBI.TrueBB->getNumber() << ",F:"
442                     << BBI.FalseBB->getNumber() << ") ");
443        RetVal = IfConvertDiamond(BBI, Kind, NumDups, NumDups2,
444                                  Token->TClobbersPred,
445                                  Token->FClobbersPred);
446        DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n");
447        if (RetVal) ++NumDiamonds;
448        break;
449      }
450      case ICForkedDiamond: {
451        if (DisableForkedDiamond) break;
452        DEBUG(dbgs() << "Ifcvt (Forked Diamond): BB#"
453                     << BBI.BB->getNumber() << " (T:"
454                     << BBI.TrueBB->getNumber() << ",F:"
455                     << BBI.FalseBB->getNumber() << ") ");
456        RetVal = IfConvertForkedDiamond(BBI, Kind, NumDups, NumDups2,
457                                      Token->TClobbersPred,
458                                      Token->FClobbersPred);
459        DEBUG(dbgs() << (RetVal ? "succeeded!" : "failed!") << "\n");
460        if (RetVal) ++NumForkedDiamonds;
461        break;
462      }
463      }
464
465      Change |= RetVal;
466
467      NumIfCvts = NumSimple + NumSimpleFalse + NumTriangle + NumTriangleRev +
468        NumTriangleFalse + NumTriangleFRev + NumDiamonds;
469      if (IfCvtLimit != -1 && (int)NumIfCvts >= IfCvtLimit)
470        break;
471    }
472
473    if (!Change)
474      break;
475    MadeChange |= Change;
476  }
477
478  Tokens.clear();
479  BBAnalysis.clear();
480
481  if (MadeChange && IfCvtBranchFold) {
482    BranchFolder BF(false, false, MBFI, *MBPI);
483    BF.OptimizeFunction(MF, TII, MF.getSubtarget().getRegisterInfo(),
484                        getAnalysisIfAvailable<MachineModuleInfo>());
485  }
486
487  MadeChange |= BFChange;
488  return MadeChange;
489}
490
491/// BB has a fallthrough. Find its 'false' successor given its 'true' successor.
492static MachineBasicBlock *findFalseBlock(MachineBasicBlock *BB,
493                                         MachineBasicBlock *TrueBB) {
494  for (MachineBasicBlock *SuccBB : BB->successors()) {
495    if (SuccBB != TrueBB)
496      return SuccBB;
497  }
498  return nullptr;
499}
500
501/// Reverse the condition of the end of the block branch. Swap block's 'true'
502/// and 'false' successors.
503bool IfConverter::reverseBranchCondition(BBInfo &BBI) const {
504  DebugLoc dl;  // FIXME: this is nowhere
505  if (!TII->reverseBranchCondition(BBI.BrCond)) {
506    TII->removeBranch(*BBI.BB);
507    TII->insertBranch(*BBI.BB, BBI.FalseBB, BBI.TrueBB, BBI.BrCond, dl);
508    std::swap(BBI.TrueBB, BBI.FalseBB);
509    return true;
510  }
511  return false;
512}
513
514/// Returns the next block in the function blocks ordering. If it is the end,
515/// returns NULL.
516static inline MachineBasicBlock *getNextBlock(MachineBasicBlock &MBB) {
517  MachineFunction::iterator I = MBB.getIterator();
518  MachineFunction::iterator E = MBB.getParent()->end();
519  if (++I == E)
520    return nullptr;
521  return &*I;
522}
523
524/// Returns true if the 'true' block (along with its predecessor) forms a valid
525/// simple shape for ifcvt. It also returns the number of instructions that the
526/// ifcvt would need to duplicate if performed in Dups.
527bool IfConverter::ValidSimple(BBInfo &TrueBBI, unsigned &Dups,
528                              BranchProbability Prediction) const {
529  Dups = 0;
530  if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone)
531    return false;
532
533  if (TrueBBI.IsBrAnalyzable)
534    return false;
535
536  if (TrueBBI.BB->pred_size() > 1) {
537    if (TrueBBI.CannotBeCopied ||
538        !TII->isProfitableToDupForIfCvt(*TrueBBI.BB, TrueBBI.NonPredSize,
539                                        Prediction))
540      return false;
541    Dups = TrueBBI.NonPredSize;
542  }
543
544  return true;
545}
546
547/// Returns true if the 'true' and 'false' blocks (along with their common
548/// predecessor) forms a valid triangle shape for ifcvt. If 'FalseBranch' is
549/// true, it checks if 'true' block's false branch branches to the 'false' block
550/// rather than the other way around. It also returns the number of instructions
551/// that the ifcvt would need to duplicate if performed in 'Dups'.
552bool IfConverter::ValidTriangle(BBInfo &TrueBBI, BBInfo &FalseBBI,
553                                bool FalseBranch, unsigned &Dups,
554                                BranchProbability Prediction) const {
555  Dups = 0;
556  if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone)
557    return false;
558
559  if (TrueBBI.BB->pred_size() > 1) {
560    if (TrueBBI.CannotBeCopied)
561      return false;
562
563    unsigned Size = TrueBBI.NonPredSize;
564    if (TrueBBI.IsBrAnalyzable) {
565      if (TrueBBI.TrueBB && TrueBBI.BrCond.empty())
566        // Ends with an unconditional branch. It will be removed.
567        --Size;
568      else {
569        MachineBasicBlock *FExit = FalseBranch
570          ? TrueBBI.TrueBB : TrueBBI.FalseBB;
571        if (FExit)
572          // Require a conditional branch
573          ++Size;
574      }
575    }
576    if (!TII->isProfitableToDupForIfCvt(*TrueBBI.BB, Size, Prediction))
577      return false;
578    Dups = Size;
579  }
580
581  MachineBasicBlock *TExit = FalseBranch ? TrueBBI.FalseBB : TrueBBI.TrueBB;
582  if (!TExit && blockAlwaysFallThrough(TrueBBI)) {
583    MachineFunction::iterator I = TrueBBI.BB->getIterator();
584    if (++I == TrueBBI.BB->getParent()->end())
585      return false;
586    TExit = &*I;
587  }
588  return TExit && TExit == FalseBBI.BB;
589}
590
591/// Count duplicated instructions and move the iterators to show where they
592/// are.
593/// @param TIB True Iterator Begin
594/// @param FIB False Iterator Begin
595/// These two iterators initially point to the first instruction of the two
596/// blocks, and finally point to the first non-shared instruction.
597/// @param TIE True Iterator End
598/// @param FIE False Iterator End
599/// These two iterators initially point to End() for the two blocks() and
600/// finally point to the first shared instruction in the tail.
601/// Upon return [TIB, TIE), and [FIB, FIE) mark the un-duplicated portions of
602/// two blocks.
603/// @param Dups1 count of duplicated instructions at the beginning of the 2
604/// blocks.
605/// @param Dups2 count of duplicated instructions at the end of the 2 blocks.
606/// @param SkipUnconditionalBranches if true, Don't make sure that
607/// unconditional branches at the end of the blocks are the same. True is
608/// passed when the blocks are analyzable to allow for fallthrough to be
609/// handled.
610/// @return false if the shared portion prevents if conversion.
611bool IfConverter::CountDuplicatedInstructions(
612    MachineBasicBlock::iterator &TIB,
613    MachineBasicBlock::iterator &FIB,
614    MachineBasicBlock::iterator &TIE,
615    MachineBasicBlock::iterator &FIE,
616    unsigned &Dups1, unsigned &Dups2,
617    MachineBasicBlock &TBB, MachineBasicBlock &FBB,
618    bool SkipUnconditionalBranches) const {
619
620  while (TIB != TIE && FIB != FIE) {
621    // Skip dbg_value instructions. These do not count.
622    TIB = skipDebugInstructionsForward(TIB, TIE);
623    FIB = skipDebugInstructionsForward(FIB, FIE);
624    if (TIB == TIE || FIB == FIE)
625      break;
626    if (!TIB->isIdenticalTo(*FIB))
627      break;
628    // A pred-clobbering instruction in the shared portion prevents
629    // if-conversion.
630    std::vector<MachineOperand> PredDefs;
631    if (TII->DefinesPredicate(*TIB, PredDefs))
632      return false;
633    // If we get all the way to the branch instructions, don't count them.
634    if (!TIB->isBranch())
635      ++Dups1;
636    ++TIB;
637    ++FIB;
638  }
639
640  // Check for already containing all of the block.
641  if (TIB == TIE || FIB == FIE)
642    return true;
643  // Now, in preparation for counting duplicate instructions at the ends of the
644  // blocks, switch to reverse_iterators. Note that getReverse() returns an
645  // iterator that points to the same instruction, unlike std::reverse_iterator.
646  // We have to do our own shifting so that we get the same range.
647  MachineBasicBlock::reverse_iterator RTIE = std::next(TIE.getReverse());
648  MachineBasicBlock::reverse_iterator RFIE = std::next(FIE.getReverse());
649  const MachineBasicBlock::reverse_iterator RTIB = std::next(TIB.getReverse());
650  const MachineBasicBlock::reverse_iterator RFIB = std::next(FIB.getReverse());
651
652  if (!TBB.succ_empty() || !FBB.succ_empty()) {
653    if (SkipUnconditionalBranches) {
654      while (RTIE != RTIB && RTIE->isUnconditionalBranch())
655        ++RTIE;
656      while (RFIE != RFIB && RFIE->isUnconditionalBranch())
657        ++RFIE;
658    }
659  }
660
661  // Count duplicate instructions at the ends of the blocks.
662  while (RTIE != RTIB && RFIE != RFIB) {
663    // Skip dbg_value instructions. These do not count.
664    // Note that these are reverse iterators going forward.
665    RTIE = skipDebugInstructionsForward(RTIE, RTIB);
666    RFIE = skipDebugInstructionsForward(RFIE, RFIB);
667    if (RTIE == RTIB || RFIE == RFIB)
668      break;
669    if (!RTIE->isIdenticalTo(*RFIE))
670      break;
671    // We have to verify that any branch instructions are the same, and then we
672    // don't count them toward the # of duplicate instructions.
673    if (!RTIE->isBranch())
674      ++Dups2;
675    ++RTIE;
676    ++RFIE;
677  }
678  TIE = std::next(RTIE.getReverse());
679  FIE = std::next(RFIE.getReverse());
680  return true;
681}
682
683/// RescanInstructions - Run ScanInstructions on a pair of blocks.
684/// @param TIB - True Iterator Begin, points to first non-shared instruction
685/// @param FIB - False Iterator Begin, points to first non-shared instruction
686/// @param TIE - True Iterator End, points past last non-shared instruction
687/// @param FIE - False Iterator End, points past last non-shared instruction
688/// @param TrueBBI  - BBInfo to update for the true block.
689/// @param FalseBBI - BBInfo to update for the false block.
690/// @returns - false if either block cannot be predicated or if both blocks end
691///   with a predicate-clobbering instruction.
692bool IfConverter::RescanInstructions(
693    MachineBasicBlock::iterator &TIB, MachineBasicBlock::iterator &FIB,
694    MachineBasicBlock::iterator &TIE, MachineBasicBlock::iterator &FIE,
695    BBInfo &TrueBBI, BBInfo &FalseBBI) const {
696  bool BranchUnpredicable = true;
697  TrueBBI.IsUnpredicable = FalseBBI.IsUnpredicable = false;
698  ScanInstructions(TrueBBI, TIB, TIE, BranchUnpredicable);
699  if (TrueBBI.IsUnpredicable)
700    return false;
701  ScanInstructions(FalseBBI, FIB, FIE, BranchUnpredicable);
702  if (FalseBBI.IsUnpredicable)
703    return false;
704  if (TrueBBI.ClobbersPred && FalseBBI.ClobbersPred)
705    return false;
706  return true;
707}
708
709#ifndef NDEBUG
710static void verifySameBranchInstructions(
711    MachineBasicBlock *MBB1,
712    MachineBasicBlock *MBB2) {
713  const MachineBasicBlock::reverse_iterator B1 = MBB1->rend();
714  const MachineBasicBlock::reverse_iterator B2 = MBB2->rend();
715  MachineBasicBlock::reverse_iterator E1 = MBB1->rbegin();
716  MachineBasicBlock::reverse_iterator E2 = MBB2->rbegin();
717  while (E1 != B1 && E2 != B2) {
718    skipDebugInstructionsForward(E1, B1);
719    skipDebugInstructionsForward(E2, B2);
720    if (E1 == B1 && E2 == B2)
721      break;
722
723    if (E1 == B1) {
724      assert(!E2->isBranch() && "Branch mis-match, one block is empty.");
725      break;
726    }
727    if (E2 == B2) {
728      assert(!E1->isBranch() && "Branch mis-match, one block is empty.");
729      break;
730    }
731
732    if (E1->isBranch() || E2->isBranch())
733      assert(E1->isIdenticalTo(*E2) &&
734             "Branch mis-match, branch instructions don't match.");
735    else
736      break;
737    ++E1;
738    ++E2;
739  }
740}
741#endif
742
743/// ValidForkedDiamond - Returns true if the 'true' and 'false' blocks (along
744/// with their common predecessor) form a diamond if a common tail block is
745/// extracted.
746/// While not strictly a diamond, this pattern would form a diamond if
747/// tail-merging had merged the shared tails.
748///           EBB
749///         _/   \_
750///         |     |
751///        TBB   FBB
752///        /  \ /   \
753///  FalseBB TrueBB FalseBB
754/// Currently only handles analyzable branches.
755/// Specifically excludes actual diamonds to avoid overlap.
756bool IfConverter::ValidForkedDiamond(
757    BBInfo &TrueBBI, BBInfo &FalseBBI,
758    unsigned &Dups1, unsigned &Dups2,
759    BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const {
760  Dups1 = Dups2 = 0;
761  if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone ||
762      FalseBBI.IsBeingAnalyzed || FalseBBI.IsDone)
763    return false;
764
765  if (!TrueBBI.IsBrAnalyzable || !FalseBBI.IsBrAnalyzable)
766    return false;
767  // Don't IfConvert blocks that can't be folded into their predecessor.
768  if  (TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1)
769    return false;
770
771  // This function is specifically looking for conditional tails, as
772  // unconditional tails are already handled by the standard diamond case.
773  if (TrueBBI.BrCond.size() == 0 ||
774      FalseBBI.BrCond.size() == 0)
775    return false;
776
777  MachineBasicBlock *TT = TrueBBI.TrueBB;
778  MachineBasicBlock *TF = TrueBBI.FalseBB;
779  MachineBasicBlock *FT = FalseBBI.TrueBB;
780  MachineBasicBlock *FF = FalseBBI.FalseBB;
781
782  if (!TT)
783    TT = getNextBlock(*TrueBBI.BB);
784  if (!TF)
785    TF = getNextBlock(*TrueBBI.BB);
786  if (!FT)
787    FT = getNextBlock(*FalseBBI.BB);
788  if (!FF)
789    FF = getNextBlock(*FalseBBI.BB);
790
791  if (!TT || !TF)
792    return false;
793
794  // Check successors. If they don't match, bail.
795  if (!((TT == FT && TF == FF) || (TF == FT && TT == FF)))
796    return false;
797
798  bool FalseReversed = false;
799  if (TF == FT && TT == FF) {
800    // If the branches are opposing, but we can't reverse, don't do it.
801    if (!FalseBBI.IsBrReversible)
802      return false;
803    FalseReversed = true;
804    reverseBranchCondition(FalseBBI);
805  }
806  auto UnReverseOnExit = make_scope_exit([&]() {
807    if (FalseReversed)
808      reverseBranchCondition(FalseBBI);
809  });
810
811  // Count duplicate instructions at the beginning of the true and false blocks.
812  MachineBasicBlock::iterator TIB = TrueBBI.BB->begin();
813  MachineBasicBlock::iterator FIB = FalseBBI.BB->begin();
814  MachineBasicBlock::iterator TIE = TrueBBI.BB->end();
815  MachineBasicBlock::iterator FIE = FalseBBI.BB->end();
816  if(!CountDuplicatedInstructions(TIB, FIB, TIE, FIE, Dups1, Dups2,
817                                  *TrueBBI.BB, *FalseBBI.BB,
818                                  /* SkipUnconditionalBranches */ true))
819    return false;
820
821  TrueBBICalc.BB = TrueBBI.BB;
822  FalseBBICalc.BB = FalseBBI.BB;
823  if (!RescanInstructions(TIB, FIB, TIE, FIE, TrueBBICalc, FalseBBICalc))
824    return false;
825
826  // The size is used to decide whether to if-convert, and the shared portions
827  // are subtracted off. Because of the subtraction, we just use the size that
828  // was calculated by the original ScanInstructions, as it is correct.
829  TrueBBICalc.NonPredSize = TrueBBI.NonPredSize;
830  FalseBBICalc.NonPredSize = FalseBBI.NonPredSize;
831  return true;
832}
833
834/// ValidDiamond - Returns true if the 'true' and 'false' blocks (along
835/// with their common predecessor) forms a valid diamond shape for ifcvt.
836bool IfConverter::ValidDiamond(
837    BBInfo &TrueBBI, BBInfo &FalseBBI,
838    unsigned &Dups1, unsigned &Dups2,
839    BBInfo &TrueBBICalc, BBInfo &FalseBBICalc) const {
840  Dups1 = Dups2 = 0;
841  if (TrueBBI.IsBeingAnalyzed || TrueBBI.IsDone ||
842      FalseBBI.IsBeingAnalyzed || FalseBBI.IsDone)
843    return false;
844
845  MachineBasicBlock *TT = TrueBBI.TrueBB;
846  MachineBasicBlock *FT = FalseBBI.TrueBB;
847
848  if (!TT && blockAlwaysFallThrough(TrueBBI))
849    TT = getNextBlock(*TrueBBI.BB);
850  if (!FT && blockAlwaysFallThrough(FalseBBI))
851    FT = getNextBlock(*FalseBBI.BB);
852  if (TT != FT)
853    return false;
854  if (!TT && (TrueBBI.IsBrAnalyzable || FalseBBI.IsBrAnalyzable))
855    return false;
856  if  (TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1)
857    return false;
858
859  // FIXME: Allow true block to have an early exit?
860  if (TrueBBI.FalseBB || FalseBBI.FalseBB)
861    return false;
862
863  // Count duplicate instructions at the beginning and end of the true and
864  // false blocks.
865  // Skip unconditional branches only if we are considering an analyzable
866  // diamond. Otherwise the branches must be the same.
867  bool SkipUnconditionalBranches =
868      TrueBBI.IsBrAnalyzable && FalseBBI.IsBrAnalyzable;
869  MachineBasicBlock::iterator TIB = TrueBBI.BB->begin();
870  MachineBasicBlock::iterator FIB = FalseBBI.BB->begin();
871  MachineBasicBlock::iterator TIE = TrueBBI.BB->end();
872  MachineBasicBlock::iterator FIE = FalseBBI.BB->end();
873  if(!CountDuplicatedInstructions(TIB, FIB, TIE, FIE, Dups1, Dups2,
874                                  *TrueBBI.BB, *FalseBBI.BB,
875                                  SkipUnconditionalBranches))
876    return false;
877
878  TrueBBICalc.BB = TrueBBI.BB;
879  FalseBBICalc.BB = FalseBBI.BB;
880  if (!RescanInstructions(TIB, FIB, TIE, FIE, TrueBBICalc, FalseBBICalc))
881    return false;
882  // The size is used to decide whether to if-convert, and the shared portions
883  // are subtracted off. Because of the subtraction, we just use the size that
884  // was calculated by the original ScanInstructions, as it is correct.
885  TrueBBICalc.NonPredSize = TrueBBI.NonPredSize;
886  FalseBBICalc.NonPredSize = FalseBBI.NonPredSize;
887  return true;
888}
889
890/// AnalyzeBranches - Look at the branches at the end of a block to determine if
891/// the block is predicable.
892void IfConverter::AnalyzeBranches(BBInfo &BBI) {
893  if (BBI.IsDone)
894    return;
895
896  BBI.TrueBB = BBI.FalseBB = nullptr;
897  BBI.BrCond.clear();
898  BBI.IsBrAnalyzable =
899      !TII->analyzeBranch(*BBI.BB, BBI.TrueBB, BBI.FalseBB, BBI.BrCond);
900  SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end());
901  BBI.IsBrReversible = (RevCond.size() == 0) ||
902      !TII->reverseBranchCondition(RevCond);
903  BBI.HasFallThrough = BBI.IsBrAnalyzable && BBI.FalseBB == nullptr;
904
905  if (BBI.BrCond.size()) {
906    // No false branch. This BB must end with a conditional branch and a
907    // fallthrough.
908    if (!BBI.FalseBB)
909      BBI.FalseBB = findFalseBlock(BBI.BB, BBI.TrueBB);
910    if (!BBI.FalseBB) {
911      // Malformed bcc? True and false blocks are the same?
912      BBI.IsUnpredicable = true;
913    }
914  }
915}
916
917/// ScanInstructions - Scan all the instructions in the block to determine if
918/// the block is predicable. In most cases, that means all the instructions
919/// in the block are isPredicable(). Also checks if the block contains any
920/// instruction which can clobber a predicate (e.g. condition code register).
921/// If so, the block is not predicable unless it's the last instruction.
922void IfConverter::ScanInstructions(BBInfo &BBI,
923                                   MachineBasicBlock::iterator &Begin,
924                                   MachineBasicBlock::iterator &End,
925                                   bool BranchUnpredicable) const {
926  if (BBI.IsDone || BBI.IsUnpredicable)
927    return;
928
929  bool AlreadyPredicated = !BBI.Predicate.empty();
930
931  BBI.NonPredSize = 0;
932  BBI.ExtraCost = 0;
933  BBI.ExtraCost2 = 0;
934  BBI.ClobbersPred = false;
935  for (MachineInstr &MI : make_range(Begin, End)) {
936    if (MI.isDebugValue())
937      continue;
938
939    // It's unsafe to duplicate convergent instructions in this context, so set
940    // BBI.CannotBeCopied to true if MI is convergent.  To see why, consider the
941    // following CFG, which is subject to our "simple" transformation.
942    //
943    //    BB0     // if (c1) goto BB1; else goto BB2;
944    //   /   \
945    //  BB1   |
946    //   |   BB2  // if (c2) goto TBB; else goto FBB;
947    //   |   / |
948    //   |  /  |
949    //   TBB   |
950    //    |    |
951    //    |   FBB
952    //    |
953    //    exit
954    //
955    // Suppose we want to move TBB's contents up into BB1 and BB2 (in BB1 they'd
956    // be unconditional, and in BB2, they'd be predicated upon c2), and suppose
957    // TBB contains a convergent instruction.  This is safe iff doing so does
958    // not add a control-flow dependency to the convergent instruction -- i.e.,
959    // it's safe iff the set of control flows that leads us to the convergent
960    // instruction does not get smaller after the transformation.
961    //
962    // Originally we executed TBB if c1 || c2.  After the transformation, there
963    // are two copies of TBB's instructions.  We get to the first if c1, and we
964    // get to the second if !c1 && c2.
965    //
966    // There are clearly fewer ways to satisfy the condition "c1" than
967    // "c1 || c2".  Since we've shrunk the set of control flows which lead to
968    // our convergent instruction, the transformation is unsafe.
969    if (MI.isNotDuplicable() || MI.isConvergent())
970      BBI.CannotBeCopied = true;
971
972    bool isPredicated = TII->isPredicated(MI);
973    bool isCondBr = BBI.IsBrAnalyzable && MI.isConditionalBranch();
974
975    if (BranchUnpredicable && MI.isBranch()) {
976      BBI.IsUnpredicable = true;
977      return;
978    }
979
980    // A conditional branch is not predicable, but it may be eliminated.
981    if (isCondBr)
982      continue;
983
984    if (!isPredicated) {
985      BBI.NonPredSize++;
986      unsigned ExtraPredCost = TII->getPredicationCost(MI);
987      unsigned NumCycles = SchedModel.computeInstrLatency(&MI, false);
988      if (NumCycles > 1)
989        BBI.ExtraCost += NumCycles-1;
990      BBI.ExtraCost2 += ExtraPredCost;
991    } else if (!AlreadyPredicated) {
992      // FIXME: This instruction is already predicated before the
993      // if-conversion pass. It's probably something like a conditional move.
994      // Mark this block unpredicable for now.
995      BBI.IsUnpredicable = true;
996      return;
997    }
998
999    if (BBI.ClobbersPred && !isPredicated) {
1000      // Predicate modification instruction should end the block (except for
1001      // already predicated instructions and end of block branches).
1002      // Predicate may have been modified, the subsequent (currently)
1003      // unpredicated instructions cannot be correctly predicated.
1004      BBI.IsUnpredicable = true;
1005      return;
1006    }
1007
1008    // FIXME: Make use of PredDefs? e.g. ADDC, SUBC sets predicates but are
1009    // still potentially predicable.
1010    std::vector<MachineOperand> PredDefs;
1011    if (TII->DefinesPredicate(MI, PredDefs))
1012      BBI.ClobbersPred = true;
1013
1014    if (!TII->isPredicable(MI)) {
1015      BBI.IsUnpredicable = true;
1016      return;
1017    }
1018  }
1019}
1020
1021/// Determine if the block is a suitable candidate to be predicated by the
1022/// specified predicate.
1023/// @param BBI BBInfo for the block to check
1024/// @param Pred Predicate array for the branch that leads to BBI
1025/// @param isTriangle true if the Analysis is for a triangle
1026/// @param RevBranch true if Reverse(Pred) leads to BBI (e.g. BBI is the false
1027///        case
1028/// @param hasCommonTail true if BBI shares a tail with a sibling block that
1029///        contains any instruction that would make the block unpredicable.
1030bool IfConverter::FeasibilityAnalysis(BBInfo &BBI,
1031                                      SmallVectorImpl<MachineOperand> &Pred,
1032                                      bool isTriangle, bool RevBranch,
1033                                      bool hasCommonTail) {
1034  // If the block is dead or unpredicable, then it cannot be predicated.
1035  // Two blocks may share a common unpredicable tail, but this doesn't prevent
1036  // them from being if-converted. The non-shared portion is assumed to have
1037  // been checked
1038  if (BBI.IsDone || (BBI.IsUnpredicable && !hasCommonTail))
1039    return false;
1040
1041  // If it is already predicated but we couldn't analyze its terminator, the
1042  // latter might fallthrough, but we can't determine where to.
1043  // Conservatively avoid if-converting again.
1044  if (BBI.Predicate.size() && !BBI.IsBrAnalyzable)
1045    return false;
1046
1047  // If it is already predicated, check if the new predicate subsumes
1048  // its predicate.
1049  if (BBI.Predicate.size() && !TII->SubsumesPredicate(Pred, BBI.Predicate))
1050    return false;
1051
1052  if (!hasCommonTail && BBI.BrCond.size()) {
1053    if (!isTriangle)
1054      return false;
1055
1056    // Test predicate subsumption.
1057    SmallVector<MachineOperand, 4> RevPred(Pred.begin(), Pred.end());
1058    SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
1059    if (RevBranch) {
1060      if (TII->reverseBranchCondition(Cond))
1061        return false;
1062    }
1063    if (TII->reverseBranchCondition(RevPred) ||
1064        !TII->SubsumesPredicate(Cond, RevPred))
1065      return false;
1066  }
1067
1068  return true;
1069}
1070
1071/// Analyze the structure of the sub-CFG starting from the specified block.
1072/// Record its successors and whether it looks like an if-conversion candidate.
1073void IfConverter::AnalyzeBlock(
1074    MachineBasicBlock &MBB, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
1075  struct BBState {
1076    BBState(MachineBasicBlock &MBB) : MBB(&MBB), SuccsAnalyzed(false) {}
1077    MachineBasicBlock *MBB;
1078
1079    /// This flag is true if MBB's successors have been analyzed.
1080    bool SuccsAnalyzed;
1081  };
1082
1083  // Push MBB to the stack.
1084  SmallVector<BBState, 16> BBStack(1, MBB);
1085
1086  while (!BBStack.empty()) {
1087    BBState &State = BBStack.back();
1088    MachineBasicBlock *BB = State.MBB;
1089    BBInfo &BBI = BBAnalysis[BB->getNumber()];
1090
1091    if (!State.SuccsAnalyzed) {
1092      if (BBI.IsAnalyzed || BBI.IsBeingAnalyzed) {
1093        BBStack.pop_back();
1094        continue;
1095      }
1096
1097      BBI.BB = BB;
1098      BBI.IsBeingAnalyzed = true;
1099
1100      AnalyzeBranches(BBI);
1101      MachineBasicBlock::iterator Begin = BBI.BB->begin();
1102      MachineBasicBlock::iterator End = BBI.BB->end();
1103      ScanInstructions(BBI, Begin, End);
1104
1105      // Unanalyzable or ends with fallthrough or unconditional branch, or if is
1106      // not considered for ifcvt anymore.
1107      if (!BBI.IsBrAnalyzable || BBI.BrCond.empty() || BBI.IsDone) {
1108        BBI.IsBeingAnalyzed = false;
1109        BBI.IsAnalyzed = true;
1110        BBStack.pop_back();
1111        continue;
1112      }
1113
1114      // Do not ifcvt if either path is a back edge to the entry block.
1115      if (BBI.TrueBB == BB || BBI.FalseBB == BB) {
1116        BBI.IsBeingAnalyzed = false;
1117        BBI.IsAnalyzed = true;
1118        BBStack.pop_back();
1119        continue;
1120      }
1121
1122      // Do not ifcvt if true and false fallthrough blocks are the same.
1123      if (!BBI.FalseBB) {
1124        BBI.IsBeingAnalyzed = false;
1125        BBI.IsAnalyzed = true;
1126        BBStack.pop_back();
1127        continue;
1128      }
1129
1130      // Push the False and True blocks to the stack.
1131      State.SuccsAnalyzed = true;
1132      BBStack.push_back(*BBI.FalseBB);
1133      BBStack.push_back(*BBI.TrueBB);
1134      continue;
1135    }
1136
1137    BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()];
1138    BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
1139
1140    if (TrueBBI.IsDone && FalseBBI.IsDone) {
1141      BBI.IsBeingAnalyzed = false;
1142      BBI.IsAnalyzed = true;
1143      BBStack.pop_back();
1144      continue;
1145    }
1146
1147    SmallVector<MachineOperand, 4>
1148        RevCond(BBI.BrCond.begin(), BBI.BrCond.end());
1149    bool CanRevCond = !TII->reverseBranchCondition(RevCond);
1150
1151    unsigned Dups = 0;
1152    unsigned Dups2 = 0;
1153    bool TNeedSub = !TrueBBI.Predicate.empty();
1154    bool FNeedSub = !FalseBBI.Predicate.empty();
1155    bool Enqueued = false;
1156
1157    BranchProbability Prediction = MBPI->getEdgeProbability(BB, TrueBBI.BB);
1158
1159    if (CanRevCond) {
1160      BBInfo TrueBBICalc, FalseBBICalc;
1161      auto feasibleDiamond = [&]() {
1162        bool MeetsSize = MeetIfcvtSizeLimit(
1163            *TrueBBI.BB, (TrueBBICalc.NonPredSize - (Dups + Dups2) +
1164                          TrueBBICalc.ExtraCost), TrueBBICalc.ExtraCost2,
1165            *FalseBBI.BB, (FalseBBICalc.NonPredSize - (Dups + Dups2) +
1166                           FalseBBICalc.ExtraCost), FalseBBICalc.ExtraCost2,
1167            Prediction);
1168        bool TrueFeasible = FeasibilityAnalysis(TrueBBI, BBI.BrCond,
1169                                                /* IsTriangle */ false, /* RevCond */ false,
1170                                                /* hasCommonTail */ true);
1171        bool FalseFeasible = FeasibilityAnalysis(FalseBBI, RevCond,
1172                                                 /* IsTriangle */ false, /* RevCond */ false,
1173                                                 /* hasCommonTail */ true);
1174        return MeetsSize && TrueFeasible && FalseFeasible;
1175      };
1176
1177      if (ValidDiamond(TrueBBI, FalseBBI, Dups, Dups2,
1178                       TrueBBICalc, FalseBBICalc)) {
1179        if (feasibleDiamond()) {
1180          // Diamond:
1181          //   EBB
1182          //   / \_
1183          //  |   |
1184          // TBB FBB
1185          //   \ /
1186          //  TailBB
1187          // Note TailBB can be empty.
1188          Tokens.push_back(llvm::make_unique<IfcvtToken>(
1189              BBI, ICDiamond, TNeedSub | FNeedSub, Dups, Dups2,
1190              (bool) TrueBBICalc.ClobbersPred, (bool) FalseBBICalc.ClobbersPred));
1191          Enqueued = true;
1192        }
1193      } else if (ValidForkedDiamond(TrueBBI, FalseBBI, Dups, Dups2,
1194                                    TrueBBICalc, FalseBBICalc)) {
1195        if (feasibleDiamond()) {
1196          // ForkedDiamond:
1197          // if TBB and FBB have a common tail that includes their conditional
1198          // branch instructions, then we can If Convert this pattern.
1199          //          EBB
1200          //         _/ \_
1201          //         |   |
1202          //        TBB  FBB
1203          //        / \ /   \
1204          //  FalseBB TrueBB FalseBB
1205          //
1206          Tokens.push_back(llvm::make_unique<IfcvtToken>(
1207              BBI, ICForkedDiamond, TNeedSub | FNeedSub, Dups, Dups2,
1208              (bool) TrueBBICalc.ClobbersPred, (bool) FalseBBICalc.ClobbersPred));
1209          Enqueued = true;
1210        }
1211      }
1212    }
1213
1214    if (ValidTriangle(TrueBBI, FalseBBI, false, Dups, Prediction) &&
1215        MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost,
1216                           TrueBBI.ExtraCost2, Prediction) &&
1217        FeasibilityAnalysis(TrueBBI, BBI.BrCond, true)) {
1218      // Triangle:
1219      //   EBB
1220      //   | \_
1221      //   |  |
1222      //   | TBB
1223      //   |  /
1224      //   FBB
1225      Tokens.push_back(
1226          llvm::make_unique<IfcvtToken>(BBI, ICTriangle, TNeedSub, Dups));
1227      Enqueued = true;
1228    }
1229
1230    if (ValidTriangle(TrueBBI, FalseBBI, true, Dups, Prediction) &&
1231        MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost,
1232                           TrueBBI.ExtraCost2, Prediction) &&
1233        FeasibilityAnalysis(TrueBBI, BBI.BrCond, true, true)) {
1234      Tokens.push_back(
1235          llvm::make_unique<IfcvtToken>(BBI, ICTriangleRev, TNeedSub, Dups));
1236      Enqueued = true;
1237    }
1238
1239    if (ValidSimple(TrueBBI, Dups, Prediction) &&
1240        MeetIfcvtSizeLimit(*TrueBBI.BB, TrueBBI.NonPredSize + TrueBBI.ExtraCost,
1241                           TrueBBI.ExtraCost2, Prediction) &&
1242        FeasibilityAnalysis(TrueBBI, BBI.BrCond)) {
1243      // Simple (split, no rejoin):
1244      //   EBB
1245      //   | \_
1246      //   |  |
1247      //   | TBB---> exit
1248      //   |
1249      //   FBB
1250      Tokens.push_back(
1251          llvm::make_unique<IfcvtToken>(BBI, ICSimple, TNeedSub, Dups));
1252      Enqueued = true;
1253    }
1254
1255    if (CanRevCond) {
1256      // Try the other path...
1257      if (ValidTriangle(FalseBBI, TrueBBI, false, Dups,
1258                        Prediction.getCompl()) &&
1259          MeetIfcvtSizeLimit(*FalseBBI.BB,
1260                             FalseBBI.NonPredSize + FalseBBI.ExtraCost,
1261                             FalseBBI.ExtraCost2, Prediction.getCompl()) &&
1262          FeasibilityAnalysis(FalseBBI, RevCond, true)) {
1263        Tokens.push_back(llvm::make_unique<IfcvtToken>(BBI, ICTriangleFalse,
1264                                                       FNeedSub, Dups));
1265        Enqueued = true;
1266      }
1267
1268      if (ValidTriangle(FalseBBI, TrueBBI, true, Dups,
1269                        Prediction.getCompl()) &&
1270          MeetIfcvtSizeLimit(*FalseBBI.BB,
1271                             FalseBBI.NonPredSize + FalseBBI.ExtraCost,
1272                           FalseBBI.ExtraCost2, Prediction.getCompl()) &&
1273        FeasibilityAnalysis(FalseBBI, RevCond, true, true)) {
1274        Tokens.push_back(
1275            llvm::make_unique<IfcvtToken>(BBI, ICTriangleFRev, FNeedSub, Dups));
1276        Enqueued = true;
1277      }
1278
1279      if (ValidSimple(FalseBBI, Dups, Prediction.getCompl()) &&
1280          MeetIfcvtSizeLimit(*FalseBBI.BB,
1281                             FalseBBI.NonPredSize + FalseBBI.ExtraCost,
1282                             FalseBBI.ExtraCost2, Prediction.getCompl()) &&
1283          FeasibilityAnalysis(FalseBBI, RevCond)) {
1284        Tokens.push_back(
1285            llvm::make_unique<IfcvtToken>(BBI, ICSimpleFalse, FNeedSub, Dups));
1286        Enqueued = true;
1287      }
1288    }
1289
1290    BBI.IsEnqueued = Enqueued;
1291    BBI.IsBeingAnalyzed = false;
1292    BBI.IsAnalyzed = true;
1293    BBStack.pop_back();
1294  }
1295}
1296
1297/// Analyze all blocks and find entries for all if-conversion candidates.
1298void IfConverter::AnalyzeBlocks(
1299    MachineFunction &MF, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
1300  for (MachineBasicBlock &MBB : MF)
1301    AnalyzeBlock(MBB, Tokens);
1302
1303  // Sort to favor more complex ifcvt scheme.
1304  std::stable_sort(Tokens.begin(), Tokens.end(), IfcvtTokenCmp);
1305}
1306
1307/// Returns true either if ToMBB is the next block after MBB or that all the
1308/// intervening blocks are empty (given MBB can fall through to its next block).
1309static bool canFallThroughTo(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB) {
1310  MachineFunction::iterator PI = MBB.getIterator();
1311  MachineFunction::iterator I = std::next(PI);
1312  MachineFunction::iterator TI = ToMBB.getIterator();
1313  MachineFunction::iterator E = MBB.getParent()->end();
1314  while (I != TI) {
1315    // Check isSuccessor to avoid case where the next block is empty, but
1316    // it's not a successor.
1317    if (I == E || !I->empty() || !PI->isSuccessor(&*I))
1318      return false;
1319    PI = I++;
1320  }
1321  // Finally see if the last I is indeed a successor to PI.
1322  return PI->isSuccessor(&*I);
1323}
1324
1325/// Invalidate predecessor BB info so it would be re-analyzed to determine if it
1326/// can be if-converted. If predecessor is already enqueued, dequeue it!
1327void IfConverter::InvalidatePreds(MachineBasicBlock &MBB) {
1328  for (const MachineBasicBlock *Predecessor : MBB.predecessors()) {
1329    BBInfo &PBBI = BBAnalysis[Predecessor->getNumber()];
1330    if (PBBI.IsDone || PBBI.BB == &MBB)
1331      continue;
1332    PBBI.IsAnalyzed = false;
1333    PBBI.IsEnqueued = false;
1334  }
1335}
1336
1337/// Inserts an unconditional branch from \p MBB to \p ToMBB.
1338static void InsertUncondBranch(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB,
1339                               const TargetInstrInfo *TII) {
1340  DebugLoc dl;  // FIXME: this is nowhere
1341  SmallVector<MachineOperand, 0> NoCond;
1342  TII->insertBranch(MBB, &ToMBB, nullptr, NoCond, dl);
1343}
1344
1345/// Remove true / false edges if either / both are no longer successors.
1346void IfConverter::RemoveExtraEdges(BBInfo &BBI) {
1347  MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
1348  SmallVector<MachineOperand, 4> Cond;
1349  if (!TII->analyzeBranch(*BBI.BB, TBB, FBB, Cond))
1350    BBI.BB->CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
1351}
1352
1353/// Behaves like LiveRegUnits::StepForward() but also adds implicit uses to all
1354/// values defined in MI which are also live/used by MI.
1355static void UpdatePredRedefs(MachineInstr &MI, LivePhysRegs &Redefs) {
1356  const TargetRegisterInfo *TRI = MI.getParent()->getParent()
1357    ->getSubtarget().getRegisterInfo();
1358
1359  // Before stepping forward past MI, remember which regs were live
1360  // before MI. This is needed to set the Undef flag only when reg is
1361  // dead.
1362  SparseSet<unsigned> LiveBeforeMI;
1363  LiveBeforeMI.setUniverse(TRI->getNumRegs());
1364  for (unsigned Reg : Redefs)
1365    LiveBeforeMI.insert(Reg);
1366
1367  SmallVector<std::pair<unsigned, const MachineOperand*>, 4> Clobbers;
1368  Redefs.stepForward(MI, Clobbers);
1369
1370  // Now add the implicit uses for each of the clobbered values.
1371  for (auto Clobber : Clobbers) {
1372    // FIXME: Const cast here is nasty, but better than making StepForward
1373    // take a mutable instruction instead of const.
1374    unsigned Reg = Clobber.first;
1375    MachineOperand &Op = const_cast<MachineOperand&>(*Clobber.second);
1376    MachineInstr *OpMI = Op.getParent();
1377    MachineInstrBuilder MIB(*OpMI->getParent()->getParent(), OpMI);
1378    if (Op.isRegMask()) {
1379      // First handle regmasks.  They clobber any entries in the mask which
1380      // means that we need a def for those registers.
1381      if (LiveBeforeMI.count(Reg))
1382        MIB.addReg(Reg, RegState::Implicit);
1383
1384      // We also need to add an implicit def of this register for the later
1385      // use to read from.
1386      // For the register allocator to have allocated a register clobbered
1387      // by the call which is used later, it must be the case that
1388      // the call doesn't return.
1389      MIB.addReg(Reg, RegState::Implicit | RegState::Define);
1390      continue;
1391    }
1392    assert(Op.isReg() && "Register operand required");
1393    if (Op.isDead()) {
1394      // If we found a dead def, but it needs to be live, then remove the dead
1395      // flag.
1396      if (Redefs.contains(Op.getReg()))
1397        Op.setIsDead(false);
1398    }
1399    if (LiveBeforeMI.count(Reg))
1400      MIB.addReg(Reg, RegState::Implicit);
1401    else {
1402      bool HasLiveSubReg = false;
1403      for (MCSubRegIterator S(Reg, TRI); S.isValid(); ++S) {
1404        if (!LiveBeforeMI.count(*S))
1405          continue;
1406        HasLiveSubReg = true;
1407        break;
1408      }
1409      if (HasLiveSubReg)
1410        MIB.addReg(Reg, RegState::Implicit);
1411    }
1412  }
1413}
1414
1415/// Remove kill flags from operands with a registers in the \p DontKill set.
1416static void RemoveKills(MachineInstr &MI, const LivePhysRegs &DontKill) {
1417  for (MIBundleOperands O(MI); O.isValid(); ++O) {
1418    if (!O->isReg() || !O->isKill())
1419      continue;
1420    if (DontKill.contains(O->getReg()))
1421      O->setIsKill(false);
1422  }
1423}
1424
1425/// Walks a range of machine instructions and removes kill flags for registers
1426/// in the \p DontKill set.
1427static void RemoveKills(MachineBasicBlock::iterator I,
1428                        MachineBasicBlock::iterator E,
1429                        const LivePhysRegs &DontKill,
1430                        const MCRegisterInfo &MCRI) {
1431  for (MachineInstr &MI : make_range(I, E))
1432    RemoveKills(MI, DontKill);
1433}
1434
1435/// If convert a simple (split, no rejoin) sub-CFG.
1436bool IfConverter::IfConvertSimple(BBInfo &BBI, IfcvtKind Kind) {
1437  BBInfo &TrueBBI  = BBAnalysis[BBI.TrueBB->getNumber()];
1438  BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
1439  BBInfo *CvtBBI = &TrueBBI;
1440  BBInfo *NextBBI = &FalseBBI;
1441
1442  SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
1443  if (Kind == ICSimpleFalse)
1444    std::swap(CvtBBI, NextBBI);
1445
1446  MachineBasicBlock &CvtMBB = *CvtBBI->BB;
1447  MachineBasicBlock &NextMBB = *NextBBI->BB;
1448  if (CvtBBI->IsDone ||
1449      (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) {
1450    // Something has changed. It's no longer safe to predicate this block.
1451    BBI.IsAnalyzed = false;
1452    CvtBBI->IsAnalyzed = false;
1453    return false;
1454  }
1455
1456  if (CvtMBB.hasAddressTaken())
1457    // Conservatively abort if-conversion if BB's address is taken.
1458    return false;
1459
1460  if (Kind == ICSimpleFalse)
1461    if (TII->reverseBranchCondition(Cond))
1462      llvm_unreachable("Unable to reverse branch condition!");
1463
1464  Redefs.init(*TRI);
1465  DontKill.init(*TRI);
1466
1467  if (MRI->tracksLiveness()) {
1468    // Initialize liveins to the first BB. These are potentiall redefined by
1469    // predicated instructions.
1470    Redefs.addLiveIns(CvtMBB);
1471    Redefs.addLiveIns(NextMBB);
1472    // Compute a set of registers which must not be killed by instructions in
1473    // BB1: This is everything live-in to BB2.
1474    DontKill.addLiveIns(NextMBB);
1475  }
1476
1477  // Remove the branches from the entry so we can add the contents of the true
1478  // block to it.
1479  BBI.NonPredSize -= TII->removeBranch(*BBI.BB);
1480
1481  if (CvtMBB.pred_size() > 1) {
1482    // Copy instructions in the true block, predicate them, and add them to
1483    // the entry block.
1484    CopyAndPredicateBlock(BBI, *CvtBBI, Cond);
1485
1486    // RemoveExtraEdges won't work if the block has an unanalyzable branch, so
1487    // explicitly remove CvtBBI as a successor.
1488    BBI.BB->removeSuccessor(&CvtMBB, true);
1489  } else {
1490    // Predicate the instructions in the true block.
1491    RemoveKills(CvtMBB.begin(), CvtMBB.end(), DontKill, *TRI);
1492    PredicateBlock(*CvtBBI, CvtMBB.end(), Cond);
1493
1494    // Merge converted block into entry block.
1495    MergeBlocks(BBI, *CvtBBI);
1496  }
1497
1498  bool IterIfcvt = true;
1499  if (!canFallThroughTo(*BBI.BB, NextMBB)) {
1500    InsertUncondBranch(*BBI.BB, NextMBB, TII);
1501    BBI.HasFallThrough = false;
1502    // Now ifcvt'd block will look like this:
1503    // BB:
1504    // ...
1505    // t, f = cmp
1506    // if t op
1507    // b BBf
1508    //
1509    // We cannot further ifcvt this block because the unconditional branch
1510    // will have to be predicated on the new condition, that will not be
1511    // available if cmp executes.
1512    IterIfcvt = false;
1513  }
1514
1515  RemoveExtraEdges(BBI);
1516
1517  // Update block info. BB can be iteratively if-converted.
1518  if (!IterIfcvt)
1519    BBI.IsDone = true;
1520  InvalidatePreds(*BBI.BB);
1521  CvtBBI->IsDone = true;
1522
1523  // FIXME: Must maintain LiveIns.
1524  return true;
1525}
1526
1527/// If convert a triangle sub-CFG.
1528bool IfConverter::IfConvertTriangle(BBInfo &BBI, IfcvtKind Kind) {
1529  BBInfo &TrueBBI = BBAnalysis[BBI.TrueBB->getNumber()];
1530  BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
1531  BBInfo *CvtBBI = &TrueBBI;
1532  BBInfo *NextBBI = &FalseBBI;
1533  DebugLoc dl;  // FIXME: this is nowhere
1534
1535  SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
1536  if (Kind == ICTriangleFalse || Kind == ICTriangleFRev)
1537    std::swap(CvtBBI, NextBBI);
1538
1539  MachineBasicBlock &CvtMBB = *CvtBBI->BB;
1540  MachineBasicBlock &NextMBB = *NextBBI->BB;
1541  if (CvtBBI->IsDone ||
1542      (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) {
1543    // Something has changed. It's no longer safe to predicate this block.
1544    BBI.IsAnalyzed = false;
1545    CvtBBI->IsAnalyzed = false;
1546    return false;
1547  }
1548
1549  if (CvtMBB.hasAddressTaken())
1550    // Conservatively abort if-conversion if BB's address is taken.
1551    return false;
1552
1553  if (Kind == ICTriangleFalse || Kind == ICTriangleFRev)
1554    if (TII->reverseBranchCondition(Cond))
1555      llvm_unreachable("Unable to reverse branch condition!");
1556
1557  if (Kind == ICTriangleRev || Kind == ICTriangleFRev) {
1558    if (reverseBranchCondition(*CvtBBI)) {
1559      // BB has been changed, modify its predecessors (except for this
1560      // one) so they don't get ifcvt'ed based on bad intel.
1561      for (MachineBasicBlock *PBB : CvtMBB.predecessors()) {
1562        if (PBB == BBI.BB)
1563          continue;
1564        BBInfo &PBBI = BBAnalysis[PBB->getNumber()];
1565        if (PBBI.IsEnqueued) {
1566          PBBI.IsAnalyzed = false;
1567          PBBI.IsEnqueued = false;
1568        }
1569      }
1570    }
1571  }
1572
1573  // Initialize liveins to the first BB. These are potentially redefined by
1574  // predicated instructions.
1575  Redefs.init(*TRI);
1576  if (MRI->tracksLiveness()) {
1577    Redefs.addLiveIns(CvtMBB);
1578    Redefs.addLiveIns(NextMBB);
1579  }
1580
1581  DontKill.clear();
1582
1583  bool HasEarlyExit = CvtBBI->FalseBB != nullptr;
1584  BranchProbability CvtNext, CvtFalse, BBNext, BBCvt;
1585
1586  if (HasEarlyExit) {
1587    // Get probabilities before modifying CvtMBB and BBI.BB.
1588    CvtNext = MBPI->getEdgeProbability(&CvtMBB, &NextMBB);
1589    CvtFalse = MBPI->getEdgeProbability(&CvtMBB, CvtBBI->FalseBB);
1590    BBNext = MBPI->getEdgeProbability(BBI.BB, &NextMBB);
1591    BBCvt = MBPI->getEdgeProbability(BBI.BB, &CvtMBB);
1592  }
1593
1594  // Remove the branches from the entry so we can add the contents of the true
1595  // block to it.
1596  BBI.NonPredSize -= TII->removeBranch(*BBI.BB);
1597
1598  if (CvtMBB.pred_size() > 1) {
1599    // Copy instructions in the true block, predicate them, and add them to
1600    // the entry block.
1601    CopyAndPredicateBlock(BBI, *CvtBBI, Cond, true);
1602
1603    // RemoveExtraEdges won't work if the block has an unanalyzable branch, so
1604    // explicitly remove CvtBBI as a successor.
1605    BBI.BB->removeSuccessor(&CvtMBB, true);
1606  } else {
1607    // Predicate the 'true' block after removing its branch.
1608    CvtBBI->NonPredSize -= TII->removeBranch(CvtMBB);
1609    PredicateBlock(*CvtBBI, CvtMBB.end(), Cond);
1610
1611    // Now merge the entry of the triangle with the true block.
1612    MergeBlocks(BBI, *CvtBBI, false);
1613  }
1614
1615  // If 'true' block has a 'false' successor, add an exit branch to it.
1616  if (HasEarlyExit) {
1617    SmallVector<MachineOperand, 4> RevCond(CvtBBI->BrCond.begin(),
1618                                           CvtBBI->BrCond.end());
1619    if (TII->reverseBranchCondition(RevCond))
1620      llvm_unreachable("Unable to reverse branch condition!");
1621
1622    // Update the edge probability for both CvtBBI->FalseBB and NextBBI.
1623    // NewNext = New_Prob(BBI.BB, NextMBB) =
1624    //   Prob(BBI.BB, NextMBB) +
1625    //   Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, NextMBB)
1626    // NewFalse = New_Prob(BBI.BB, CvtBBI->FalseBB) =
1627    //   Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, CvtBBI->FalseBB)
1628    auto NewTrueBB = getNextBlock(*BBI.BB);
1629    auto NewNext = BBNext + BBCvt * CvtNext;
1630    auto NewTrueBBIter = find(BBI.BB->successors(), NewTrueBB);
1631    if (NewTrueBBIter != BBI.BB->succ_end())
1632      BBI.BB->setSuccProbability(NewTrueBBIter, NewNext);
1633
1634    auto NewFalse = BBCvt * CvtFalse;
1635    TII->insertBranch(*BBI.BB, CvtBBI->FalseBB, nullptr, RevCond, dl);
1636    BBI.BB->addSuccessor(CvtBBI->FalseBB, NewFalse);
1637  }
1638
1639  // Merge in the 'false' block if the 'false' block has no other
1640  // predecessors. Otherwise, add an unconditional branch to 'false'.
1641  bool FalseBBDead = false;
1642  bool IterIfcvt = true;
1643  bool isFallThrough = canFallThroughTo(*BBI.BB, NextMBB);
1644  if (!isFallThrough) {
1645    // Only merge them if the true block does not fallthrough to the false
1646    // block. By not merging them, we make it possible to iteratively
1647    // ifcvt the blocks.
1648    if (!HasEarlyExit &&
1649        NextMBB.pred_size() == 1 && !NextBBI->HasFallThrough &&
1650        !NextMBB.hasAddressTaken()) {
1651      MergeBlocks(BBI, *NextBBI);
1652      FalseBBDead = true;
1653    } else {
1654      InsertUncondBranch(*BBI.BB, NextMBB, TII);
1655      BBI.HasFallThrough = false;
1656    }
1657    // Mixed predicated and unpredicated code. This cannot be iteratively
1658    // predicated.
1659    IterIfcvt = false;
1660  }
1661
1662  RemoveExtraEdges(BBI);
1663
1664  // Update block info. BB can be iteratively if-converted.
1665  if (!IterIfcvt)
1666    BBI.IsDone = true;
1667  InvalidatePreds(*BBI.BB);
1668  CvtBBI->IsDone = true;
1669  if (FalseBBDead)
1670    NextBBI->IsDone = true;
1671
1672  // FIXME: Must maintain LiveIns.
1673  return true;
1674}
1675
1676/// Common code shared between diamond conversions.
1677/// \p BBI, \p TrueBBI, and \p FalseBBI form the diamond shape.
1678/// \p NumDups1 - number of shared instructions at the beginning of \p TrueBBI
1679///               and FalseBBI
1680/// \p NumDups2 - number of shared instructions at the end of \p TrueBBI
1681///               and \p FalseBBI
1682/// \p RemoveBranch - Remove the common branch of the two blocks before
1683///                   predicating. Only false for unanalyzable fallthrough
1684///                   cases. The caller will replace the branch if necessary.
1685/// \p MergeAddEdges - Add successor edges when merging blocks. Only false for
1686///                    unanalyzable fallthrough
1687bool IfConverter::IfConvertDiamondCommon(
1688    BBInfo &BBI, BBInfo &TrueBBI, BBInfo &FalseBBI,
1689    unsigned NumDups1, unsigned NumDups2,
1690    bool TClobbersPred, bool FClobbersPred,
1691    bool RemoveBranch, bool MergeAddEdges) {
1692
1693  if (TrueBBI.IsDone || FalseBBI.IsDone ||
1694      TrueBBI.BB->pred_size() > 1 || FalseBBI.BB->pred_size() > 1) {
1695    // Something has changed. It's no longer safe to predicate these blocks.
1696    BBI.IsAnalyzed = false;
1697    TrueBBI.IsAnalyzed = false;
1698    FalseBBI.IsAnalyzed = false;
1699    return false;
1700  }
1701
1702  if (TrueBBI.BB->hasAddressTaken() || FalseBBI.BB->hasAddressTaken())
1703    // Conservatively abort if-conversion if either BB has its address taken.
1704    return false;
1705
1706  // Put the predicated instructions from the 'true' block before the
1707  // instructions from the 'false' block, unless the true block would clobber
1708  // the predicate, in which case, do the opposite.
1709  BBInfo *BBI1 = &TrueBBI;
1710  BBInfo *BBI2 = &FalseBBI;
1711  SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end());
1712  if (TII->reverseBranchCondition(RevCond))
1713    llvm_unreachable("Unable to reverse branch condition!");
1714  SmallVector<MachineOperand, 4> *Cond1 = &BBI.BrCond;
1715  SmallVector<MachineOperand, 4> *Cond2 = &RevCond;
1716
1717  // Figure out the more profitable ordering.
1718  bool DoSwap = false;
1719  if (TClobbersPred && !FClobbersPred)
1720    DoSwap = true;
1721  else if (!TClobbersPred && !FClobbersPred) {
1722    if (TrueBBI.NonPredSize > FalseBBI.NonPredSize)
1723      DoSwap = true;
1724  } else if (TClobbersPred && FClobbersPred)
1725    llvm_unreachable("Predicate info cannot be clobbered by both sides.");
1726  if (DoSwap) {
1727    std::swap(BBI1, BBI2);
1728    std::swap(Cond1, Cond2);
1729  }
1730
1731  // Remove the conditional branch from entry to the blocks.
1732  BBI.NonPredSize -= TII->removeBranch(*BBI.BB);
1733
1734  MachineBasicBlock &MBB1 = *BBI1->BB;
1735  MachineBasicBlock &MBB2 = *BBI2->BB;
1736
1737  // Initialize the Redefs:
1738  // - BB2 live-in regs need implicit uses before being redefined by BB1
1739  //   instructions.
1740  // - BB1 live-out regs need implicit uses before being redefined by BB2
1741  //   instructions. We start with BB1 live-ins so we have the live-out regs
1742  //   after tracking the BB1 instructions.
1743  Redefs.init(*TRI);
1744  if (MRI->tracksLiveness()) {
1745    Redefs.addLiveIns(MBB1);
1746    Redefs.addLiveIns(MBB2);
1747  }
1748
1749  // Remove the duplicated instructions at the beginnings of both paths.
1750  // Skip dbg_value instructions
1751  MachineBasicBlock::iterator DI1 = MBB1.getFirstNonDebugInstr();
1752  MachineBasicBlock::iterator DI2 = MBB2.getFirstNonDebugInstr();
1753  BBI1->NonPredSize -= NumDups1;
1754  BBI2->NonPredSize -= NumDups1;
1755
1756  // Skip past the dups on each side separately since there may be
1757  // differing dbg_value entries.
1758  for (unsigned i = 0; i < NumDups1; ++DI1) {
1759    if (!DI1->isDebugValue())
1760      ++i;
1761  }
1762  while (NumDups1 != 0) {
1763    ++DI2;
1764    if (!DI2->isDebugValue())
1765      --NumDups1;
1766  }
1767
1768  // Compute a set of registers which must not be killed by instructions in BB1:
1769  // This is everything used+live in BB2 after the duplicated instructions. We
1770  // can compute this set by simulating liveness backwards from the end of BB2.
1771  DontKill.init(*TRI);
1772  if (MRI->tracksLiveness()) {
1773    for (const MachineInstr &MI : make_range(MBB2.rbegin(), ++DI2.getReverse()))
1774      DontKill.stepBackward(MI);
1775
1776    for (const MachineInstr &MI : make_range(MBB1.begin(), DI1)) {
1777      SmallVector<std::pair<unsigned, const MachineOperand*>, 4> Dummy;
1778      Redefs.stepForward(MI, Dummy);
1779    }
1780  }
1781  BBI.BB->splice(BBI.BB->end(), &MBB1, MBB1.begin(), DI1);
1782  MBB2.erase(MBB2.begin(), DI2);
1783
1784  // The branches have been checked to match, so it is safe to remove the branch
1785  // in BB1 and rely on the copy in BB2
1786#ifndef NDEBUG
1787  // Unanalyzable branches must match exactly. Check that now.
1788  if (!BBI1->IsBrAnalyzable)
1789    verifySameBranchInstructions(&MBB1, &MBB2);
1790#endif
1791  BBI1->NonPredSize -= TII->removeBranch(*BBI1->BB);
1792  // Remove duplicated instructions.
1793  DI1 = MBB1.end();
1794  for (unsigned i = 0; i != NumDups2; ) {
1795    // NumDups2 only counted non-dbg_value instructions, so this won't
1796    // run off the head of the list.
1797    assert(DI1 != MBB1.begin());
1798    --DI1;
1799    // skip dbg_value instructions
1800    if (!DI1->isDebugValue())
1801      ++i;
1802  }
1803  MBB1.erase(DI1, MBB1.end());
1804
1805  // Kill flags in the true block for registers living into the false block
1806  // must be removed.
1807  RemoveKills(MBB1.begin(), MBB1.end(), DontKill, *TRI);
1808
1809  DI2 = BBI2->BB->end();
1810  // The branches have been checked to match. Skip over the branch in the false
1811  // block so that we don't try to predicate it.
1812  if (RemoveBranch)
1813    BBI2->NonPredSize -= TII->removeBranch(*BBI2->BB);
1814  else {
1815    do {
1816      assert(DI2 != MBB2.begin());
1817      DI2--;
1818    } while (DI2->isBranch() || DI2->isDebugValue());
1819    DI2++;
1820  }
1821  while (NumDups2 != 0) {
1822    // NumDups2 only counted non-dbg_value instructions, so this won't
1823    // run off the head of the list.
1824    assert(DI2 != MBB2.begin());
1825    --DI2;
1826    // skip dbg_value instructions
1827    if (!DI2->isDebugValue())
1828      --NumDups2;
1829  }
1830
1831  // Remember which registers would later be defined by the false block.
1832  // This allows us not to predicate instructions in the true block that would
1833  // later be re-defined. That is, rather than
1834  //   subeq  r0, r1, #1
1835  //   addne  r0, r1, #1
1836  // generate:
1837  //   sub    r0, r1, #1
1838  //   addne  r0, r1, #1
1839  SmallSet<unsigned, 4> RedefsByFalse;
1840  SmallSet<unsigned, 4> ExtUses;
1841  if (TII->isProfitableToUnpredicate(MBB1, MBB2)) {
1842    for (const MachineInstr &FI : make_range(MBB2.begin(), DI2)) {
1843      if (FI.isDebugValue())
1844        continue;
1845      SmallVector<unsigned, 4> Defs;
1846      for (const MachineOperand &MO : FI.operands()) {
1847        if (!MO.isReg())
1848          continue;
1849        unsigned Reg = MO.getReg();
1850        if (!Reg)
1851          continue;
1852        if (MO.isDef()) {
1853          Defs.push_back(Reg);
1854        } else if (!RedefsByFalse.count(Reg)) {
1855          // These are defined before ctrl flow reach the 'false' instructions.
1856          // They cannot be modified by the 'true' instructions.
1857          for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
1858               SubRegs.isValid(); ++SubRegs)
1859            ExtUses.insert(*SubRegs);
1860        }
1861      }
1862
1863      for (unsigned Reg : Defs) {
1864        if (!ExtUses.count(Reg)) {
1865          for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
1866               SubRegs.isValid(); ++SubRegs)
1867            RedefsByFalse.insert(*SubRegs);
1868        }
1869      }
1870    }
1871  }
1872
1873  // Predicate the 'true' block.
1874  PredicateBlock(*BBI1, MBB1.end(), *Cond1, &RedefsByFalse);
1875
1876  // After predicating BBI1, if there is a predicated terminator in BBI1 and
1877  // a non-predicated in BBI2, then we don't want to predicate the one from
1878  // BBI2. The reason is that if we merged these blocks, we would end up with
1879  // two predicated terminators in the same block.
1880  if (!MBB2.empty() && (DI2 == MBB2.end())) {
1881    MachineBasicBlock::iterator BBI1T = MBB1.getFirstTerminator();
1882    MachineBasicBlock::iterator BBI2T = MBB2.getFirstTerminator();
1883    if (BBI1T != MBB1.end() && TII->isPredicated(*BBI1T) &&
1884        BBI2T != MBB2.end() && !TII->isPredicated(*BBI2T))
1885      --DI2;
1886  }
1887
1888  // Predicate the 'false' block.
1889  PredicateBlock(*BBI2, DI2, *Cond2);
1890
1891  // Merge the true block into the entry of the diamond.
1892  MergeBlocks(BBI, *BBI1, MergeAddEdges);
1893  MergeBlocks(BBI, *BBI2, MergeAddEdges);
1894  return true;
1895}
1896
1897/// If convert an almost-diamond sub-CFG where the true
1898/// and false blocks share a common tail.
1899bool IfConverter::IfConvertForkedDiamond(
1900    BBInfo &BBI, IfcvtKind Kind,
1901    unsigned NumDups1, unsigned NumDups2,
1902    bool TClobbersPred, bool FClobbersPred) {
1903  BBInfo &TrueBBI  = BBAnalysis[BBI.TrueBB->getNumber()];
1904  BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
1905
1906  // Save the debug location for later.
1907  DebugLoc dl;
1908  MachineBasicBlock::iterator TIE = TrueBBI.BB->getFirstTerminator();
1909  if (TIE != TrueBBI.BB->end())
1910    dl = TIE->getDebugLoc();
1911  // Removing branches from both blocks is safe, because we have already
1912  // determined that both blocks have the same branch instructions. The branch
1913  // will be added back at the end, unpredicated.
1914  if (!IfConvertDiamondCommon(
1915      BBI, TrueBBI, FalseBBI,
1916      NumDups1, NumDups2,
1917      TClobbersPred, FClobbersPred,
1918      /* RemoveBranch */ true, /* MergeAddEdges */ true))
1919    return false;
1920
1921  // Add back the branch.
1922  // Debug location saved above when removing the branch from BBI2
1923  TII->insertBranch(*BBI.BB, TrueBBI.TrueBB, TrueBBI.FalseBB,
1924                    TrueBBI.BrCond, dl);
1925
1926  RemoveExtraEdges(BBI);
1927
1928  // Update block info.
1929  BBI.IsDone = TrueBBI.IsDone = FalseBBI.IsDone = true;
1930  InvalidatePreds(*BBI.BB);
1931
1932  // FIXME: Must maintain LiveIns.
1933  return true;
1934}
1935
1936/// If convert a diamond sub-CFG.
1937bool IfConverter::IfConvertDiamond(BBInfo &BBI, IfcvtKind Kind,
1938                                   unsigned NumDups1, unsigned NumDups2,
1939                                   bool TClobbersPred, bool FClobbersPred) {
1940  BBInfo &TrueBBI  = BBAnalysis[BBI.TrueBB->getNumber()];
1941  BBInfo &FalseBBI = BBAnalysis[BBI.FalseBB->getNumber()];
1942  MachineBasicBlock *TailBB = TrueBBI.TrueBB;
1943
1944  // True block must fall through or end with an unanalyzable terminator.
1945  if (!TailBB) {
1946    if (blockAlwaysFallThrough(TrueBBI))
1947      TailBB = FalseBBI.TrueBB;
1948    assert((TailBB || !TrueBBI.IsBrAnalyzable) && "Unexpected!");
1949  }
1950
1951  if (!IfConvertDiamondCommon(
1952      BBI, TrueBBI, FalseBBI,
1953      NumDups1, NumDups2,
1954      TClobbersPred, FClobbersPred,
1955      /* RemoveBranch */ TrueBBI.IsBrAnalyzable,
1956      /* MergeAddEdges */ TailBB == nullptr))
1957    return false;
1958
1959  // If the if-converted block falls through or unconditionally branches into
1960  // the tail block, and the tail block does not have other predecessors, then
1961  // fold the tail block in as well. Otherwise, unless it falls through to the
1962  // tail, add a unconditional branch to it.
1963  if (TailBB) {
1964    BBInfo &TailBBI = BBAnalysis[TailBB->getNumber()];
1965    bool CanMergeTail = !TailBBI.HasFallThrough &&
1966      !TailBBI.BB->hasAddressTaken();
1967    // The if-converted block can still have a predicated terminator
1968    // (e.g. a predicated return). If that is the case, we cannot merge
1969    // it with the tail block.
1970    MachineBasicBlock::const_iterator TI = BBI.BB->getFirstTerminator();
1971    if (TI != BBI.BB->end() && TII->isPredicated(*TI))
1972      CanMergeTail = false;
1973    // There may still be a fall-through edge from BBI1 or BBI2 to TailBB;
1974    // check if there are any other predecessors besides those.
1975    unsigned NumPreds = TailBB->pred_size();
1976    if (NumPreds > 1)
1977      CanMergeTail = false;
1978    else if (NumPreds == 1 && CanMergeTail) {
1979      MachineBasicBlock::pred_iterator PI = TailBB->pred_begin();
1980      if (*PI != TrueBBI.BB && *PI != FalseBBI.BB)
1981        CanMergeTail = false;
1982    }
1983    if (CanMergeTail) {
1984      MergeBlocks(BBI, TailBBI);
1985      TailBBI.IsDone = true;
1986    } else {
1987      BBI.BB->addSuccessor(TailBB, BranchProbability::getOne());
1988      InsertUncondBranch(*BBI.BB, *TailBB, TII);
1989      BBI.HasFallThrough = false;
1990    }
1991  }
1992
1993  // RemoveExtraEdges won't work if the block has an unanalyzable branch,
1994  // which can happen here if TailBB is unanalyzable and is merged, so
1995  // explicitly remove BBI1 and BBI2 as successors.
1996  BBI.BB->removeSuccessor(TrueBBI.BB);
1997  BBI.BB->removeSuccessor(FalseBBI.BB, /* NormalizeSuccessProbs */ true);
1998  RemoveExtraEdges(BBI);
1999
2000  // Update block info.
2001  BBI.IsDone = TrueBBI.IsDone = FalseBBI.IsDone = true;
2002  InvalidatePreds(*BBI.BB);
2003
2004  // FIXME: Must maintain LiveIns.
2005  return true;
2006}
2007
2008static bool MaySpeculate(const MachineInstr &MI,
2009                         SmallSet<unsigned, 4> &LaterRedefs) {
2010  bool SawStore = true;
2011  if (!MI.isSafeToMove(nullptr, SawStore))
2012    return false;
2013
2014  for (const MachineOperand &MO : MI.operands()) {
2015    if (!MO.isReg())
2016      continue;
2017    unsigned Reg = MO.getReg();
2018    if (!Reg)
2019      continue;
2020    if (MO.isDef() && !LaterRedefs.count(Reg))
2021      return false;
2022  }
2023
2024  return true;
2025}
2026
2027/// Predicate instructions from the start of the block to the specified end with
2028/// the specified condition.
2029void IfConverter::PredicateBlock(BBInfo &BBI,
2030                                 MachineBasicBlock::iterator E,
2031                                 SmallVectorImpl<MachineOperand> &Cond,
2032                                 SmallSet<unsigned, 4> *LaterRedefs) {
2033  bool AnyUnpred = false;
2034  bool MaySpec = LaterRedefs != nullptr;
2035  for (MachineInstr &I : make_range(BBI.BB->begin(), E)) {
2036    if (I.isDebugValue() || TII->isPredicated(I))
2037      continue;
2038    // It may be possible not to predicate an instruction if it's the 'true'
2039    // side of a diamond and the 'false' side may re-define the instruction's
2040    // defs.
2041    if (MaySpec && MaySpeculate(I, *LaterRedefs)) {
2042      AnyUnpred = true;
2043      continue;
2044    }
2045    // If any instruction is predicated, then every instruction after it must
2046    // be predicated.
2047    MaySpec = false;
2048    if (!TII->PredicateInstruction(I, Cond)) {
2049#ifndef NDEBUG
2050      dbgs() << "Unable to predicate " << I << "!\n";
2051#endif
2052      llvm_unreachable(nullptr);
2053    }
2054
2055    // If the predicated instruction now redefines a register as the result of
2056    // if-conversion, add an implicit kill.
2057    UpdatePredRedefs(I, Redefs);
2058  }
2059
2060  BBI.Predicate.append(Cond.begin(), Cond.end());
2061
2062  BBI.IsAnalyzed = false;
2063  BBI.NonPredSize = 0;
2064
2065  ++NumIfConvBBs;
2066  if (AnyUnpred)
2067    ++NumUnpred;
2068}
2069
2070/// Copy and predicate instructions from source BB to the destination block.
2071/// Skip end of block branches if IgnoreBr is true.
2072void IfConverter::CopyAndPredicateBlock(BBInfo &ToBBI, BBInfo &FromBBI,
2073                                        SmallVectorImpl<MachineOperand> &Cond,
2074                                        bool IgnoreBr) {
2075  MachineFunction &MF = *ToBBI.BB->getParent();
2076
2077  MachineBasicBlock &FromMBB = *FromBBI.BB;
2078  for (MachineInstr &I : FromMBB) {
2079    // Do not copy the end of the block branches.
2080    if (IgnoreBr && I.isBranch())
2081      break;
2082
2083    MachineInstr *MI = MF.CloneMachineInstr(&I);
2084    ToBBI.BB->insert(ToBBI.BB->end(), MI);
2085    ToBBI.NonPredSize++;
2086    unsigned ExtraPredCost = TII->getPredicationCost(I);
2087    unsigned NumCycles = SchedModel.computeInstrLatency(&I, false);
2088    if (NumCycles > 1)
2089      ToBBI.ExtraCost += NumCycles-1;
2090    ToBBI.ExtraCost2 += ExtraPredCost;
2091
2092    if (!TII->isPredicated(I) && !MI->isDebugValue()) {
2093      if (!TII->PredicateInstruction(*MI, Cond)) {
2094#ifndef NDEBUG
2095        dbgs() << "Unable to predicate " << I << "!\n";
2096#endif
2097        llvm_unreachable(nullptr);
2098      }
2099    }
2100
2101    // If the predicated instruction now redefines a register as the result of
2102    // if-conversion, add an implicit kill.
2103    UpdatePredRedefs(*MI, Redefs);
2104
2105    // Some kill flags may not be correct anymore.
2106    if (!DontKill.empty())
2107      RemoveKills(*MI, DontKill);
2108  }
2109
2110  if (!IgnoreBr) {
2111    std::vector<MachineBasicBlock *> Succs(FromMBB.succ_begin(),
2112                                           FromMBB.succ_end());
2113    MachineBasicBlock *NBB = getNextBlock(FromMBB);
2114    MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
2115
2116    for (MachineBasicBlock *Succ : Succs) {
2117      // Fallthrough edge can't be transferred.
2118      if (Succ == FallThrough)
2119        continue;
2120      ToBBI.BB->addSuccessor(Succ);
2121    }
2122  }
2123
2124  ToBBI.Predicate.append(FromBBI.Predicate.begin(), FromBBI.Predicate.end());
2125  ToBBI.Predicate.append(Cond.begin(), Cond.end());
2126
2127  ToBBI.ClobbersPred |= FromBBI.ClobbersPred;
2128  ToBBI.IsAnalyzed = false;
2129
2130  ++NumDupBBs;
2131}
2132
2133/// Move all instructions from FromBB to the end of ToBB.  This will leave
2134/// FromBB as an empty block, so remove all of its successor edges except for
2135/// the fall-through edge.  If AddEdges is true, i.e., when FromBBI's branch is
2136/// being moved, add those successor edges to ToBBI.
2137void IfConverter::MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges) {
2138  MachineBasicBlock &FromMBB = *FromBBI.BB;
2139  assert(!FromMBB.hasAddressTaken() &&
2140         "Removing a BB whose address is taken!");
2141
2142  // In case FromMBB contains terminators (e.g. return instruction),
2143  // first move the non-terminator instructions, then the terminators.
2144  MachineBasicBlock::iterator FromTI = FromMBB.getFirstTerminator();
2145  MachineBasicBlock::iterator ToTI = ToBBI.BB->getFirstTerminator();
2146  ToBBI.BB->splice(ToTI, &FromMBB, FromMBB.begin(), FromTI);
2147
2148  // If FromBB has non-predicated terminator we should copy it at the end.
2149  if (FromTI != FromMBB.end() && !TII->isPredicated(*FromTI))
2150    ToTI = ToBBI.BB->end();
2151  ToBBI.BB->splice(ToTI, &FromMBB, FromTI, FromMBB.end());
2152
2153  // Force normalizing the successors' probabilities of ToBBI.BB to convert all
2154  // unknown probabilities into known ones.
2155  // FIXME: This usage is too tricky and in the future we would like to
2156  // eliminate all unknown probabilities in MBB.
2157  if (ToBBI.IsBrAnalyzable)
2158    ToBBI.BB->normalizeSuccProbs();
2159
2160  SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.succ_begin(),
2161                                                FromMBB.succ_end());
2162  MachineBasicBlock *NBB = getNextBlock(FromMBB);
2163  MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
2164  // The edge probability from ToBBI.BB to FromMBB, which is only needed when
2165  // AddEdges is true and FromMBB is a successor of ToBBI.BB.
2166  auto To2FromProb = BranchProbability::getZero();
2167  if (AddEdges && ToBBI.BB->isSuccessor(&FromMBB)) {
2168    To2FromProb = MBPI->getEdgeProbability(ToBBI.BB, &FromMBB);
2169    // Set the edge probability from ToBBI.BB to FromMBB to zero to avoid the
2170    // edge probability being merged to other edges when this edge is removed
2171    // later.
2172    ToBBI.BB->setSuccProbability(find(ToBBI.BB->successors(), &FromMBB),
2173                                 BranchProbability::getZero());
2174  }
2175
2176  for (MachineBasicBlock *Succ : FromSuccs) {
2177    // Fallthrough edge can't be transferred.
2178    if (Succ == FallThrough)
2179      continue;
2180
2181    auto NewProb = BranchProbability::getZero();
2182    if (AddEdges) {
2183      // Calculate the edge probability for the edge from ToBBI.BB to Succ,
2184      // which is a portion of the edge probability from FromMBB to Succ. The
2185      // portion ratio is the edge probability from ToBBI.BB to FromMBB (if
2186      // FromBBI is a successor of ToBBI.BB. See comment below for excepion).
2187      NewProb = MBPI->getEdgeProbability(&FromMBB, Succ);
2188
2189      // To2FromProb is 0 when FromMBB is not a successor of ToBBI.BB. This
2190      // only happens when if-converting a diamond CFG and FromMBB is the
2191      // tail BB.  In this case FromMBB post-dominates ToBBI.BB and hence we
2192      // could just use the probabilities on FromMBB's out-edges when adding
2193      // new successors.
2194      if (!To2FromProb.isZero())
2195        NewProb *= To2FromProb;
2196    }
2197
2198    FromMBB.removeSuccessor(Succ);
2199
2200    if (AddEdges) {
2201      // If the edge from ToBBI.BB to Succ already exists, update the
2202      // probability of this edge by adding NewProb to it. An example is shown
2203      // below, in which A is ToBBI.BB and B is FromMBB. In this case we
2204      // don't have to set C as A's successor as it already is. We only need to
2205      // update the edge probability on A->C. Note that B will not be
2206      // immediately removed from A's successors. It is possible that B->D is
2207      // not removed either if D is a fallthrough of B. Later the edge A->D
2208      // (generated here) and B->D will be combined into one edge. To maintain
2209      // correct edge probability of this combined edge, we need to set the edge
2210      // probability of A->B to zero, which is already done above. The edge
2211      // probability on A->D is calculated by scaling the original probability
2212      // on A->B by the probability of B->D.
2213      //
2214      // Before ifcvt:      After ifcvt (assume B->D is kept):
2215      //
2216      //       A                A
2217      //      /|               /|\
2218      //     / B              / B|
2219      //    | /|             |  ||
2220      //    |/ |             |  |/
2221      //    C  D             C  D
2222      //
2223      if (ToBBI.BB->isSuccessor(Succ))
2224        ToBBI.BB->setSuccProbability(
2225            find(ToBBI.BB->successors(), Succ),
2226            MBPI->getEdgeProbability(ToBBI.BB, Succ) + NewProb);
2227      else
2228        ToBBI.BB->addSuccessor(Succ, NewProb);
2229    }
2230  }
2231
2232  // Now FromBBI always falls through to the next block!
2233  if (NBB && !FromMBB.isSuccessor(NBB))
2234    FromMBB.addSuccessor(NBB);
2235
2236  // Normalize the probabilities of ToBBI.BB's successors with all adjustment
2237  // we've done above.
2238  if (ToBBI.IsBrAnalyzable && FromBBI.IsBrAnalyzable)
2239    ToBBI.BB->normalizeSuccProbs();
2240
2241  ToBBI.Predicate.append(FromBBI.Predicate.begin(), FromBBI.Predicate.end());
2242  FromBBI.Predicate.clear();
2243
2244  ToBBI.NonPredSize += FromBBI.NonPredSize;
2245  ToBBI.ExtraCost += FromBBI.ExtraCost;
2246  ToBBI.ExtraCost2 += FromBBI.ExtraCost2;
2247  FromBBI.NonPredSize = 0;
2248  FromBBI.ExtraCost = 0;
2249  FromBBI.ExtraCost2 = 0;
2250
2251  ToBBI.ClobbersPred |= FromBBI.ClobbersPred;
2252  ToBBI.HasFallThrough = FromBBI.HasFallThrough;
2253  ToBBI.IsAnalyzed = false;
2254  FromBBI.IsAnalyzed = false;
2255}
2256
2257FunctionPass *
2258llvm::createIfConverter(std::function<bool(const MachineFunction &)> Ftor) {
2259  return new IfConverter(std::move(Ftor));
2260}
2261