1//===- Standard pass instrumentations handling ----------------*- C++ -*--===//
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/// \file
9///
10/// This file defines IR-printing pass instrumentation callbacks as well as
11/// StandardInstrumentations class that manages standard pass instrumentations.
12///
13//===----------------------------------------------------------------------===//
14
15#include "llvm/Passes/StandardInstrumentations.h"
16#include "llvm/ADT/Any.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/Analysis/LazyCallGraph.h"
19#include "llvm/Analysis/LoopInfo.h"
20#include "llvm/CodeGen/MIRPrinter.h"
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/MachineModuleInfo.h"
23#include "llvm/CodeGen/MachineVerifier.h"
24#include "llvm/IR/Constants.h"
25#include "llvm/IR/Function.h"
26#include "llvm/IR/Module.h"
27#include "llvm/IR/PassInstrumentation.h"
28#include "llvm/IR/PassManager.h"
29#include "llvm/IR/PrintPasses.h"
30#include "llvm/IR/StructuralHash.h"
31#include "llvm/IR/Verifier.h"
32#include "llvm/Support/CommandLine.h"
33#include "llvm/Support/Debug.h"
34#include "llvm/Support/Error.h"
35#include "llvm/Support/FormatVariadic.h"
36#include "llvm/Support/GraphWriter.h"
37#include "llvm/Support/Path.h"
38#include "llvm/Support/Program.h"
39#include "llvm/Support/Regex.h"
40#include "llvm/Support/Signals.h"
41#include "llvm/Support/raw_ostream.h"
42#include "llvm/Support/xxhash.h"
43#include <unordered_map>
44#include <unordered_set>
45#include <utility>
46#include <vector>
47
48using namespace llvm;
49
50static cl::opt<bool> VerifyAnalysisInvalidation("verify-analysis-invalidation",
51 cl::Hidden,
52#ifdef EXPENSIVE_CHECKS
53 cl::init(true)
54#else
55 cl::init(Val: false)
56#endif
57);
58
59// An option that supports the -print-changed option. See
60// the description for -print-changed for an explanation of the use
61// of this option. Note that this option has no effect without -print-changed.
62static cl::opt<bool>
63 PrintChangedBefore("print-before-changed",
64 cl::desc("Print before passes that change them"),
65 cl::init(Val: false), cl::Hidden);
66
67// An option for specifying the dot used by
68// print-changed=[dot-cfg | dot-cfg-quiet]
69static cl::opt<std::string>
70 DotBinary("print-changed-dot-path", cl::Hidden, cl::init(Val: "dot"),
71 cl::desc("system dot used by change reporters"));
72
73// An option that determines the colour used for elements that are only
74// in the before part. Must be a colour named in appendix J of
75// https://graphviz.org/pdf/dotguide.pdf
76static cl::opt<std::string>
77 BeforeColour("dot-cfg-before-color",
78 cl::desc("Color for dot-cfg before elements"), cl::Hidden,
79 cl::init(Val: "red"));
80// An option that determines the colour used for elements that are only
81// in the after part. Must be a colour named in appendix J of
82// https://graphviz.org/pdf/dotguide.pdf
83static cl::opt<std::string>
84 AfterColour("dot-cfg-after-color",
85 cl::desc("Color for dot-cfg after elements"), cl::Hidden,
86 cl::init(Val: "forestgreen"));
87// An option that determines the colour used for elements that are in both
88// the before and after parts. Must be a colour named in appendix J of
89// https://graphviz.org/pdf/dotguide.pdf
90static cl::opt<std::string>
91 CommonColour("dot-cfg-common-color",
92 cl::desc("Color for dot-cfg common elements"), cl::Hidden,
93 cl::init(Val: "black"));
94
95// An option that determines where the generated website file (named
96// passes.html) and the associated pdf files (named diff_*.pdf) are saved.
97static cl::opt<std::string> DotCfgDir(
98 "dot-cfg-dir",
99 cl::desc("Generate dot files into specified directory for changed IRs"),
100 cl::Hidden, cl::init(Val: "./"));
101
102// Options to print the IR that was being processed when a pass crashes.
103static cl::opt<std::string> PrintOnCrashPath(
104 "print-on-crash-path",
105 cl::desc("Print the last form of the IR before crash to a file"),
106 cl::Hidden);
107
108static cl::opt<bool> PrintOnCrash(
109 "print-on-crash",
110 cl::desc("Print the last form of the IR before crash (use -print-on-crash-path to dump to a file)"),
111 cl::Hidden);
112
113static cl::opt<std::string> OptBisectPrintIRPath(
114 "opt-bisect-print-ir-path",
115 cl::desc("Print IR to path when opt-bisect-limit is reached"), cl::Hidden);
116
117static cl::opt<bool> PrintPassNumbers(
118 "print-pass-numbers", cl::init(Val: false), cl::Hidden,
119 cl::desc("Print pass names and their ordinals"));
120
121static cl::list<unsigned> PrintBeforePassNumber(
122 "print-before-pass-number", cl::CommaSeparated, cl::Hidden,
123 cl::desc("Print IR before the passes with specified numbers as "
124 "reported by print-pass-numbers"));
125
126static cl::list<unsigned> PrintAfterPassNumber(
127 "print-after-pass-number", cl::CommaSeparated, cl::Hidden,
128 cl::desc("Print IR after the passes with specified numbers as "
129 "reported by print-pass-numbers"));
130
131static cl::opt<std::string> IRDumpDirectory(
132 "ir-dump-directory",
133 cl::desc("If specified, IR printed using the "
134 "-print-[before|after]{-all} options will be dumped into "
135 "files in this directory rather than written to stderr"),
136 cl::Hidden, cl::value_desc("filename"));
137
138static cl::opt<bool>
139 DroppedVarStats("dropped-variable-stats", cl::Hidden,
140 cl::desc("Dump dropped debug variables stats"),
141 cl::init(Val: false));
142
143template <typename IRUnitT> static const IRUnitT *unwrapIR(Any IR) {
144 const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&IR);
145 return IRPtr ? *IRPtr : nullptr;
146}
147
148namespace {
149
150// An option for specifying an executable that will be called with the IR
151// everytime it changes in the opt pipeline. It will also be called on
152// the initial IR as it enters the pipeline. The executable will be passed
153// the name of a temporary file containing the IR and the PassID. This may
154// be used, for example, to call llc on the IR and run a test to determine
155// which pass makes a change that changes the functioning of the IR.
156// The usual modifier options work as expected.
157static cl::opt<std::string>
158 TestChanged("exec-on-ir-change", cl::Hidden, cl::init(Val: ""),
159 cl::desc("exe called with module IR after each pass that "
160 "changes it"));
161
162/// Extract Module out of \p IR unit. May return nullptr if \p IR does not match
163/// certain global filters. Will never return nullptr if \p Force is true.
164const Module *unwrapModule(Any IR, bool Force = false) {
165 if (const auto *M = unwrapIR<Module>(IR))
166 return M;
167
168 if (const auto *F = unwrapIR<Function>(IR)) {
169 if (!Force && !isFunctionInPrintList(FunctionName: F->getName()))
170 return nullptr;
171
172 return F->getParent();
173 }
174
175 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
176 for (const LazyCallGraph::Node &N : *C) {
177 const Function &F = N.getFunction();
178 if (Force || (!F.isDeclaration() && isFunctionInPrintList(FunctionName: F.getName()))) {
179 return F.getParent();
180 }
181 }
182 assert(!Force && "Expected a module");
183 return nullptr;
184 }
185
186 if (const auto *L = unwrapIR<Loop>(IR)) {
187 const Function *F = L->getHeader()->getParent();
188 if (!Force && !isFunctionInPrintList(FunctionName: F->getName()))
189 return nullptr;
190 return F->getParent();
191 }
192
193 if (const auto *MF = unwrapIR<MachineFunction>(IR)) {
194 if (!Force && !isFunctionInPrintList(FunctionName: MF->getName()))
195 return nullptr;
196 return MF->getFunction().getParent();
197 }
198
199 llvm_unreachable("Unknown IR unit");
200}
201
202void printIR(raw_ostream &OS, const Function *F) {
203 if (!isFunctionInPrintList(FunctionName: F->getName()))
204 return;
205 OS << *F;
206}
207
208void printIR(raw_ostream &OS, const Module *M) {
209 if (isFunctionInPrintList(FunctionName: "*") || forcePrintModuleIR()) {
210 M->print(OS, AAW: nullptr);
211 } else {
212 for (const auto &F : M->functions()) {
213 printIR(OS, F: &F);
214 }
215 }
216}
217
218void printIR(raw_ostream &OS, const LazyCallGraph::SCC *C) {
219 for (const LazyCallGraph::Node &N : *C) {
220 const Function &F = N.getFunction();
221 if (!F.isDeclaration() && isFunctionInPrintList(FunctionName: F.getName())) {
222 F.print(OS);
223 }
224 }
225}
226
227void printIR(raw_ostream &OS, const Loop *L) {
228 const Function *F = L->getHeader()->getParent();
229 if (!isFunctionInPrintList(FunctionName: F->getName()))
230 return;
231 printLoop(L: const_cast<Loop &>(*L), OS);
232}
233
234void printIR(raw_ostream &OS, const MachineFunction *MF) {
235 if (!isFunctionInPrintList(FunctionName: MF->getName()))
236 return;
237 MF->print(OS);
238}
239
240std::string getIRName(Any IR) {
241 if (unwrapIR<Module>(IR))
242 return "[module]";
243
244 if (const auto *F = unwrapIR<Function>(IR))
245 return F->getName().str();
246
247 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
248 return C->getName();
249
250 if (const auto *L = unwrapIR<Loop>(IR))
251 return "loop %" + L->getName().str() + " in function " +
252 L->getHeader()->getParent()->getName().str();
253
254 if (const auto *MF = unwrapIR<MachineFunction>(IR))
255 return MF->getName().str();
256
257 llvm_unreachable("Unknown wrapped IR type");
258}
259
260bool moduleContainsFilterPrintFunc(const Module &M) {
261 return any_of(Range: M.functions(),
262 P: [](const Function &F) {
263 return isFunctionInPrintList(FunctionName: F.getName());
264 }) ||
265 isFunctionInPrintList(FunctionName: "*");
266}
267
268bool sccContainsFilterPrintFunc(const LazyCallGraph::SCC &C) {
269 return any_of(Range: C,
270 P: [](const LazyCallGraph::Node &N) {
271 return isFunctionInPrintList(FunctionName: N.getName());
272 }) ||
273 isFunctionInPrintList(FunctionName: "*");
274}
275
276bool shouldPrintIR(Any IR) {
277 if (const auto *M = unwrapIR<Module>(IR))
278 return moduleContainsFilterPrintFunc(M: *M);
279
280 if (const auto *F = unwrapIR<Function>(IR))
281 return isFunctionInPrintList(FunctionName: F->getName());
282
283 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
284 return sccContainsFilterPrintFunc(C: *C);
285
286 if (const auto *L = unwrapIR<Loop>(IR))
287 return isFunctionInPrintList(FunctionName: L->getHeader()->getParent()->getName());
288
289 if (const auto *MF = unwrapIR<MachineFunction>(IR))
290 return isFunctionInPrintList(FunctionName: MF->getName());
291 llvm_unreachable("Unknown wrapped IR type");
292}
293
294/// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
295/// Any and does actual print job.
296void unwrapAndPrint(raw_ostream &OS, Any IR) {
297 if (!shouldPrintIR(IR))
298 return;
299
300 if (forcePrintModuleIR()) {
301 auto *M = unwrapModule(IR);
302 assert(M && "should have unwrapped module");
303 printIR(OS, M);
304 return;
305 }
306
307 if (const auto *M = unwrapIR<Module>(IR)) {
308 printIR(OS, M);
309 return;
310 }
311
312 if (const auto *F = unwrapIR<Function>(IR)) {
313 printIR(OS, F);
314 return;
315 }
316
317 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
318 printIR(OS, C);
319 return;
320 }
321
322 if (const auto *L = unwrapIR<Loop>(IR)) {
323 printIR(OS, L);
324 return;
325 }
326
327 if (const auto *MF = unwrapIR<MachineFunction>(IR)) {
328 printIR(OS, MF);
329 return;
330 }
331 llvm_unreachable("Unknown wrapped IR type");
332}
333
334// Return true when this is a pass for which changes should be ignored
335bool isIgnored(StringRef PassID) {
336 return isSpecialPass(PassID,
337 Specials: {"PassManager", "PassAdaptor", "AnalysisManagerProxy",
338 "DevirtSCCRepeatedPass", "ModuleInlinerWrapperPass",
339 "VerifierPass", "PrintModulePass", "PrintMIRPass",
340 "PrintMIRPreparePass"});
341}
342
343std::string makeHTMLReady(StringRef SR) {
344 std::string S;
345 while (true) {
346 StringRef Clean =
347 SR.take_until(F: [](char C) { return C == '<' || C == '>'; });
348 S.append(str: Clean.str());
349 SR = SR.drop_front(N: Clean.size());
350 if (SR.size() == 0)
351 return S;
352 S.append(s: SR[0] == '<' ? "&lt;" : "&gt;");
353 SR = SR.drop_front();
354 }
355 llvm_unreachable("problems converting string to HTML");
356}
357
358// Return the module when that is the appropriate level of comparison for \p IR.
359const Module *getModuleForComparison(Any IR) {
360 if (const auto *M = unwrapIR<Module>(IR))
361 return M;
362 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
363 return C->begin()->getFunction().getParent();
364 return nullptr;
365}
366
367bool isInterestingFunction(const Function &F) {
368 return isFunctionInPrintList(FunctionName: F.getName());
369}
370
371// Return true when this is a pass on IR for which printing
372// of changes is desired.
373bool isInteresting(Any IR, StringRef PassID, StringRef PassName) {
374 if (isIgnored(PassID) || !isPassInPrintList(PassName))
375 return false;
376 if (const auto *F = unwrapIR<Function>(IR))
377 return isInterestingFunction(F: *F);
378 return true;
379}
380
381} // namespace
382
383template <typename T> ChangeReporter<T>::~ChangeReporter() {
384 assert(BeforeStack.empty() && "Problem with Change Printer stack.");
385}
386
387template <typename T>
388void ChangeReporter<T>::saveIRBeforePass(Any IR, StringRef PassID,
389 StringRef PassName) {
390 // Is this the initial IR?
391 if (InitialIR) {
392 InitialIR = false;
393 if (VerboseMode)
394 handleInitialIR(IR);
395 }
396
397 // Always need to place something on the stack because invalidated passes
398 // are not given the IR so it cannot be determined whether the pass was for
399 // something that was filtered out.
400 BeforeStack.emplace_back();
401
402 if (!isInteresting(IR, PassID, PassName))
403 return;
404
405 // Save the IR representation on the stack.
406 T &Data = BeforeStack.back();
407 generateIRRepresentation(IR, PassID, Output&: Data);
408}
409
410template <typename T>
411void ChangeReporter<T>::handleIRAfterPass(Any IR, StringRef PassID,
412 StringRef PassName) {
413 assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
414
415 std::string Name = getIRName(IR);
416
417 if (isIgnored(PassID)) {
418 if (VerboseMode)
419 handleIgnored(PassID, Name);
420 } else if (!isInteresting(IR, PassID, PassName)) {
421 if (VerboseMode)
422 handleFiltered(PassID, Name);
423 } else {
424 // Get the before rep from the stack
425 T &Before = BeforeStack.back();
426 // Create the after rep
427 T After;
428 generateIRRepresentation(IR, PassID, Output&: After);
429
430 // Was there a change in IR?
431 if (Before == After) {
432 if (VerboseMode)
433 omitAfter(PassID, Name);
434 } else
435 handleAfter(PassID, Name, Before, After, IR);
436 }
437 BeforeStack.pop_back();
438}
439
440template <typename T>
441void ChangeReporter<T>::handleInvalidatedPass(StringRef PassID) {
442 assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
443
444 // Always flag it as invalidated as we cannot determine when
445 // a pass for a filtered function is invalidated since we do not
446 // get the IR in the call. Also, the output is just alternate
447 // forms of the banner anyway.
448 if (VerboseMode)
449 handleInvalidated(PassID);
450 BeforeStack.pop_back();
451}
452
453template <typename T>
454void ChangeReporter<T>::registerRequiredCallbacks(
455 PassInstrumentationCallbacks &PIC) {
456 PIC.registerBeforeNonSkippedPassCallback([&PIC, this](StringRef P, Any IR) {
457 saveIRBeforePass(IR, PassID: P, PassName: PIC.getPassNameForClassName(ClassName: P));
458 });
459
460 PIC.registerAfterPassCallback(
461 [&PIC, this](StringRef P, Any IR, const PreservedAnalyses &) {
462 handleIRAfterPass(IR, PassID: P, PassName: PIC.getPassNameForClassName(ClassName: P));
463 });
464 PIC.registerAfterPassInvalidatedCallback(
465 [this](StringRef P, const PreservedAnalyses &) {
466 handleInvalidatedPass(PassID: P);
467 });
468}
469
470template <typename T>
471TextChangeReporter<T>::TextChangeReporter(bool Verbose)
472 : ChangeReporter<T>(Verbose), Out(dbgs()) {}
473
474template <typename T> void TextChangeReporter<T>::handleInitialIR(Any IR) {
475 // Always print the module.
476 // Unwrap and print directly to avoid filtering problems in general routines.
477 auto *M = unwrapModule(IR, /*Force=*/true);
478 assert(M && "Expected module to be unwrapped when forced.");
479 Out << "*** IR Dump At Start ***\n";
480 M->print(OS&: Out, AAW: nullptr);
481}
482
483template <typename T>
484void TextChangeReporter<T>::omitAfter(StringRef PassID, std::string &Name) {
485 Out << formatv(Fmt: "*** IR Dump After {0} on {1} omitted because no change ***\n",
486 Vals&: PassID, Vals&: Name);
487}
488
489template <typename T>
490void TextChangeReporter<T>::handleInvalidated(StringRef PassID) {
491 Out << formatv(Fmt: "*** IR Pass {0} invalidated ***\n", Vals&: PassID);
492}
493
494template <typename T>
495void TextChangeReporter<T>::handleFiltered(StringRef PassID,
496 std::string &Name) {
497 SmallString<20> Banner =
498 formatv(Fmt: "*** IR Dump After {0} on {1} filtered out ***\n", Vals&: PassID, Vals&: Name);
499 Out << Banner;
500}
501
502template <typename T>
503void TextChangeReporter<T>::handleIgnored(StringRef PassID, std::string &Name) {
504 Out << formatv(Fmt: "*** IR Pass {0} on {1} ignored ***\n", Vals&: PassID, Vals&: Name);
505}
506
507IRChangedPrinter::~IRChangedPrinter() = default;
508
509void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
510 if (PrintChanged == ChangePrinter::Verbose ||
511 PrintChanged == ChangePrinter::Quiet)
512 TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
513}
514
515void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
516 std::string &Output) {
517 raw_string_ostream OS(Output);
518 unwrapAndPrint(OS, IR);
519 OS.str();
520}
521
522void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
523 const std::string &Before,
524 const std::string &After, Any) {
525 // Report the IR before the changes when requested.
526 if (PrintChangedBefore)
527 Out << "*** IR Dump Before " << PassID << " on " << Name << " ***\n"
528 << Before;
529
530 // We might not get anything to print if we only want to print a specific
531 // function but it gets deleted.
532 if (After.empty()) {
533 Out << "*** IR Deleted After " << PassID << " on " << Name << " ***\n";
534 return;
535 }
536
537 Out << "*** IR Dump After " << PassID << " on " << Name << " ***\n" << After;
538}
539
540IRChangedTester::~IRChangedTester() = default;
541
542void IRChangedTester::registerCallbacks(PassInstrumentationCallbacks &PIC) {
543 if (TestChanged != "")
544 TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
545}
546
547void IRChangedTester::handleIR(const std::string &S, StringRef PassID) {
548 // Store the body into a temporary file
549 static SmallVector<int> FD{-1};
550 SmallVector<StringRef> SR{S};
551 static SmallVector<std::string> FileName{""};
552 if (prepareTempFiles(FD, SR, FileName)) {
553 dbgs() << "Unable to create temporary file.";
554 return;
555 }
556 static ErrorOr<std::string> Exe = sys::findProgramByName(Name: TestChanged);
557 if (!Exe) {
558 dbgs() << "Unable to find test-changed executable.";
559 return;
560 }
561
562 StringRef Args[] = {TestChanged, FileName[0], PassID};
563 int Result = sys::ExecuteAndWait(Program: *Exe, Args);
564 if (Result < 0) {
565 dbgs() << "Error executing test-changed executable.";
566 return;
567 }
568
569 if (cleanUpTempFiles(FileName))
570 dbgs() << "Unable to remove temporary file.";
571}
572
573void IRChangedTester::handleInitialIR(Any IR) {
574 // Always test the initial module.
575 // Unwrap and print directly to avoid filtering problems in general routines.
576 std::string S;
577 generateIRRepresentation(IR, PassID: "Initial IR", Output&: S);
578 handleIR(S, PassID: "Initial IR");
579}
580
581void IRChangedTester::omitAfter(StringRef PassID, std::string &Name) {}
582void IRChangedTester::handleInvalidated(StringRef PassID) {}
583void IRChangedTester::handleFiltered(StringRef PassID, std::string &Name) {}
584void IRChangedTester::handleIgnored(StringRef PassID, std::string &Name) {}
585void IRChangedTester::handleAfter(StringRef PassID, std::string &Name,
586 const std::string &Before,
587 const std::string &After, Any) {
588 handleIR(S: After, PassID);
589}
590
591template <typename T>
592void OrderedChangedData<T>::report(
593 const OrderedChangedData &Before, const OrderedChangedData &After,
594 function_ref<void(const T *, const T *)> HandlePair) {
595 const auto &BFD = Before.getData();
596 const auto &AFD = After.getData();
597 std::vector<std::string>::const_iterator BI = Before.getOrder().begin();
598 std::vector<std::string>::const_iterator BE = Before.getOrder().end();
599 std::vector<std::string>::const_iterator AI = After.getOrder().begin();
600 std::vector<std::string>::const_iterator AE = After.getOrder().end();
601
602 auto HandlePotentiallyRemovedData = [&](std::string S) {
603 // The order in LLVM may have changed so check if still exists.
604 if (!AFD.count(S)) {
605 // This has been removed.
606 HandlePair(&BFD.find(*BI)->getValue(), nullptr);
607 }
608 };
609 auto HandleNewData = [&](std::vector<const T *> &Q) {
610 // Print out any queued up new sections
611 for (const T *NBI : Q)
612 HandlePair(nullptr, NBI);
613 Q.clear();
614 };
615
616 // Print out the data in the after order, with before ones interspersed
617 // appropriately (ie, somewhere near where they were in the before list).
618 // Start at the beginning of both lists. Loop through the
619 // after list. If an element is common, then advance in the before list
620 // reporting the removed ones until the common one is reached. Report any
621 // queued up new ones and then report the common one. If an element is not
622 // common, then enqueue it for reporting. When the after list is exhausted,
623 // loop through the before list, reporting any removed ones. Finally,
624 // report the rest of the enqueued new ones.
625 std::vector<const T *> NewDataQueue;
626 while (AI != AE) {
627 if (!BFD.count(*AI)) {
628 // This section is new so place it in the queue. This will cause it
629 // to be reported after deleted sections.
630 NewDataQueue.emplace_back(&AFD.find(*AI)->getValue());
631 ++AI;
632 continue;
633 }
634 // This section is in both; advance and print out any before-only
635 // until we get to it.
636 // It's possible that this section has moved to be later than before. This
637 // will mess up printing most blocks side by side, but it's a rare case and
638 // it's better than crashing.
639 while (BI != BE && *BI != *AI) {
640 HandlePotentiallyRemovedData(*BI);
641 ++BI;
642 }
643 // Report any new sections that were queued up and waiting.
644 HandleNewData(NewDataQueue);
645
646 const T &AData = AFD.find(*AI)->getValue();
647 const T &BData = BFD.find(*AI)->getValue();
648 HandlePair(&BData, &AData);
649 if (BI != BE)
650 ++BI;
651 ++AI;
652 }
653
654 // Check any remaining before sections to see if they have been removed
655 while (BI != BE) {
656 HandlePotentiallyRemovedData(*BI);
657 ++BI;
658 }
659
660 HandleNewData(NewDataQueue);
661}
662
663template <typename T>
664void IRComparer<T>::compare(
665 bool CompareModule,
666 std::function<void(bool InModule, unsigned Minor,
667 const FuncDataT<T> &Before, const FuncDataT<T> &After)>
668 CompareFunc) {
669 if (!CompareModule) {
670 // Just handle the single function.
671 assert(Before.getData().size() == 1 && After.getData().size() == 1 &&
672 "Expected only one function.");
673 CompareFunc(false, 0, Before.getData().begin()->getValue(),
674 After.getData().begin()->getValue());
675 return;
676 }
677
678 unsigned Minor = 0;
679 FuncDataT<T> Missing("");
680 IRDataT<T>::report(Before, After,
681 [&](const FuncDataT<T> *B, const FuncDataT<T> *A) {
682 assert((B || A) && "Both functions cannot be missing.");
683 if (!B)
684 B = &Missing;
685 else if (!A)
686 A = &Missing;
687 CompareFunc(true, Minor++, *B, *A);
688 });
689}
690
691template <typename T> void IRComparer<T>::analyzeIR(Any IR, IRDataT<T> &Data) {
692 if (const Module *M = getModuleForComparison(IR)) {
693 // Create data for each existing/interesting function in the module.
694 for (const Function &F : *M)
695 generateFunctionData(Data, F);
696 return;
697 }
698
699 if (const auto *F = unwrapIR<Function>(IR)) {
700 generateFunctionData(Data, *F);
701 return;
702 }
703
704 if (const auto *L = unwrapIR<Loop>(IR)) {
705 auto *F = L->getHeader()->getParent();
706 generateFunctionData(Data, *F);
707 return;
708 }
709
710 if (const auto *MF = unwrapIR<MachineFunction>(IR)) {
711 generateFunctionData(Data, *MF);
712 return;
713 }
714
715 llvm_unreachable("Unknown IR unit");
716}
717
718static bool shouldGenerateData(const Function &F) {
719 return !F.isDeclaration() && isFunctionInPrintList(FunctionName: F.getName());
720}
721
722static bool shouldGenerateData(const MachineFunction &MF) {
723 return isFunctionInPrintList(FunctionName: MF.getName());
724}
725
726template <typename T>
727template <typename FunctionT>
728bool IRComparer<T>::generateFunctionData(IRDataT<T> &Data, const FunctionT &F) {
729 if (shouldGenerateData(F)) {
730 FuncDataT<T> FD(F.front().getName().str());
731 int I = 0;
732 for (const auto &B : F) {
733 std::string BBName = B.getName().str();
734 if (BBName.empty()) {
735 BBName = formatv(Fmt: "{0}", Vals&: I);
736 ++I;
737 }
738 FD.getOrder().emplace_back(BBName);
739 FD.getData().insert({BBName, B});
740 }
741 Data.getOrder().emplace_back(F.getName());
742 Data.getData().insert({F.getName(), FD});
743 return true;
744 }
745 return false;
746}
747
748PrintIRInstrumentation::~PrintIRInstrumentation() {
749 assert(PassRunDescriptorStack.empty() &&
750 "PassRunDescriptorStack is not empty at exit");
751}
752
753static void writeIRFileDisplayName(raw_ostream &ResultStream, Any IR) {
754 const Module *M = unwrapModule(IR, /*Force=*/true);
755 assert(M && "should have unwrapped module");
756 uint64_t NameHash = xxh3_64bits(data: M->getName());
757 unsigned MaxHashWidth = sizeof(uint64_t) * 2;
758 write_hex(S&: ResultStream, N: NameHash, Style: HexPrintStyle::Lower, Width: MaxHashWidth);
759 if (unwrapIR<Module>(IR)) {
760 ResultStream << "-module";
761 } else if (const auto *F = unwrapIR<Function>(IR)) {
762 ResultStream << "-function-";
763 auto FunctionNameHash = xxh3_64bits(data: F->getName());
764 write_hex(S&: ResultStream, N: FunctionNameHash, Style: HexPrintStyle::Lower,
765 Width: MaxHashWidth);
766 } else if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
767 ResultStream << "-scc-";
768 auto SCCNameHash = xxh3_64bits(data: C->getName());
769 write_hex(S&: ResultStream, N: SCCNameHash, Style: HexPrintStyle::Lower, Width: MaxHashWidth);
770 } else if (const auto *L = unwrapIR<Loop>(IR)) {
771 ResultStream << "-loop-";
772 auto LoopNameHash = xxh3_64bits(data: L->getName());
773 write_hex(S&: ResultStream, N: LoopNameHash, Style: HexPrintStyle::Lower, Width: MaxHashWidth);
774 } else if (const auto *MF = unwrapIR<MachineFunction>(IR)) {
775 ResultStream << "-machine-function-";
776 auto MachineFunctionNameHash = xxh3_64bits(data: MF->getName());
777 write_hex(S&: ResultStream, N: MachineFunctionNameHash, Style: HexPrintStyle::Lower,
778 Width: MaxHashWidth);
779 } else {
780 llvm_unreachable("Unknown wrapped IR type");
781 }
782}
783
784static std::string getIRFileDisplayName(Any IR) {
785 std::string Result;
786 raw_string_ostream ResultStream(Result);
787 writeIRFileDisplayName(ResultStream, IR);
788 return Result;
789}
790
791StringRef PrintIRInstrumentation::getFileSuffix(IRDumpFileSuffixType Type) {
792 static constexpr std::array FileSuffixes = {"-before.ll", "-after.ll",
793 "-invalidated.ll"};
794 return FileSuffixes[static_cast<size_t>(Type)];
795}
796
797std::string PrintIRInstrumentation::fetchDumpFilename(
798 StringRef PassName, StringRef IRFileDisplayName, unsigned PassNumber,
799 IRDumpFileSuffixType SuffixType) {
800 assert(!IRDumpDirectory.empty() &&
801 "The flag -ir-dump-directory must be passed to dump IR to files");
802
803 SmallString<64> Filename;
804 raw_svector_ostream FilenameStream(Filename);
805 FilenameStream << PassNumber;
806 FilenameStream << '-' << IRFileDisplayName << '-';
807 FilenameStream << PassName;
808 FilenameStream << getFileSuffix(Type: SuffixType);
809
810 SmallString<128> ResultPath;
811 sys::path::append(path&: ResultPath, a: IRDumpDirectory, b: Filename);
812 return std::string(ResultPath);
813}
814
815void PrintIRInstrumentation::pushPassRunDescriptor(StringRef PassID, Any IR,
816 unsigned PassNumber) {
817 const Module *M = unwrapModule(IR);
818 PassRunDescriptorStack.emplace_back(Args&: M, Args&: PassNumber, Args: getIRFileDisplayName(IR),
819 Args: getIRName(IR), Args&: PassID);
820}
821
822PrintIRInstrumentation::PassRunDescriptor
823PrintIRInstrumentation::popPassRunDescriptor(StringRef PassID) {
824 assert(!PassRunDescriptorStack.empty() && "empty PassRunDescriptorStack");
825 PassRunDescriptor Descriptor = PassRunDescriptorStack.pop_back_val();
826 assert(Descriptor.PassID == PassID && "malformed PassRunDescriptorStack");
827 return Descriptor;
828}
829
830// Callers are responsible for closing the returned file descriptor
831static int prepareDumpIRFileDescriptor(const StringRef DumpIRFilename) {
832 std::error_code EC;
833 auto ParentPath = llvm::sys::path::parent_path(path: DumpIRFilename);
834 if (!ParentPath.empty()) {
835 std::error_code EC = llvm::sys::fs::create_directories(path: ParentPath);
836 if (EC)
837 report_fatal_error(reason: Twine("Failed to create directory ") + ParentPath +
838 " to support -ir-dump-directory: " + EC.message());
839 }
840 int Result = 0;
841 EC = sys::fs::openFile(Name: DumpIRFilename, ResultFD&: Result, Disp: sys::fs::CD_OpenAlways,
842 Access: sys::fs::FA_Write, Flags: sys::fs::OF_Text);
843 if (EC)
844 report_fatal_error(reason: Twine("Failed to open ") + DumpIRFilename +
845 " to support -ir-dump-directory: " + EC.message());
846 return Result;
847}
848
849void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
850 if (isIgnored(PassID))
851 return;
852
853 // Saving Module for AfterPassInvalidated operations.
854 // Note: here we rely on a fact that we do not change modules while
855 // traversing the pipeline, so the latest captured module is good
856 // for all print operations that has not happen yet.
857 if (shouldPrintAfterPass(PassID))
858 pushPassRunDescriptor(PassID, IR, PassNumber: CurrentPassNumber);
859
860 if (!shouldPrintIR(IR))
861 return;
862
863 ++CurrentPassNumber;
864
865 if (shouldPrintPassNumbers())
866 dbgs() << " Running pass " << CurrentPassNumber << " " << PassID
867 << " on " << getIRName(IR) << "\n";
868
869 if (shouldPrintAfterCurrentPassNumber())
870 pushPassRunDescriptor(PassID, IR, PassNumber: CurrentPassNumber);
871
872 if (!shouldPrintBeforePass(PassID) && !shouldPrintBeforeCurrentPassNumber())
873 return;
874
875 auto WriteIRToStream = [&](raw_ostream &Stream) {
876 Stream << "; *** IR Dump Before ";
877 if (shouldPrintBeforeSomePassNumber())
878 Stream << CurrentPassNumber << "-";
879 Stream << PassID << " on " << getIRName(IR) << " ***\n";
880 unwrapAndPrint(OS&: Stream, IR);
881 };
882
883 if (!IRDumpDirectory.empty()) {
884 std::string DumpIRFilename =
885 fetchDumpFilename(PassName: PassID, IRFileDisplayName: getIRFileDisplayName(IR), PassNumber: CurrentPassNumber,
886 SuffixType: IRDumpFileSuffixType::Before);
887 llvm::raw_fd_ostream DumpIRFileStream{
888 prepareDumpIRFileDescriptor(DumpIRFilename), /* shouldClose */ true};
889 WriteIRToStream(DumpIRFileStream);
890 } else {
891 WriteIRToStream(dbgs());
892 }
893}
894
895void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
896 if (isIgnored(PassID))
897 return;
898
899 if (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber())
900 return;
901
902 auto [M, PassNumber, IRFileDisplayName, IRName, StoredPassID] =
903 popPassRunDescriptor(PassID);
904 assert(StoredPassID == PassID && "mismatched PassID");
905
906 if (!shouldPrintIR(IR) ||
907 (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber()))
908 return;
909
910 auto WriteIRToStream = [&](raw_ostream &Stream, const StringRef IRName) {
911 Stream << "; *** IR Dump After ";
912 if (shouldPrintAfterSomePassNumber())
913 Stream << CurrentPassNumber << "-";
914 Stream << StringRef(formatv(Fmt: "{0}", Vals&: PassID)) << " on " << IRName << " ***\n";
915 unwrapAndPrint(OS&: Stream, IR);
916 };
917
918 if (!IRDumpDirectory.empty()) {
919 std::string DumpIRFilename =
920 fetchDumpFilename(PassName: PassID, IRFileDisplayName: getIRFileDisplayName(IR), PassNumber: CurrentPassNumber,
921 SuffixType: IRDumpFileSuffixType::After);
922 llvm::raw_fd_ostream DumpIRFileStream{
923 prepareDumpIRFileDescriptor(DumpIRFilename),
924 /* shouldClose */ true};
925 WriteIRToStream(DumpIRFileStream, IRName);
926 } else {
927 WriteIRToStream(dbgs(), IRName);
928 }
929}
930
931void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
932 if (isIgnored(PassID))
933 return;
934
935 if (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber())
936 return;
937
938 auto [M, PassNumber, IRFileDisplayName, IRName, StoredPassID] =
939 popPassRunDescriptor(PassID);
940 assert(StoredPassID == PassID && "mismatched PassID");
941 // Additional filtering (e.g. -filter-print-func) can lead to module
942 // printing being skipped.
943 if (!M ||
944 (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber()))
945 return;
946
947 auto WriteIRToStream = [&](raw_ostream &Stream, const Module *M,
948 const StringRef IRName) {
949 SmallString<20> Banner;
950 Banner = formatv(Fmt: "; *** IR Dump After {0} on {1} (invalidated) ***", Vals&: PassID,
951 Vals: IRName);
952 Stream << Banner << "\n";
953 printIR(OS&: Stream, M);
954 };
955
956 if (!IRDumpDirectory.empty()) {
957 std::string DumpIRFilename =
958 fetchDumpFilename(PassName: PassID, IRFileDisplayName, PassNumber,
959 SuffixType: IRDumpFileSuffixType::Invalidated);
960 llvm::raw_fd_ostream DumpIRFileStream{
961 prepareDumpIRFileDescriptor(DumpIRFilename),
962 /*shouldClose=*/true};
963 WriteIRToStream(DumpIRFileStream, M, IRName);
964 } else {
965 WriteIRToStream(dbgs(), M, IRName);
966 }
967}
968
969bool PrintIRInstrumentation::shouldPrintBeforePass(StringRef PassID) {
970 if (shouldPrintBeforeAll())
971 return true;
972
973 StringRef PassName = PIC->getPassNameForClassName(ClassName: PassID);
974 return is_contained(Range: printBeforePasses(), Element: PassName);
975}
976
977bool PrintIRInstrumentation::shouldPrintAfterPass(StringRef PassID) {
978 if (shouldPrintAfterAll())
979 return true;
980
981 StringRef PassName = PIC->getPassNameForClassName(ClassName: PassID);
982 return is_contained(Range: printAfterPasses(), Element: PassName);
983}
984
985bool PrintIRInstrumentation::shouldPrintBeforeCurrentPassNumber() {
986 return shouldPrintBeforeSomePassNumber() &&
987 (is_contained(Range&: PrintBeforePassNumber, Element: CurrentPassNumber));
988}
989
990bool PrintIRInstrumentation::shouldPrintAfterCurrentPassNumber() {
991 return shouldPrintAfterSomePassNumber() &&
992 (is_contained(Range&: PrintAfterPassNumber, Element: CurrentPassNumber));
993}
994
995bool PrintIRInstrumentation::shouldPrintPassNumbers() {
996 return PrintPassNumbers;
997}
998
999bool PrintIRInstrumentation::shouldPrintBeforeSomePassNumber() {
1000 return !PrintBeforePassNumber.empty();
1001}
1002
1003bool PrintIRInstrumentation::shouldPrintAfterSomePassNumber() {
1004 return !PrintAfterPassNumber.empty();
1005}
1006
1007void PrintIRInstrumentation::registerCallbacks(
1008 PassInstrumentationCallbacks &PIC) {
1009 this->PIC = &PIC;
1010
1011 // BeforePass callback is not just for printing, it also saves a Module
1012 // for later use in AfterPassInvalidated and keeps tracks of the
1013 // CurrentPassNumber.
1014 if (shouldPrintPassNumbers() || shouldPrintBeforeSomePassNumber() ||
1015 shouldPrintAfterSomePassNumber() || shouldPrintBeforeSomePass() ||
1016 shouldPrintAfterSomePass())
1017 PIC.registerBeforeNonSkippedPassCallback(
1018 C: [this](StringRef P, Any IR) { this->printBeforePass(PassID: P, IR); });
1019
1020 if (shouldPrintAfterSomePass() || shouldPrintAfterSomePassNumber()) {
1021 PIC.registerAfterPassCallback(
1022 C: [this](StringRef P, Any IR, const PreservedAnalyses &) {
1023 this->printAfterPass(PassID: P, IR);
1024 });
1025 PIC.registerAfterPassInvalidatedCallback(
1026 C: [this](StringRef P, const PreservedAnalyses &) {
1027 this->printAfterPassInvalidated(PassID: P);
1028 });
1029 }
1030}
1031
1032void OptNoneInstrumentation::registerCallbacks(
1033 PassInstrumentationCallbacks &PIC) {
1034 PIC.registerShouldRunOptionalPassCallback(
1035 C: [this](StringRef P, Any IR) { return this->shouldRun(PassID: P, IR); });
1036}
1037
1038bool OptNoneInstrumentation::shouldRun(StringRef PassID, Any IR) {
1039 bool ShouldRun = true;
1040 if (const auto *F = unwrapIR<Function>(IR))
1041 ShouldRun = !F->hasOptNone();
1042 else if (const auto *L = unwrapIR<Loop>(IR))
1043 ShouldRun = !L->getHeader()->getParent()->hasOptNone();
1044 else if (const auto *MF = unwrapIR<MachineFunction>(IR))
1045 ShouldRun = !MF->getFunction().hasOptNone();
1046
1047 if (!ShouldRun && DebugLogging) {
1048 errs() << "Skipping pass " << PassID << " on " << getIRName(IR)
1049 << " due to optnone attribute\n";
1050 }
1051 return ShouldRun;
1052}
1053
1054bool OptPassGateInstrumentation::shouldRun(StringRef PassName, Any IR) {
1055 if (isIgnored(PassID: PassName))
1056 return true;
1057
1058 bool ShouldRun =
1059 Context.getOptPassGate().shouldRunPass(PassName, IRDescription: getIRName(IR));
1060 if (!ShouldRun && !this->HasWrittenIR && !OptBisectPrintIRPath.empty()) {
1061 // FIXME: print IR if limit is higher than number of opt-bisect
1062 // invocations
1063 this->HasWrittenIR = true;
1064 const Module *M = unwrapModule(IR, /*Force=*/true);
1065 assert((M && &M->getContext() == &Context) && "Missing/Mismatching Module");
1066 std::error_code EC;
1067 raw_fd_ostream OS(OptBisectPrintIRPath, EC);
1068 if (EC)
1069 report_fatal_error(Err: errorCodeToError(EC));
1070 M->print(OS, AAW: nullptr);
1071 }
1072 return ShouldRun;
1073}
1074
1075void OptPassGateInstrumentation::registerCallbacks(
1076 PassInstrumentationCallbacks &PIC) {
1077 const OptPassGate &PassGate = Context.getOptPassGate();
1078 if (!PassGate.isEnabled())
1079 return;
1080
1081 PIC.registerShouldRunOptionalPassCallback(
1082 C: [this, &PIC](StringRef ClassName, Any IR) {
1083 StringRef PassName = PIC.getPassNameForClassName(ClassName);
1084 if (PassName.empty())
1085 return this->shouldRun(PassName: ClassName, IR);
1086 return this->shouldRun(PassName, IR);
1087 });
1088}
1089
1090raw_ostream &PrintPassInstrumentation::print() {
1091 if (Opts.Indent) {
1092 assert(Indent >= 0);
1093 dbgs().indent(NumSpaces: Indent);
1094 }
1095 return dbgs();
1096}
1097
1098void PrintPassInstrumentation::registerCallbacks(
1099 PassInstrumentationCallbacks &PIC) {
1100 if (!Enabled)
1101 return;
1102
1103 std::vector<StringRef> SpecialPasses;
1104 if (!Opts.Verbose) {
1105 SpecialPasses.emplace_back(args: "PassManager");
1106 SpecialPasses.emplace_back(args: "PassAdaptor");
1107 }
1108
1109 PIC.registerBeforeSkippedPassCallback(C: [this, SpecialPasses](StringRef PassID,
1110 Any IR) {
1111 assert(!isSpecialPass(PassID, SpecialPasses) &&
1112 "Unexpectedly skipping special pass");
1113
1114 print() << "Skipping pass: " << PassID << " on " << getIRName(IR) << "\n";
1115 });
1116 PIC.registerBeforeNonSkippedPassCallback(C: [this, SpecialPasses](
1117 StringRef PassID, Any IR) {
1118 if (isSpecialPass(PassID, Specials: SpecialPasses))
1119 return;
1120
1121 auto &OS = print();
1122 OS << "Running pass: " << PassID << " on " << getIRName(IR);
1123 if (const auto *F = unwrapIR<Function>(IR)) {
1124 unsigned Count = F->getInstructionCount();
1125 OS << " (" << Count << " instruction";
1126 if (Count != 1)
1127 OS << 's';
1128 OS << ')';
1129 } else if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR)) {
1130 int Count = C->size();
1131 OS << " (" << Count << " node";
1132 if (Count != 1)
1133 OS << 's';
1134 OS << ')';
1135 }
1136 OS << "\n";
1137 Indent += 2;
1138 });
1139 PIC.registerAfterPassCallback(
1140 C: [this, SpecialPasses](StringRef PassID, Any IR,
1141 const PreservedAnalyses &) {
1142 if (isSpecialPass(PassID, Specials: SpecialPasses))
1143 return;
1144
1145 Indent -= 2;
1146 });
1147 PIC.registerAfterPassInvalidatedCallback(
1148 C: [this, SpecialPasses](StringRef PassID, Any IR) {
1149 if (isSpecialPass(PassID, Specials: SpecialPasses))
1150 return;
1151
1152 Indent -= 2;
1153 });
1154
1155 if (!Opts.SkipAnalyses) {
1156 PIC.registerBeforeAnalysisCallback(C: [this](StringRef PassID, Any IR) {
1157 print() << "Running analysis: " << PassID << " on " << getIRName(IR)
1158 << "\n";
1159 Indent += 2;
1160 });
1161 PIC.registerAfterAnalysisCallback(
1162 C: [this](StringRef PassID, Any IR) { Indent -= 2; });
1163 PIC.registerAnalysisInvalidatedCallback(C: [this](StringRef PassID, Any IR) {
1164 print() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
1165 << "\n";
1166 });
1167 PIC.registerAnalysesClearedCallback(C: [this](StringRef IRName) {
1168 print() << "Clearing all analysis results for: " << IRName << "\n";
1169 });
1170 }
1171}
1172
1173PreservedCFGCheckerInstrumentation::CFG::CFG(const Function *F,
1174 bool TrackBBLifetime) {
1175 if (TrackBBLifetime)
1176 BBGuards = DenseMap<intptr_t, BBGuard>(F->size());
1177 for (const auto &BB : *F) {
1178 if (BBGuards)
1179 BBGuards->try_emplace(Key: intptr_t(&BB), Args: &BB);
1180 for (const auto *Succ : successors(BB: &BB)) {
1181 Graph[&BB][Succ]++;
1182 if (BBGuards)
1183 BBGuards->try_emplace(Key: intptr_t(Succ), Args&: Succ);
1184 }
1185 }
1186}
1187
1188static void printBBName(raw_ostream &out, const BasicBlock *BB) {
1189 if (BB->hasName()) {
1190 out << BB->getName() << "<" << BB << ">";
1191 return;
1192 }
1193
1194 if (!BB->getParent()) {
1195 out << "unnamed_removed<" << BB << ">";
1196 return;
1197 }
1198
1199 if (BB->isEntryBlock()) {
1200 out << "entry"
1201 << "<" << BB << ">";
1202 return;
1203 }
1204
1205 unsigned FuncOrderBlockNum = 0;
1206 for (auto &FuncBB : *BB->getParent()) {
1207 if (&FuncBB == BB)
1208 break;
1209 FuncOrderBlockNum++;
1210 }
1211 out << "unnamed_" << FuncOrderBlockNum << "<" << BB << ">";
1212}
1213
1214void PreservedCFGCheckerInstrumentation::CFG::printDiff(raw_ostream &out,
1215 const CFG &Before,
1216 const CFG &After) {
1217 assert(!After.isPoisoned());
1218 if (Before.isPoisoned()) {
1219 out << "Some blocks were deleted\n";
1220 return;
1221 }
1222
1223 // Find and print graph differences.
1224 if (Before.Graph.size() != After.Graph.size())
1225 out << "Different number of non-leaf basic blocks: before="
1226 << Before.Graph.size() << ", after=" << After.Graph.size() << "\n";
1227
1228 for (auto &BB : Before.Graph) {
1229 auto BA = After.Graph.find(Val: BB.first);
1230 if (BA == After.Graph.end()) {
1231 out << "Non-leaf block ";
1232 printBBName(out, BB: BB.first);
1233 out << " is removed (" << BB.second.size() << " successors)\n";
1234 }
1235 }
1236
1237 for (auto &BA : After.Graph) {
1238 auto BB = Before.Graph.find(Val: BA.first);
1239 if (BB == Before.Graph.end()) {
1240 out << "Non-leaf block ";
1241 printBBName(out, BB: BA.first);
1242 out << " is added (" << BA.second.size() << " successors)\n";
1243 continue;
1244 }
1245
1246 if (BB->second == BA.second)
1247 continue;
1248
1249 out << "Different successors of block ";
1250 printBBName(out, BB: BA.first);
1251 out << " (unordered):\n";
1252 out << "- before (" << BB->second.size() << "): ";
1253 for (auto &SuccB : BB->second) {
1254 printBBName(out, BB: SuccB.first);
1255 if (SuccB.second != 1)
1256 out << "(" << SuccB.second << "), ";
1257 else
1258 out << ", ";
1259 }
1260 out << "\n";
1261 out << "- after (" << BA.second.size() << "): ";
1262 for (auto &SuccA : BA.second) {
1263 printBBName(out, BB: SuccA.first);
1264 if (SuccA.second != 1)
1265 out << "(" << SuccA.second << "), ";
1266 else
1267 out << ", ";
1268 }
1269 out << "\n";
1270 }
1271}
1272
1273// PreservedCFGCheckerInstrumentation uses PreservedCFGCheckerAnalysis to check
1274// passes, that reported they kept CFG analyses up-to-date, did not actually
1275// change CFG. This check is done as follows. Before every functional pass in
1276// BeforeNonSkippedPassCallback a CFG snapshot (an instance of
1277// PreservedCFGCheckerInstrumentation::CFG) is requested from
1278// FunctionAnalysisManager as a result of PreservedCFGCheckerAnalysis. When the
1279// functional pass finishes and reports that CFGAnalyses or AllAnalyses are
1280// up-to-date then the cached result of PreservedCFGCheckerAnalysis (if
1281// available) is checked to be equal to a freshly created CFG snapshot.
1282struct PreservedCFGCheckerAnalysis
1283 : public AnalysisInfoMixin<PreservedCFGCheckerAnalysis> {
1284 friend AnalysisInfoMixin<PreservedCFGCheckerAnalysis>;
1285
1286 static AnalysisKey Key;
1287
1288public:
1289 /// Provide the result type for this analysis pass.
1290 using Result = PreservedCFGCheckerInstrumentation::CFG;
1291
1292 /// Run the analysis pass over a function and produce CFG.
1293 Result run(Function &F, FunctionAnalysisManager &FAM) {
1294 return Result(&F, /* TrackBBLifetime */ true);
1295 }
1296};
1297
1298AnalysisKey PreservedCFGCheckerAnalysis::Key;
1299
1300struct PreservedFunctionHashAnalysis
1301 : public AnalysisInfoMixin<PreservedFunctionHashAnalysis> {
1302 static AnalysisKey Key;
1303
1304 struct FunctionHash {
1305 uint64_t Hash;
1306 };
1307
1308 using Result = FunctionHash;
1309
1310 Result run(Function &F, FunctionAnalysisManager &FAM) {
1311 return Result{.Hash: StructuralHash(F)};
1312 }
1313};
1314
1315AnalysisKey PreservedFunctionHashAnalysis::Key;
1316
1317struct PreservedModuleHashAnalysis
1318 : public AnalysisInfoMixin<PreservedModuleHashAnalysis> {
1319 static AnalysisKey Key;
1320
1321 struct ModuleHash {
1322 uint64_t Hash;
1323 };
1324
1325 using Result = ModuleHash;
1326
1327 Result run(Module &F, ModuleAnalysisManager &FAM) {
1328 return Result{.Hash: StructuralHash(M: F)};
1329 }
1330};
1331
1332AnalysisKey PreservedModuleHashAnalysis::Key;
1333
1334bool PreservedCFGCheckerInstrumentation::CFG::invalidate(
1335 Function &F, const PreservedAnalyses &PA,
1336 FunctionAnalysisManager::Invalidator &) {
1337 auto PAC = PA.getChecker<PreservedCFGCheckerAnalysis>();
1338 return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
1339 PAC.preservedSet<CFGAnalyses>());
1340}
1341
1342static SmallVector<Function *, 1> GetFunctions(Any IR) {
1343 SmallVector<Function *, 1> Functions;
1344
1345 if (const auto *MaybeF = unwrapIR<Function>(IR)) {
1346 Functions.push_back(Elt: const_cast<Function *>(MaybeF));
1347 } else if (const auto *MaybeM = unwrapIR<Module>(IR)) {
1348 for (Function &F : *const_cast<Module *>(MaybeM))
1349 Functions.push_back(Elt: &F);
1350 }
1351 return Functions;
1352}
1353
1354void PreservedCFGCheckerInstrumentation::registerCallbacks(
1355 PassInstrumentationCallbacks &PIC, ModuleAnalysisManager &MAM) {
1356 if (!VerifyAnalysisInvalidation)
1357 return;
1358
1359 bool Registered = false;
1360 PIC.registerBeforeNonSkippedPassCallback(C: [this, &MAM, Registered](
1361 StringRef P, Any IR) mutable {
1362#if LLVM_ENABLE_ABI_BREAKING_CHECKS
1363 assert(&PassStack.emplace_back(P));
1364#endif
1365 (void)this;
1366
1367 auto &FAM = MAM.getResult<FunctionAnalysisManagerModuleProxy>(
1368 IR&: *const_cast<Module *>(unwrapModule(IR, /*Force=*/true)))
1369 .getManager();
1370 if (!Registered) {
1371 FAM.registerPass(PassBuilder: [&] { return PreservedCFGCheckerAnalysis(); });
1372 FAM.registerPass(PassBuilder: [&] { return PreservedFunctionHashAnalysis(); });
1373 MAM.registerPass(PassBuilder: [&] { return PreservedModuleHashAnalysis(); });
1374 Registered = true;
1375 }
1376
1377 for (Function *F : GetFunctions(IR)) {
1378 // Make sure a fresh CFG snapshot is available before the pass.
1379 FAM.getResult<PreservedCFGCheckerAnalysis>(IR&: *F);
1380 FAM.getResult<PreservedFunctionHashAnalysis>(IR&: *F);
1381 }
1382
1383 if (const auto *MPtr = unwrapIR<Module>(IR)) {
1384 auto &M = *const_cast<Module *>(MPtr);
1385 MAM.getResult<PreservedModuleHashAnalysis>(IR&: M);
1386 }
1387 });
1388
1389 PIC.registerAfterPassInvalidatedCallback(
1390 C: [this](StringRef P, const PreservedAnalyses &PassPA) {
1391#if LLVM_ENABLE_ABI_BREAKING_CHECKS
1392 assert(PassStack.pop_back_val() == P &&
1393 "Before and After callbacks must correspond");
1394#endif
1395 (void)this;
1396 });
1397
1398 PIC.registerAfterPassCallback(C: [this, &MAM](StringRef P, Any IR,
1399 const PreservedAnalyses &PassPA) {
1400#if LLVM_ENABLE_ABI_BREAKING_CHECKS
1401 assert(PassStack.pop_back_val() == P &&
1402 "Before and After callbacks must correspond");
1403#endif
1404 (void)this;
1405
1406 // We have to get the FAM via the MAM, rather than directly use a passed in
1407 // FAM because if MAM has not cached the FAM, it won't invalidate function
1408 // analyses in FAM.
1409 auto &FAM = MAM.getResult<FunctionAnalysisManagerModuleProxy>(
1410 IR&: *const_cast<Module *>(unwrapModule(IR, /*Force=*/true)))
1411 .getManager();
1412
1413 for (Function *F : GetFunctions(IR)) {
1414 if (auto *HashBefore =
1415 FAM.getCachedResult<PreservedFunctionHashAnalysis>(IR&: *F)) {
1416 if (HashBefore->Hash != StructuralHash(F: *F)) {
1417 report_fatal_error(reason: formatv(
1418 Fmt: "Function @{0} changed by {1} without invalidating analyses",
1419 Vals: F->getName(), Vals&: P));
1420 }
1421 }
1422
1423 auto CheckCFG = [](StringRef Pass, StringRef FuncName,
1424 const CFG &GraphBefore, const CFG &GraphAfter) {
1425 if (GraphAfter == GraphBefore)
1426 return;
1427
1428 dbgs()
1429 << "Error: " << Pass
1430 << " does not invalidate CFG analyses but CFG changes detected in "
1431 "function @"
1432 << FuncName << ":\n";
1433 CFG::printDiff(out&: dbgs(), Before: GraphBefore, After: GraphAfter);
1434 report_fatal_error(reason: Twine("CFG unexpectedly changed by ", Pass));
1435 };
1436
1437 if (auto *GraphBefore =
1438 FAM.getCachedResult<PreservedCFGCheckerAnalysis>(IR&: *F))
1439 CheckCFG(P, F->getName(), *GraphBefore,
1440 CFG(F, /* TrackBBLifetime */ false));
1441 }
1442 if (const auto *MPtr = unwrapIR<Module>(IR)) {
1443 auto &M = *const_cast<Module *>(MPtr);
1444 if (auto *HashBefore =
1445 MAM.getCachedResult<PreservedModuleHashAnalysis>(IR&: M)) {
1446 if (HashBefore->Hash != StructuralHash(M)) {
1447 report_fatal_error(reason: formatv(
1448 Fmt: "Module changed by {0} without invalidating analyses", Vals&: P));
1449 }
1450 }
1451 }
1452 });
1453}
1454
1455void VerifyInstrumentation::registerCallbacks(PassInstrumentationCallbacks &PIC,
1456 ModuleAnalysisManager *MAM) {
1457 PIC.registerAfterPassCallback(
1458 C: [this, MAM](StringRef P, Any IR, const PreservedAnalyses &PassPA) {
1459 if (isIgnored(PassID: P) || P == "VerifierPass")
1460 return;
1461 const auto *F = unwrapIR<Function>(IR);
1462 if (!F) {
1463 if (const auto *L = unwrapIR<Loop>(IR))
1464 F = L->getHeader()->getParent();
1465 }
1466
1467 if (F) {
1468 if (DebugLogging)
1469 dbgs() << "Verifying function " << F->getName() << "\n";
1470
1471 if (verifyFunction(F: *F, OS: &errs()))
1472 report_fatal_error(reason: formatv(Fmt: "Broken function found after pass "
1473 "\"{0}\", compilation aborted!",
1474 Vals&: P));
1475 } else {
1476 const auto *M = unwrapIR<Module>(IR);
1477 if (!M) {
1478 if (const auto *C = unwrapIR<LazyCallGraph::SCC>(IR))
1479 M = C->begin()->getFunction().getParent();
1480 }
1481
1482 if (M) {
1483 if (DebugLogging)
1484 dbgs() << "Verifying module " << M->getName() << "\n";
1485
1486 if (verifyModule(M: *M, OS: &errs()))
1487 report_fatal_error(reason: formatv(Fmt: "Broken module found after pass "
1488 "\"{0}\", compilation aborted!",
1489 Vals&: P));
1490 }
1491
1492 if (auto *MF = unwrapIR<MachineFunction>(IR)) {
1493 if (DebugLogging)
1494 dbgs() << "Verifying machine function " << MF->getName() << '\n';
1495 std::string Banner =
1496 formatv(Fmt: "Broken machine function found after pass "
1497 "\"{0}\", compilation aborted!",
1498 Vals&: P);
1499 if (MAM) {
1500 Module &M = const_cast<Module &>(*MF->getFunction().getParent());
1501 auto &MFAM =
1502 MAM->getResult<MachineFunctionAnalysisManagerModuleProxy>(IR&: M)
1503 .getManager();
1504 MachineVerifierPass Verifier(Banner);
1505 Verifier.run(MF&: const_cast<MachineFunction &>(*MF), MFAM);
1506 } else {
1507 verifyMachineFunction(Banner, MF: *MF);
1508 }
1509 }
1510 }
1511 });
1512}
1513
1514InLineChangePrinter::~InLineChangePrinter() = default;
1515
1516void InLineChangePrinter::generateIRRepresentation(Any IR,
1517 StringRef PassID,
1518 IRDataT<EmptyData> &D) {
1519 IRComparer<EmptyData>::analyzeIR(IR, Data&: D);
1520}
1521
1522void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
1523 const IRDataT<EmptyData> &Before,
1524 const IRDataT<EmptyData> &After,
1525 Any IR) {
1526 SmallString<20> Banner =
1527 formatv(Fmt: "*** IR Dump After {0} on {1} ***\n", Vals&: PassID, Vals&: Name);
1528 Out << Banner;
1529 IRComparer<EmptyData>(Before, After)
1530 .compare(CompareModule: getModuleForComparison(IR),
1531 CompareFunc: [&](bool InModule, unsigned Minor,
1532 const FuncDataT<EmptyData> &Before,
1533 const FuncDataT<EmptyData> &After) -> void {
1534 handleFunctionCompare(Name, Prefix: "", PassID, Divider: " on ", InModule,
1535 Minor, Before, After);
1536 });
1537 Out << "\n";
1538}
1539
1540void InLineChangePrinter::handleFunctionCompare(
1541 StringRef Name, StringRef Prefix, StringRef PassID, StringRef Divider,
1542 bool InModule, unsigned Minor, const FuncDataT<EmptyData> &Before,
1543 const FuncDataT<EmptyData> &After) {
1544 // Print a banner when this is being shown in the context of a module
1545 if (InModule)
1546 Out << "\n*** IR for function " << Name << " ***\n";
1547
1548 FuncDataT<EmptyData>::report(
1549 Before, After,
1550 HandlePair: [&](const BlockDataT<EmptyData> *B, const BlockDataT<EmptyData> *A) {
1551 StringRef BStr = B ? B->getBody() : "\n";
1552 StringRef AStr = A ? A->getBody() : "\n";
1553 const std::string Removed =
1554 UseColour ? "\033[31m-%l\033[0m\n" : "-%l\n";
1555 const std::string Added = UseColour ? "\033[32m+%l\033[0m\n" : "+%l\n";
1556 const std::string NoChange = " %l\n";
1557 Out << doSystemDiff(Before: BStr, After: AStr, OldLineFormat: Removed, NewLineFormat: Added, UnchangedLineFormat: NoChange);
1558 });
1559}
1560
1561void InLineChangePrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
1562 if (PrintChanged == ChangePrinter::DiffVerbose ||
1563 PrintChanged == ChangePrinter::DiffQuiet ||
1564 PrintChanged == ChangePrinter::ColourDiffVerbose ||
1565 PrintChanged == ChangePrinter::ColourDiffQuiet)
1566 TextChangeReporter<IRDataT<EmptyData>>::registerRequiredCallbacks(PIC);
1567}
1568
1569TimeProfilingPassesHandler::TimeProfilingPassesHandler() = default;
1570
1571void TimeProfilingPassesHandler::registerCallbacks(
1572 PassInstrumentationCallbacks &PIC) {
1573 if (!getTimeTraceProfilerInstance())
1574 return;
1575 PIC.registerBeforeNonSkippedPassCallback(
1576 C: [this](StringRef P, Any IR) { this->runBeforePass(PassID: P, IR); });
1577 PIC.registerAfterPassCallback(
1578 C: [this](StringRef P, Any IR, const PreservedAnalyses &) {
1579 this->runAfterPass();
1580 },
1581 ToFront: true);
1582 PIC.registerAfterPassInvalidatedCallback(
1583 C: [this](StringRef P, const PreservedAnalyses &) { this->runAfterPass(); },
1584 ToFront: true);
1585 PIC.registerBeforeAnalysisCallback(
1586 C: [this](StringRef P, Any IR) { this->runBeforePass(PassID: P, IR); });
1587 PIC.registerAfterAnalysisCallback(
1588 C: [this](StringRef P, Any IR) { this->runAfterPass(); }, ToFront: true);
1589}
1590
1591void TimeProfilingPassesHandler::runBeforePass(StringRef PassID, Any IR) {
1592 timeTraceProfilerBegin(Name: PassID, Detail: getIRName(IR));
1593}
1594
1595void TimeProfilingPassesHandler::runAfterPass() { timeTraceProfilerEnd(); }
1596
1597namespace {
1598
1599class DisplayNode;
1600class DotCfgDiffDisplayGraph;
1601
1602// Base class for a node or edge in the dot-cfg-changes graph.
1603class DisplayElement {
1604public:
1605 // Is this in before, after, or both?
1606 StringRef getColour() const { return Colour; }
1607
1608protected:
1609 DisplayElement(StringRef Colour) : Colour(Colour) {}
1610 const StringRef Colour;
1611};
1612
1613// An edge representing a transition between basic blocks in the
1614// dot-cfg-changes graph.
1615class DisplayEdge : public DisplayElement {
1616public:
1617 DisplayEdge(std::string Value, DisplayNode &Node, StringRef Colour)
1618 : DisplayElement(Colour), Value(Value), Node(Node) {}
1619 // The value on which the transition is made.
1620 std::string getValue() const { return Value; }
1621 // The node (representing a basic block) reached by this transition.
1622 const DisplayNode &getDestinationNode() const { return Node; }
1623
1624protected:
1625 std::string Value;
1626 const DisplayNode &Node;
1627};
1628
1629// A node in the dot-cfg-changes graph which represents a basic block.
1630class DisplayNode : public DisplayElement {
1631public:
1632 // \p C is the content for the node, \p T indicates the colour for the
1633 // outline of the node
1634 DisplayNode(std::string Content, StringRef Colour)
1635 : DisplayElement(Colour), Content(Content) {}
1636
1637 // Iterator to the child nodes. Required by GraphWriter.
1638 using ChildIterator = std::unordered_set<DisplayNode *>::const_iterator;
1639 ChildIterator children_begin() const { return Children.cbegin(); }
1640 ChildIterator children_end() const { return Children.cend(); }
1641
1642 // Iterator for the edges. Required by GraphWriter.
1643 using EdgeIterator = std::vector<DisplayEdge *>::const_iterator;
1644 EdgeIterator edges_begin() const { return EdgePtrs.cbegin(); }
1645 EdgeIterator edges_end() const { return EdgePtrs.cend(); }
1646
1647 // Create an edge to \p Node on value \p Value, with colour \p Colour.
1648 void createEdge(StringRef Value, DisplayNode &Node, StringRef Colour);
1649
1650 // Return the content of this node.
1651 std::string getContent() const { return Content; }
1652
1653 // Return the edge to node \p S.
1654 const DisplayEdge &getEdge(const DisplayNode &To) const {
1655 assert(EdgeMap.find(&To) != EdgeMap.end() && "Expected to find edge.");
1656 return *EdgeMap.find(x: &To)->second;
1657 }
1658
1659 // Return the value for the transition to basic block \p S.
1660 // Required by GraphWriter.
1661 std::string getEdgeSourceLabel(const DisplayNode &Sink) const {
1662 return getEdge(To: Sink).getValue();
1663 }
1664
1665 void createEdgeMap();
1666
1667protected:
1668 const std::string Content;
1669
1670 // Place to collect all of the edges. Once they are all in the vector,
1671 // the vector will not reallocate so then we can use pointers to them,
1672 // which are required by the graph writing routines.
1673 std::vector<DisplayEdge> Edges;
1674
1675 std::vector<DisplayEdge *> EdgePtrs;
1676 std::unordered_set<DisplayNode *> Children;
1677 std::unordered_map<const DisplayNode *, const DisplayEdge *> EdgeMap;
1678
1679 // Safeguard adding of edges.
1680 bool AllEdgesCreated = false;
1681};
1682
1683// Class representing a difference display (corresponds to a pdf file).
1684class DotCfgDiffDisplayGraph {
1685public:
1686 DotCfgDiffDisplayGraph(std::string Name) : GraphName(Name) {}
1687
1688 // Generate the file into \p DotFile.
1689 void generateDotFile(StringRef DotFile);
1690
1691 // Iterator to the nodes. Required by GraphWriter.
1692 using NodeIterator = std::vector<DisplayNode *>::const_iterator;
1693 NodeIterator nodes_begin() const {
1694 assert(NodeGenerationComplete && "Unexpected children iterator creation");
1695 return NodePtrs.cbegin();
1696 }
1697 NodeIterator nodes_end() const {
1698 assert(NodeGenerationComplete && "Unexpected children iterator creation");
1699 return NodePtrs.cend();
1700 }
1701
1702 // Record the index of the entry node. At this point, we can build up
1703 // vectors of pointers that are required by the graph routines.
1704 void setEntryNode(unsigned N) {
1705 // At this point, there will be no new nodes.
1706 assert(!NodeGenerationComplete && "Unexpected node creation");
1707 NodeGenerationComplete = true;
1708 for (auto &N : Nodes)
1709 NodePtrs.emplace_back(args: &N);
1710
1711 EntryNode = NodePtrs[N];
1712 }
1713
1714 // Create a node.
1715 void createNode(std::string C, StringRef Colour) {
1716 assert(!NodeGenerationComplete && "Unexpected node creation");
1717 Nodes.emplace_back(args&: C, args&: Colour);
1718 }
1719 // Return the node at index \p N to avoid problems with vectors reallocating.
1720 DisplayNode &getNode(unsigned N) {
1721 assert(N < Nodes.size() && "Node is out of bounds");
1722 return Nodes[N];
1723 }
1724 unsigned size() const {
1725 assert(NodeGenerationComplete && "Unexpected children iterator creation");
1726 return Nodes.size();
1727 }
1728
1729 // Return the name of the graph. Required by GraphWriter.
1730 std::string getGraphName() const { return GraphName; }
1731
1732 // Return the string representing the differences for basic block \p Node.
1733 // Required by GraphWriter.
1734 std::string getNodeLabel(const DisplayNode &Node) const {
1735 return Node.getContent();
1736 }
1737
1738 // Return a string with colour information for Dot. Required by GraphWriter.
1739 std::string getNodeAttributes(const DisplayNode &Node) const {
1740 return attribute(Colour: Node.getColour());
1741 }
1742
1743 // Return a string with colour information for Dot. Required by GraphWriter.
1744 std::string getEdgeColorAttr(const DisplayNode &From,
1745 const DisplayNode &To) const {
1746 return attribute(Colour: From.getEdge(To).getColour());
1747 }
1748
1749 // Get the starting basic block. Required by GraphWriter.
1750 DisplayNode *getEntryNode() const {
1751 assert(NodeGenerationComplete && "Unexpected children iterator creation");
1752 return EntryNode;
1753 }
1754
1755protected:
1756 // Return the string containing the colour to use as a Dot attribute.
1757 std::string attribute(StringRef Colour) const {
1758 return "color=" + Colour.str();
1759 }
1760
1761 bool NodeGenerationComplete = false;
1762 const std::string GraphName;
1763 std::vector<DisplayNode> Nodes;
1764 std::vector<DisplayNode *> NodePtrs;
1765 DisplayNode *EntryNode = nullptr;
1766};
1767
1768void DisplayNode::createEdge(StringRef Value, DisplayNode &Node,
1769 StringRef Colour) {
1770 assert(!AllEdgesCreated && "Expected to be able to still create edges.");
1771 Edges.emplace_back(args: Value.str(), args&: Node, args&: Colour);
1772 Children.insert(x: &Node);
1773}
1774
1775void DisplayNode::createEdgeMap() {
1776 // No more edges will be added so we can now use pointers to the edges
1777 // as the vector will not grow and reallocate.
1778 AllEdgesCreated = true;
1779 for (auto &E : Edges)
1780 EdgeMap.insert(x: {&E.getDestinationNode(), &E});
1781}
1782
1783class DotCfgDiffNode;
1784class DotCfgDiff;
1785
1786// A class representing a basic block in the Dot difference graph.
1787class DotCfgDiffNode {
1788public:
1789 DotCfgDiffNode() = delete;
1790
1791 // Create a node in Dot difference graph \p G representing the basic block
1792 // represented by \p BD with colour \p Colour (where it exists).
1793 DotCfgDiffNode(DotCfgDiff &G, unsigned N, const BlockDataT<DCData> &BD,
1794 StringRef Colour)
1795 : Graph(G), N(N), Data{&BD, nullptr}, Colour(Colour) {}
1796 DotCfgDiffNode(const DotCfgDiffNode &DN)
1797 : Graph(DN.Graph), N(DN.N), Data{DN.Data[0], DN.Data[1]},
1798 Colour(DN.Colour), EdgesMap(DN.EdgesMap), Children(DN.Children),
1799 Edges(DN.Edges) {}
1800
1801 unsigned getIndex() const { return N; }
1802
1803 // The label of the basic block
1804 StringRef getLabel() const {
1805 assert(Data[0] && "Expected Data[0] to be set.");
1806 return Data[0]->getLabel();
1807 }
1808 // Return the colour for this block
1809 StringRef getColour() const { return Colour; }
1810 // Change this basic block from being only in before to being common.
1811 // Save the pointer to \p Other.
1812 void setCommon(const BlockDataT<DCData> &Other) {
1813 assert(!Data[1] && "Expected only one block datum");
1814 Data[1] = &Other;
1815 Colour = CommonColour;
1816 }
1817 // Add an edge to \p E of colour {\p Value, \p Colour}.
1818 void addEdge(unsigned E, StringRef Value, StringRef Colour) {
1819 // This is a new edge or it is an edge being made common.
1820 assert((EdgesMap.count(E) == 0 || Colour == CommonColour) &&
1821 "Unexpected edge count and color.");
1822 EdgesMap[E] = {Value.str(), Colour};
1823 }
1824 // Record the children and create edges.
1825 void finalize(DotCfgDiff &G);
1826
1827 // Return the colour of the edge to node \p S.
1828 StringRef getEdgeColour(const unsigned S) const {
1829 assert(EdgesMap.count(S) == 1 && "Expected to find edge.");
1830 return EdgesMap.at(k: S).second;
1831 }
1832
1833 // Return the string representing the basic block.
1834 std::string getBodyContent() const;
1835
1836 void createDisplayEdges(DotCfgDiffDisplayGraph &Graph, unsigned DisplayNode,
1837 std::map<const unsigned, unsigned> &NodeMap) const;
1838
1839protected:
1840 DotCfgDiff &Graph;
1841 const unsigned N;
1842 const BlockDataT<DCData> *Data[2];
1843 StringRef Colour;
1844 std::map<const unsigned, std::pair<std::string, StringRef>> EdgesMap;
1845 std::vector<unsigned> Children;
1846 std::vector<unsigned> Edges;
1847};
1848
1849// Class representing the difference graph between two functions.
1850class DotCfgDiff {
1851public:
1852 // \p Title is the title given to the graph. \p EntryNodeName is the
1853 // entry node for the function. \p Before and \p After are the before
1854 // after versions of the function, respectively. \p Dir is the directory
1855 // in which to store the results.
1856 DotCfgDiff(StringRef Title, const FuncDataT<DCData> &Before,
1857 const FuncDataT<DCData> &After);
1858
1859 DotCfgDiff(const DotCfgDiff &) = delete;
1860 DotCfgDiff &operator=(const DotCfgDiff &) = delete;
1861
1862 DotCfgDiffDisplayGraph createDisplayGraph(StringRef Title,
1863 StringRef EntryNodeName);
1864
1865 // Return a string consisting of the labels for the \p Source and \p Sink.
1866 // The combination allows distinguishing changing transitions on the
1867 // same value (ie, a transition went to X before and goes to Y after).
1868 // Required by GraphWriter.
1869 StringRef getEdgeSourceLabel(const unsigned &Source,
1870 const unsigned &Sink) const {
1871 std::string S =
1872 getNode(N: Source).getLabel().str() + " " + getNode(N: Sink).getLabel().str();
1873 assert(EdgeLabels.count(S) == 1 && "Expected to find edge label.");
1874 return EdgeLabels.find(Key: S)->getValue();
1875 }
1876
1877 // Return the number of basic blocks (nodes). Required by GraphWriter.
1878 unsigned size() const { return Nodes.size(); }
1879
1880 const DotCfgDiffNode &getNode(unsigned N) const {
1881 assert(N < Nodes.size() && "Unexpected index for node reference");
1882 return Nodes[N];
1883 }
1884
1885protected:
1886 // Return the string surrounded by HTML to make it the appropriate colour.
1887 std::string colourize(std::string S, StringRef Colour) const;
1888
1889 void createNode(StringRef Label, const BlockDataT<DCData> &BD, StringRef C) {
1890 unsigned Pos = Nodes.size();
1891 Nodes.emplace_back(args&: *this, args&: Pos, args: BD, args&: C);
1892 NodePosition.insert(KV: {Label, Pos});
1893 }
1894
1895 // TODO Nodes should probably be a StringMap<DotCfgDiffNode> after the
1896 // display graph is separated out, which would remove the need for
1897 // NodePosition.
1898 std::vector<DotCfgDiffNode> Nodes;
1899 StringMap<unsigned> NodePosition;
1900 const std::string GraphName;
1901
1902 StringMap<std::string> EdgeLabels;
1903};
1904
1905std::string DotCfgDiffNode::getBodyContent() const {
1906 if (Colour == CommonColour) {
1907 assert(Data[1] && "Expected Data[1] to be set.");
1908
1909 StringRef SR[2];
1910 for (unsigned I = 0; I < 2; ++I) {
1911 SR[I] = Data[I]->getBody();
1912 // drop initial '\n' if present
1913 SR[I].consume_front(Prefix: "\n");
1914 // drop predecessors as they can be big and are redundant
1915 SR[I] = SR[I].drop_until(F: [](char C) { return C == '\n'; }).drop_front();
1916 }
1917
1918 SmallString<80> OldLineFormat = formatv(
1919 Fmt: "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Vals&: BeforeColour);
1920 SmallString<80> NewLineFormat = formatv(
1921 Fmt: "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Vals&: AfterColour);
1922 SmallString<80> UnchangedLineFormat = formatv(
1923 Fmt: "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>", Vals&: CommonColour);
1924 std::string Diff = Data[0]->getLabel().str();
1925 Diff += ":\n<BR align=\"left\"/>" +
1926 doSystemDiff(Before: makeHTMLReady(SR: SR[0]), After: makeHTMLReady(SR: SR[1]),
1927 OldLineFormat, NewLineFormat, UnchangedLineFormat);
1928
1929 // Diff adds in some empty colour changes which are not valid HTML
1930 // so remove them. Colours are all lowercase alpha characters (as
1931 // listed in https://graphviz.org/pdf/dotguide.pdf).
1932 Regex R("<FONT COLOR=\"\\w+\"></FONT>");
1933 while (true) {
1934 std::string Error;
1935 std::string S = R.sub(Repl: "", String: Diff, Error: &Error);
1936 if (Error != "")
1937 return Error;
1938 if (S == Diff)
1939 return Diff;
1940 Diff = S;
1941 }
1942 llvm_unreachable("Should not get here");
1943 }
1944
1945 // Put node out in the appropriate colour.
1946 assert(!Data[1] && "Data[1] is set unexpectedly.");
1947 std::string Body = makeHTMLReady(SR: Data[0]->getBody());
1948 const StringRef BS = Body;
1949 StringRef BS1 = BS;
1950 // Drop leading newline, if present.
1951 if (BS.front() == '\n')
1952 BS1 = BS1.drop_front(N: 1);
1953 // Get label.
1954 StringRef Label = BS1.take_until(F: [](char C) { return C == ':'; });
1955 // drop predecessors as they can be big and are redundant
1956 BS1 = BS1.drop_until(F: [](char C) { return C == '\n'; }).drop_front();
1957
1958 std::string S = "<FONT COLOR=\"" + Colour.str() + "\">" + Label.str() + ":";
1959
1960 // align each line to the left.
1961 while (BS1.size()) {
1962 S.append(s: "<BR align=\"left\"/>");
1963 StringRef Line = BS1.take_until(F: [](char C) { return C == '\n'; });
1964 S.append(str: Line.str());
1965 BS1 = BS1.drop_front(N: Line.size() + 1);
1966 }
1967 S.append(s: "<BR align=\"left\"/></FONT>");
1968 return S;
1969}
1970
1971std::string DotCfgDiff::colourize(std::string S, StringRef Colour) const {
1972 if (S.length() == 0)
1973 return S;
1974 return "<FONT COLOR=\"" + Colour.str() + "\">" + S + "</FONT>";
1975}
1976
1977DotCfgDiff::DotCfgDiff(StringRef Title, const FuncDataT<DCData> &Before,
1978 const FuncDataT<DCData> &After)
1979 : GraphName(Title.str()) {
1980 StringMap<StringRef> EdgesMap;
1981
1982 // Handle each basic block in the before IR.
1983 for (auto &B : Before.getData()) {
1984 StringRef Label = B.getKey();
1985 const BlockDataT<DCData> &BD = B.getValue();
1986 createNode(Label, BD, C: BeforeColour);
1987
1988 // Create transitions with names made up of the from block label, the value
1989 // on which the transition is made and the to block label.
1990 for (StringMap<std::string>::const_iterator Sink = BD.getData().begin(),
1991 E = BD.getData().end();
1992 Sink != E; ++Sink) {
1993 std::string Key = (Label + " " + Sink->getKey().str()).str() + " " +
1994 BD.getData().getSuccessorLabel(S: Sink->getKey()).str();
1995 EdgesMap.insert(KV: {Key, BeforeColour});
1996 }
1997 }
1998
1999 // Handle each basic block in the after IR
2000 for (auto &A : After.getData()) {
2001 StringRef Label = A.getKey();
2002 const BlockDataT<DCData> &BD = A.getValue();
2003 auto It = NodePosition.find(Key: Label);
2004 if (It == NodePosition.end())
2005 // This only exists in the after IR. Create the node.
2006 createNode(Label, BD, C: AfterColour);
2007 else
2008 Nodes[It->second].setCommon(BD);
2009 // Add in the edges between the nodes (as common or only in after).
2010 for (StringMap<std::string>::const_iterator Sink = BD.getData().begin(),
2011 E = BD.getData().end();
2012 Sink != E; ++Sink) {
2013 std::string Key = (Label + " " + Sink->getKey().str()).str() + " " +
2014 BD.getData().getSuccessorLabel(S: Sink->getKey()).str();
2015 auto [It, Inserted] = EdgesMap.try_emplace(Key, Args&: AfterColour);
2016 if (!Inserted)
2017 It->second = CommonColour;
2018 }
2019 }
2020
2021 // Now go through the map of edges and add them to the node.
2022 for (auto &E : EdgesMap) {
2023 // Extract the source, sink and value from the edge key.
2024 StringRef S = E.getKey();
2025 auto SP1 = S.rsplit(Separator: ' ');
2026 auto &SourceSink = SP1.first;
2027 auto SP2 = SourceSink.split(Separator: ' ');
2028 StringRef Source = SP2.first;
2029 StringRef Sink = SP2.second;
2030 StringRef Value = SP1.second;
2031
2032 assert(NodePosition.count(Source) == 1 && "Expected to find node.");
2033 DotCfgDiffNode &SourceNode = Nodes[NodePosition[Source]];
2034 assert(NodePosition.count(Sink) == 1 && "Expected to find node.");
2035 unsigned SinkNode = NodePosition[Sink];
2036 StringRef Colour = E.second;
2037
2038 // Look for an edge from Source to Sink
2039 auto [It, Inserted] = EdgeLabels.try_emplace(Key: SourceSink);
2040 if (Inserted)
2041 It->getValue() = colourize(S: Value.str(), Colour);
2042 else {
2043 StringRef V = It->getValue();
2044 std::string NV = colourize(S: V.str() + " " + Value.str(), Colour);
2045 Colour = CommonColour;
2046 It->getValue() = NV;
2047 }
2048 SourceNode.addEdge(E: SinkNode, Value, Colour);
2049 }
2050 for (auto &I : Nodes)
2051 I.finalize(G&: *this);
2052}
2053
2054DotCfgDiffDisplayGraph DotCfgDiff::createDisplayGraph(StringRef Title,
2055 StringRef EntryNodeName) {
2056 assert(NodePosition.count(EntryNodeName) == 1 &&
2057 "Expected to find entry block in map.");
2058 unsigned Entry = NodePosition[EntryNodeName];
2059 assert(Entry < Nodes.size() && "Expected to find entry node");
2060 DotCfgDiffDisplayGraph G(Title.str());
2061
2062 std::map<const unsigned, unsigned> NodeMap;
2063
2064 int EntryIndex = -1;
2065 unsigned Index = 0;
2066 for (auto &I : Nodes) {
2067 if (I.getIndex() == Entry)
2068 EntryIndex = Index;
2069 G.createNode(C: I.getBodyContent(), Colour: I.getColour());
2070 NodeMap.insert(x: {I.getIndex(), Index++});
2071 }
2072 assert(EntryIndex >= 0 && "Expected entry node index to be set.");
2073 G.setEntryNode(EntryIndex);
2074
2075 for (auto &I : NodeMap) {
2076 unsigned SourceNode = I.first;
2077 unsigned DisplayNode = I.second;
2078 getNode(N: SourceNode).createDisplayEdges(Graph&: G, DisplayNode, NodeMap);
2079 }
2080 return G;
2081}
2082
2083void DotCfgDiffNode::createDisplayEdges(
2084 DotCfgDiffDisplayGraph &DisplayGraph, unsigned DisplayNodeIndex,
2085 std::map<const unsigned, unsigned> &NodeMap) const {
2086
2087 DisplayNode &SourceDisplayNode = DisplayGraph.getNode(N: DisplayNodeIndex);
2088
2089 for (auto I : Edges) {
2090 unsigned SinkNodeIndex = I;
2091 StringRef Colour = getEdgeColour(S: SinkNodeIndex);
2092 const DotCfgDiffNode *SinkNode = &Graph.getNode(N: SinkNodeIndex);
2093
2094 StringRef Label = Graph.getEdgeSourceLabel(Source: getIndex(), Sink: SinkNodeIndex);
2095 DisplayNode &SinkDisplayNode = DisplayGraph.getNode(N: SinkNode->getIndex());
2096 SourceDisplayNode.createEdge(Value: Label, Node&: SinkDisplayNode, Colour);
2097 }
2098 SourceDisplayNode.createEdgeMap();
2099}
2100
2101void DotCfgDiffNode::finalize(DotCfgDiff &G) {
2102 for (auto E : EdgesMap) {
2103 Children.emplace_back(args: E.first);
2104 Edges.emplace_back(args: E.first);
2105 }
2106}
2107
2108} // namespace
2109
2110namespace llvm {
2111
2112template <> struct GraphTraits<DotCfgDiffDisplayGraph *> {
2113 using NodeRef = const DisplayNode *;
2114 using ChildIteratorType = DisplayNode::ChildIterator;
2115 using nodes_iterator = DotCfgDiffDisplayGraph::NodeIterator;
2116 using EdgeRef = const DisplayEdge *;
2117 using ChildEdgeIterator = DisplayNode::EdgeIterator;
2118
2119 static NodeRef getEntryNode(const DotCfgDiffDisplayGraph *G) {
2120 return G->getEntryNode();
2121 }
2122 static ChildIteratorType child_begin(NodeRef N) {
2123 return N->children_begin();
2124 }
2125 static ChildIteratorType child_end(NodeRef N) { return N->children_end(); }
2126 static nodes_iterator nodes_begin(const DotCfgDiffDisplayGraph *G) {
2127 return G->nodes_begin();
2128 }
2129 static nodes_iterator nodes_end(const DotCfgDiffDisplayGraph *G) {
2130 return G->nodes_end();
2131 }
2132 static ChildEdgeIterator child_edge_begin(NodeRef N) {
2133 return N->edges_begin();
2134 }
2135 static ChildEdgeIterator child_edge_end(NodeRef N) { return N->edges_end(); }
2136 static NodeRef edge_dest(EdgeRef E) { return &E->getDestinationNode(); }
2137 static unsigned size(const DotCfgDiffDisplayGraph *G) { return G->size(); }
2138};
2139
2140template <>
2141struct DOTGraphTraits<DotCfgDiffDisplayGraph *> : public DefaultDOTGraphTraits {
2142 explicit DOTGraphTraits(bool Simple = false)
2143 : DefaultDOTGraphTraits(Simple) {}
2144
2145 static bool renderNodesUsingHTML() { return true; }
2146 static std::string getGraphName(const DotCfgDiffDisplayGraph *DiffData) {
2147 return DiffData->getGraphName();
2148 }
2149 static std::string
2150 getGraphProperties(const DotCfgDiffDisplayGraph *DiffData) {
2151 return "\tsize=\"190, 190\";\n";
2152 }
2153 static std::string getNodeLabel(const DisplayNode *Node,
2154 const DotCfgDiffDisplayGraph *DiffData) {
2155 return DiffData->getNodeLabel(Node: *Node);
2156 }
2157 static std::string getNodeAttributes(const DisplayNode *Node,
2158 const DotCfgDiffDisplayGraph *DiffData) {
2159 return DiffData->getNodeAttributes(Node: *Node);
2160 }
2161 static std::string getEdgeSourceLabel(const DisplayNode *From,
2162 DisplayNode::ChildIterator &To) {
2163 return From->getEdgeSourceLabel(Sink: **To);
2164 }
2165 static std::string getEdgeAttributes(const DisplayNode *From,
2166 DisplayNode::ChildIterator &To,
2167 const DotCfgDiffDisplayGraph *DiffData) {
2168 return DiffData->getEdgeColorAttr(From: *From, To: **To);
2169 }
2170};
2171
2172} // namespace llvm
2173
2174namespace {
2175
2176void DotCfgDiffDisplayGraph::generateDotFile(StringRef DotFile) {
2177 std::error_code EC;
2178 raw_fd_ostream OutStream(DotFile, EC);
2179 if (EC) {
2180 errs() << "Error: " << EC.message() << "\n";
2181 return;
2182 }
2183 WriteGraph(O&: OutStream, G: this, ShortNames: false);
2184 OutStream.flush();
2185 OutStream.close();
2186}
2187
2188} // namespace
2189
2190namespace llvm {
2191
2192DCData::DCData(const BasicBlock &B) {
2193 // Build up transition labels.
2194 const Instruction *Term = B.getTerminator();
2195 if (const BranchInst *Br = dyn_cast<const BranchInst>(Val: Term))
2196 if (Br->isUnconditional())
2197 addSuccessorLabel(Succ: Br->getSuccessor(i: 0)->getName().str(), Label: "");
2198 else {
2199 addSuccessorLabel(Succ: Br->getSuccessor(i: 0)->getName().str(), Label: "true");
2200 addSuccessorLabel(Succ: Br->getSuccessor(i: 1)->getName().str(), Label: "false");
2201 }
2202 else if (const SwitchInst *Sw = dyn_cast<const SwitchInst>(Val: Term)) {
2203 addSuccessorLabel(Succ: Sw->case_default()->getCaseSuccessor()->getName().str(),
2204 Label: "default");
2205 for (auto &C : Sw->cases()) {
2206 assert(C.getCaseValue() && "Expected to find case value.");
2207 SmallString<20> Value = formatv(Fmt: "{0}", Vals: C.getCaseValue()->getSExtValue());
2208 addSuccessorLabel(Succ: C.getCaseSuccessor()->getName().str(), Label: Value);
2209 }
2210 } else
2211 for (const BasicBlock *Succ : successors(BB: &B))
2212 addSuccessorLabel(Succ: Succ->getName().str(), Label: "");
2213}
2214
2215DCData::DCData(const MachineBasicBlock &B) {
2216 for (const MachineBasicBlock *Succ : successors(BB: &B))
2217 addSuccessorLabel(Succ: Succ->getName().str(), Label: "");
2218}
2219
2220DotCfgChangeReporter::DotCfgChangeReporter(bool Verbose)
2221 : ChangeReporter<IRDataT<DCData>>(Verbose) {}
2222
2223void DotCfgChangeReporter::handleFunctionCompare(
2224 StringRef Name, StringRef Prefix, StringRef PassID, StringRef Divider,
2225 bool InModule, unsigned Minor, const FuncDataT<DCData> &Before,
2226 const FuncDataT<DCData> &After) {
2227 assert(HTML && "Expected outstream to be set");
2228 SmallString<8> Extender;
2229 SmallString<8> Number;
2230 // Handle numbering and file names.
2231 if (InModule) {
2232 Extender = formatv(Fmt: "{0}_{1}", Vals&: N, Vals&: Minor);
2233 Number = formatv(Fmt: "{0}.{1}", Vals&: N, Vals&: Minor);
2234 } else {
2235 Extender = formatv(Fmt: "{0}", Vals&: N);
2236 Number = formatv(Fmt: "{0}", Vals&: N);
2237 }
2238 // Create a temporary file name for the dot file.
2239 SmallVector<char, 128> SV;
2240 sys::fs::createUniquePath(Model: "cfgdot-%%%%%%.dot", ResultPath&: SV, MakeAbsolute: true);
2241 std::string DotFile = Twine(SV).str();
2242
2243 SmallString<20> PDFFileName = formatv(Fmt: "diff_{0}.pdf", Vals&: Extender);
2244 SmallString<200> Text;
2245
2246 Text = formatv(Fmt: "{0}.{1}{2}{3}{4}", Vals&: Number, Vals&: Prefix, Vals: makeHTMLReady(SR: PassID),
2247 Vals&: Divider, Vals&: Name);
2248
2249 DotCfgDiff Diff(Text, Before, After);
2250 std::string EntryBlockName = After.getEntryBlockName();
2251 // Use the before entry block if the after entry block was removed.
2252 if (EntryBlockName == "")
2253 EntryBlockName = Before.getEntryBlockName();
2254 assert(EntryBlockName != "" && "Expected to find entry block");
2255
2256 DotCfgDiffDisplayGraph DG = Diff.createDisplayGraph(Title: Text, EntryNodeName: EntryBlockName);
2257 DG.generateDotFile(DotFile);
2258
2259 *HTML << genHTML(Text, DotFile, PDFFileName);
2260 std::error_code EC = sys::fs::remove(path: DotFile);
2261 if (EC)
2262 errs() << "Error: " << EC.message() << "\n";
2263}
2264
2265std::string DotCfgChangeReporter::genHTML(StringRef Text, StringRef DotFile,
2266 StringRef PDFFileName) {
2267 SmallString<20> PDFFile = formatv(Fmt: "{0}/{1}", Vals&: DotCfgDir, Vals&: PDFFileName);
2268 // Create the PDF file.
2269 static ErrorOr<std::string> DotExe = sys::findProgramByName(Name: DotBinary);
2270 if (!DotExe)
2271 return "Unable to find dot executable.";
2272
2273 StringRef Args[] = {DotBinary, "-Tpdf", "-o", PDFFile, DotFile};
2274 int Result = sys::ExecuteAndWait(Program: *DotExe, Args, Env: std::nullopt);
2275 if (Result < 0)
2276 return "Error executing system dot.";
2277
2278 // Create the HTML tag refering to the PDF file.
2279 SmallString<200> S = formatv(
2280 Fmt: " <a href=\"{0}\" target=\"_blank\">{1}</a><br/>\n", Vals&: PDFFileName, Vals&: Text);
2281 return S.c_str();
2282}
2283
2284void DotCfgChangeReporter::handleInitialIR(Any IR) {
2285 assert(HTML && "Expected outstream to be set");
2286 *HTML << "<button type=\"button\" class=\"collapsible\">0. "
2287 << "Initial IR (by function)</button>\n"
2288 << "<div class=\"content\">\n"
2289 << " <p>\n";
2290 // Create representation of IR
2291 IRDataT<DCData> Data;
2292 IRComparer<DCData>::analyzeIR(IR, Data);
2293 // Now compare it against itself, which will have everything the
2294 // same and will generate the files.
2295 IRComparer<DCData>(Data, Data)
2296 .compare(CompareModule: getModuleForComparison(IR),
2297 CompareFunc: [&](bool InModule, unsigned Minor,
2298 const FuncDataT<DCData> &Before,
2299 const FuncDataT<DCData> &After) -> void {
2300 handleFunctionCompare(Name: "", Prefix: " ", PassID: "Initial IR", Divider: "", InModule,
2301 Minor, Before, After);
2302 });
2303 *HTML << " </p>\n"
2304 << "</div><br/>\n";
2305 ++N;
2306}
2307
2308void DotCfgChangeReporter::generateIRRepresentation(Any IR, StringRef PassID,
2309 IRDataT<DCData> &Data) {
2310 IRComparer<DCData>::analyzeIR(IR, Data);
2311}
2312
2313void DotCfgChangeReporter::omitAfter(StringRef PassID, std::string &Name) {
2314 assert(HTML && "Expected outstream to be set");
2315 SmallString<20> Banner =
2316 formatv(Fmt: " <a>{0}. Pass {1} on {2} omitted because no change</a><br/>\n",
2317 Vals&: N, Vals: makeHTMLReady(SR: PassID), Vals&: Name);
2318 *HTML << Banner;
2319 ++N;
2320}
2321
2322void DotCfgChangeReporter::handleAfter(StringRef PassID, std::string &Name,
2323 const IRDataT<DCData> &Before,
2324 const IRDataT<DCData> &After, Any IR) {
2325 assert(HTML && "Expected outstream to be set");
2326 IRComparer<DCData>(Before, After)
2327 .compare(CompareModule: getModuleForComparison(IR),
2328 CompareFunc: [&](bool InModule, unsigned Minor,
2329 const FuncDataT<DCData> &Before,
2330 const FuncDataT<DCData> &After) -> void {
2331 handleFunctionCompare(Name, Prefix: " Pass ", PassID, Divider: " on ", InModule,
2332 Minor, Before, After);
2333 });
2334 *HTML << " </p></div>\n";
2335 ++N;
2336}
2337
2338void DotCfgChangeReporter::handleInvalidated(StringRef PassID) {
2339 assert(HTML && "Expected outstream to be set");
2340 SmallString<20> Banner =
2341 formatv(Fmt: " <a>{0}. {1} invalidated</a><br/>\n", Vals&: N, Vals: makeHTMLReady(SR: PassID));
2342 *HTML << Banner;
2343 ++N;
2344}
2345
2346void DotCfgChangeReporter::handleFiltered(StringRef PassID, std::string &Name) {
2347 assert(HTML && "Expected outstream to be set");
2348 SmallString<20> Banner =
2349 formatv(Fmt: " <a>{0}. Pass {1} on {2} filtered out</a><br/>\n", Vals&: N,
2350 Vals: makeHTMLReady(SR: PassID), Vals&: Name);
2351 *HTML << Banner;
2352 ++N;
2353}
2354
2355void DotCfgChangeReporter::handleIgnored(StringRef PassID, std::string &Name) {
2356 assert(HTML && "Expected outstream to be set");
2357 SmallString<20> Banner = formatv(Fmt: " <a>{0}. {1} on {2} ignored</a><br/>\n", Vals&: N,
2358 Vals: makeHTMLReady(SR: PassID), Vals&: Name);
2359 *HTML << Banner;
2360 ++N;
2361}
2362
2363bool DotCfgChangeReporter::initializeHTML() {
2364 std::error_code EC;
2365 HTML = std::make_unique<raw_fd_ostream>(args: DotCfgDir + "/passes.html", args&: EC);
2366 if (EC) {
2367 HTML = nullptr;
2368 return false;
2369 }
2370
2371 *HTML << "<!doctype html>"
2372 << "<html>"
2373 << "<head>"
2374 << "<style>.collapsible { "
2375 << "background-color: #777;"
2376 << " color: white;"
2377 << " cursor: pointer;"
2378 << " padding: 18px;"
2379 << " width: 100%;"
2380 << " border: none;"
2381 << " text-align: left;"
2382 << " outline: none;"
2383 << " font-size: 15px;"
2384 << "} .active, .collapsible:hover {"
2385 << " background-color: #555;"
2386 << "} .content {"
2387 << " padding: 0 18px;"
2388 << " display: none;"
2389 << " overflow: hidden;"
2390 << " background-color: #f1f1f1;"
2391 << "}"
2392 << "</style>"
2393 << "<title>passes.html</title>"
2394 << "</head>\n"
2395 << "<body>";
2396 return true;
2397}
2398
2399DotCfgChangeReporter::~DotCfgChangeReporter() {
2400 if (!HTML)
2401 return;
2402 *HTML
2403 << "<script>var coll = document.getElementsByClassName(\"collapsible\");"
2404 << "var i;"
2405 << "for (i = 0; i < coll.length; i++) {"
2406 << "coll[i].addEventListener(\"click\", function() {"
2407 << " this.classList.toggle(\"active\");"
2408 << " var content = this.nextElementSibling;"
2409 << " if (content.style.display === \"block\"){"
2410 << " content.style.display = \"none\";"
2411 << " }"
2412 << " else {"
2413 << " content.style.display= \"block\";"
2414 << " }"
2415 << " });"
2416 << " }"
2417 << "</script>"
2418 << "</body>"
2419 << "</html>\n";
2420 HTML->flush();
2421 HTML->close();
2422}
2423
2424void DotCfgChangeReporter::registerCallbacks(
2425 PassInstrumentationCallbacks &PIC) {
2426 if (PrintChanged == ChangePrinter::DotCfgVerbose ||
2427 PrintChanged == ChangePrinter::DotCfgQuiet) {
2428 SmallString<128> OutputDir;
2429 sys::fs::expand_tilde(path: DotCfgDir, output&: OutputDir);
2430 sys::fs::make_absolute(path&: OutputDir);
2431 assert(!OutputDir.empty() && "expected output dir to be non-empty");
2432 DotCfgDir = OutputDir.c_str();
2433 if (initializeHTML()) {
2434 ChangeReporter<IRDataT<DCData>>::registerRequiredCallbacks(PIC);
2435 return;
2436 }
2437 dbgs() << "Unable to open output stream for -cfg-dot-changed\n";
2438 }
2439}
2440
2441StandardInstrumentations::StandardInstrumentations(
2442 LLVMContext &Context, bool DebugLogging, bool VerifyEach,
2443 PrintPassOptions PrintPassOpts)
2444 : PrintPass(DebugLogging, PrintPassOpts), OptNone(DebugLogging),
2445 OptPassGate(Context),
2446 PrintChangedIR(PrintChanged == ChangePrinter::Verbose),
2447 PrintChangedDiff(PrintChanged == ChangePrinter::DiffVerbose ||
2448 PrintChanged == ChangePrinter::ColourDiffVerbose,
2449 PrintChanged == ChangePrinter::ColourDiffVerbose ||
2450 PrintChanged == ChangePrinter::ColourDiffQuiet),
2451 WebsiteChangeReporter(PrintChanged == ChangePrinter::DotCfgVerbose),
2452 Verify(DebugLogging), DroppedStatsIR(DroppedVarStats),
2453 VerifyEach(VerifyEach) {}
2454
2455PrintCrashIRInstrumentation *PrintCrashIRInstrumentation::CrashReporter =
2456 nullptr;
2457
2458void PrintCrashIRInstrumentation::reportCrashIR() {
2459 if (!PrintOnCrashPath.empty()) {
2460 std::error_code EC;
2461 raw_fd_ostream Out(PrintOnCrashPath, EC);
2462 if (EC)
2463 report_fatal_error(Err: errorCodeToError(EC));
2464 Out << SavedIR;
2465 } else {
2466 dbgs() << SavedIR;
2467 }
2468}
2469
2470void PrintCrashIRInstrumentation::SignalHandler(void *) {
2471 // Called by signal handlers so do not lock here
2472 // Is the PrintCrashIRInstrumentation still alive?
2473 if (!CrashReporter)
2474 return;
2475
2476 assert((PrintOnCrash || !PrintOnCrashPath.empty()) &&
2477 "Did not expect to get here without option set.");
2478 CrashReporter->reportCrashIR();
2479}
2480
2481PrintCrashIRInstrumentation::~PrintCrashIRInstrumentation() {
2482 if (!CrashReporter)
2483 return;
2484
2485 assert((PrintOnCrash || !PrintOnCrashPath.empty()) &&
2486 "Did not expect to get here without option set.");
2487 CrashReporter = nullptr;
2488}
2489
2490void PrintCrashIRInstrumentation::registerCallbacks(
2491 PassInstrumentationCallbacks &PIC) {
2492 if ((!PrintOnCrash && PrintOnCrashPath.empty()) || CrashReporter)
2493 return;
2494
2495 sys::AddSignalHandler(FnPtr: SignalHandler, Cookie: nullptr);
2496 CrashReporter = this;
2497
2498 PIC.registerBeforeNonSkippedPassCallback(
2499 C: [&PIC, this](StringRef PassID, Any IR) {
2500 SavedIR.clear();
2501 raw_string_ostream OS(SavedIR);
2502 OS << formatv(Fmt: "; *** Dump of {0}IR Before Last Pass {1}",
2503 Vals: llvm::forcePrintModuleIR() ? "Module " : "", Vals&: PassID);
2504 if (!isInteresting(IR, PassID, PassName: PIC.getPassNameForClassName(ClassName: PassID))) {
2505 OS << " Filtered Out ***\n";
2506 return;
2507 }
2508 OS << " Started ***\n";
2509 unwrapAndPrint(OS, IR);
2510 });
2511}
2512
2513void StandardInstrumentations::registerCallbacks(
2514 PassInstrumentationCallbacks &PIC, ModuleAnalysisManager *MAM) {
2515 PrintIR.registerCallbacks(PIC);
2516 PrintPass.registerCallbacks(PIC);
2517 TimePasses.registerCallbacks(PIC);
2518 OptNone.registerCallbacks(PIC);
2519 OptPassGate.registerCallbacks(PIC);
2520 PrintChangedIR.registerCallbacks(PIC);
2521 PseudoProbeVerification.registerCallbacks(PIC);
2522 if (VerifyEach)
2523 Verify.registerCallbacks(PIC, MAM);
2524 PrintChangedDiff.registerCallbacks(PIC);
2525 WebsiteChangeReporter.registerCallbacks(PIC);
2526 ChangeTester.registerCallbacks(PIC);
2527 PrintCrashIR.registerCallbacks(PIC);
2528 DroppedStatsIR.registerCallbacks(PIC);
2529 if (MAM)
2530 PreservedCFGChecker.registerCallbacks(PIC, MAM&: *MAM);
2531
2532 // TimeProfiling records the pass running time cost.
2533 // Its 'BeforePassCallback' can be appended at the tail of all the
2534 // BeforeCallbacks by calling `registerCallbacks` in the end.
2535 // Its 'AfterPassCallback' is put at the front of all the
2536 // AfterCallbacks by its `registerCallbacks`. This is necessary
2537 // to ensure that other callbacks are not included in the timings.
2538 TimeProfilingPasses.registerCallbacks(PIC);
2539}
2540
2541template class ChangeReporter<std::string>;
2542template class TextChangeReporter<std::string>;
2543
2544template class BlockDataT<EmptyData>;
2545template class FuncDataT<EmptyData>;
2546template class IRDataT<EmptyData>;
2547template class ChangeReporter<IRDataT<EmptyData>>;
2548template class TextChangeReporter<IRDataT<EmptyData>>;
2549template class IRComparer<EmptyData>;
2550
2551} // namespace llvm
2552