polly/lib/Analysis/ScopGraphPrinter.cpp

   1 //===- GraphPrinter.cpp - Create a DOT output describing the Scop. --------===//
   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 // Create a DOT output describing the Scop.
  10 //
  11 // For each function a dot file is created that shows the control flow graph of
  12 // the function and highlights the detected Scops.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "polly/ScopGraphPrinter.h"
  17 #include "polly/LinkAllPasses.h"
  18 #include "polly/ScopDetection.h"
  19 #include "llvm/Support/CommandLine.h"
  20
  21 using namespace polly;
  22 using namespace llvm;
  23 static cl::opt<std::string>
  24     ViewFilter("polly-view-only",
  25                cl::desc("Only view functions that match this pattern"),
  26                cl::Hidden, cl::init(""));
  27
  28 static cl::opt<bool> ViewAll("polly-view-all",
  29                              cl::desc("Also show functions without any scops"),
  30                              cl::Hidden, cl::init(false));
  31
  32 namespace llvm {
  33
  34 std::string DOTGraphTraits<ScopDetection *>::getEdgeAttributes(
  35     RegionNode *srcNode, GraphTraits<RegionInfo *>::ChildIteratorType CI,
  36     ScopDetection *SD) {
  37   RegionNode *destNode = *CI;
  38
  39   if (srcNode->isSubRegion() || destNode->isSubRegion())
  40     return "";
  41
  42   // In case of a backedge, do not use it to define the layout of the nodes.
  43   BasicBlock *srcBB = srcNode->getNodeAs<BasicBlock>();
  44   BasicBlock *destBB = destNode->getNodeAs<BasicBlock>();
  45
  46   RegionInfo *RI = SD->getRI();
  47   Region *R = RI->getRegionFor(destBB);
  48
  49   while (R && R->getParent())
  50     if (R->getParent()->getEntry() == destBB)
  51       R = R->getParent();
  52     else
  53       break;
  54
  55   if (R && R->getEntry() == destBB && R->contains(srcBB))
  56     return "constraint=false";
  57
  58   return "";
  59 }
  60
  61 std::string
  62 DOTGraphTraits<ScopDetection *>::escapeString(llvm::StringRef String) {
  63   std::string Escaped;
  64
  65   for (const auto &C : String) {
  66     if (C == '"')
  67       Escaped += '\\';
  68
  69     Escaped += C;
  70   }
  71   return Escaped;
  72 }
  73
  74 void DOTGraphTraits<ScopDetection *>::printRegionCluster(ScopDetection *SD,
  75                                                          const Region *R,
  76                                                          raw_ostream &O,
  77                                                          unsigned depth) {
  78   O.indent(2 * depth) << "subgraph cluster_" << static_cast<const void *>(R)
  79                       << " {\n";
  80   unsigned LineBegin, LineEnd;
  81   std::string FileName;
  82
  83   getDebugLocation(R, LineBegin, LineEnd, FileName);
  84
  85   std::string Location;
  86   if (LineBegin != (unsigned)-1) {
  87     Location = escapeString(FileName + ":" + std::to_string(LineBegin) + "-" +
  88                             std::to_string(LineEnd) + "\n");
  89   }
  90
  91   std::string ErrorMessage = SD->regionIsInvalidBecause(R);
  92   ErrorMessage = escapeString(ErrorMessage);
  93   O.indent(2 * (depth + 1))
  94       << "label = \"" << Location << ErrorMessage << "\";\n";
  95
  96   if (SD->isMaxRegionInScop(*R)) {
  97     O.indent(2 * (depth + 1)) << "style = filled;\n";
  98
  99     // Set color to green.
 100     O.indent(2 * (depth + 1)) << "color = 3";
 101   } else {
 102     O.indent(2 * (depth + 1)) << "style = solid;\n";
 103
 104     int color = (R->getDepth() * 2 % 12) + 1;
 105
 106     // We do not want green again.
 107     if (color == 3)
 108       color = 6;
 109
 110     O.indent(2 * (depth + 1)) << "color = " << color << "\n";
 111   }
 112
 113   for (const auto &SubRegion : *R)
 114     printRegionCluster(SD, SubRegion.get(), O, depth + 1);
 115
 116   RegionInfo *RI = R->getRegionInfo();
 117
 118   for (BasicBlock *BB : R->blocks())
 119     if (RI->getRegionFor(BB) == R)
 120       O.indent(2 * (depth + 1))
 121           << "Node"
 122           << static_cast<void *>(RI->getTopLevelRegion()->getBBNode(BB))
 123           << ";\n";
 124
 125   O.indent(2 * depth) << "}\n";
 126 }
 127
 128 void DOTGraphTraits<ScopDetection *>::addCustomGraphFeatures(
 129     ScopDetection *SD, GraphWriter<ScopDetection *> &GW) {
 130   raw_ostream &O = GW.getOStream();
 131   O << "\tcolorscheme = \"paired12\"\n";
 132   printRegionCluster(SD, SD->getRI()->getTopLevelRegion(), O, 4);
 133 }
 134
 135 } // namespace llvm
 136
 137 struct ScopDetectionAnalysisGraphTraits {
 138   static ScopDetection *getGraph(ScopDetectionWrapperPass *Analysis) {
 139     return &Analysis->getSD();
 140   }
 141 };
 142
 143 struct ScopViewerWrapperPass
 144     : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false,
 145                                       ScopDetection *,
 146                                       ScopDetectionAnalysisGraphTraits> {
 147   static char ID;
 148   ScopViewerWrapperPass()
 149       : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false,
 150                                         ScopDetection *,
 151                                         ScopDetectionAnalysisGraphTraits>(
 152             "scops", ID) {}
 153   bool processFunction(Function &F, ScopDetectionWrapperPass &SD) override {
 154     if (ViewFilter != "" && !F.getName().count(ViewFilter))
 155       return false;
 156
 157     if (ViewAll)
 158       return true;
 159
 160     // Check that at least one scop was detected.
 161     return std::distance(SD.getSD().begin(), SD.getSD().end()) > 0;
 162   }
 163 };
 164 char ScopViewerWrapperPass::ID = 0;
 165
 166 struct ScopOnlyViewerWrapperPass
 167     : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false,
 168                                       ScopDetection *,
 169                                       ScopDetectionAnalysisGraphTraits> {
 170   static char ID;
 171   ScopOnlyViewerWrapperPass()
 172       : DOTGraphTraitsViewerWrapperPass<ScopDetectionWrapperPass, false,
 173                                         ScopDetection *,
 174                                         ScopDetectionAnalysisGraphTraits>(
 175             "scopsonly", ID) {}
 176 };
 177 char ScopOnlyViewerWrapperPass::ID = 0;
 178
 179 struct ScopPrinterWrapperPass
 180     : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, false,
 181                                        ScopDetection *,
 182                                        ScopDetectionAnalysisGraphTraits> {
 183   static char ID;
 184   ScopPrinterWrapperPass()
 185       : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, false,
 186                                          ScopDetection *,
 187                                          ScopDetectionAnalysisGraphTraits>(
 188             "scops", ID) {}
 189 };
 190 char ScopPrinterWrapperPass::ID = 0;
 191
 192 struct ScopOnlyPrinterWrapperPass
 193     : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, true,
 194                                        ScopDetection *,
 195                                        ScopDetectionAnalysisGraphTraits> {
 196   static char ID;
 197   ScopOnlyPrinterWrapperPass()
 198       : DOTGraphTraitsPrinterWrapperPass<ScopDetectionWrapperPass, true,
 199                                          ScopDetection *,
 200                                          ScopDetectionAnalysisGraphTraits>(
 201             "scopsonly", ID) {}
 202 };
 203 char ScopOnlyPrinterWrapperPass::ID = 0;
 204
 205 static RegisterPass<ScopViewerWrapperPass> X("view-scops",
 206                                              "Polly - View Scops of function");
 207
 208 static RegisterPass<ScopOnlyViewerWrapperPass>
 209     Y("view-scops-only",
 210       "Polly - View Scops of function (with no function bodies)");
 211
 212 static RegisterPass<ScopPrinterWrapperPass>
 213     M("dot-scops", "Polly - Print Scops of function");
 214
 215 static RegisterPass<ScopOnlyPrinterWrapperPass>
 216     N("dot-scops-only",
 217       "Polly - Print Scops of function (with no function bodies)");
 218
 219 Pass *polly::createDOTViewerWrapperPass() {
 220   return new ScopViewerWrapperPass();
 221 }
 222
 223 Pass *polly::createDOTOnlyViewerWrapperPass() {
 224   return new ScopOnlyViewerWrapperPass();
 225 }
 226
 227 Pass *polly::createDOTPrinterWrapperPass() {
 228   return new ScopPrinterWrapperPass();
 229 }
 230
 231 Pass *polly::createDOTOnlyPrinterWrapperPass() {
 232   return new ScopOnlyPrinterWrapperPass();
 233 }
 234
 235 bool ScopViewer::processFunction(Function &F, const ScopDetection &SD) {
 236   if (ViewFilter != "" && !F.getName().count(ViewFilter))
 237     return false;
 238
 239   if (ViewAll)
 240     return true;
 241
 242   // Check that at least one scop was detected.
 243   return std::distance(SD.begin(), SD.end()) > 0;
 244 }