llvm/lib/Target/WebAssembly/WebAssemblySortRegion.cpp

   1 #include "WebAssemblySortRegion.h"
   2 #include "WebAssemblyExceptionInfo.h"
   3 #include "llvm/CodeGen/MachineLoopInfo.h"
   4
   5 using namespace llvm;
   6 using namespace WebAssembly;
   7
   8 namespace llvm {
   9 namespace WebAssembly {
  10 template <>
  11 bool ConcreteSortRegion<MachineLoop>::isLoop() const {
  12   return true;
  13 }
  14 } // end namespace WebAssembly
  15 } // end namespace llvm
  16
  17 const SortRegion *SortRegionInfo::getRegionFor(const MachineBasicBlock *MBB) {
  18   const auto *ML = MLI.getLoopFor(MBB);
  19   const auto *WE = WEI.getExceptionFor(MBB);
  20   if (!ML && !WE)
  21     return nullptr;
  22   // We determine subregion relationship by domination of their headers, i.e.,
  23   // if region A's header dominates region B's header, B is a subregion of A.
  24   // WebAssemblyException contains BBs in all its subregions (loops or
  25   // exceptions), but MachineLoop may not, because MachineLoop does not
  26   // contain BBs that don't have a path to its header even if they are
  27   // dominated by its header. So here we should use
  28   // WE->contains(ML->getHeader()), but not ML->contains(WE->getHeader()).
  29   if ((ML && !WE) || (ML && WE && WE->contains(ML->getHeader()))) {
  30     // If the smallest region containing MBB is a loop
  31     if (LoopMap.count(ML))
  32       return LoopMap[ML].get();
  33     LoopMap[ML] = std::make_unique<ConcreteSortRegion<MachineLoop>>(ML);
  34     return LoopMap[ML].get();
  35   } else {
  36     // If the smallest region containing MBB is an exception
  37     if (ExceptionMap.count(WE))
  38       return ExceptionMap[WE].get();
  39     ExceptionMap[WE] =
  40         std::make_unique<ConcreteSortRegion<WebAssemblyException>>(WE);
  41     return ExceptionMap[WE].get();
  42   }
  43 }
  44
  45 MachineBasicBlock *SortRegionInfo::getBottom(const SortRegion *R) {
  46   if (R->isLoop())
  47     return getBottom(MLI.getLoopFor(R->getHeader()));
  48   else
  49     return getBottom(WEI.getExceptionFor(R->getHeader()));
  50 }
  51
  52 MachineBasicBlock *SortRegionInfo::getBottom(const MachineLoop *ML) {
  53   MachineBasicBlock *Bottom = ML->getHeader();
  54   for (MachineBasicBlock *MBB : ML->blocks()) {
  55     if (MBB->getNumber() > Bottom->getNumber())
  56       Bottom = MBB;
  57     // MachineLoop does not contain all BBs dominated by its header. BBs that
  58     // don't have a path back to the loop header aren't included. But for the
  59     // purpose of CFG sorting and stackification, we need a bottom BB among all
  60     // BBs that are dominated by the loop header. So we check if there is any
  61     // WebAssemblyException contained in this loop, and computes the most bottom
  62     // BB of them all.
  63     if (MBB->isEHPad()) {
  64       MachineBasicBlock *ExBottom = getBottom(WEI.getExceptionFor(MBB));
  65       if (ExBottom->getNumber() > Bottom->getNumber())
  66         Bottom = ExBottom;
  67     }
  68   }
  69   return Bottom;
  70 }
  71
  72 MachineBasicBlock *SortRegionInfo::getBottom(const WebAssemblyException *WE) {
  73   MachineBasicBlock *Bottom = WE->getHeader();
  74   for (MachineBasicBlock *MBB : WE->blocks())
  75     if (MBB->getNumber() > Bottom->getNumber())
  76       Bottom = MBB;
  77   return Bottom;
  78 }