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(p: Str.begin()+i, c: '\\'); // Escape character... |
61 | ++i; |
62 | Str[i] = 'n'; |
63 | break; |
64 | case '\t': |
65 | Str.insert(p: Str.begin()+i, c: ' '); // 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(position: Str.begin()+i); continue; |
75 | default: break; |
76 | } |
77 | [[fallthrough]]; |
78 | case '{': case '}': |
79 | case '<': case '>': |
80 | case '|': case '"': |
81 | Str.insert(p: Str.begin()+i, c: '\\'); // 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(S: sys::path::Style::native) ? "\\/:?\"<>|" : "/" ; |
103 | |
104 | for (char IllegalChar : IllegalChars) { |
105 | std::replace(first: Filename.begin(), last: Filename.end(), old_value: IllegalChar, |
106 | new_value: 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(pos: 0, n: std::min<std::size_t>(a: N.size(), b: 140)); |
119 | |
120 | // Replace illegal characters in graph Filename with '_' if needed |
121 | std::string CleansedName = replaceIllegalFilenameChars(Filename: N, ReplacementChar: '_'); |
122 | |
123 | std::error_code EC = |
124 | sys::fs::createTemporaryFile(Prefix: CleansedName, Suffix: "dot" , ResultFD&: FD, ResultPath&: Filename); |
125 | if (EC) { |
126 | errs() << "Error: " << EC.message() << "\n" ; |
127 | return "" ; |
128 | } |
129 | |
130 | errs() << "Writing '" << Filename << "'... " ; |
131 | return std::string(Filename); |
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(Program: ExecPath, Args: args, Env: std::nullopt, Redirects: {}, SecondsToWait: 0, MemoryLimit: 0, ErrMsg: &ErrMsg)) { |
140 | errs() << "Error: " << ErrMsg << "\n" ; |
141 | return true; |
142 | } |
143 | sys::fs::remove(path: Filename); |
144 | errs() << " done. \n" ; |
145 | } else { |
146 | sys::ExecuteNoWait(Program: ExecPath, Args: args, Env: std::nullopt, Redirects: {}, MemoryLimit: 0, ErrMsg: &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(A&: parts, Separator: '|'); |
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(Names: "xdg-open" , ProgramPath&: ViewerPath)) { |
211 | std::vector<StringRef> args; |
212 | args.push_back(x: ViewerPath); |
213 | args.push_back(x: Filename); |
214 | errs() << "Trying 'xdg-open' program... " ; |
215 | if (!ExecGraphViewer(ExecPath: ViewerPath, args, Filename, wait, ErrMsg)) |
216 | return false; |
217 | } |
218 | |
219 | // Graphviz |
220 | if (S.TryFindProgram(Names: "Graphviz" , ProgramPath&: ViewerPath)) { |
221 | std::vector<StringRef> args; |
222 | args.push_back(x: ViewerPath); |
223 | args.push_back(x: Filename); |
224 | |
225 | errs() << "Running 'Graphviz' program... " ; |
226 | return ExecGraphViewer(ExecPath: ViewerPath, args, Filename, wait, ErrMsg); |
227 | } |
228 | |
229 | // xdot |
230 | if (S.TryFindProgram(Names: "xdot|xdot.py" , ProgramPath&: ViewerPath)) { |
231 | std::vector<StringRef> args; |
232 | args.push_back(x: ViewerPath); |
233 | args.push_back(x: Filename); |
234 | |
235 | args.push_back(x: "-f" ); |
236 | args.push_back(x: getProgramName(program)); |
237 | |
238 | errs() << "Running 'xdot.py' program... " ; |
239 | return ExecGraphViewer(ExecPath: 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(Names: "gv" , ProgramPath&: ViewerPath)) |
255 | Viewer = VK_Ghostview; |
256 | if (!Viewer && S.TryFindProgram(Names: "xdg-open" , ProgramPath&: 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(Names: getProgramName(program), ProgramPath&: GeneratorPath) || |
268 | S.TryFindProgram(Names: "dot|fdp|neato|twopi|circo" , ProgramPath&: GeneratorPath))) { |
269 | std::string OutputFilename = |
270 | Filename + (Viewer == VK_CmdStart ? ".pdf" : ".ps" ); |
271 | |
272 | std::vector<StringRef> args; |
273 | args.push_back(x: GeneratorPath); |
274 | if (Viewer == VK_CmdStart) |
275 | args.push_back(x: "-Tpdf" ); |
276 | else |
277 | args.push_back(x: "-Tps" ); |
278 | args.push_back(x: "-Nfontname=Courier" ); |
279 | args.push_back(x: "-Gsize=7.5,10" ); |
280 | args.push_back(x: Filename); |
281 | args.push_back(x: "-o" ); |
282 | args.push_back(x: OutputFilename); |
283 | |
284 | errs() << "Running '" << GeneratorPath << "' program... " ; |
285 | |
286 | if (ExecGraphViewer(ExecPath: GeneratorPath, args, Filename, wait: 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(x: ViewerPath); |
295 | switch (Viewer) { |
296 | case VK_OSXOpen: |
297 | args.push_back(x: "-W" ); |
298 | args.push_back(x: OutputFilename); |
299 | break; |
300 | case VK_XDGOpen: |
301 | wait = false; |
302 | args.push_back(x: OutputFilename); |
303 | break; |
304 | case VK_Ghostview: |
305 | args.push_back(x: "--spartan" ); |
306 | args.push_back(x: OutputFilename); |
307 | break; |
308 | case VK_CmdStart: |
309 | args.push_back(x: "/S" ); |
310 | args.push_back(x: "/C" ); |
311 | StartArg = |
312 | (StringRef("start " ) + (wait ? "/WAIT " : "" ) + OutputFilename).str(); |
313 | args.push_back(x: StartArg); |
314 | break; |
315 | case VK_None: |
316 | llvm_unreachable("Invalid viewer" ); |
317 | } |
318 | |
319 | ErrMsg.clear(); |
320 | return ExecGraphViewer(ExecPath: ViewerPath, args, Filename: OutputFilename, wait, ErrMsg); |
321 | } |
322 | |
323 | // dotty |
324 | if (S.TryFindProgram(Names: "dotty" , ProgramPath&: ViewerPath)) { |
325 | std::vector<StringRef> args; |
326 | args.push_back(x: ViewerPath); |
327 | args.push_back(x: 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(ExecPath: 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 | |