llvm/lib/Analysis/RegionPrinter.cpp

   1 //===- RegionPrinter.cpp - Print regions tree 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 // Print out the region tree of a function using dotty/graphviz.
   9 //===----------------------------------------------------------------------===//
  10
  11 #include "llvm/Analysis/RegionPrinter.h"
  12 #include "llvm/ADT/DepthFirstIterator.h"
  13 #include "llvm/Analysis/DOTGraphTraitsPass.h"
  14 #include "llvm/Analysis/RegionInfo.h"
  15 #include "llvm/Analysis/RegionIterator.h"
  16 #include "llvm/InitializePasses.h"
  17 #include "llvm/Support/CommandLine.h"
  18 #include "llvm/Support/raw_ostream.h"
  19 #ifndef NDEBUG
  20 #include "llvm/IR/LegacyPassManager.h"
  21 #endif
  22
  23 using namespace llvm;
  24
  25 //===----------------------------------------------------------------------===//
  26 /// onlySimpleRegion - Show only the simple regions in the RegionViewer.
  27 static cl::opt<bool>
  28 onlySimpleRegions("only-simple-regions",
  29                   cl::desc("Show only simple regions in the graphviz viewer"),
  30                   cl::Hidden,
  31                   cl::init(false));
  32
  33 namespace llvm {
  34
  35 std::string DOTGraphTraits<RegionNode *>::getNodeLabel(RegionNode *Node,
  36                                                        RegionNode *Graph) {
  37   if (!Node->isSubRegion()) {
  38     BasicBlock *BB = Node->getNodeAs<BasicBlock>();
  39
  40     if (isSimple())
  41       return DOTGraphTraits<DOTFuncInfo *>::getSimpleNodeLabel(BB, nullptr);
  42     else
  43       return DOTGraphTraits<DOTFuncInfo *>::getCompleteNodeLabel(BB, nullptr);
  44   }
  45
  46   return "Not implemented";
  47 }
  48
  49 template <>
  50 struct DOTGraphTraits<RegionInfo *> : public DOTGraphTraits<RegionNode *> {
  51
  52   DOTGraphTraits (bool isSimple = false)
  53     : DOTGraphTraits<RegionNode*>(isSimple) {}
  54
  55   static std::string getGraphName(const RegionInfo *) { return "Region Graph"; }
  56
  57   std::string getNodeLabel(RegionNode *Node, RegionInfo *G) {
  58     return DOTGraphTraits<RegionNode *>::getNodeLabel(
  59         Node, reinterpret_cast<RegionNode *>(G->getTopLevelRegion()));
  60   }
  61
  62   std::string getEdgeAttributes(RegionNode *srcNode,
  63                                 GraphTraits<RegionInfo *>::ChildIteratorType CI,
  64                                 RegionInfo *G) {
  65     RegionNode *destNode = *CI;
  66
  67     if (srcNode->isSubRegion() || destNode->isSubRegion())
  68       return "";
  69
  70     // In case of a backedge, do not use it to define the layout of the nodes.
  71     BasicBlock *srcBB = srcNode->getNodeAs<BasicBlock>();
  72     BasicBlock *destBB = destNode->getNodeAs<BasicBlock>();
  73
  74     Region *R = G->getRegionFor(destBB);
  75
  76     while (R && R->getParent())
  77       if (R->getParent()->getEntry() == destBB)
  78         R = R->getParent();
  79       else
  80         break;
  81
  82     if (R && R->getEntry() == destBB && R->contains(srcBB))
  83       return "constraint=false";
  84
  85     return "";
  86   }
  87
  88   // Print the cluster of the subregions. This groups the single basic blocks
  89   // and adds a different background color for each group.
  90   static void printRegionCluster(const Region &R, GraphWriter<RegionInfo *> &GW,
  91                                  unsigned depth = 0) {
  92     raw_ostream &O = GW.getOStream();
  93     O.indent(2 * depth) << "subgraph cluster_" << static_cast<const void*>(&R)
  94       << " {\n";
  95     O.indent(2 * (depth + 1)) << "label = \"\";\n";
  96
  97     if (!onlySimpleRegions || R.isSimple()) {
  98       O.indent(2 * (depth + 1)) << "style = filled;\n";
  99       O.indent(2 * (depth + 1)) << "color = "
 100         << ((R.getDepth() * 2 % 12) + 1) << "\n";
 101
 102     } else {
 103       O.indent(2 * (depth + 1)) << "style = solid;\n";
 104       O.indent(2 * (depth + 1)) << "color = "
 105         << ((R.getDepth() * 2 % 12) + 2) << "\n";
 106     }
 107
 108     for (const auto &RI : R)
 109       printRegionCluster(*RI, GW, depth + 1);
 110
 111     const RegionInfo &RI = *static_cast<const RegionInfo*>(R.getRegionInfo());
 112
 113     for (auto *BB : R.blocks())
 114       if (RI.getRegionFor(BB) == &R)
 115         O.indent(2 * (depth + 1)) << "Node"
 116           << static_cast<const void*>(RI.getTopLevelRegion()->getBBNode(BB))
 117           << ";\n";
 118
 119     O.indent(2 * depth) << "}\n";
 120   }
 121
 122   static void addCustomGraphFeatures(const RegionInfo *G,
 123                                      GraphWriter<RegionInfo *> &GW) {
 124     raw_ostream &O = GW.getOStream();
 125     O << "\tcolorscheme = \"paired12\"\n";
 126     printRegionCluster(*G->getTopLevelRegion(), GW, 4);
 127   }
 128 };
 129 } // end namespace llvm
 130
 131 namespace {
 132
 133 struct RegionInfoPassGraphTraits {
 134   static RegionInfo *getGraph(RegionInfoPass *RIP) {
 135     return &RIP->getRegionInfo();
 136   }
 137 };
 138
 139 struct RegionPrinter
 140     : public DOTGraphTraitsPrinterWrapperPass<
 141           RegionInfoPass, false, RegionInfo *, RegionInfoPassGraphTraits> {
 142   static char ID;
 143   RegionPrinter()
 144       : DOTGraphTraitsPrinterWrapperPass<RegionInfoPass, false, RegionInfo *,
 145                                          RegionInfoPassGraphTraits>("reg", ID) {
 146     initializeRegionPrinterPass(*PassRegistry::getPassRegistry());
 147   }
 148 };
 149 char RegionPrinter::ID = 0;
 150
 151 struct RegionOnlyPrinter
 152     : public DOTGraphTraitsPrinterWrapperPass<
 153           RegionInfoPass, true, RegionInfo *, RegionInfoPassGraphTraits> {
 154   static char ID;
 155   RegionOnlyPrinter()
 156       : DOTGraphTraitsPrinterWrapperPass<RegionInfoPass, true, RegionInfo *,
 157                                          RegionInfoPassGraphTraits>("reg", ID) {
 158     initializeRegionOnlyPrinterPass(*PassRegistry::getPassRegistry());
 159   }
 160 };
 161 char RegionOnlyPrinter::ID = 0;
 162
 163 struct RegionViewer
 164     : public DOTGraphTraitsViewerWrapperPass<
 165           RegionInfoPass, false, RegionInfo *, RegionInfoPassGraphTraits> {
 166   static char ID;
 167   RegionViewer()
 168       : DOTGraphTraitsViewerWrapperPass<RegionInfoPass, false, RegionInfo *,
 169                                         RegionInfoPassGraphTraits>("reg", ID) {
 170     initializeRegionViewerPass(*PassRegistry::getPassRegistry());
 171   }
 172 };
 173 char RegionViewer::ID = 0;
 174
 175 struct RegionOnlyViewer
 176     : public DOTGraphTraitsViewerWrapperPass<RegionInfoPass, true, RegionInfo *,
 177                                              RegionInfoPassGraphTraits> {
 178   static char ID;
 179   RegionOnlyViewer()
 180       : DOTGraphTraitsViewerWrapperPass<RegionInfoPass, true, RegionInfo *,
 181                                         RegionInfoPassGraphTraits>("regonly",
 182                                                                    ID) {
 183     initializeRegionOnlyViewerPass(*PassRegistry::getPassRegistry());
 184   }
 185 };
 186 char RegionOnlyViewer::ID = 0;
 187
 188 } //end anonymous namespace
 189
 190 INITIALIZE_PASS(RegionPrinter, "dot-regions",
 191                 "Print regions of function to 'dot' file", true, true)
 192
 193 INITIALIZE_PASS(
 194     RegionOnlyPrinter, "dot-regions-only",
 195     "Print regions of function to 'dot' file (with no function bodies)", true,
 196     true)
 197
 198 INITIALIZE_PASS(RegionViewer, "view-regions", "View regions of function",
 199                 true, true)
 200
 201 INITIALIZE_PASS(RegionOnlyViewer, "view-regions-only",
 202                 "View regions of function (with no function bodies)",
 203                 true, true)
 204
 205 FunctionPass *llvm::createRegionPrinterPass() { return new RegionPrinter(); }
 206
 207 FunctionPass *llvm::createRegionOnlyPrinterPass() {
 208   return new RegionOnlyPrinter();
 209 }
 210
 211 FunctionPass* llvm::createRegionViewerPass() {
 212   return new RegionViewer();
 213 }
 214
 215 FunctionPass* llvm::createRegionOnlyViewerPass() {
 216   return new RegionOnlyViewer();
 217 }
 218
 219 #ifndef NDEBUG
 220 static void viewRegionInfo(RegionInfo *RI, bool ShortNames) {
 221   assert(RI && "Argument must be non-null");
 222
 223   llvm::Function *F = RI->getTopLevelRegion()->getEntry()->getParent();
 224   std::string GraphName = DOTGraphTraits<RegionInfo *>::getGraphName(RI);
 225
 226   llvm::ViewGraph(RI, "reg", ShortNames,
 227                   Twine(GraphName) + " for '" + F->getName() + "' function");
 228 }
 229
 230 static void invokeFunctionPass(const Function *F, FunctionPass *ViewerPass) {
 231   assert(F && "Argument must be non-null");
 232   assert(!F->isDeclaration() && "Function must have an implementation");
 233
 234   // The viewer and analysis passes do not modify anything, so we can safely
 235   // remove the const qualifier
 236   auto NonConstF = const_cast<Function *>(F);
 237
 238   llvm::legacy::FunctionPassManager FPM(NonConstF->getParent());
 239   FPM.add(ViewerPass);
 240   FPM.doInitialization();
 241   FPM.run(*NonConstF);
 242   FPM.doFinalization();
 243 }
 244
 245 void llvm::viewRegion(RegionInfo *RI) { viewRegionInfo(RI, false); }
 246
 247 void llvm::viewRegion(const Function *F) {
 248   invokeFunctionPass(F, createRegionViewerPass());
 249 }
 250
 251 void llvm::viewRegionOnly(RegionInfo *RI) { viewRegionInfo(RI, true); }
 252
 253 void llvm::viewRegionOnly(const Function *F) {
 254   invokeFunctionPass(F, createRegionOnlyViewerPass());
 255 }
 256 #endif