contrib/llvm/lib/CodeGen/IfConversion.cpp

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