1//=- MachineLoopUtils.cpp - Functions for manipulating loops ----------------=//
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#include "llvm/CodeGen/MachineLoopInfo.h"
10#include "llvm/CodeGen/MachineLoopUtils.h"
11#include "llvm/CodeGen/MachineBasicBlock.h"
12#include "llvm/CodeGen/MachineRegisterInfo.h"
13#include "llvm/CodeGen/TargetInstrInfo.h"
14using namespace llvm;
15
16namespace {
17// MI's parent and BB are clones of each other. Find the equivalent copy of MI
18// in BB.
19MachineInstr &findEquivalentInstruction(MachineInstr &MI,
20                                        MachineBasicBlock *BB) {
21  MachineBasicBlock *PB = MI.getParent();
22  unsigned Offset = std::distance(PB->instr_begin(), MachineBasicBlock::instr_iterator(MI));
23  return *std::next(BB->instr_begin(), Offset);
24}
25} // namespace
26
27MachineBasicBlock *llvm::PeelSingleBlockLoop(LoopPeelDirection Direction,
28                                             MachineBasicBlock *Loop,
29                                             MachineRegisterInfo &MRI,
30                                             const TargetInstrInfo *TII) {
31  MachineFunction &MF = *Loop->getParent();
32  MachineBasicBlock *Preheader = *Loop->pred_begin();
33  if (Preheader == Loop)
34    Preheader = *std::next(Loop->pred_begin());
35  MachineBasicBlock *Exit = *Loop->succ_begin();
36  if (Exit == Loop)
37    Exit = *std::next(Loop->succ_begin());
38
39  MachineBasicBlock *NewBB = MF.CreateMachineBasicBlock(Loop->getBasicBlock());
40  if (Direction == LPD_Front)
41    MF.insert(Loop->getIterator(), NewBB);
42  else
43    MF.insert(std::next(Loop->getIterator()), NewBB);
44
45  DenseMap<Register, Register> Remaps;
46  auto InsertPt = NewBB->end();
47  for (MachineInstr &MI : *Loop) {
48    MachineInstr *NewMI = MF.CloneMachineInstr(&MI);
49    NewBB->insert(InsertPt, NewMI);
50    for (MachineOperand &MO : NewMI->defs()) {
51      Register OrigR = MO.getReg();
52      if (OrigR.isPhysical())
53        continue;
54      Register &R = Remaps[OrigR];
55      R = MRI.createVirtualRegister(MRI.getRegClass(OrigR));
56      MO.setReg(R);
57
58      if (Direction == LPD_Back) {
59        // Replace all uses outside the original loop with the new register.
60        // FIXME: is the use_iterator stable enough to mutate register uses
61        // while iterating?
62        SmallVector<MachineOperand *, 4> Uses;
63        for (auto &Use : MRI.use_operands(OrigR))
64          if (Use.getParent()->getParent() != Loop)
65            Uses.push_back(&Use);
66        for (auto *Use : Uses) {
67          MRI.constrainRegClass(R, MRI.getRegClass(Use->getReg()));
68          Use->setReg(R);
69        }
70      }
71    }
72  }
73
74  for (auto I = NewBB->getFirstNonPHI(); I != NewBB->end(); ++I)
75    for (MachineOperand &MO : I->uses())
76      if (MO.isReg() && Remaps.count(MO.getReg()))
77        MO.setReg(Remaps[MO.getReg()]);
78
79  for (auto I = NewBB->begin(); I->isPHI(); ++I) {
80    MachineInstr &MI = *I;
81    unsigned LoopRegIdx = 3, InitRegIdx = 1;
82    if (MI.getOperand(2).getMBB() != Preheader)
83      std::swap(LoopRegIdx, InitRegIdx);
84    MachineInstr &OrigPhi = findEquivalentInstruction(MI, Loop);
85    assert(OrigPhi.isPHI());
86    if (Direction == LPD_Front) {
87      // When peeling front, we are only left with the initial value from the
88      // preheader.
89      Register R = MI.getOperand(LoopRegIdx).getReg();
90      if (Remaps.count(R))
91        R = Remaps[R];
92      OrigPhi.getOperand(InitRegIdx).setReg(R);
93      MI.RemoveOperand(LoopRegIdx + 1);
94      MI.RemoveOperand(LoopRegIdx + 0);
95    } else {
96      // When peeling back, the initial value is the loop-carried value from
97      // the original loop.
98      Register LoopReg = OrigPhi.getOperand(LoopRegIdx).getReg();
99      MI.getOperand(LoopRegIdx).setReg(LoopReg);
100      MI.RemoveOperand(InitRegIdx + 1);
101      MI.RemoveOperand(InitRegIdx + 0);
102    }
103  }
104
105  DebugLoc DL;
106  if (Direction == LPD_Front) {
107    Preheader->replaceSuccessor(Loop, NewBB);
108    NewBB->addSuccessor(Loop);
109    Loop->replacePhiUsesWith(Preheader, NewBB);
110    if (TII->removeBranch(*Preheader) > 0)
111      TII->insertBranch(*Preheader, NewBB, nullptr, {}, DL);
112    TII->removeBranch(*NewBB);
113    TII->insertBranch(*NewBB, Loop, nullptr, {}, DL);
114  } else {
115    Loop->replaceSuccessor(Exit, NewBB);
116    Exit->replacePhiUsesWith(Loop, NewBB);
117    NewBB->addSuccessor(Exit);
118
119    MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
120    SmallVector<MachineOperand, 4> Cond;
121    bool CanAnalyzeBr = !TII->analyzeBranch(*Loop, TBB, FBB, Cond);
122    (void)CanAnalyzeBr;
123    assert(CanAnalyzeBr && "Must be able to analyze the loop branch!");
124    TII->removeBranch(*Loop);
125    TII->insertBranch(*Loop, TBB == Exit ? NewBB : TBB,
126                      FBB == Exit ? NewBB : FBB, Cond, DL);
127    if (TII->removeBranch(*NewBB) > 0)
128      TII->insertBranch(*NewBB, Exit, nullptr, {}, DL);
129  }
130
131  return NewBB;
132}
133
134bool llvm::isRegLiveInExitBlocks(MachineLoop *Loop, int PhysReg) {
135  SmallVector<MachineBasicBlock *, 4> ExitBlocks;
136  Loop->getExitBlocks(ExitBlocks);
137
138  for (auto *MBB : ExitBlocks)
139    if (MBB->isLiveIn(PhysReg))
140      return true;
141
142  return false;
143}
144