polly/lib/Analysis/ScopGraphPrinter.cpp

//===- GraphPrinter.cpp - Create a DOT output describing the Scop. --------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Create a DOT output describing the Scop.
//
// For each function a dot file is created that shows the control flow graph of
// the function and highlights the detected Scops.
//
//===----------------------------------------------------------------------===//

#include "polly/ScopGraphPrinter.h"
#include "polly/ScopDetection.h"
#include "llvm/Support/CommandLine.h"

using namespace polly;
using namespace llvm;

namespace polly {
std::string ViewFilter;
bool ViewAll;
} // namespace polly

static cl::opt<std::string, true>
    XViewFilter("polly-view-only",
                cl::desc("Only view functions that match this pattern"),
                cl::location(ViewFilter), cl::Hidden, cl::init(""));

static cl::opt<bool, true>
    XViewAll("polly-view-all",
             cl::desc("Also show functions without any scops"),
             cl::location(ViewAll), cl::Hidden, cl::init(false));

namespace llvm {

std::string DOTGraphTraits<ScopDetection *>::getEdgeAttributes(
    RegionNode *srcNode, GraphTraits<RegionInfo *>::ChildIteratorType CI,
    ScopDetection *SD) {
  RegionNode *destNode = *CI;

  if (srcNode->isSubRegion() || destNode->isSubRegion())
    return "";

  // In case of a backedge, do not use it to define the layout of the nodes.
  BasicBlock *srcBB = srcNode->getNodeAs<BasicBlock>();
  BasicBlock *destBB = destNode->getNodeAs<BasicBlock>();

  RegionInfo *RI = SD->getRI();
  Region *R = RI->getRegionFor(destBB);

  while (R && R->getParent())
    if (R->getParent()->getEntry() == destBB)
      R = R->getParent();
    else
      break;

  if (R && R->getEntry() == destBB && R->contains(srcBB))
    return "constraint=false";

  return "";
}

std::string
DOTGraphTraits<ScopDetection *>::escapeString(llvm::StringRef String) {
  std::string Escaped;

  for (const auto &C : String) {
    if (C == '"')
      Escaped += '\\';

    Escaped += C;
  }
  return Escaped;
}

void DOTGraphTraits<ScopDetection *>::printRegionCluster(ScopDetection *SD,
                                                         const Region *R,
                                                         raw_ostream &O,
                                                         unsigned depth) {
  O.indent(2 * depth) << "subgraph cluster_" << static_cast<const void *>(R)
                      << " {\n";
  unsigned LineBegin, LineEnd;
  std::string FileName;

  getDebugLocation(R, LineBegin, LineEnd, FileName);

  std::string Location;
  if (LineBegin != (unsigned)-1) {
    Location = escapeString(FileName + ":" + std::to_string(LineBegin) + "-" +
                            std::to_string(LineEnd) + "\n");
  }

  std::string ErrorMessage = SD->regionIsInvalidBecause(R);
  ErrorMessage = escapeString(ErrorMessage);
  O.indent(2 * (depth + 1))
      << "label = \"" << Location << ErrorMessage << "\";\n";

  if (SD->isMaxRegionInScop(*R)) {
    O.indent(2 * (depth + 1)) << "style = filled;\n";

    // Set color to green.
    O.indent(2 * (depth + 1)) << "color = 3";
  } else {
    O.indent(2 * (depth + 1)) << "style = solid;\n";

    int color = (R->getDepth() * 2 % 12) + 1;

    // We do not want green again.
    if (color == 3)
      color = 6;

    O.indent(2 * (depth + 1)) << "color = " << color << "\n";
  }

  for (const auto &SubRegion : *R)
    printRegionCluster(SD, SubRegion.get(), O, depth + 1);

  RegionInfo *RI = R->getRegionInfo();

  for (BasicBlock *BB : R->blocks())
    if (RI->getRegionFor(BB) == R)
      O.indent(2 * (depth + 1))
          << "Node"
          << static_cast<void *>(RI->getTopLevelRegion()->getBBNode(BB))
          << ";\n";

  O.indent(2 * depth) << "}\n";
}

void DOTGraphTraits<ScopDetection *>::addCustomGraphFeatures(
    ScopDetection *SD, GraphWriter<ScopDetection *> &GW) {
  raw_ostream &O = GW.getOStream();
  O << "\tcolorscheme = \"paired12\"\n";
  printRegionCluster(SD, SD->getRI()->getTopLevelRegion(), O, 4);
}

} // namespace llvm

bool ScopViewer::processFunction(Function &F, const ScopDetection &SD) {
  if (ViewFilter != "" && !F.getName().count(ViewFilter))
    return false;

  if (ViewAll)
    return true;

  // Check that at least one scop was detected.
  return std::distance(SD.begin(), SD.end()) > 0;
}