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