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/Optional.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Analysis/CallGraphSCCPass.h"
20 #include "llvm/Analysis/LazyCallGraph.h"
21 #include "llvm/Analysis/LoopInfo.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/IR/LegacyPassManager.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/PassInstrumentation.h"
26 #include "llvm/IR/PassManager.h"
27 #include "llvm/IR/PrintPasses.h"
28 #include "llvm/IR/Verifier.h"
29 #include "llvm/Support/CommandLine.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/FormatVariadic.h"
32 #include "llvm/Support/MemoryBuffer.h"
33 #include "llvm/Support/Program.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include <unordered_set>
36 #include <vector>
37
38 using namespace llvm;
39
40 cl::opt<bool> PreservedCFGCheckerInstrumentation::VerifyPreservedCFG(
41 "verify-cfg-preserved", cl::Hidden,
42 #ifdef NDEBUG
43 cl::init(false));
44 #else
45 cl::init(true));
46 #endif
47
48 // An option that prints out the IR after passes, similar to
49 // -print-after-all except that it only prints the IR after passes that
50 // change the IR. Those passes that do not make changes to the IR are
51 // reported as not making any changes. In addition, the initial IR is
52 // also reported. Other hidden options affect the output from this
53 // option. -filter-passes will limit the output to the named passes
54 // that actually change the IR and other passes are reported as filtered out.
55 // The specified passes will either be reported as making no changes (with
56 // no IR reported) or the changed IR will be reported. Also, the
57 // -filter-print-funcs and -print-module-scope options will do similar
58 // filtering based on function name, reporting changed IRs as functions(or
59 // modules if -print-module-scope is specified) for a particular function
60 // or indicating that the IR has been filtered out. The extra options
61 // can be combined, allowing only changed IRs for certain passes on certain
62 // functions to be reported in different formats, with the rest being
63 // reported as filtered out. The -print-before-changed option will print
64 // the IR as it was before each pass that changed it. The optional
65 // value of quiet will only report when the IR changes, suppressing
66 // all other messages, including the initial IR. The values "diff" and
67 // "diff-quiet" will present the changes in a form similar to a patch, in
68 // either verbose or quiet mode, respectively. The lines that are removed
69 // and added are prefixed with '-' and '+', respectively. The
70 // -filter-print-funcs and -filter-passes can be used to filter the output.
71 // This reporter relies on the linux diff utility to do comparisons and
72 // insert the prefixes. For systems that do not have the necessary
73 // facilities, the error message will be shown in place of the expected output.
74 //
75 enum class ChangePrinter {
76 NoChangePrinter,
77 PrintChangedVerbose,
78 PrintChangedQuiet,
79 PrintChangedDiffVerbose,
80 PrintChangedDiffQuiet,
81 PrintChangedColourDiffVerbose,
82 PrintChangedColourDiffQuiet
83 };
84 static cl::opt<ChangePrinter> PrintChanged(
85 "print-changed", cl::desc("Print changed IRs"), cl::Hidden,
86 cl::ValueOptional, cl::init(ChangePrinter::NoChangePrinter),
87 cl::values(
88 clEnumValN(ChangePrinter::PrintChangedQuiet, "quiet",
89 "Run in quiet mode"),
90 clEnumValN(ChangePrinter::PrintChangedDiffVerbose, "diff",
91 "Display patch-like changes"),
92 clEnumValN(ChangePrinter::PrintChangedDiffQuiet, "diff-quiet",
93 "Display patch-like changes in quiet mode"),
94 clEnumValN(ChangePrinter::PrintChangedColourDiffVerbose, "cdiff",
95 "Display patch-like changes with color"),
96 clEnumValN(ChangePrinter::PrintChangedColourDiffQuiet, "cdiff-quiet",
97 "Display patch-like changes in quiet mode with color"),
98 // Sentinel value for unspecified option.
99 clEnumValN(ChangePrinter::PrintChangedVerbose, "", "")));
100
101 // An option that supports the -print-changed option. See
102 // the description for -print-changed for an explanation of the use
103 // of this option. Note that this option has no effect without -print-changed.
104 static cl::list<std::string>
105 PrintPassesList("filter-passes", cl::value_desc("pass names"),
106 cl::desc("Only consider IR changes for passes whose names "
107 "match for the print-changed option"),
108 cl::CommaSeparated, cl::Hidden);
109 // An option that supports the -print-changed option. See
110 // the description for -print-changed for an explanation of the use
111 // of this option. Note that this option has no effect without -print-changed.
112 static cl::opt<bool>
113 PrintChangedBefore("print-before-changed",
114 cl::desc("Print before passes that change them"),
115 cl::init(false), cl::Hidden);
116
117 // An option for specifying the diff used by print-changed=[diff | diff-quiet]
118 static cl::opt<std::string>
119 DiffBinary("print-changed-diff-path", cl::Hidden, cl::init("diff"),
120 cl::desc("system diff used by change reporters"));
121
122 namespace {
123
124 // Perform a system based diff between \p Before and \p After, using
125 // \p OldLineFormat, \p NewLineFormat, and \p UnchangedLineFormat
126 // to control the formatting of the output. Return an error message
127 // for any failures instead of the diff.
doSystemDiff(StringRef Before,StringRef After,StringRef OldLineFormat,StringRef NewLineFormat,StringRef UnchangedLineFormat)128 std::string doSystemDiff(StringRef Before, StringRef After,
129 StringRef OldLineFormat, StringRef NewLineFormat,
130 StringRef UnchangedLineFormat) {
131 StringRef SR[2]{Before, After};
132 // Store the 2 bodies into temporary files and call diff on them
133 // to get the body of the node.
134 const unsigned NumFiles = 3;
135 static std::string FileName[NumFiles];
136 static int FD[NumFiles]{-1, -1, -1};
137 for (unsigned I = 0; I < NumFiles; ++I) {
138 if (FD[I] == -1) {
139 SmallVector<char, 200> SV;
140 std::error_code EC =
141 sys::fs::createTemporaryFile("tmpdiff", "txt", FD[I], SV);
142 if (EC)
143 return "Unable to create temporary file.";
144 FileName[I] = Twine(SV).str();
145 }
146 // The third file is used as the result of the diff.
147 if (I == NumFiles - 1)
148 break;
149
150 std::error_code EC = sys::fs::openFileForWrite(FileName[I], FD[I]);
151 if (EC)
152 return "Unable to open temporary file for writing.";
153
154 raw_fd_ostream OutStream(FD[I], /*shouldClose=*/true);
155 if (FD[I] == -1)
156 return "Error opening file for writing.";
157 OutStream << SR[I];
158 }
159
160 static ErrorOr<std::string> DiffExe = sys::findProgramByName(DiffBinary);
161 if (!DiffExe)
162 return "Unable to find diff executable.";
163
164 SmallString<128> OLF = formatv("--old-line-format={0}", OldLineFormat);
165 SmallString<128> NLF = formatv("--new-line-format={0}", NewLineFormat);
166 SmallString<128> ULF =
167 formatv("--unchanged-line-format={0}", UnchangedLineFormat);
168
169 StringRef Args[] = {"-w", "-d", OLF, NLF, ULF, FileName[0], FileName[1]};
170 Optional<StringRef> Redirects[] = {None, StringRef(FileName[2]), None};
171 int Result = sys::ExecuteAndWait(*DiffExe, Args, None, Redirects);
172 if (Result < 0)
173 return "Error executing system diff.";
174 std::string Diff;
175 auto B = MemoryBuffer::getFile(FileName[2]);
176 if (B && *B)
177 Diff = (*B)->getBuffer().str();
178 else
179 return "Unable to read result.";
180
181 // Clean up.
182 for (unsigned I = 0; I < NumFiles; ++I) {
183 std::error_code EC = sys::fs::remove(FileName[I]);
184 if (EC)
185 return "Unable to remove temporary file.";
186 }
187 return Diff;
188 }
189
190 /// Extract Module out of \p IR unit. May return nullptr if \p IR does not match
191 /// certain global filters. Will never return nullptr if \p Force is true.
unwrapModule(Any IR,bool Force=false)192 const Module *unwrapModule(Any IR, bool Force = false) {
193 if (any_isa<const Module *>(IR))
194 return any_cast<const Module *>(IR);
195
196 if (any_isa<const Function *>(IR)) {
197 const Function *F = any_cast<const Function *>(IR);
198 if (!Force && !isFunctionInPrintList(F->getName()))
199 return nullptr;
200
201 return F->getParent();
202 }
203
204 if (any_isa<const LazyCallGraph::SCC *>(IR)) {
205 const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
206 for (const LazyCallGraph::Node &N : *C) {
207 const Function &F = N.getFunction();
208 if (Force || (!F.isDeclaration() && isFunctionInPrintList(F.getName()))) {
209 return F.getParent();
210 }
211 }
212 assert(!Force && "Expected a module");
213 return nullptr;
214 }
215
216 if (any_isa<const Loop *>(IR)) {
217 const Loop *L = any_cast<const Loop *>(IR);
218 const Function *F = L->getHeader()->getParent();
219 if (!Force && !isFunctionInPrintList(F->getName()))
220 return nullptr;
221 return F->getParent();
222 }
223
224 llvm_unreachable("Unknown IR unit");
225 }
226
printIR(raw_ostream & OS,const Function * F)227 void printIR(raw_ostream &OS, const Function *F) {
228 if (!isFunctionInPrintList(F->getName()))
229 return;
230 OS << *F;
231 }
232
printIR(raw_ostream & OS,const Module * M,bool ShouldPreserveUseListOrder=false)233 void printIR(raw_ostream &OS, const Module *M,
234 bool ShouldPreserveUseListOrder = false) {
235 if (isFunctionInPrintList("*") || forcePrintModuleIR()) {
236 M->print(OS, nullptr, ShouldPreserveUseListOrder);
237 } else {
238 for (const auto &F : M->functions()) {
239 printIR(OS, &F);
240 }
241 }
242 }
243
printIR(raw_ostream & OS,const LazyCallGraph::SCC * C)244 void printIR(raw_ostream &OS, const LazyCallGraph::SCC *C) {
245 for (const LazyCallGraph::Node &N : *C) {
246 const Function &F = N.getFunction();
247 if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
248 F.print(OS);
249 }
250 }
251 }
252
printIR(raw_ostream & OS,const Loop * L)253 void printIR(raw_ostream &OS, const Loop *L) {
254 const Function *F = L->getHeader()->getParent();
255 if (!isFunctionInPrintList(F->getName()))
256 return;
257 printLoop(const_cast<Loop &>(*L), OS);
258 }
259
getIRName(Any IR)260 std::string getIRName(Any IR) {
261 if (any_isa<const Module *>(IR))
262 return "[module]";
263
264 if (any_isa<const Function *>(IR)) {
265 const Function *F = any_cast<const Function *>(IR);
266 return F->getName().str();
267 }
268
269 if (any_isa<const LazyCallGraph::SCC *>(IR)) {
270 const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
271 return C->getName();
272 }
273
274 if (any_isa<const Loop *>(IR)) {
275 const Loop *L = any_cast<const Loop *>(IR);
276 std::string S;
277 raw_string_ostream OS(S);
278 L->print(OS, /*Verbose*/ false, /*PrintNested*/ false);
279 return OS.str();
280 }
281
282 llvm_unreachable("Unknown wrapped IR type");
283 }
284
moduleContainsFilterPrintFunc(const Module & M)285 bool moduleContainsFilterPrintFunc(const Module &M) {
286 return any_of(M.functions(),
287 [](const Function &F) {
288 return isFunctionInPrintList(F.getName());
289 }) ||
290 isFunctionInPrintList("*");
291 }
292
sccContainsFilterPrintFunc(const LazyCallGraph::SCC & C)293 bool sccContainsFilterPrintFunc(const LazyCallGraph::SCC &C) {
294 return any_of(C,
295 [](const LazyCallGraph::Node &N) {
296 return isFunctionInPrintList(N.getName());
297 }) ||
298 isFunctionInPrintList("*");
299 }
300
shouldPrintIR(Any IR)301 bool shouldPrintIR(Any IR) {
302 if (any_isa<const Module *>(IR)) {
303 const Module *M = any_cast<const Module *>(IR);
304 return moduleContainsFilterPrintFunc(*M);
305 }
306
307 if (any_isa<const Function *>(IR)) {
308 const Function *F = any_cast<const Function *>(IR);
309 return isFunctionInPrintList(F->getName());
310 }
311
312 if (any_isa<const LazyCallGraph::SCC *>(IR)) {
313 const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
314 return sccContainsFilterPrintFunc(*C);
315 }
316
317 if (any_isa<const Loop *>(IR)) {
318 const Loop *L = any_cast<const Loop *>(IR);
319 return isFunctionInPrintList(L->getHeader()->getParent()->getName());
320 }
321 llvm_unreachable("Unknown wrapped IR type");
322 }
323
324 /// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
325 /// llvm::Any and does actual print job.
unwrapAndPrint(raw_ostream & OS,Any IR,bool ShouldPreserveUseListOrder=false)326 void unwrapAndPrint(raw_ostream &OS, Any IR,
327 bool ShouldPreserveUseListOrder = false) {
328 if (!shouldPrintIR(IR))
329 return;
330
331 if (forcePrintModuleIR()) {
332 auto *M = unwrapModule(IR);
333 assert(M && "should have unwrapped module");
334 printIR(OS, M, ShouldPreserveUseListOrder);
335 return;
336 }
337
338 if (any_isa<const Module *>(IR)) {
339 const Module *M = any_cast<const Module *>(IR);
340 printIR(OS, M, ShouldPreserveUseListOrder);
341 return;
342 }
343
344 if (any_isa<const Function *>(IR)) {
345 const Function *F = any_cast<const Function *>(IR);
346 printIR(OS, F);
347 return;
348 }
349
350 if (any_isa<const LazyCallGraph::SCC *>(IR)) {
351 const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
352 printIR(OS, C);
353 return;
354 }
355
356 if (any_isa<const Loop *>(IR)) {
357 const Loop *L = any_cast<const Loop *>(IR);
358 printIR(OS, L);
359 return;
360 }
361 llvm_unreachable("Unknown wrapped IR type");
362 }
363
364 // Return true when this is a pass for which changes should be ignored
isIgnored(StringRef PassID)365 bool isIgnored(StringRef PassID) {
366 return isSpecialPass(PassID,
367 {"PassManager", "PassAdaptor", "AnalysisManagerProxy",
368 "DevirtSCCRepeatedPass", "ModuleInlinerWrapperPass"});
369 }
370
371 } // namespace
372
373 template <typename IRUnitT>
~ChangeReporter()374 ChangeReporter<IRUnitT>::~ChangeReporter<IRUnitT>() {
375 assert(BeforeStack.empty() && "Problem with Change Printer stack.");
376 }
377
378 template <typename IRUnitT>
isInterestingFunction(const Function & F)379 bool ChangeReporter<IRUnitT>::isInterestingFunction(const Function &F) {
380 return isFunctionInPrintList(F.getName());
381 }
382
383 template <typename IRUnitT>
isInterestingPass(StringRef PassID)384 bool ChangeReporter<IRUnitT>::isInterestingPass(StringRef PassID) {
385 if (isIgnored(PassID))
386 return false;
387
388 static std::unordered_set<std::string> PrintPassNames(PrintPassesList.begin(),
389 PrintPassesList.end());
390 return PrintPassNames.empty() || PrintPassNames.count(PassID.str());
391 }
392
393 // Return true when this is a pass on IR for which printing
394 // of changes is desired.
395 template <typename IRUnitT>
isInteresting(Any IR,StringRef PassID)396 bool ChangeReporter<IRUnitT>::isInteresting(Any IR, StringRef PassID) {
397 if (!isInterestingPass(PassID))
398 return false;
399 if (any_isa<const Function *>(IR))
400 return isInterestingFunction(*any_cast<const Function *>(IR));
401 return true;
402 }
403
404 template <typename IRUnitT>
saveIRBeforePass(Any IR,StringRef PassID)405 void ChangeReporter<IRUnitT>::saveIRBeforePass(Any IR, StringRef PassID) {
406 // Always need to place something on the stack because invalidated passes
407 // are not given the IR so it cannot be determined whether the pass was for
408 // something that was filtered out.
409 BeforeStack.emplace_back();
410
411 if (!isInteresting(IR, PassID))
412 return;
413 // Is this the initial IR?
414 if (InitialIR) {
415 InitialIR = false;
416 if (VerboseMode)
417 handleInitialIR(IR);
418 }
419
420 // Save the IR representation on the stack.
421 IRUnitT &Data = BeforeStack.back();
422 generateIRRepresentation(IR, PassID, Data);
423 }
424
425 template <typename IRUnitT>
handleIRAfterPass(Any IR,StringRef PassID)426 void ChangeReporter<IRUnitT>::handleIRAfterPass(Any IR, StringRef PassID) {
427 assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
428
429 std::string Name = getIRName(IR);
430
431 if (isIgnored(PassID)) {
432 if (VerboseMode)
433 handleIgnored(PassID, Name);
434 } else if (!isInteresting(IR, PassID)) {
435 if (VerboseMode)
436 handleFiltered(PassID, Name);
437 } else {
438 // Get the before rep from the stack
439 IRUnitT &Before = BeforeStack.back();
440 // Create the after rep
441 IRUnitT After;
442 generateIRRepresentation(IR, PassID, After);
443
444 // Was there a change in IR?
445 if (same(Before, After)) {
446 if (VerboseMode)
447 omitAfter(PassID, Name);
448 } else
449 handleAfter(PassID, Name, Before, After, IR);
450 }
451 BeforeStack.pop_back();
452 }
453
454 template <typename IRUnitT>
handleInvalidatedPass(StringRef PassID)455 void ChangeReporter<IRUnitT>::handleInvalidatedPass(StringRef PassID) {
456 assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
457
458 // Always flag it as invalidated as we cannot determine when
459 // a pass for a filtered function is invalidated since we do not
460 // get the IR in the call. Also, the output is just alternate
461 // forms of the banner anyway.
462 if (VerboseMode)
463 handleInvalidated(PassID);
464 BeforeStack.pop_back();
465 }
466
467 template <typename IRUnitT>
registerRequiredCallbacks(PassInstrumentationCallbacks & PIC)468 void ChangeReporter<IRUnitT>::registerRequiredCallbacks(
469 PassInstrumentationCallbacks &PIC) {
470 PIC.registerBeforeNonSkippedPassCallback(
471 [this](StringRef P, Any IR) { saveIRBeforePass(IR, P); });
472
473 PIC.registerAfterPassCallback(
474 [this](StringRef P, Any IR, const PreservedAnalyses &) {
475 handleIRAfterPass(IR, P);
476 });
477 PIC.registerAfterPassInvalidatedCallback(
478 [this](StringRef P, const PreservedAnalyses &) {
479 handleInvalidatedPass(P);
480 });
481 }
482
ChangedBlockData(const BasicBlock & B)483 ChangedBlockData::ChangedBlockData(const BasicBlock &B)
484 : Label(B.getName().str()) {
485 raw_string_ostream SS(Body);
486 B.print(SS, nullptr, true, true);
487 }
488
489 template <typename IRUnitT>
TextChangeReporter(bool Verbose)490 TextChangeReporter<IRUnitT>::TextChangeReporter(bool Verbose)
491 : ChangeReporter<IRUnitT>(Verbose), Out(dbgs()) {}
492
493 template <typename IRUnitT>
handleInitialIR(Any IR)494 void TextChangeReporter<IRUnitT>::handleInitialIR(Any IR) {
495 // Always print the module.
496 // Unwrap and print directly to avoid filtering problems in general routines.
497 auto *M = unwrapModule(IR, /*Force=*/true);
498 assert(M && "Expected module to be unwrapped when forced.");
499 Out << "*** IR Dump At Start ***\n";
500 M->print(Out, nullptr,
501 /*ShouldPreserveUseListOrder=*/true);
502 }
503
504 template <typename IRUnitT>
omitAfter(StringRef PassID,std::string & Name)505 void TextChangeReporter<IRUnitT>::omitAfter(StringRef PassID,
506 std::string &Name) {
507 Out << formatv("*** IR Dump After {0} on {1} omitted because no change ***\n",
508 PassID, Name);
509 }
510
511 template <typename IRUnitT>
handleInvalidated(StringRef PassID)512 void TextChangeReporter<IRUnitT>::handleInvalidated(StringRef PassID) {
513 Out << formatv("*** IR Pass {0} invalidated ***\n", PassID);
514 }
515
516 template <typename IRUnitT>
handleFiltered(StringRef PassID,std::string & Name)517 void TextChangeReporter<IRUnitT>::handleFiltered(StringRef PassID,
518 std::string &Name) {
519 SmallString<20> Banner =
520 formatv("*** IR Dump After {0} on {1} filtered out ***\n", PassID, Name);
521 Out << Banner;
522 }
523
524 template <typename IRUnitT>
handleIgnored(StringRef PassID,std::string & Name)525 void TextChangeReporter<IRUnitT>::handleIgnored(StringRef PassID,
526 std::string &Name) {
527 Out << formatv("*** IR Pass {0} on {1} ignored ***\n", PassID, Name);
528 }
529
~IRChangedPrinter()530 IRChangedPrinter::~IRChangedPrinter() {}
531
registerCallbacks(PassInstrumentationCallbacks & PIC)532 void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
533 if (PrintChanged == ChangePrinter::PrintChangedVerbose ||
534 PrintChanged == ChangePrinter::PrintChangedQuiet)
535 TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
536 }
537
generateIRRepresentation(Any IR,StringRef PassID,std::string & Output)538 void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
539 std::string &Output) {
540 raw_string_ostream OS(Output);
541 unwrapAndPrint(OS, IR,
542 /*ShouldPreserveUseListOrder=*/true);
543 OS.str();
544 }
545
handleAfter(StringRef PassID,std::string & Name,const std::string & Before,const std::string & After,Any)546 void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
547 const std::string &Before,
548 const std::string &After, Any) {
549 // Report the IR before the changes when requested.
550 if (PrintChangedBefore)
551 Out << "*** IR Dump Before " << PassID << " on " << Name << " ***\n"
552 << Before;
553
554 // We might not get anything to print if we only want to print a specific
555 // function but it gets deleted.
556 if (After.empty()) {
557 Out << "*** IR Deleted After " << PassID << " on " << Name << " ***\n";
558 return;
559 }
560
561 Out << "*** IR Dump After " << PassID << " on " << Name << " ***\n" << After;
562 }
563
same(const std::string & S1,const std::string & S2)564 bool IRChangedPrinter::same(const std::string &S1, const std::string &S2) {
565 return S1 == S2;
566 }
567
568 template <typename IRData>
report(const OrderedChangedData & Before,const OrderedChangedData & After,function_ref<void (const IRData *,const IRData *)> HandlePair)569 void OrderedChangedData<IRData>::report(
570 const OrderedChangedData &Before, const OrderedChangedData &After,
571 function_ref<void(const IRData *, const IRData *)> HandlePair) {
572 const auto &BFD = Before.getData();
573 const auto &AFD = After.getData();
574 std::vector<std::string>::const_iterator BI = Before.getOrder().begin();
575 std::vector<std::string>::const_iterator BE = Before.getOrder().end();
576 std::vector<std::string>::const_iterator AI = After.getOrder().begin();
577 std::vector<std::string>::const_iterator AE = After.getOrder().end();
578
579 auto handlePotentiallyRemovedIRData = [&](std::string S) {
580 // The order in LLVM may have changed so check if still exists.
581 if (!AFD.count(S)) {
582 // This has been removed.
583 HandlePair(&BFD.find(*BI)->getValue(), nullptr);
584 }
585 };
586 auto handleNewIRData = [&](std::vector<const IRData *> &Q) {
587 // Print out any queued up new sections
588 for (const IRData *NBI : Q)
589 HandlePair(nullptr, NBI);
590 Q.clear();
591 };
592
593 // Print out the IRData in the after order, with before ones interspersed
594 // appropriately (ie, somewhere near where they were in the before list).
595 // Start at the beginning of both lists. Loop through the
596 // after list. If an element is common, then advance in the before list
597 // reporting the removed ones until the common one is reached. Report any
598 // queued up new ones and then report the common one. If an element is not
599 // common, then enqueue it for reporting. When the after list is exhausted,
600 // loop through the before list, reporting any removed ones. Finally,
601 // report the rest of the enqueued new ones.
602 std::vector<const IRData *> NewIRDataQueue;
603 while (AI != AE) {
604 if (!BFD.count(*AI)) {
605 // This section is new so place it in the queue. This will cause it
606 // to be reported after deleted sections.
607 NewIRDataQueue.emplace_back(&AFD.find(*AI)->getValue());
608 ++AI;
609 continue;
610 }
611 // This section is in both; advance and print out any before-only
612 // until we get to it.
613 while (*BI != *AI) {
614 handlePotentiallyRemovedIRData(*BI);
615 ++BI;
616 }
617 // Report any new sections that were queued up and waiting.
618 handleNewIRData(NewIRDataQueue);
619
620 const IRData &AData = AFD.find(*AI)->getValue();
621 const IRData &BData = BFD.find(*AI)->getValue();
622 HandlePair(&BData, &AData);
623 ++BI;
624 ++AI;
625 }
626
627 // Check any remaining before sections to see if they have been removed
628 while (BI != BE) {
629 handlePotentiallyRemovedIRData(*BI);
630 ++BI;
631 }
632
633 handleNewIRData(NewIRDataQueue);
634 }
635
compare(Any IR,StringRef Prefix,StringRef PassID,StringRef Name)636 void ChangedIRComparer::compare(Any IR, StringRef Prefix, StringRef PassID,
637 StringRef Name) {
638 if (!getModuleForComparison(IR)) {
639 // Not a module so just handle the single function.
640 assert(Before.getData().size() == 1 && "Expected only one function.");
641 assert(After.getData().size() == 1 && "Expected only one function.");
642 handleFunctionCompare(Name, Prefix, PassID, false,
643 Before.getData().begin()->getValue(),
644 After.getData().begin()->getValue());
645 return;
646 }
647
648 ChangedIRData::report(
649 Before, After, [&](const ChangedFuncData *B, const ChangedFuncData *A) {
650 ChangedFuncData Missing;
651 if (!B)
652 B = &Missing;
653 else if (!A)
654 A = &Missing;
655 assert(B != &Missing && A != &Missing &&
656 "Both functions cannot be missing.");
657 handleFunctionCompare(Name, Prefix, PassID, true, *B, *A);
658 });
659 }
660
analyzeIR(Any IR,ChangedIRData & Data)661 void ChangedIRComparer::analyzeIR(Any IR, ChangedIRData &Data) {
662 if (const Module *M = getModuleForComparison(IR)) {
663 // Create data for each existing/interesting function in the module.
664 for (const Function &F : *M)
665 generateFunctionData(Data, F);
666 return;
667 }
668
669 const Function *F = nullptr;
670 if (any_isa<const Function *>(IR))
671 F = any_cast<const Function *>(IR);
672 else {
673 assert(any_isa<const Loop *>(IR) && "Unknown IR unit.");
674 const Loop *L = any_cast<const Loop *>(IR);
675 F = L->getHeader()->getParent();
676 }
677 assert(F && "Unknown IR unit.");
678 generateFunctionData(Data, *F);
679 }
680
getModuleForComparison(Any IR)681 const Module *ChangedIRComparer::getModuleForComparison(Any IR) {
682 if (any_isa<const Module *>(IR))
683 return any_cast<const Module *>(IR);
684 if (any_isa<const LazyCallGraph::SCC *>(IR))
685 return any_cast<const LazyCallGraph::SCC *>(IR)
686 ->begin()
687 ->getFunction()
688 .getParent();
689 return nullptr;
690 }
691
generateFunctionData(ChangedIRData & Data,const Function & F)692 bool ChangedIRComparer::generateFunctionData(ChangedIRData &Data,
693 const Function &F) {
694 if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
695 ChangedFuncData CFD;
696 for (const auto &B : F) {
697 CFD.getOrder().emplace_back(B.getName());
698 CFD.getData().insert({B.getName(), B});
699 }
700 Data.getOrder().emplace_back(F.getName());
701 Data.getData().insert({F.getName(), CFD});
702 return true;
703 }
704 return false;
705 }
706
~PrintIRInstrumentation()707 PrintIRInstrumentation::~PrintIRInstrumentation() {
708 assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
709 }
710
pushModuleDesc(StringRef PassID,Any IR)711 void PrintIRInstrumentation::pushModuleDesc(StringRef PassID, Any IR) {
712 const Module *M = unwrapModule(IR);
713 ModuleDescStack.emplace_back(M, getIRName(IR), PassID);
714 }
715
716 PrintIRInstrumentation::PrintModuleDesc
popModuleDesc(StringRef PassID)717 PrintIRInstrumentation::popModuleDesc(StringRef PassID) {
718 assert(!ModuleDescStack.empty() && "empty ModuleDescStack");
719 PrintModuleDesc ModuleDesc = ModuleDescStack.pop_back_val();
720 assert(std::get<2>(ModuleDesc).equals(PassID) && "malformed ModuleDescStack");
721 return ModuleDesc;
722 }
723
printBeforePass(StringRef PassID,Any IR)724 void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
725 if (isIgnored(PassID))
726 return;
727
728 // Saving Module for AfterPassInvalidated operations.
729 // Note: here we rely on a fact that we do not change modules while
730 // traversing the pipeline, so the latest captured module is good
731 // for all print operations that has not happen yet.
732 if (shouldPrintAfterPass(PassID))
733 pushModuleDesc(PassID, IR);
734
735 if (!shouldPrintBeforePass(PassID))
736 return;
737
738 if (!shouldPrintIR(IR))
739 return;
740
741 dbgs() << "*** IR Dump Before " << PassID << " on " << getIRName(IR)
742 << " ***\n";
743 unwrapAndPrint(dbgs(), IR);
744 }
745
printAfterPass(StringRef PassID,Any IR)746 void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
747 if (isIgnored(PassID))
748 return;
749
750 if (!shouldPrintAfterPass(PassID))
751 return;
752
753 const Module *M;
754 std::string IRName;
755 StringRef StoredPassID;
756 std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
757 assert(StoredPassID == PassID && "mismatched PassID");
758
759 if (!shouldPrintIR(IR))
760 return;
761
762 dbgs() << "*** IR Dump After " << PassID << " on " << IRName << " ***\n";
763 unwrapAndPrint(dbgs(), IR);
764 }
765
printAfterPassInvalidated(StringRef PassID)766 void PrintIRInstrumentation::printAfterPassInvalidated(StringRef PassID) {
767 StringRef PassName = PIC->getPassNameForClassName(PassID);
768 if (!shouldPrintAfterPass(PassName))
769 return;
770
771 if (isIgnored(PassID))
772 return;
773
774 const Module *M;
775 std::string IRName;
776 StringRef StoredPassID;
777 std::tie(M, IRName, StoredPassID) = popModuleDesc(PassID);
778 assert(StoredPassID == PassID && "mismatched PassID");
779 // Additional filtering (e.g. -filter-print-func) can lead to module
780 // printing being skipped.
781 if (!M)
782 return;
783
784 SmallString<20> Banner =
785 formatv("*** IR Dump After {0} on {1} (invalidated) ***", PassID, IRName);
786 dbgs() << Banner << "\n";
787 printIR(dbgs(), M);
788 }
789
shouldPrintBeforePass(StringRef PassID)790 bool PrintIRInstrumentation::shouldPrintBeforePass(StringRef PassID) {
791 if (shouldPrintBeforeAll())
792 return true;
793
794 StringRef PassName = PIC->getPassNameForClassName(PassID);
795 return llvm::is_contained(printBeforePasses(), PassName);
796 }
797
shouldPrintAfterPass(StringRef PassID)798 bool PrintIRInstrumentation::shouldPrintAfterPass(StringRef PassID) {
799 if (shouldPrintAfterAll())
800 return true;
801
802 StringRef PassName = PIC->getPassNameForClassName(PassID);
803 return llvm::is_contained(printAfterPasses(), PassName);
804 }
805
registerCallbacks(PassInstrumentationCallbacks & PIC)806 void PrintIRInstrumentation::registerCallbacks(
807 PassInstrumentationCallbacks &PIC) {
808 this->PIC = &PIC;
809
810 // BeforePass callback is not just for printing, it also saves a Module
811 // for later use in AfterPassInvalidated.
812 if (shouldPrintBeforeSomePass() || shouldPrintAfterSomePass())
813 PIC.registerBeforeNonSkippedPassCallback(
814 [this](StringRef P, Any IR) { this->printBeforePass(P, IR); });
815
816 if (shouldPrintAfterSomePass()) {
817 PIC.registerAfterPassCallback(
818 [this](StringRef P, Any IR, const PreservedAnalyses &) {
819 this->printAfterPass(P, IR);
820 });
821 PIC.registerAfterPassInvalidatedCallback(
822 [this](StringRef P, const PreservedAnalyses &) {
823 this->printAfterPassInvalidated(P);
824 });
825 }
826 }
827
registerCallbacks(PassInstrumentationCallbacks & PIC)828 void OptNoneInstrumentation::registerCallbacks(
829 PassInstrumentationCallbacks &PIC) {
830 PIC.registerShouldRunOptionalPassCallback(
831 [this](StringRef P, Any IR) { return this->shouldRun(P, IR); });
832 }
833
shouldRun(StringRef PassID,Any IR)834 bool OptNoneInstrumentation::shouldRun(StringRef PassID, Any IR) {
835 const Function *F = nullptr;
836 if (any_isa<const Function *>(IR)) {
837 F = any_cast<const Function *>(IR);
838 } else if (any_isa<const Loop *>(IR)) {
839 F = any_cast<const Loop *>(IR)->getHeader()->getParent();
840 }
841 bool ShouldRun = !(F && F->hasOptNone());
842 if (!ShouldRun && DebugLogging) {
843 errs() << "Skipping pass " << PassID << " on " << F->getName()
844 << " due to optnone attribute\n";
845 }
846 return ShouldRun;
847 }
848
registerCallbacks(PassInstrumentationCallbacks & PIC)849 void OptBisectInstrumentation::registerCallbacks(
850 PassInstrumentationCallbacks &PIC) {
851 if (!OptBisector->isEnabled())
852 return;
853 PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, Any IR) {
854 return isIgnored(PassID) || OptBisector->checkPass(PassID, getIRName(IR));
855 });
856 }
857
print()858 raw_ostream &PrintPassInstrumentation::print() {
859 if (Opts.Indent) {
860 assert(Indent >= 0);
861 dbgs().indent(Indent);
862 }
863 return dbgs();
864 }
865
registerCallbacks(PassInstrumentationCallbacks & PIC)866 void PrintPassInstrumentation::registerCallbacks(
867 PassInstrumentationCallbacks &PIC) {
868 if (!Enabled)
869 return;
870
871 std::vector<StringRef> SpecialPasses;
872 if (!Opts.Verbose) {
873 SpecialPasses.emplace_back("PassManager");
874 SpecialPasses.emplace_back("PassAdaptor");
875 }
876
877 PIC.registerBeforeSkippedPassCallback(
878 [this, SpecialPasses](StringRef PassID, Any IR) {
879 assert(!isSpecialPass(PassID, SpecialPasses) &&
880 "Unexpectedly skipping special pass");
881
882 print() << "Skipping pass: " << PassID << " on " << getIRName(IR)
883 << "\n";
884 });
885 PIC.registerBeforeNonSkippedPassCallback([this, SpecialPasses](
886 StringRef PassID, Any IR) {
887 if (isSpecialPass(PassID, SpecialPasses))
888 return;
889
890 print() << "Running pass: " << PassID << " on " << getIRName(IR) << "\n";
891 Indent += 2;
892 });
893 PIC.registerAfterPassCallback(
894 [this, SpecialPasses](StringRef PassID, Any IR,
895 const PreservedAnalyses &) {
896 if (isSpecialPass(PassID, SpecialPasses))
897 return;
898
899 Indent -= 2;
900 });
901 PIC.registerAfterPassInvalidatedCallback(
902 [this, SpecialPasses](StringRef PassID, Any IR) {
903 if (isSpecialPass(PassID, SpecialPasses))
904 return;
905
906 Indent -= 2;
907 });
908
909 if (!Opts.SkipAnalyses) {
910 PIC.registerBeforeAnalysisCallback([this](StringRef PassID, Any IR) {
911 print() << "Running analysis: " << PassID << " on " << getIRName(IR)
912 << "\n";
913 Indent += 2;
914 });
915 PIC.registerAfterAnalysisCallback(
916 [this](StringRef PassID, Any IR) { Indent -= 2; });
917 PIC.registerAnalysisInvalidatedCallback([this](StringRef PassID, Any IR) {
918 print() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
919 << "\n";
920 });
921 PIC.registerAnalysesClearedCallback([this](StringRef IRName) {
922 print() << "Clearing all analysis results for: " << IRName << "\n";
923 });
924 }
925 }
926
CFG(const Function * F,bool TrackBBLifetime)927 PreservedCFGCheckerInstrumentation::CFG::CFG(const Function *F,
928 bool TrackBBLifetime) {
929 if (TrackBBLifetime)
930 BBGuards = DenseMap<intptr_t, BBGuard>(F->size());
931 for (const auto &BB : *F) {
932 if (BBGuards)
933 BBGuards->try_emplace(intptr_t(&BB), &BB);
934 for (auto *Succ : successors(&BB)) {
935 Graph[&BB][Succ]++;
936 if (BBGuards)
937 BBGuards->try_emplace(intptr_t(Succ), Succ);
938 }
939 }
940 }
941
printBBName(raw_ostream & out,const BasicBlock * BB)942 static void printBBName(raw_ostream &out, const BasicBlock *BB) {
943 if (BB->hasName()) {
944 out << BB->getName() << "<" << BB << ">";
945 return;
946 }
947
948 if (!BB->getParent()) {
949 out << "unnamed_removed<" << BB << ">";
950 return;
951 }
952
953 if (BB->isEntryBlock()) {
954 out << "entry"
955 << "<" << BB << ">";
956 return;
957 }
958
959 unsigned FuncOrderBlockNum = 0;
960 for (auto &FuncBB : *BB->getParent()) {
961 if (&FuncBB == BB)
962 break;
963 FuncOrderBlockNum++;
964 }
965 out << "unnamed_" << FuncOrderBlockNum << "<" << BB << ">";
966 }
967
printDiff(raw_ostream & out,const CFG & Before,const CFG & After)968 void PreservedCFGCheckerInstrumentation::CFG::printDiff(raw_ostream &out,
969 const CFG &Before,
970 const CFG &After) {
971 assert(!After.isPoisoned());
972 if (Before.isPoisoned()) {
973 out << "Some blocks were deleted\n";
974 return;
975 }
976
977 // Find and print graph differences.
978 if (Before.Graph.size() != After.Graph.size())
979 out << "Different number of non-leaf basic blocks: before="
980 << Before.Graph.size() << ", after=" << After.Graph.size() << "\n";
981
982 for (auto &BB : Before.Graph) {
983 auto BA = After.Graph.find(BB.first);
984 if (BA == After.Graph.end()) {
985 out << "Non-leaf block ";
986 printBBName(out, BB.first);
987 out << " is removed (" << BB.second.size() << " successors)\n";
988 }
989 }
990
991 for (auto &BA : After.Graph) {
992 auto BB = Before.Graph.find(BA.first);
993 if (BB == Before.Graph.end()) {
994 out << "Non-leaf block ";
995 printBBName(out, BA.first);
996 out << " is added (" << BA.second.size() << " successors)\n";
997 continue;
998 }
999
1000 if (BB->second == BA.second)
1001 continue;
1002
1003 out << "Different successors of block ";
1004 printBBName(out, BA.first);
1005 out << " (unordered):\n";
1006 out << "- before (" << BB->second.size() << "): ";
1007 for (auto &SuccB : BB->second) {
1008 printBBName(out, SuccB.first);
1009 if (SuccB.second != 1)
1010 out << "(" << SuccB.second << "), ";
1011 else
1012 out << ", ";
1013 }
1014 out << "\n";
1015 out << "- after (" << BA.second.size() << "): ";
1016 for (auto &SuccA : BA.second) {
1017 printBBName(out, SuccA.first);
1018 if (SuccA.second != 1)
1019 out << "(" << SuccA.second << "), ";
1020 else
1021 out << ", ";
1022 }
1023 out << "\n";
1024 }
1025 }
1026
1027 // PreservedCFGCheckerInstrumentation uses PreservedCFGCheckerAnalysis to check
1028 // passes, that reported they kept CFG analyses up-to-date, did not actually
1029 // change CFG. This check is done as follows. Before every functional pass in
1030 // BeforeNonSkippedPassCallback a CFG snapshot (an instance of
1031 // PreservedCFGCheckerInstrumentation::CFG) is requested from
1032 // FunctionAnalysisManager as a result of PreservedCFGCheckerAnalysis. When the
1033 // functional pass finishes and reports that CFGAnalyses or AllAnalyses are
1034 // up-to-date then the cached result of PreservedCFGCheckerAnalysis (if
1035 // available) is checked to be equal to a freshly created CFG snapshot.
1036 struct PreservedCFGCheckerAnalysis
1037 : public AnalysisInfoMixin<PreservedCFGCheckerAnalysis> {
1038 friend AnalysisInfoMixin<PreservedCFGCheckerAnalysis>;
1039
1040 static AnalysisKey Key;
1041
1042 public:
1043 /// Provide the result type for this analysis pass.
1044 using Result = PreservedCFGCheckerInstrumentation::CFG;
1045
1046 /// Run the analysis pass over a function and produce CFG.
runPreservedCFGCheckerAnalysis1047 Result run(Function &F, FunctionAnalysisManager &FAM) {
1048 return Result(&F, /* TrackBBLifetime */ true);
1049 }
1050 };
1051
1052 AnalysisKey PreservedCFGCheckerAnalysis::Key;
1053
invalidate(Function & F,const PreservedAnalyses & PA,FunctionAnalysisManager::Invalidator &)1054 bool PreservedCFGCheckerInstrumentation::CFG::invalidate(
1055 Function &F, const PreservedAnalyses &PA,
1056 FunctionAnalysisManager::Invalidator &) {
1057 auto PAC = PA.getChecker<PreservedCFGCheckerAnalysis>();
1058 return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
1059 PAC.preservedSet<CFGAnalyses>());
1060 }
1061
registerCallbacks(PassInstrumentationCallbacks & PIC,FunctionAnalysisManager & FAM)1062 void PreservedCFGCheckerInstrumentation::registerCallbacks(
1063 PassInstrumentationCallbacks &PIC, FunctionAnalysisManager &FAM) {
1064 if (!VerifyPreservedCFG)
1065 return;
1066
1067 FAM.registerPass([&] { return PreservedCFGCheckerAnalysis(); });
1068
1069 auto checkCFG = [](StringRef Pass, StringRef FuncName, const CFG &GraphBefore,
1070 const CFG &GraphAfter) {
1071 if (GraphAfter == GraphBefore)
1072 return;
1073
1074 dbgs() << "Error: " << Pass
1075 << " does not invalidate CFG analyses but CFG changes detected in "
1076 "function @"
1077 << FuncName << ":\n";
1078 CFG::printDiff(dbgs(), GraphBefore, GraphAfter);
1079 report_fatal_error(Twine("CFG unexpectedly changed by ", Pass));
1080 };
1081
1082 PIC.registerBeforeNonSkippedPassCallback(
1083 [this, &FAM](StringRef P, Any IR) {
1084 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1085 assert(&PassStack.emplace_back(P));
1086 #endif
1087 (void)this;
1088 if (!any_isa<const Function *>(IR))
1089 return;
1090
1091 const auto *F = any_cast<const Function *>(IR);
1092 // Make sure a fresh CFG snapshot is available before the pass.
1093 FAM.getResult<PreservedCFGCheckerAnalysis>(*const_cast<Function *>(F));
1094 });
1095
1096 PIC.registerAfterPassInvalidatedCallback(
1097 [this](StringRef P, const PreservedAnalyses &PassPA) {
1098 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1099 assert(PassStack.pop_back_val() == P &&
1100 "Before and After callbacks must correspond");
1101 #endif
1102 (void)this;
1103 });
1104
1105 PIC.registerAfterPassCallback([this, &FAM,
1106 checkCFG](StringRef P, Any IR,
1107 const PreservedAnalyses &PassPA) {
1108 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1109 assert(PassStack.pop_back_val() == P &&
1110 "Before and After callbacks must correspond");
1111 #endif
1112 (void)this;
1113
1114 if (!any_isa<const Function *>(IR))
1115 return;
1116
1117 if (!PassPA.allAnalysesInSetPreserved<CFGAnalyses>() &&
1118 !PassPA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>())
1119 return;
1120
1121 const auto *F = any_cast<const Function *>(IR);
1122 if (auto *GraphBefore = FAM.getCachedResult<PreservedCFGCheckerAnalysis>(
1123 *const_cast<Function *>(F)))
1124 checkCFG(P, F->getName(), *GraphBefore,
1125 CFG(F, /* TrackBBLifetime */ false));
1126 });
1127 }
1128
registerCallbacks(PassInstrumentationCallbacks & PIC)1129 void VerifyInstrumentation::registerCallbacks(
1130 PassInstrumentationCallbacks &PIC) {
1131 PIC.registerAfterPassCallback(
1132 [this](StringRef P, Any IR, const PreservedAnalyses &PassPA) {
1133 if (isIgnored(P) || P == "VerifierPass")
1134 return;
1135 if (any_isa<const Function *>(IR) || any_isa<const Loop *>(IR)) {
1136 const Function *F;
1137 if (any_isa<const Loop *>(IR))
1138 F = any_cast<const Loop *>(IR)->getHeader()->getParent();
1139 else
1140 F = any_cast<const Function *>(IR);
1141 if (DebugLogging)
1142 dbgs() << "Verifying function " << F->getName() << "\n";
1143
1144 if (verifyFunction(*F))
1145 report_fatal_error("Broken function found, compilation aborted!");
1146 } else if (any_isa<const Module *>(IR) ||
1147 any_isa<const LazyCallGraph::SCC *>(IR)) {
1148 const Module *M;
1149 if (any_isa<const LazyCallGraph::SCC *>(IR))
1150 M = any_cast<const LazyCallGraph::SCC *>(IR)
1151 ->begin()
1152 ->getFunction()
1153 .getParent();
1154 else
1155 M = any_cast<const Module *>(IR);
1156 if (DebugLogging)
1157 dbgs() << "Verifying module " << M->getName() << "\n";
1158
1159 if (verifyModule(*M))
1160 report_fatal_error("Broken module found, compilation aborted!");
1161 }
1162 });
1163 }
1164
~InLineChangePrinter()1165 InLineChangePrinter::~InLineChangePrinter() {}
1166
generateIRRepresentation(Any IR,StringRef PassID,ChangedIRData & D)1167 void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
1168 ChangedIRData &D) {
1169 ChangedIRComparer::analyzeIR(IR, D);
1170 }
1171
handleAfter(StringRef PassID,std::string & Name,const ChangedIRData & Before,const ChangedIRData & After,Any IR)1172 void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
1173 const ChangedIRData &Before,
1174 const ChangedIRData &After, Any IR) {
1175 SmallString<20> Banner =
1176 formatv("*** IR Dump After {0} on {1} ***\n", PassID, Name);
1177 Out << Banner;
1178 ChangedIRComparer(Out, Before, After, UseColour)
1179 .compare(IR, "", PassID, Name);
1180 Out << "\n";
1181 }
1182
same(const ChangedIRData & D1,const ChangedIRData & D2)1183 bool InLineChangePrinter::same(const ChangedIRData &D1,
1184 const ChangedIRData &D2) {
1185 return D1 == D2;
1186 }
1187
handleFunctionCompare(StringRef Name,StringRef Prefix,StringRef PassID,bool InModule,const ChangedFuncData & Before,const ChangedFuncData & After)1188 void ChangedIRComparer::handleFunctionCompare(StringRef Name, StringRef Prefix,
1189 StringRef PassID, bool InModule,
1190 const ChangedFuncData &Before,
1191 const ChangedFuncData &After) {
1192 // Print a banner when this is being shown in the context of a module
1193 if (InModule)
1194 Out << "\n*** IR for function " << Name << " ***\n";
1195
1196 ChangedFuncData::report(
1197 Before, After, [&](const ChangedBlockData *B, const ChangedBlockData *A) {
1198 StringRef BStr = B ? B->getBody() : "\n";
1199 StringRef AStr = A ? A->getBody() : "\n";
1200 const std::string Removed =
1201 UseColour ? "\033[31m-%l\033[0m\n" : "-%l\n";
1202 const std::string Added = UseColour ? "\033[32m+%l\033[0m\n" : "+%l\n";
1203 const std::string NoChange = " %l\n";
1204 Out << doSystemDiff(BStr, AStr, Removed, Added, NoChange);
1205 });
1206 }
1207
registerCallbacks(PassInstrumentationCallbacks & PIC)1208 void InLineChangePrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
1209 if (PrintChanged == ChangePrinter::PrintChangedDiffVerbose ||
1210 PrintChanged == ChangePrinter::PrintChangedDiffQuiet ||
1211 PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose ||
1212 PrintChanged == ChangePrinter::PrintChangedColourDiffQuiet)
1213 TextChangeReporter<ChangedIRData>::registerRequiredCallbacks(PIC);
1214 }
1215
StandardInstrumentations(bool DebugLogging,bool VerifyEach,PrintPassOptions PrintPassOpts)1216 StandardInstrumentations::StandardInstrumentations(
1217 bool DebugLogging, bool VerifyEach, PrintPassOptions PrintPassOpts)
1218 : PrintPass(DebugLogging, PrintPassOpts), OptNone(DebugLogging),
1219 PrintChangedIR(PrintChanged == ChangePrinter::PrintChangedVerbose),
1220 PrintChangedDiff(
1221 PrintChanged == ChangePrinter::PrintChangedDiffVerbose ||
1222 PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose,
1223 PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose ||
1224 PrintChanged == ChangePrinter::PrintChangedColourDiffQuiet),
1225 Verify(DebugLogging), VerifyEach(VerifyEach) {}
1226
registerCallbacks(PassInstrumentationCallbacks & PIC,FunctionAnalysisManager * FAM)1227 void StandardInstrumentations::registerCallbacks(
1228 PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM) {
1229 PrintIR.registerCallbacks(PIC);
1230 PrintPass.registerCallbacks(PIC);
1231 TimePasses.registerCallbacks(PIC);
1232 OptNone.registerCallbacks(PIC);
1233 OptBisect.registerCallbacks(PIC);
1234 if (FAM)
1235 PreservedCFGChecker.registerCallbacks(PIC, *FAM);
1236 PrintChangedIR.registerCallbacks(PIC);
1237 PseudoProbeVerification.registerCallbacks(PIC);
1238 if (VerifyEach)
1239 Verify.registerCallbacks(PIC);
1240 PrintChangedDiff.registerCallbacks(PIC);
1241 }
1242
1243 namespace llvm {
1244
1245 template class ChangeReporter<std::string>;
1246 template class TextChangeReporter<std::string>;
1247
1248 template class ChangeReporter<ChangedIRData>;
1249 template class TextChangeReporter<ChangedIRData>;
1250
1251 } // namespace llvm
1252