FixIrreducible.cpp

Go to the documentation of this file.

//===- FixIrreducible.cpp - Convert irreducible control-flow into loops ---===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// INPUT CFG: The blocks H and B form an irreducible cycle with two headers.
//
//                        Entry
//                       /     \
//                      v       v
//                      H ----> B
//                      ^      /|
//                       `----' |
//                              v
//                             Exit
//
// OUTPUT CFG: Converted to a natural loop with a new header N.
//
//                        Entry
//                          |
//                          v
//                          N <---.
//                         / \     \
//                        /   \     |
//                       v     v    /
//                       H --> B --'
//                             |
//                             v
//                            Exit
//
// To convert an irreducible cycle C to a natural loop L:
//
// 1. Add a new node N to C.
// 2. Redirect all external incoming edges through N.
// 3. Redirect all edges incident on header H through N.
//
// This is sufficient to ensure that:
//
// a. Every closed path in C also exists in L, with the modification that any
//    path passing through H now passes through N before reaching H.
// b. Every external path incident on any entry of C is now incident on N and
//    then redirected to the entry.
//
// Thus, L is a strongly connected component dominated by N, and hence L is a
// natural loop with header N.
//
// When an irreducible cycle C with header H is transformed into a loop, the
// following invariants hold:
//
// 1. No new subcycles are "discovered" in the set (C-H). The only internal
//    edges that are redirected by the transform are incident on H. Any subcycle
//    S in (C-H), already existed prior to this transform, and is already in the
//    list of children for this cycle C.
//
// 2. Subcycles of C are not modified by the transform. For some subcycle S of
//    C, edges incident on the entries of S are either internal to C, or they
//    are now redirected through N, which is outside of S. So the list of
//    entries to S does not change. Since the transform only adds a block
//    outside S, and redirects edges that are not internal to S, the list of
//    blocks in S does not change.
//
// 3. Similarly, any natural loop L included in C is not affected, with one
//    exception: L is "destroyed" by the transform iff its header is H. The
//    backedges of such a loop are now redirected to N instead, and hence the
//    body of this loop gets merged into the new loop with header N.
//
// The actual transformation is handled by the ControlFlowHub, which redirects
// specified control flow edges through a set of guard blocks. This also moves
// every PHINode in an outgoing block to the hub. Since the hub dominates all
// the outgoing blocks, each such PHINode continues to dominate its uses. Since
// every header in an SCC has at least two predecessors, every value used in the
// header (or later) but defined in a predecessor (or earlier) is represented by
// a PHINode in a header. Hence the above handling of PHINodes is sufficient and
// no further processing is required to restore SSA.
//
// Limitation: The pass cannot handle indirect branches. They must be lowered to
//             plain branches first.
//
// CallBr and Switch support: CallBr and Switch terminators are handled as a
// more general branch instruction which can have multiple successors. The pass
// redirects the edges to intermediate target blocks that unconditionally branch
// to the original target blocks. This allows the control flow hub to know to
// which of the original target blocks to jump to. Example input CFG:
//                        Entry (callbr/switch)
//                       /     \
//                      v       v
//                      H ----> B
//                      ^      /|
//                       `----' |
//                              v
//                             Exit
//
// becomes:
//                        Entry (callbr/switch)
//                       /     \
//                      v       v
//                 target.H   target.B
//                      |       |
//                      v       v
//                      H ----> B
//                      ^      /|
//                       `----' |
//                              v
//                             Exit
//
// Note
// OUTPUT CFG: Converted to a natural loop with a new header N.
//
//                        Entry (callbr/switch)
//                       /     \
//                      v       v
//                 target.H   target.B
//                      \       /
//                       \     /
//                        v   v
//                          N <---.
//                         / \     \
//                        /   \     |
//                       v     v    /
//                       H --> B --'
//                             |
//                             v
//                            Exit
//
//===----------------------------------------------------------------------===//
 
#include "llvm/Transforms/Utils/FixIrreducible.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/Analysis/CycleAnalysis.h"
#include "llvm/Analysis/DomTreeUpdater.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/Instructions.h"
#include "llvm/InitializePasses.h"
#include "llvm/Pass.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Transforms/Utils.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/ControlFlowUtils.h"
 
#define DEBUG_TYPE "fix-irreducible"
 
using namespace llvm;
 
namespace {
struct FixIrreducible : public FunctionPass {
  static char ID;
  FixIrreducible() : FunctionPass(ID) {
    initializeFixIrreduciblePass(*PassRegistry::getPassRegistry());
  }
 
  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.addRequired<DominatorTreeWrapperPass>();
    AU.addRequired<CycleInfoWrapperPass>();
    AU.addPreserved<DominatorTreeWrapperPass>();
    AU.addPreserved<CycleInfoWrapperPass>();
    AU.addPreserved<LoopInfoWrapperPass>();
  }
 
  bool runOnFunction(Function &F) override;
};
} // namespace
 
char FixIrreducible::ID = 0;
 
FunctionPass *llvm::createFixIrreduciblePass() { return new FixIrreducible(); }
 
INITIALIZE_PASS_BEGIN(FixIrreducible, "fix-irreducible",
                      "Convert irreducible control-flow into natural loops",
                      false /* Only looks at CFG */, false /* Analysis Pass */)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(FixIrreducible, "fix-irreducible",
                    "Convert irreducible control-flow into natural loops",
                    false /* Only looks at CFG */, false /* Analysis Pass */)
 
// When a new loop is created, existing children of the parent loop may now be
// fully inside the new loop. Reconnect these as children of the new loop.
static void reconnectChildLoops(LoopInfo &LI, Loop *ParentLoop, Loop *NewLoop,
                                BasicBlock *OldHeader) {
  // Any candidate (sibling of NewLoop, or top-level loop if there is no
  // parent) is a child iff its header is owned by the new loop. The new loop's
  // block list is already populated but its subloops are not yet attached, so
  // query the block list directly rather than contains(), which would derive
  // from the not-yet-updated block-to-loop map.
  SmallVector<Loop *, 4> ChildLoops =
      LI.takeChildrenIf(ParentLoop, [&](Loop *L) {
        return NewLoop != L &&
               llvm::is_contained(NewLoop->getBlocks(), L->getHeader());
      });
 
  for (Loop *Child : ChildLoops) {
    LLVM_DEBUG(dbgs() << "child loop: " << Child->getHeader()->getName()
                      << "\n");
    // A child loop whose header was the old cycle header gets destroyed since
    // its backedges are removed.
    if (Child->getHeader() == OldHeader) {
      for (auto *BB : Child->blocks()) {
        if (LI.getLoopFor(BB) != Child)
          continue;
        LI.changeLoopFor(BB, NewLoop);
        LLVM_DEBUG(dbgs() << "moved block from child: " << BB->getName()
                          << "\n");
      }
      for (Loop *GrandChildLoop :
           LI.takeChildrenIf(Child, [](const Loop *) { return true; }))
        NewLoop->addChildLoop(GrandChildLoop);
      LI.destroy(Child);
      LLVM_DEBUG(dbgs() << "subsumed child loop (common header)\n");
      continue;
    }
 
    NewLoop->addChildLoop(Child);
    LLVM_DEBUG(dbgs() << "added child loop to new loop\n");
  }
}
 
static void updateLoopInfo(CycleInfo &CI, LoopInfo &LI, CycleRef C,
                           ArrayRef<BasicBlock *> GuardBlocks) {
  // The parent loop is a natural loop L mapped to the cycle header H as long as
  // H is not also the header of L. In the latter case, L is destroyed and we
  // seek its parent instead.
  BasicBlock *CycleHeader = CI.getHeader(C);
  Loop *ParentLoop = LI.getLoopFor(CycleHeader);
  if (ParentLoop && ParentLoop->getHeader() == CycleHeader)
    ParentLoop = ParentLoop->getParentLoop();
 
  // Create a new loop from the now-transformed cycle
  auto *NewLoop = LI.AllocateLoop();
  if (ParentLoop) {
    ParentLoop->addChildLoop(NewLoop);
  } else {
    LI.addTopLevelLoop(NewLoop);
  }
 
  // Add the guard blocks to the new loop. The first guard block is
  // the head of all the backedges, and it is the first to be inserted
  // in the loop. This ensures that it is recognized as the
  // header. Since the new loop is already in LoopInfo, the new blocks
  // are also propagated up the chain of parent loops.
  for (auto *G : GuardBlocks) {
    LLVM_DEBUG(dbgs() << "added guard block to loop: " << G->getName() << "\n");
    NewLoop->addBasicBlockToLoop(G, LI);
  }
 
  for (auto *BB : CI.getBlocks(C)) {
    NewLoop->addBlockEntry(BB);
    if (LI.getLoopFor(BB) == ParentLoop) {
      LLVM_DEBUG(dbgs() << "moved block from parent: " << BB->getName()
                        << "\n");
      LI.changeLoopFor(BB, NewLoop);
    } else {
      LLVM_DEBUG(dbgs() << "added block from child: " << BB->getName() << "\n");
    }
  }
  LLVM_DEBUG(dbgs() << "header for new loop: "
                    << NewLoop->getHeader()->getName() << "\n");
 
  reconnectChildLoops(LI, ParentLoop, NewLoop, CI.getHeader(C));
 
  LLVM_DEBUG(dbgs() << "Verify new loop.\n"; NewLoop->print(dbgs()));
  NewLoop->verifyLoop();
  if (ParentLoop) {
    LLVM_DEBUG(dbgs() << "Verify parent loop.\n"; ParentLoop->print(dbgs()));
    ParentLoop->verifyLoop();
  }
}
 
// Given a set of blocks and headers in an irreducible SCC, convert it into a
// natural loop. Also insert this new loop at its appropriate place in the
// hierarchy of loops.
static bool fixIrreducible(CycleRef C, CycleInfo &CI, DominatorTree &DT,
                           LoopInfo *LI) {
  if (CI.isReducible(C))
    return false;
  LLVM_DEBUG(dbgs() << "Processing cycle:\n" << CI.print(C) << "\n";);
 
  DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
  ControlFlowHub CHub;
  SetVector<BasicBlock *> Predecessors;
 
  // Redirect internal edges incident on the header.
  BasicBlock *Header = CI.getHeader(C);
  for (BasicBlock *P : predecessors(Header)) {
    if (CI.contains(C, P))
      Predecessors.insert(P);
  }
 
  for (BasicBlock *P : Predecessors) {
    Instruction *Term = P->getTerminator();
    if (isa<UncondBrInst>(Term)) {
      assert(Term->getSuccessor(0) == Header);
      CHub.addBranch(P, Header);
 
      LLVM_DEBUG(dbgs() << "Added internal branch: " << printBasicBlock(P)
                        << " -> " << printBasicBlock(Header) << '\n');
    } else if (CondBrInst *Branch = dyn_cast<CondBrInst>(Term)) {
      BasicBlock *Succ0 = Branch->getSuccessor(0) == Header ? Header : nullptr;
      BasicBlock *Succ1 = Branch->getSuccessor(1) == Header ? Header : nullptr;
      assert(Succ0 || Succ1);
      CHub.addBranch(P, Succ0, Succ1);
 
      LLVM_DEBUG(dbgs() << "Added internal branch: " << printBasicBlock(P)
                        << " -> " << printBasicBlock(Succ0)
                        << (Succ0 && Succ1 ? " " : "") << printBasicBlock(Succ1)
                        << '\n');
    } else if (isa<CallBrInst>(Term) || isa<SwitchInst>(Term)) {
      BasicBlock *NewSucc = nullptr;
      for (unsigned I = 0; I < Term->getNumSuccessors(); ++I) {
        BasicBlock *Succ = Term->getSuccessor(I);
        if (Succ != Header)
          continue;
        NewSucc = SplitMultiBrEdge(P, Succ, I, NewSucc, &DTU, &CI, LI);
        LLVM_DEBUG(dbgs() << "Added internal branch: "
                          << printBasicBlock(NewSucc) << " -> "
                          << printBasicBlock(Succ) << '\n');
      }
      if (NewSucc)
        CHub.addBranch(NewSucc, Header);
    } else {
      reportFatalUsageError(
          "unsupported block terminator: fix-irreducible "
          "only supports br, callbr, and switch instructions");
    }
  }
 
  // Redirect external incoming edges. This includes the edges on the header.
  Predecessors.clear();
  for (BasicBlock *E : CI.getEntries(C)) {
    for (BasicBlock *P : predecessors(E)) {
      if (!CI.contains(C, P))
        Predecessors.insert(P);
    }
  }
 
  for (BasicBlock *P : Predecessors) {
    Instruction *Term = P->getTerminator();
    if (UncondBrInst *Branch = dyn_cast<UncondBrInst>(Term)) {
      BasicBlock *Succ0 = Branch->getSuccessor();
      Succ0 = CI.contains(C, Succ0) ? Succ0 : nullptr;
      CHub.addBranch(P, Succ0);
 
      LLVM_DEBUG(dbgs() << "Added external branch: " << printBasicBlock(P)
                        << " -> " << printBasicBlock(Succ0) << '\n');
    } else if (CondBrInst *Branch = dyn_cast<CondBrInst>(Term)) {
      BasicBlock *Succ0 = Branch->getSuccessor(0);
      Succ0 = CI.contains(C, Succ0) ? Succ0 : nullptr;
      BasicBlock *Succ1 = Branch->getSuccessor(1);
      Succ1 = CI.contains(C, Succ1) ? Succ1 : nullptr;
      CHub.addBranch(P, Succ0, Succ1);
 
      LLVM_DEBUG(dbgs() << "Added external branch: " << printBasicBlock(P)
                        << " -> " << printBasicBlock(Succ0)
                        << (Succ0 && Succ1 ? " " : "") << printBasicBlock(Succ1)
                        << '\n');
    } else if (isa<CallBrInst>(Term) || isa<SwitchInst>(Term)) {
      SmallDenseMap<BasicBlock *, BasicBlock *> MultiBrTargets;
      for (unsigned I = 0; I < Term->getNumSuccessors(); ++I) {
        BasicBlock *Succ = Term->getSuccessor(I);
        if (!CI.contains(C, Succ))
          continue;
        auto It = MultiBrTargets.find(Succ);
        BasicBlock *ExistingTarget =
            (It != MultiBrTargets.end()) ? It->second : nullptr;
 
        BasicBlock *NewSucc =
            SplitMultiBrEdge(P, Succ, I, ExistingTarget, &DTU, &CI, LI);
        if (!ExistingTarget) {
          CHub.addBranch(NewSucc, Succ);
          MultiBrTargets[Succ] = NewSucc;
        }
        LLVM_DEBUG(dbgs() << "Added external branch: "
                          << printBasicBlock(NewSucc) << " -> "
                          << printBasicBlock(Succ) << '\n');
      }
    } else {
      reportFatalUsageError(
          "unsupported block terminator: fix-irreducible "
          "only supports br, callbr, and switch instructions");
    }
  }
 
  // Redirect all the backedges through a "hub" consisting of a series
  // of guard blocks that manage the flow of control from the
  // predecessors to the headers.
  SmallVector<BasicBlock *> GuardBlocks;
 
  // Minor optimization: The cycle entries are discovered in an order that is
  // the opposite of the order in which these blocks appear as branch targets.
  // This results in a lot of condition inversions in the control flow out of
  // the new ControlFlowHub, which can be mitigated if the orders match. So we
  // reverse the entries when adding them to the hub.
  SetVector<BasicBlock *> Entries;
  Entries.insert(CI.getEntries(C).rbegin(), CI.getEntries(C).rend());
 
  CHub.finalize(&DTU, GuardBlocks, "irr");
#if defined(EXPENSIVE_CHECKS)
  assert(DT.verify(DominatorTree::VerificationLevel::Full));
#else
  assert(DT.verify(DominatorTree::VerificationLevel::Fast));
#endif
 
  // If we are updating LoopInfo, do that now before modifying the cycle. This
  // ensures that the first guard block is the header of a new natural loop.
  if (LI)
    updateLoopInfo(CI, *LI, C, GuardBlocks);
 
  for (auto *G : GuardBlocks) {
    LLVM_DEBUG(dbgs() << "added guard block to cycle: " << G->getName()
                      << "\n");
    CI.addBlockToCycle(G, C);
  }
  CI.setSingleEntry(C, GuardBlocks[0]);
 
  CI.verifyCycle(C);
  if (CycleRef Parent = CI.getParentCycle(C))
    CI.verifyCycle(Parent);
 
  LLVM_DEBUG(dbgs() << "Finished one cycle:\n"; CI.print(dbgs()););
  return true;
}
 
static bool FixIrreducibleImpl(Function &F, CycleInfo &CI, DominatorTree &DT,
                               LoopInfo *LI) {
  LLVM_DEBUG(dbgs() << "===== Fix irreducible control-flow in function: "
                    << F.getName() << "\n");
 
  bool Changed = false;
  for (auto C : CI.cycles())
    Changed |= fixIrreducible(C, CI, DT, LI);
 
  if (!Changed)
    return false;
 
#if defined(EXPENSIVE_CHECKS)
  CI.verify();
  if (LI) {
    LI->verify(DT);
  }
#endif // EXPENSIVE_CHECKS
 
  return true;
}
 
bool FixIrreducible::runOnFunction(Function &F) {
  auto *LIWP = getAnalysisIfAvailable<LoopInfoWrapperPass>();
  LoopInfo *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
  auto &CI = getAnalysis<CycleInfoWrapperPass>().getResult();
  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  return FixIrreducibleImpl(F, CI, DT, LI);
}
 
PreservedAnalyses FixIrreduciblePass::run(Function &F,
                                          FunctionAnalysisManager &AM) {
  auto *LI = AM.getCachedResult<LoopAnalysis>(F);
  auto &CI = AM.getResult<CycleAnalysis>(F);
  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
 
  if (!FixIrreducibleImpl(F, CI, DT, LI))
    return PreservedAnalyses::all();
 
  PreservedAnalyses PA;
  PA.preserve<LoopAnalysis>();
  PA.preserve<CycleAnalysis>();
  PA.preserve<DominatorTreeAnalysis>();
  return PA;
}