Home | History | Annotate | Line # | Download | only in Support 
      1 //===- GraphWriter.cpp - Implements GraphWriter support routines ----------===//
      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 // This file implements misc. GraphWriter support routines.
     10 //
     11 //===----------------------------------------------------------------------===//
     12 
     13 #include "llvm/Support/GraphWriter.h"
     14 #include "llvm/ADT/SmallString.h"
     15 #include "llvm/ADT/SmallVector.h"
     16 #include "llvm/ADT/StringRef.h"
     17 #include "llvm/Config/config.h"
     18 #include "llvm/Support/CommandLine.h"
     19 #include "llvm/Support/Compiler.h"
     20 #include "llvm/Support/ErrorHandling.h"
     21 #include "llvm/Support/ErrorOr.h"
     22 #include "llvm/Support/FileSystem.h"
     23 #include "llvm/Support/Program.h"
     24 #include "llvm/Support/raw_ostream.h"
     25 #include <cassert>
     26 #include <system_error>
     27 #include <string>
     28 #include <vector>
     29 
     30 using namespace llvm;
     31 
     32 static cl::opt<bool> ViewBackground("view-background", cl::Hidden,
     33   cl::desc("Execute graph viewer in the background. Creates tmp file litter."));
     34 
     35 std::string llvm::DOT::EscapeString(const std::string &Label) {
     36   std::string Str(Label);
     37   for (unsigned i = 0; i != Str.length(); ++i)
     38   switch (Str[i]) {
     39     case '\n':
     40       Str.insert(Str.begin()+i, '\\');  // Escape character...
     41       ++i;
     42       Str[i] = 'n';
     43       break;
     44     case '\t':
     45       Str.insert(Str.begin()+i, ' ');  // Convert to two spaces
     46       ++i;
     47       Str[i] = ' ';
     48       break;
     49     case '\\':
     50       if (i+1 != Str.length())
     51         switch (Str[i+1]) {
     52           case 'l': continue; // don't disturb \l
     53           case '|': case '{': case '}':
     54             Str.erase(Str.begin()+i); continue;
     55           default: break;
     56         }
     57       LLVM_FALLTHROUGH;
     58     case '{': case '}':
     59     case '<': case '>':
     60     case '|': case '"':
     61       Str.insert(Str.begin()+i, '\\');  // Escape character...
     62       ++i;  // don't infinite loop
     63       break;
     64   }
     65   return Str;
     66 }
     67 
     68 /// Get a color string for this node number. Simply round-robin selects
     69 /// from a reasonable number of colors.
     70 StringRef llvm::DOT::getColorString(unsigned ColorNumber) {
     71   static const int NumColors = 20;
     72   static const char* Colors[NumColors] = {
     73     "aaaaaa", "aa0000", "00aa00", "aa5500", "0055ff", "aa00aa", "00aaaa",
     74     "555555", "ff5555", "55ff55", "ffff55", "5555ff", "ff55ff", "55ffff",
     75     "ffaaaa", "aaffaa", "ffffaa", "aaaaff", "ffaaff", "aaffff"};
     76   return Colors[ColorNumber % NumColors];
     77 }
     78 
     79 static std::string replaceIllegalFilenameChars(std::string Filename,
     80                                                const char ReplacementChar) {
     81 #ifdef _WIN32
     82   std::string IllegalChars = "\\/:?\"<>|";
     83 #else
     84   std::string IllegalChars = "/";
     85 #endif
     86 
     87   for (char IllegalChar : IllegalChars) {
     88     std::replace(Filename.begin(), Filename.end(), IllegalChar,
     89                  ReplacementChar);
     90   }
     91 
     92   return Filename;
     93 }
     94 
     95 std::string llvm::createGraphFilename(const Twine &Name, int &FD) {
     96   FD = -1;
     97   SmallString<128> Filename;
     98 
     99   // Windows can't always handle long paths, so limit the length of the name.
    100   std::string N = Name.str();
    101   N = N.substr(0, std::min<std::size_t>(N.size(), 140));
    102 
    103   // Replace illegal characters in graph Filename with '_' if needed
    104   std::string CleansedName = replaceIllegalFilenameChars(N, '_');
    105 
    106   std::error_code EC =
    107       sys::fs::createTemporaryFile(CleansedName, "dot", FD, Filename);
    108   if (EC) {
    109     errs() << "Error: " << EC.message() << "\n";
    110     return "";
    111   }
    112 
    113   errs() << "Writing '" << Filename << "'... ";
    114   return std::string(Filename.str());
    115 }
    116 
    117 // Execute the graph viewer. Return true if there were errors.
    118 static bool ExecGraphViewer(StringRef ExecPath, std::vector<StringRef> &args,
    119                             StringRef Filename, bool wait,
    120                             std::string &ErrMsg) {
    121   if (wait) {
    122     if (sys::ExecuteAndWait(ExecPath, args, None, {}, 0, 0, &ErrMsg)) {
    123       errs() << "Error: " << ErrMsg << "\n";
    124       return true;
    125     }
    126     sys::fs::remove(Filename);
    127     errs() << " done. \n";
    128   } else {
    129     sys::ExecuteNoWait(ExecPath, args, None, {}, 0, &ErrMsg);
    130     errs() << "Remember to erase graph file: " << Filename << "\n";
    131   }
    132   return false;
    133 }
    134 
    135 namespace {
    136 
    137 struct GraphSession {
    138   std::string LogBuffer;
    139 
    140   bool TryFindProgram(StringRef Names, std::string &ProgramPath) {
    141     raw_string_ostream Log(LogBuffer);
    142     SmallVector<StringRef, 8> parts;
    143     Names.split(parts, '|');
    144     for (auto Name : parts) {
    145       if (ErrorOr<std::string> P = sys::findProgramByName(Name)) {
    146         ProgramPath = *P;
    147         return true;
    148       }
    149       Log << "  Tried '" << Name << "'\n";
    150     }
    151     return false;
    152   }
    153 };
    154 
    155 } // end anonymous namespace
    156 
    157 static const char *getProgramName(GraphProgram::Name program) {
    158   switch (program) {
    159   case GraphProgram::DOT:
    160     return "dot";
    161   case GraphProgram::FDP:
    162     return "fdp";
    163   case GraphProgram::NEATO:
    164     return "neato";
    165   case GraphProgram::TWOPI:
    166     return "twopi";
    167   case GraphProgram::CIRCO:
    168     return "circo";
    169   }
    170   llvm_unreachable("bad kind");
    171 }
    172 
    173 bool llvm::DisplayGraph(StringRef FilenameRef, bool wait,
    174                         GraphProgram::Name program) {
    175   std::string Filename = std::string(FilenameRef);
    176   std::string ErrMsg;
    177   std::string ViewerPath;
    178   GraphSession S;
    179 
    180 #ifdef __APPLE__
    181   wait &= !ViewBackground;
    182   if (S.TryFindProgram("open", ViewerPath)) {
    183     std::vector<StringRef> args;
    184     args.push_back(ViewerPath);
    185     if (wait)
    186       args.push_back("-W");
    187     args.push_back(Filename);
    188     errs() << "Trying 'open' program... ";
    189     if (!ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg))
    190       return false;
    191   }
    192 #endif
    193   if (S.TryFindProgram("xdg-open", ViewerPath)) {
    194     std::vector<StringRef> args;
    195     args.push_back(ViewerPath);
    196     args.push_back(Filename);
    197     errs() << "Trying 'xdg-open' program... ";
    198     if (!ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg))
    199       return false;
    200   }
    201 
    202   // Graphviz
    203   if (S.TryFindProgram("Graphviz", ViewerPath)) {
    204     std::vector<StringRef> args;
    205     args.push_back(ViewerPath);
    206     args.push_back(Filename);
    207 
    208     errs() << "Running 'Graphviz' program... ";
    209     return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
    210   }
    211 
    212   // xdot
    213   if (S.TryFindProgram("xdot|xdot.py", ViewerPath)) {
    214     std::vector<StringRef> args;
    215     args.push_back(ViewerPath);
    216     args.push_back(Filename);
    217 
    218     args.push_back("-f");
    219     args.push_back(getProgramName(program));
    220 
    221     errs() << "Running 'xdot.py' program... ";
    222     return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
    223   }
    224 
    225   enum ViewerKind {
    226     VK_None,
    227     VK_OSXOpen,
    228     VK_XDGOpen,
    229     VK_Ghostview,
    230     VK_CmdStart
    231   };
    232   ViewerKind Viewer = VK_None;
    233 #ifdef __APPLE__
    234   if (!Viewer && S.TryFindProgram("open", ViewerPath))
    235     Viewer = VK_OSXOpen;
    236 #endif
    237   if (!Viewer && S.TryFindProgram("gv", ViewerPath))
    238     Viewer = VK_Ghostview;
    239   if (!Viewer && S.TryFindProgram("xdg-open", ViewerPath))
    240     Viewer = VK_XDGOpen;
    241 #ifdef _WIN32
    242   if (!Viewer && S.TryFindProgram("cmd", ViewerPath)) {
    243     Viewer = VK_CmdStart;
    244   }
    245 #endif
    246 
    247   // PostScript or PDF graph generator + PostScript/PDF viewer
    248   std::string GeneratorPath;
    249   if (Viewer &&
    250       (S.TryFindProgram(getProgramName(program), GeneratorPath) ||
    251        S.TryFindProgram("dot|fdp|neato|twopi|circo", GeneratorPath))) {
    252     std::string OutputFilename =
    253         Filename + (Viewer == VK_CmdStart ? ".pdf" : ".ps");
    254 
    255     std::vector<StringRef> args;
    256     args.push_back(GeneratorPath);
    257     if (Viewer == VK_CmdStart)
    258       args.push_back("-Tpdf");
    259     else
    260       args.push_back("-Tps");
    261     args.push_back("-Nfontname=Courier");
    262     args.push_back("-Gsize=7.5,10");
    263     args.push_back(Filename);
    264     args.push_back("-o");
    265     args.push_back(OutputFilename);
    266 
    267     errs() << "Running '" << GeneratorPath << "' program... ";
    268 
    269     if (ExecGraphViewer(GeneratorPath, args, Filename, true, ErrMsg))
    270       return true;
    271 
    272     // The lifetime of StartArg must include the call of ExecGraphViewer
    273     // because the args are passed as vector of char*.
    274     std::string StartArg;
    275 
    276     args.clear();
    277     args.push_back(ViewerPath);
    278     switch (Viewer) {
    279     case VK_OSXOpen:
    280       args.push_back("-W");
    281       args.push_back(OutputFilename);
    282       break;
    283     case VK_XDGOpen:
    284       wait = false;
    285       args.push_back(OutputFilename);
    286       break;
    287     case VK_Ghostview:
    288       args.push_back("--spartan");
    289       args.push_back(OutputFilename);
    290       break;
    291     case VK_CmdStart:
    292       args.push_back("/S");
    293       args.push_back("/C");
    294       StartArg =
    295           (StringRef("start ") + (wait ? "/WAIT " : "") + OutputFilename).str();
    296       args.push_back(StartArg);
    297       break;
    298     case VK_None:
    299       llvm_unreachable("Invalid viewer");
    300     }
    301 
    302     ErrMsg.clear();
    303     return ExecGraphViewer(ViewerPath, args, OutputFilename, wait, ErrMsg);
    304   }
    305 
    306   // dotty
    307   if (S.TryFindProgram("dotty", ViewerPath)) {
    308     std::vector<StringRef> args;
    309     args.push_back(ViewerPath);
    310     args.push_back(Filename);
    311 
    312 // Dotty spawns another app and doesn't wait until it returns
    313 #ifdef _WIN32
    314     wait = false;
    315 #endif
    316     errs() << "Running 'dotty' program... ";
    317     return ExecGraphViewer(ViewerPath, args, Filename, wait, ErrMsg);
    318   }
    319 
    320   errs() << "Error: Couldn't find a usable graph viewer program:\n";
    321   errs() << S.LogBuffer << "\n";
    322   return true;
    323 }
    324