47#include <unordered_map>
48#include <unordered_set>
56#ifdef EXPENSIVE_CHECKS
68 cl::desc(
"Print before passes that change them"),
75 cl::desc(
"system dot used by change reporters"));
103 cl::desc(
"Generate dot files into specified directory for changed IRs"),
108 "print-on-crash-path",
109 cl::desc(
"Print the last form of the IR before crash to a file"),
114 cl::desc(
"Print the last form of the IR before crash (use -print-on-crash-path to dump to a file)"),
118 "opt-bisect-print-ir-path",
123 cl::desc(
"Print pass names and their ordinals"));
127 cl::desc(
"Print IR before the pass with this number as "
128 "reported by print-pass-numbers"));
132 cl::desc(
"Print IR after the pass with this number as "
133 "reported by print-pass-numbers"));
137 cl::desc(
"If specified, IR printed using the "
138 "-print-[before|after]{-all} options will be dumped into "
139 "files in this directory rather than written to stderr"),
143 const IRUnitT **IRPtr = llvm::any_cast<const IRUnitT *>(&
IR);
144 return IRPtr ? *IRPtr :
nullptr;
158 cl::desc(
"exe called with module IR after each pass that "
163const Module *unwrapModule(
Any IR,
bool Force =
false) {
164 if (
const auto *M = unwrapIR<Module>(
IR))
167 if (
const auto *
F = unwrapIR<Function>(
IR)) {
171 return F->getParent();
174 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR)) {
178 return F.getParent();
181 assert(!Force &&
"Expected a module");
185 if (
const auto *L = unwrapIR<Loop>(
IR)) {
186 const Function *
F =
L->getHeader()->getParent();
189 return F->getParent();
192 if (
const auto *MF = unwrapIR<MachineFunction>(
IR)) {
195 return MF->getFunction().getParent();
209 M->print(
OS,
nullptr);
211 for (
const auto &
F : M->functions()) {
227 const Function *
F =
L->getHeader()->getParent();
239std::string getIRName(
Any IR,
bool demangled =
false) {
240 if (unwrapIR<Module>(
IR))
243 if (
const auto *
F = unwrapIR<Function>(
IR))
246 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR))
249 if (
const auto *L = unwrapIR<Loop>(
IR))
250 return "loop %" + L->getName().str() +
" in function " +
251 L->getHeader()->getParent()->getName().str();
253 if (
const auto *MF = unwrapIR<MachineFunction>(
IR))
259bool moduleContainsFilterPrintFunc(
const Module &M) {
260 return any_of(M.functions(),
262 return isFunctionInPrintList(F.getName());
275bool shouldPrintIR(
Any IR) {
276 if (
const auto *M = unwrapIR<Module>(
IR))
277 return moduleContainsFilterPrintFunc(*M);
279 if (
const auto *
F = unwrapIR<Function>(
IR))
282 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR))
283 return sccContainsFilterPrintFunc(*
C);
285 if (
const auto *L = unwrapIR<Loop>(
IR))
288 if (
const auto *MF = unwrapIR<MachineFunction>(
IR))
296 if (!shouldPrintIR(
IR))
300 auto *
M = unwrapModule(
IR);
301 assert(M &&
"should have unwrapped module");
306 if (
const auto *M = unwrapIR<Module>(
IR)) {
311 if (
const auto *
F = unwrapIR<Function>(
IR)) {
316 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR)) {
321 if (
const auto *L = unwrapIR<Loop>(
IR)) {
326 if (
const auto *MF = unwrapIR<MachineFunction>(
IR)) {
336 {
"PassManager",
"PassAdaptor",
"AnalysisManagerProxy",
337 "DevirtSCCRepeatedPass",
"ModuleInlinerWrapperPass",
338 "VerifierPass",
"PrintModulePass",
"PrintMIRPass",
339 "PrintMIRPreparePass"});
347 S.append(Clean.
str());
351 S.append(SR[0] ==
'<' ?
"<" :
">");
359 if (
const auto *M = unwrapIR<Module>(
IR))
361 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR))
362 return C->begin()->getFunction().getParent();
366bool isInterestingFunction(
const Function &
F) {
375 if (
const auto *
F = unwrapIR<Function>(
IR))
376 return isInterestingFunction(*
F);
383 assert(BeforeStack.empty() &&
"Problem with Change Printer stack.");
399 BeforeStack.emplace_back();
405 T &Data = BeforeStack.back();
406 generateIRRepresentation(
IR, PassID, Data);
412 assert(!BeforeStack.empty() &&
"Unexpected empty stack encountered.");
414 std::string
Name = getIRName(
IR);
416 if (isIgnored(PassID)) {
418 handleIgnored(PassID,
Name);
421 handleFiltered(PassID,
Name);
424 T &
Before = BeforeStack.back();
427 generateIRRepresentation(
IR, PassID,
After);
432 omitAfter(PassID,
Name);
436 BeforeStack.pop_back();
441 assert(!BeforeStack.empty() &&
"Unexpected empty stack encountered.");
448 handleInvalidated(PassID);
449 BeforeStack.pop_back();
465 handleInvalidatedPass(
P);
476 auto *M = unwrapModule(
IR,
true);
477 assert(M &&
"Expected module to be unwrapped when forced.");
478 Out <<
"*** IR Dump At Start ***\n";
479 M->print(Out,
nullptr);
484 Out <<
formatv(
"*** IR Dump After {0} on {1} omitted because no change ***\n",
490 Out <<
formatv(
"*** IR Pass {0} invalidated ***\n", PassID);
497 formatv(
"*** IR Dump After {0} on {1} filtered out ***\n", PassID,
Name);
503 Out <<
formatv(
"*** IR Pass {0} on {1} ignored ***\n", PassID,
Name);
515 std::string &Output) {
517 unwrapAndPrint(
OS,
IR);
522 const std::string &
Before,
526 Out <<
"*** IR Dump Before " << PassID <<
" on " <<
Name <<
" ***\n"
532 Out <<
"*** IR Deleted After " << PassID <<
" on " <<
Name <<
" ***\n";
536 Out <<
"*** IR Dump After " << PassID <<
" on " <<
Name <<
" ***\n" <<
After;
542 if (TestChanged !=
"")
552 dbgs() <<
"Unable to create temporary file.";
557 dbgs() <<
"Unable to find test-changed executable.";
561 StringRef Args[] = {TestChanged, FileName[0], PassID};
564 dbgs() <<
"Error executing test-changed executable.";
569 dbgs() <<
"Unable to remove temporary file.";
585 const std::string &
Before,
594 const auto &BFD =
Before.getData();
595 const auto &AFD =
After.getData();
596 std::vector<std::string>::const_iterator BI =
Before.getOrder().begin();
597 std::vector<std::string>::const_iterator BE =
Before.getOrder().end();
598 std::vector<std::string>::const_iterator AI =
After.getOrder().begin();
599 std::vector<std::string>::const_iterator AE =
After.getOrder().end();
601 auto HandlePotentiallyRemovedData = [&](std::string S) {
605 HandlePair(&BFD.find(*BI)->getValue(),
nullptr);
608 auto HandleNewData = [&](std::vector<const T *> &Q) {
610 for (
const T *NBI : Q)
611 HandlePair(
nullptr, NBI);
624 std::vector<const T *> NewDataQueue;
626 if (!BFD.count(*AI)) {
629 NewDataQueue.emplace_back(&AFD.find(*AI)->getValue());
638 while (BI != BE && *BI != *AI) {
639 HandlePotentiallyRemovedData(*BI);
643 HandleNewData(NewDataQueue);
645 const T &AData = AFD.find(*AI)->getValue();
646 const T &BData = BFD.find(*AI)->getValue();
647 HandlePair(&BData, &AData);
655 HandlePotentiallyRemovedData(*BI);
659 HandleNewData(NewDataQueue);
665 std::function<
void(
bool InModule,
unsigned Minor,
668 if (!CompareModule) {
671 "Expected only one function.");
672 CompareFunc(
false, 0,
Before.getData().begin()->getValue(),
673 After.getData().begin()->getValue());
681 assert((
B ||
A) &&
"Both functions cannot be missing.");
686 CompareFunc(
true, Minor++, *
B, *
A);
691 if (
const Module *M = getModuleForComparison(
IR)) {
694 generateFunctionData(
Data,
F);
698 if (
const auto *
F = unwrapIR<Function>(
IR)) {
699 generateFunctionData(
Data, *
F);
703 if (
const auto *L = unwrapIR<Loop>(
IR)) {
704 auto *
F = L->getHeader()->getParent();
705 generateFunctionData(
Data, *
F);
709 if (
const auto *MF = unwrapIR<MachineFunction>(
IR)) {
710 generateFunctionData(
Data, *MF);
726template <
typename FunctionT>
731 for (
const auto &
B :
F) {
732 std::string BBName =
B.getName().str();
733 if (BBName.empty()) {
740 Data.getOrder().emplace_back(
F.getName());
741 Data.getData().insert({
F.getName(), FD});
749 "PassRunDescriptorStack is not empty at exit");
757 unsigned int MaxHashWidth =
sizeof(
stable_hash) * 8 / 4;
759 if (unwrapIR<Module>(
IR)) {
760 ResultStream <<
"-module";
761 }
else if (
const auto *
F = unwrapIR<Function>(
IR)) {
762 ResultStream <<
"-function-";
766 }
else if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR)) {
767 ResultStream <<
"-scc-";
770 }
else if (
const auto *L = unwrapIR<Loop>(
IR)) {
771 ResultStream <<
"-loop-";
774 }
else if (
const auto *MF = unwrapIR<MachineFunction>(
IR)) {
775 ResultStream <<
"-machine-function-";
790 "The flag -ir-dump-directory must be passed to dump IR to files");
792 ResultPath += RootDirectory;
795 FilenameStream << CurrentPassNumber;
796 FilenameStream <<
"-";
798 FilenameStream <<
"-";
801 return std::string(ResultPath);
811 static constexpr std::array FileSuffixes = {
"-before.ll",
"-after.ll",
813 return FileSuffixes[
static_cast<size_t>(
Type)];
816void PrintIRInstrumentation::pushPassRunDescriptor(
820 PassRunDescriptor(M, DumpIRFilename, getIRName(
IR), PassID));
823PrintIRInstrumentation::PassRunDescriptor
824PrintIRInstrumentation::popPassRunDescriptor(
StringRef PassID) {
825 assert(!PassRunDescriptorStack.
empty() &&
"empty PassRunDescriptorStack");
826 PassRunDescriptor Descriptor = PassRunDescriptorStack.
pop_back_val();
827 assert(Descriptor.PassID == PassID &&
"malformed PassRunDescriptorStack");
835 if (!ParentPath.empty()) {
839 " to support -ir-dump-directory: " + EC.message());
846 " to support -ir-dump-directory: " + EC.message());
850void PrintIRInstrumentation::printBeforePass(
StringRef PassID,
Any IR) {
851 if (isIgnored(PassID))
854 std::string DumpIRFilename;
856 (shouldPrintBeforePass(PassID) || shouldPrintAfterPass(PassID) ||
857 shouldPrintBeforeCurrentPassNumber() ||
858 shouldPrintAfterCurrentPassNumber()))
859 DumpIRFilename = fetchDumpFilename(PassID,
IR);
865 if (shouldPrintAfterPass(PassID))
866 pushPassRunDescriptor(PassID,
IR, DumpIRFilename);
868 if (!shouldPrintIR(
IR))
873 if (shouldPrintPassNumbers())
874 dbgs() <<
" Running pass " << CurrentPassNumber <<
" " << PassID
875 <<
" on " << getIRName(
IR) <<
"\n";
877 if (shouldPrintAfterCurrentPassNumber())
878 pushPassRunDescriptor(PassID,
IR, DumpIRFilename);
880 if (!shouldPrintBeforePass(PassID) && !shouldPrintBeforeCurrentPassNumber())
884 Stream <<
"; *** IR Dump Before ";
885 if (shouldPrintBeforeSomePassNumber())
886 Stream << CurrentPassNumber <<
"-";
887 Stream << PassID <<
" on " << getIRName(
IR) <<
" ***\n";
888 unwrapAndPrint(Stream,
IR);
891 if (!DumpIRFilename.empty()) {
892 DumpIRFilename +=
getFileSuffix(IRDumpFileSuffixType::Before);
895 WriteIRToStream(DumpIRFileStream);
897 WriteIRToStream(
dbgs());
901void PrintIRInstrumentation::printAfterPass(
StringRef PassID,
Any IR) {
902 if (isIgnored(PassID))
905 if (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber())
908 auto [
M, DumpIRFilename, IRName, StoredPassID] = popPassRunDescriptor(PassID);
909 assert(StoredPassID == PassID &&
"mismatched PassID");
911 if (!shouldPrintIR(
IR) ||
912 (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber()))
916 Stream <<
"; *** IR Dump After ";
917 if (shouldPrintAfterSomePassNumber())
918 Stream << CurrentPassNumber <<
"-";
919 Stream <<
StringRef(
formatv(
"{0}", PassID)) <<
" on " << IRName <<
" ***\n";
920 unwrapAndPrint(Stream,
IR);
924 assert(!DumpIRFilename.empty() &&
"DumpIRFilename must not be empty and "
925 "should be set in printBeforePass");
926 const std::string DumpIRFilenameWithSuffix =
931 WriteIRToStream(DumpIRFileStream, IRName);
933 WriteIRToStream(
dbgs(), IRName);
937void PrintIRInstrumentation::printAfterPassInvalidated(
StringRef PassID) {
938 if (isIgnored(PassID))
941 if (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber())
944 auto [
M, DumpIRFilename, IRName, StoredPassID] = popPassRunDescriptor(PassID);
945 assert(StoredPassID == PassID &&
"mismatched PassID");
949 (!shouldPrintAfterPass(PassID) && !shouldPrintAfterCurrentPassNumber()))
955 Banner =
formatv(
"; *** IR Dump After {0} on {1} (invalidated) ***", PassID,
957 Stream << Banner <<
"\n";
962 assert(!DumpIRFilename.empty() &&
"DumpIRFilename must not be empty and "
963 "should be set in printBeforePass");
964 const std::string DumpIRFilenameWithSuffix =
969 WriteIRToStream(DumpIRFileStream, M, IRName);
971 WriteIRToStream(
dbgs(), M, IRName);
975bool PrintIRInstrumentation::shouldPrintBeforePass(
StringRef PassID) {
983bool PrintIRInstrumentation::shouldPrintAfterPass(
StringRef PassID) {
991bool PrintIRInstrumentation::shouldPrintBeforeCurrentPassNumber() {
992 return shouldPrintBeforeSomePassNumber() &&
996bool PrintIRInstrumentation::shouldPrintAfterCurrentPassNumber() {
997 return shouldPrintAfterSomePassNumber() &&
1001bool PrintIRInstrumentation::shouldPrintPassNumbers() {
1005bool PrintIRInstrumentation::shouldPrintBeforeSomePassNumber() {
1009bool PrintIRInstrumentation::shouldPrintAfterSomePassNumber() {
1020 if (shouldPrintPassNumbers() || shouldPrintBeforeSomePassNumber() ||
1029 this->printAfterPass(
P,
IR);
1033 this->printAfterPassInvalidated(
P);
1044bool OptNoneInstrumentation::shouldRun(
StringRef PassID,
Any IR) {
1045 const auto *
F = unwrapIR<Function>(
IR);
1047 if (
const auto *L = unwrapIR<Loop>(
IR))
1048 F = L->getHeader()->getParent();
1050 bool ShouldRun = !(
F &&
F->hasOptNone());
1051 if (!ShouldRun && DebugLogging) {
1052 errs() <<
"Skipping pass " << PassID <<
" on " <<
F->getName()
1053 <<
" due to optnone attribute\n";
1067 this->HasWrittenIR =
true;
1068 const Module *M = unwrapModule(
IR,
true);
1069 assert((M && &M->getContext() == &Context) &&
"Missing/Mismatching Module");
1074 M->print(
OS,
nullptr);
1103 std::vector<StringRef> SpecialPasses;
1105 SpecialPasses.emplace_back(
"PassManager");
1106 SpecialPasses.emplace_back(
"PassAdaptor");
1112 "Unexpectedly skipping special pass");
1114 print() <<
"Skipping pass: " << PassID <<
" on " << getIRName(
IR) <<
"\n";
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";
1129 }
else if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR)) {
1130 int Count =
C->size();
1131 OS <<
" (" << Count <<
" node";
1157 print() <<
"Running analysis: " << PassID <<
" on " << getIRName(
IR)
1164 print() <<
"Invalidating analysis: " << PassID <<
" on " << getIRName(
IR)
1168 print() <<
"Clearing all analysis results for: " << IRName <<
"\n";
1174 bool TrackBBLifetime) {
1175 if (TrackBBLifetime)
1177 for (
const auto &BB : *
F) {
1179 BBGuards->try_emplace(intptr_t(&BB), &BB);
1183 BBGuards->try_emplace(intptr_t(Succ), Succ);
1190 out << BB->
getName() <<
"<" << BB <<
">";
1195 out <<
"unnamed_removed<" << BB <<
">";
1201 <<
"<" << BB <<
">";
1205 unsigned FuncOrderBlockNum = 0;
1209 FuncOrderBlockNum++;
1211 out <<
"unnamed_" << FuncOrderBlockNum <<
"<" << BB <<
">";
1218 if (
Before.isPoisoned()) {
1219 out <<
"Some blocks were deleted\n";
1225 out <<
"Different number of non-leaf basic blocks: before="
1226 <<
Before.Graph.size() <<
", after=" <<
After.Graph.size() <<
"\n";
1228 for (
auto &BB :
Before.Graph) {
1229 auto BA =
After.Graph.find(BB.first);
1230 if (BA ==
After.Graph.end()) {
1231 out <<
"Non-leaf block ";
1233 out <<
" is removed (" << BB.second.size() <<
" successors)\n";
1237 for (
auto &BA :
After.Graph) {
1238 auto BB =
Before.Graph.find(BA.first);
1239 if (BB ==
Before.Graph.end()) {
1240 out <<
"Non-leaf block ";
1242 out <<
" is added (" << BA.second.size() <<
" successors)\n";
1246 if (BB->second == BA.second)
1249 out <<
"Different successors of block ";
1251 out <<
" (unordered):\n";
1252 out <<
"- before (" << BB->second.size() <<
"): ";
1253 for (
auto &SuccB : BB->second) {
1255 if (SuccB.second != 1)
1256 out <<
"(" << SuccB.second <<
"), ";
1261 out <<
"- after (" << BA.second.size() <<
"): ";
1262 for (
auto &SuccA : BA.second) {
1264 if (SuccA.second != 1)
1265 out <<
"(" << SuccA.second <<
"), ";
1345 if (
const auto *MaybeF = unwrapIR<Function>(
IR)) {
1347 }
else if (
const auto *MaybeM = unwrapIR<Module>(
IR)) {
1359 bool Registered =
false;
1362#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1363 assert(&PassStack.emplace_back(
P));
1368 *
const_cast<Module *
>(unwrapModule(
IR,
true)))
1383 if (
const auto *MPtr = unwrapIR<Module>(
IR)) {
1384 auto &M = *
const_cast<Module *
>(MPtr);
1391#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1392 assert(PassStack.pop_back_val() ==
P &&
1393 "Before and After callbacks must correspond");
1400#ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
1401 assert(PassStack.pop_back_val() ==
P &&
1402 "Before and After callbacks must correspond");
1410 *
const_cast<Module *
>(unwrapModule(
IR,
true)))
1414 if (
auto *HashBefore =
1418 "Function @{0} changed by {1} without invalidating analyses",
1424 const CFG &GraphBefore,
const CFG &GraphAfter) {
1425 if (GraphAfter == GraphBefore)
1429 <<
"Error: " <<
Pass
1430 <<
" does not invalidate CFG analyses but CFG changes detected in "
1432 << FuncName <<
":\n";
1437 if (
auto *GraphBefore =
1439 CheckCFG(
P,
F->getName(), *GraphBefore,
1442 if (
const auto *MPtr = unwrapIR<Module>(
IR)) {
1443 auto &M = *
const_cast<Module *
>(MPtr);
1444 if (
auto *HashBefore =
1448 "Module changed by {0} without invalidating analyses",
P));
1459 if (isIgnored(
P) ||
P ==
"VerifierPass")
1461 const auto *
F = unwrapIR<Function>(
IR);
1463 if (
const auto *L = unwrapIR<Loop>(
IR))
1464 F = L->getHeader()->getParent();
1469 dbgs() <<
"Verifying function " <<
F->getName() <<
"\n";
1473 "\"{0}\", compilation aborted!",
1476 const auto *M = unwrapIR<Module>(
IR);
1478 if (
const auto *
C = unwrapIR<LazyCallGraph::SCC>(
IR))
1479 M =
C->begin()->getFunction().getParent();
1484 dbgs() <<
"Verifying module " << M->getName() <<
"\n";
1488 "\"{0}\", compilation aborted!",
1492 if (
auto *MF = unwrapIR<MachineFunction>(
IR)) {
1494 dbgs() <<
"Verifying machine function " << MF->
getName() <<
'\n';
1495 std::string Banner =
1496 formatv(
"Broken machine function found after pass "
1497 "\"{0}\", compilation aborted!",
1527 formatv(
"*** IR Dump After {0} on {1} ***\n", PassID,
Name);
1531 [&](
bool InModule,
unsigned Minor,
1534 handleFunctionCompare(
Name,
"", PassID,
" on ", InModule,
1546 Out <<
"\n*** IR for function " <<
Name <<
" ***\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(BStr, AStr, Removed, Added, NoChange);
1579 this->runAfterPass();
1591void TimeProfilingPassesHandler::runBeforePass(
StringRef PassID,
Any IR) {
1600class DotCfgDiffDisplayGraph;
1603class DisplayElement {
1606 StringRef getColour()
const {
return Colour; }
1609 DisplayElement(
StringRef Colour) : Colour(Colour) {}
1615class DisplayEdge :
public DisplayElement {
1620 std::string getValue()
const {
return Value; }
1622 const DisplayNode &getDestinationNode()
const {
return Node; }
1626 const DisplayNode &
Node;
1630class DisplayNode :
public DisplayElement {
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(); }
1643 using EdgeIterator = std::vector<DisplayEdge *>::const_iterator;
1644 EdgeIterator edges_begin()
const {
return EdgePtrs.cbegin(); }
1645 EdgeIterator edges_end()
const {
return EdgePtrs.cend(); }
1651 std::string getContent()
const {
return Content; }
1654 const DisplayEdge &getEdge(
const DisplayNode &To)
const {
1655 assert(EdgeMap.find(&To) != EdgeMap.end() &&
"Expected to find edge.");
1656 return *EdgeMap.find(&To)->second;
1661 std::string getEdgeSourceLabel(
const DisplayNode &Sink)
const {
1662 return getEdge(Sink).getValue();
1665 void createEdgeMap();
1673 std::vector<DisplayEdge> Edges;
1675 std::vector<DisplayEdge *> EdgePtrs;
1676 std::unordered_set<DisplayNode *>
Children;
1677 std::unordered_map<const DisplayNode *, const DisplayEdge *> EdgeMap;
1680 bool AllEdgesCreated =
false;
1684class DotCfgDiffDisplayGraph {
1686 DotCfgDiffDisplayGraph(std::string
Name) : GraphName(
Name) {}
1689 void generateDotFile(
StringRef DotFile);
1692 using NodeIterator = std::vector<DisplayNode *>::const_iterator;
1693 NodeIterator nodes_begin()
const {
1694 assert(NodeGenerationComplete &&
"Unexpected children iterator creation");
1695 return NodePtrs.cbegin();
1697 NodeIterator nodes_end()
const {
1698 assert(NodeGenerationComplete &&
"Unexpected children iterator creation");
1699 return NodePtrs.cend();
1704 void setEntryNode(
unsigned N) {
1706 assert(!NodeGenerationComplete &&
"Unexpected node creation");
1707 NodeGenerationComplete =
true;
1708 for (
auto &
N : Nodes)
1709 NodePtrs.emplace_back(&
N);
1711 EntryNode = NodePtrs[
N];
1715 void createNode(std::string
C,
StringRef Colour) {
1716 assert(!NodeGenerationComplete &&
"Unexpected node creation");
1717 Nodes.emplace_back(
C, Colour);
1721 assert(
N < Nodes.size() &&
"Node is out of bounds");
1724 unsigned size()
const {
1725 assert(NodeGenerationComplete &&
"Unexpected children iterator creation");
1726 return Nodes.size();
1730 std::string getGraphName()
const {
return GraphName; }
1735 return Node.getContent();
1739 std::string getNodeAttributes(
const DisplayNode &
Node)
const {
1740 return attribute(
Node.getColour());
1744 std::string getEdgeColorAttr(
const DisplayNode &
From,
1745 const DisplayNode &To)
const {
1746 return attribute(
From.getEdge(To).getColour());
1750 DisplayNode *getEntryNode()
const {
1751 assert(NodeGenerationComplete &&
"Unexpected children iterator creation");
1757 std::string attribute(
StringRef Colour)
const {
1758 return "color=" + Colour.
str();
1761 bool NodeGenerationComplete =
false;
1762 const std::string GraphName;
1763 std::vector<DisplayNode> Nodes;
1764 std::vector<DisplayNode *> NodePtrs;
1765 DisplayNode *EntryNode =
nullptr;
1770 assert(!AllEdgesCreated &&
"Expected to be able to still create edges.");
1771 Edges.emplace_back(
Value.str(),
Node, Colour);
1775void DisplayNode::createEdgeMap() {
1778 AllEdgesCreated =
true;
1779 for (
auto &E : Edges)
1780 EdgeMap.insert({&E.getDestinationNode(), &E});
1783class DotCfgDiffNode;
1787class DotCfgDiffNode {
1789 DotCfgDiffNode() =
delete;
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]},
1801 unsigned getIndex()
const {
return N; }
1805 assert(Data[0] &&
"Expected Data[0] to be set.");
1806 return Data[0]->getLabel();
1809 StringRef getColour()
const {
return Colour; }
1813 assert(!Data[1] &&
"Expected only one block datum");
1821 "Unexpected edge count and color.");
1822 EdgesMap[
E] = {
Value.str(), Colour};
1828 StringRef getEdgeColour(
const unsigned S)
const {
1829 assert(EdgesMap.count(S) == 1 &&
"Expected to find edge.");
1830 return EdgesMap.at(S).second;
1834 std::string getBodyContent()
const;
1836 void createDisplayEdges(DotCfgDiffDisplayGraph &Graph,
unsigned DisplayNode,
1837 std::map<const unsigned, unsigned> &NodeMap)
const;
1844 std::map<const unsigned, std::pair<std::string, StringRef>> EdgesMap;
1846 std::vector<unsigned> Edges;
1859 DotCfgDiff(
const DotCfgDiff &) =
delete;
1860 DotCfgDiff &operator=(
const DotCfgDiff &) =
delete;
1862 DotCfgDiffDisplayGraph createDisplayGraph(
StringRef Title,
1869 StringRef getEdgeSourceLabel(
const unsigned &Source,
1870 const unsigned &Sink)
const {
1872 getNode(Source).getLabel().str() +
" " +
getNode(Sink).getLabel().str();
1873 assert(EdgeLabels.count(S) == 1 &&
"Expected to find edge label.");
1874 return EdgeLabels.find(S)->getValue();
1878 unsigned size()
const {
return Nodes.size(); }
1880 const DotCfgDiffNode &
getNode(
unsigned N)
const {
1881 assert(
N < Nodes.size() &&
"Unexpected index for node reference");
1887 std::string colourize(std::string S,
StringRef Colour)
const;
1890 unsigned Pos = Nodes.size();
1891 Nodes.emplace_back(*
this, Pos, BD,
C);
1892 NodePosition.insert({
Label, Pos});
1898 std::vector<DotCfgDiffNode> Nodes;
1900 const std::string GraphName;
1905std::string DotCfgDiffNode::getBodyContent()
const {
1907 assert(
Data[1] &&
"Expected Data[1] to be set.");
1910 for (
unsigned I = 0;
I < 2; ++
I) {
1911 SR[
I] =
Data[
I]->getBody();
1915 SR[
I] = SR[
I].
drop_until([](
char C) {
return C ==
'\n'; }).drop_front();
1919 "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>",
BeforeColour);
1921 "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>",
AfterColour);
1923 "<FONT COLOR=\"{0}\">%l</FONT><BR align=\"left\"/>",
CommonColour);
1924 std::string Diff =
Data[0]->getLabel().str();
1925 Diff +=
":\n<BR align=\"left\"/>" +
1926 doSystemDiff(makeHTMLReady(SR[0]), makeHTMLReady(SR[1]),
1927 OldLineFormat, NewLineFormat, UnchangedLineFormat);
1932 Regex R(
"<FONT COLOR=\"\\w+\"></FONT>");
1935 std::string S =
R.sub(
"", Diff, &
Error);
1946 assert(!
Data[1] &&
"Data[1] is set unexpectedly.");
1947 std::string Body = makeHTMLReady(
Data[0]->getBody());
1951 if (BS.
front() ==
'\n')
1956 BS1 = BS1.
drop_until([](
char C) {
return C ==
'\n'; }).drop_front();
1958 std::string S =
"<FONT COLOR=\"" + Colour.
str() +
"\">" +
Label.str() +
":";
1961 while (BS1.
size()) {
1962 S.append(
"<BR align=\"left\"/>");
1964 S.append(
Line.str());
1967 S.append(
"<BR align=\"left\"/></FONT>");
1971std::string DotCfgDiff::colourize(std::string S,
StringRef Colour)
const {
1972 if (S.length() == 0)
1974 return "<FONT COLOR=\"" + Colour.
str() +
"\">" + S +
"</FONT>";
1979 : GraphName(Title.str()) {
1983 for (
auto &
B :
Before.getData()) {
1992 Sink != E; ++Sink) {
1993 std::string
Key = (
Label +
" " +
Sink->getKey().str()).str() +
" " +
1994 BD.
getData().getSuccessorLabel(
Sink->getKey()).str();
2000 for (
auto &
A :
After.getData()) {
2003 unsigned C = NodePosition.count(Label);
2008 assert(
C == 1 &&
"Unexpected multiple nodes.");
2009 Nodes[NodePosition[
Label]].setCommon(BD);
2014 Sink != E; ++Sink) {
2015 std::string
Key = (
Label +
" " +
Sink->getKey().str()).str() +
" " +
2016 BD.
getData().getSuccessorLabel(
Sink->getKey()).str();
2017 unsigned C = EdgesMap.
count(Key);
2027 for (
auto &E : EdgesMap) {
2030 auto SP1 = S.
rsplit(
' ');
2031 auto &SourceSink = SP1.first;
2032 auto SP2 = SourceSink.split(
' ');
2037 assert(NodePosition.count(Source) == 1 &&
"Expected to find node.");
2038 DotCfgDiffNode &SourceNode = Nodes[NodePosition[
Source]];
2039 assert(NodePosition.count(Sink) == 1 &&
"Expected to find node.");
2040 unsigned SinkNode = NodePosition[
Sink];
2044 if (EdgeLabels.count(SourceSink) == 0)
2045 EdgeLabels.insert({SourceSink, colourize(
Value.str(), Colour)});
2047 StringRef V = EdgeLabels.find(SourceSink)->getValue();
2048 std::string
NV = colourize(
V.str() +
" " +
Value.str(), Colour);
2050 EdgeLabels[SourceSink] =
NV;
2052 SourceNode.addEdge(SinkNode,
Value, Colour);
2054 for (
auto &
I : Nodes)
2058DotCfgDiffDisplayGraph DotCfgDiff::createDisplayGraph(
StringRef Title,
2060 assert(NodePosition.count(EntryNodeName) == 1 &&
2061 "Expected to find entry block in map.");
2062 unsigned Entry = NodePosition[EntryNodeName];
2063 assert(Entry < Nodes.size() &&
"Expected to find entry node");
2064 DotCfgDiffDisplayGraph
G(Title.
str());
2066 std::map<const unsigned, unsigned> NodeMap;
2068 int EntryIndex = -1;
2070 for (
auto &
I : Nodes) {
2071 if (
I.getIndex() == Entry)
2073 G.createNode(
I.getBodyContent(),
I.getColour());
2074 NodeMap.insert({
I.getIndex(),
Index++});
2076 assert(EntryIndex >= 0 &&
"Expected entry node index to be set.");
2077 G.setEntryNode(EntryIndex);
2079 for (
auto &
I : NodeMap) {
2080 unsigned SourceNode =
I.first;
2081 unsigned DisplayNode =
I.second;
2082 getNode(SourceNode).createDisplayEdges(
G, DisplayNode, NodeMap);
2087void DotCfgDiffNode::createDisplayEdges(
2088 DotCfgDiffDisplayGraph &
DisplayGraph,
unsigned DisplayNodeIndex,
2089 std::map<const unsigned, unsigned> &NodeMap)
const {
2091 DisplayNode &SourceDisplayNode =
DisplayGraph.getNode(DisplayNodeIndex);
2093 for (
auto I : Edges) {
2094 unsigned SinkNodeIndex =
I;
2095 StringRef Colour = getEdgeColour(SinkNodeIndex);
2096 const DotCfgDiffNode *SinkNode = &Graph.getNode(SinkNodeIndex);
2098 StringRef Label = Graph.getEdgeSourceLabel(getIndex(), SinkNodeIndex);
2099 DisplayNode &SinkDisplayNode =
DisplayGraph.getNode(SinkNode->getIndex());
2100 SourceDisplayNode.createEdge(Label, SinkDisplayNode, Colour);
2102 SourceDisplayNode.createEdgeMap();
2105void DotCfgDiffNode::finalize(DotCfgDiff &
G) {
2106 for (
auto E : EdgesMap) {
2108 Edges.emplace_back(E.first);
2124 return G->getEntryNode();
2127 return N->children_begin();
2131 return G->nodes_begin();
2134 return G->nodes_end();
2137 return N->edges_begin();
2141 static unsigned size(
const DotCfgDiffDisplayGraph *
G) {
return G->size(); }
2151 return DiffData->getGraphName();
2155 return "\tsize=\"190, 190\";\n";
2158 const DotCfgDiffDisplayGraph *DiffData) {
2159 return DiffData->getNodeLabel(*Node);
2162 const DotCfgDiffDisplayGraph *DiffData) {
2163 return DiffData->getNodeAttributes(*Node);
2166 DisplayNode::ChildIterator &To) {
2167 return From->getEdgeSourceLabel(**To);
2170 DisplayNode::ChildIterator &To,
2171 const DotCfgDiffDisplayGraph *DiffData) {
2172 return DiffData->getEdgeColorAttr(*
From, **To);
2180void DotCfgDiffDisplayGraph::generateDotFile(
StringRef DotFile) {
2184 errs() <<
"Error: " <<
EC.message() <<
"\n";
2199 if (
const BranchInst *Br = dyn_cast<const BranchInst>(Term))
2200 if (Br->isUnconditional())
2206 else if (
const SwitchInst *Sw = dyn_cast<const SwitchInst>(Term)) {
2209 for (
auto &
C : Sw->cases()) {
2210 assert(
C.getCaseValue() &&
"Expected to find case value.");
2231 assert(
HTML &&
"Expected outstream to be set");
2236 Extender =
formatv(
"{0}_{1}",
N, Minor);
2245 std::string DotFile =
Twine(SV).
str();
2250 Text =
formatv(
"{0}.{1}{2}{3}{4}",
Number, Prefix, makeHTMLReady(PassID),
2254 std::string EntryBlockName =
After.getEntryBlockName();
2256 if (EntryBlockName ==
"")
2257 EntryBlockName =
Before.getEntryBlockName();
2258 assert(EntryBlockName !=
"" &&
"Expected to find entry block");
2260 DotCfgDiffDisplayGraph DG = Diff.createDisplayGraph(Text, EntryBlockName);
2261 DG.generateDotFile(DotFile);
2266 errs() <<
"Error: " << EC.message() <<
"\n";
2275 return "Unable to find dot executable.";
2280 return "Error executing system dot.";
2284 " <a href=\"{0}\" target=\"_blank\">{1}</a><br/>\n", PDFFileName, Text);
2289 assert(
HTML &&
"Expected outstream to be set");
2290 *
HTML <<
"<button type=\"button\" class=\"collapsible\">0. "
2291 <<
"Initial IR (by function)</button>\n"
2292 <<
"<div class=\"content\">\n"
2301 [&](
bool InModule,
unsigned Minor,
2318 assert(
HTML &&
"Expected outstream to be set");
2320 formatv(
" <a>{0}. Pass {1} on {2} omitted because no change</a><br/>\n",
2321 N, makeHTMLReady(PassID),
Name);
2329 assert(
HTML &&
"Expected outstream to be set");
2332 [&](
bool InModule,
unsigned Minor,
2338 *
HTML <<
" </p></div>\n";
2343 assert(
HTML &&
"Expected outstream to be set");
2345 formatv(
" <a>{0}. {1} invalidated</a><br/>\n",
N, makeHTMLReady(PassID));
2351 assert(
HTML &&
"Expected outstream to be set");
2353 formatv(
" <a>{0}. Pass {1} on {2} filtered out</a><br/>\n",
N,
2354 makeHTMLReady(PassID),
Name);
2360 assert(
HTML &&
"Expected outstream to be set");
2362 makeHTMLReady(PassID),
Name);
2369 HTML = std::make_unique<raw_fd_ostream>(
DotCfgDir +
"/passes.html", EC);
2375 *
HTML <<
"<!doctype html>"
2378 <<
"<style>.collapsible { "
2379 <<
"background-color: #777;"
2381 <<
" cursor: pointer;"
2382 <<
" padding: 18px;"
2385 <<
" text-align: left;"
2386 <<
" outline: none;"
2387 <<
" font-size: 15px;"
2388 <<
"} .active, .collapsible:hover {"
2389 <<
" background-color: #555;"
2391 <<
" padding: 0 18px;"
2392 <<
" display: none;"
2393 <<
" overflow: hidden;"
2394 <<
" background-color: #f1f1f1;"
2397 <<
"<title>passes.html</title>"
2407 <<
"<script>var coll = document.getElementsByClassName(\"collapsible\");"
2409 <<
"for (i = 0; i < coll.length; i++) {"
2410 <<
"coll[i].addEventListener(\"click\", function() {"
2411 <<
" this.classList.toggle(\"active\");"
2412 <<
" var content = this.nextElementSibling;"
2413 <<
" if (content.style.display === \"block\"){"
2414 <<
" content.style.display = \"none\";"
2417 <<
" content.style.display= \"block\";"
2435 assert(!OutputDir.
empty() &&
"expected output dir to be non-empty");
2441 dbgs() <<
"Unable to open output stream for -cfg-dot-changed\n";
2448 : PrintPass(DebugLogging, PrintPassOpts),
2449 OptNone(DebugLogging),
2474void PrintCrashIRInstrumentation::SignalHandler(
void *) {
2481 "Did not expect to get here without option set.");
2490 "Did not expect to get here without option set.");
2491 CrashReporter =
nullptr;
2500 CrashReporter =
this;
2506 OS <<
formatv(
"*** Dump of {0}IR Before Last Pass {1}",
2509 OS <<
" Filtered Out ***\n";
2512 OS <<
" Started ***\n";
2513 unwrapAndPrint(
OS,
IR);
static msgpack::DocNode getNode(msgpack::DocNode DN, msgpack::Type Type, MCValue Val)
This file provides Any, a non-template class modeled in the spirit of std::any.
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::optional< std::vector< StOtherPiece > > Other
static bool isInteresting(const SCEV *S, const Instruction *I, const Loop *L, ScalarEvolution *SE, LoopInfo *LI)
isInteresting - Test whether the given expression is "interesting" when used by the given expression,...
static void addEdge(SmallVectorImpl< LazyCallGraph::Edge > &Edges, DenseMap< LazyCallGraph::Node *, int > &EdgeIndexMap, LazyCallGraph::Node &N, LazyCallGraph::Edge::Kind EK)
Implements a lazy call graph analysis and related passes for the new pass manager.
Legalize the Machine IR a function s Machine IR
static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS)
Module.h This file contains the declarations for the Module class.
ppc ctr loops PowerPC CTR Loops Verify
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
This file defines the Pass Instrumentation classes that provide instrumentation points into the pass ...
This header defines various interfaces for pass management in LLVM.
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
verify safepoint Safepoint IR Verifier
static cl::opt< std::string > BeforeColour("dot-cfg-before-color", cl::desc("Color for dot-cfg before elements"), cl::Hidden, cl::init("red"))
static cl::opt< std::string > IRDumpDirectory("ir-dump-directory", cl::desc("If specified, IR printed using the " "-print-[before|after]{-all} options will be dumped into " "files in this directory rather than written to stderr"), cl::Hidden, cl::value_desc("filename"))
static cl::opt< unsigned > PrintAfterPassNumber("print-after-pass-number", cl::init(0), cl::Hidden, cl::desc("Print IR after the pass with this number as " "reported by print-pass-numbers"))
static cl::opt< std::string > OptBisectPrintIRPath("opt-bisect-print-ir-path", cl::desc("Print IR to path when opt-bisect-limit is reached"), cl::Hidden)
static cl::opt< bool > PrintChangedBefore("print-before-changed", cl::desc("Print before passes that change them"), cl::init(false), cl::Hidden)
static cl::opt< std::string > DotCfgDir("dot-cfg-dir", cl::desc("Generate dot files into specified directory for changed IRs"), cl::Hidden, cl::init("./"))
static cl::opt< bool > VerifyAnalysisInvalidation("verify-analysis-invalidation", cl::Hidden, cl::init(false))
static cl::opt< unsigned > PrintBeforePassNumber("print-before-pass-number", cl::init(0), cl::Hidden, cl::desc("Print IR before the pass with this number as " "reported by print-pass-numbers"))
static cl::opt< std::string > CommonColour("dot-cfg-common-color", cl::desc("Color for dot-cfg common elements"), cl::Hidden, cl::init("black"))
static StringRef getFileSuffix(IRDumpFileSuffixType Type)
static SmallString< 32 > getIRFileDisplayName(Any IR)
static SmallVector< Function *, 1 > GetFunctions(Any IR)
static void printBBName(raw_ostream &out, const BasicBlock *BB)
static cl::opt< std::string > DotBinary("print-changed-dot-path", cl::Hidden, cl::init("dot"), cl::desc("system dot used by change reporters"))
static bool shouldGenerateData(const Function &F)
static int prepareDumpIRFileDescriptor(const StringRef DumpIRFilename)
static const IRUnitT * unwrapIR(Any IR)
static cl::opt< std::string > AfterColour("dot-cfg-after-color", cl::desc("Color for dot-cfg after elements"), cl::Hidden, cl::init("forestgreen"))
static cl::opt< bool > PrintOnCrash("print-on-crash", cl::desc("Print the last form of the IR before crash (use -print-on-crash-path to dump to a file)"), cl::Hidden)
static cl::opt< bool > PrintPassNumbers("print-pass-numbers", cl::init(false), cl::Hidden, cl::desc("Print pass names and their ordinals"))
static cl::opt< std::string > PrintOnCrashPath("print-on-crash-path", cl::desc("Print the last form of the IR before crash to a file"), cl::Hidden)
This header defines a class that provides bookkeeping for all standard (i.e in-tree) pass instrumenta...
static const char PassName[]
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
API to communicate dependencies between analyses during invalidation.
A container for analyses that lazily runs them and caches their results.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
LLVM Basic Block Representation.
bool isEntryBlock() const
Return true if this is the entry block of the containing function.
const Function * getParent() const
Return the enclosing method, or null if none.
const T & getData() const
Conditional or Unconditional Branch instruction.
Represents analyses that only rely on functions' control flow.
void saveIRBeforePass(Any IR, StringRef PassID, StringRef PassName)
void handleIRAfterPass(Any IR, StringRef PassID, StringRef PassName)
void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC)
void handleInvalidatedPass(StringRef PassID)
virtual ~ChangeReporter()
void addSuccessorLabel(StringRef Succ, StringRef Label)
DCData(const BasicBlock &B)
std::unique_ptr< raw_fd_ostream > HTML
void handleInvalidated(StringRef PassID) override
void generateIRRepresentation(Any IR, StringRef PassID, IRDataT< DCData > &Output) override
static std::string genHTML(StringRef Text, StringRef DotFile, StringRef PDFFileName)
void handleInitialIR(Any IR) override
void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID, StringRef Divider, bool InModule, unsigned Minor, const FuncDataT< DCData > &Before, const FuncDataT< DCData > &After)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
DotCfgChangeReporter(bool Verbose)
void handleIgnored(StringRef PassID, std::string &Name) override
~DotCfgChangeReporter() override
void handleAfter(StringRef PassID, std::string &Name, const IRDataT< DCData > &Before, const IRDataT< DCData > &After, Any) override
void handleFiltered(StringRef PassID, std::string &Name) override
void omitAfter(StringRef PassID, std::string &Name) override
Represents either an error or a value T.
Lightweight error class with error context and mandatory checking.
Module * getParent()
Get the module that this global value is contained inside of...
~IRChangedPrinter() override
void handleAfter(StringRef PassID, std::string &Name, const std::string &Before, const std::string &After, Any) override
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void generateIRRepresentation(Any IR, StringRef PassID, std::string &Output) override
void handleIgnored(StringRef PassID, std::string &Name) override
void handleAfter(StringRef PassID, std::string &Name, const std::string &Before, const std::string &After, Any) override
void omitAfter(StringRef PassID, std::string &Name) override
void handleInvalidated(StringRef PassID) override
void handleIR(const std::string &IR, StringRef PassID)
void handleInitialIR(Any IR) override
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void handleFiltered(StringRef PassID, std::string &Name) override
~IRChangedTester() override
static bool generateFunctionData(IRDataT< T > &Data, const FunctionT &F)
static void analyzeIR(Any IR, IRDataT< T > &Data)
void compare(bool CompareModule, std::function< void(bool InModule, unsigned Minor, const FuncDataT< T > &Before, const FuncDataT< T > &After)> CompareFunc)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
~InLineChangePrinter() override
void handleAfter(StringRef PassID, std::string &Name, const IRDataT< EmptyData > &Before, const IRDataT< EmptyData > &After, Any) override
void generateIRRepresentation(Any IR, StringRef PassID, IRDataT< EmptyData > &Output) override
void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID, StringRef Divider, bool InModule, unsigned Minor, const FuncDataT< EmptyData > &Before, const FuncDataT< EmptyData > &After)
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
This is an important class for using LLVM in a threaded context.
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time.
A node in the call graph.
An SCC of the call graph.
Represents a single loop in the control flow graph.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Function & getFunction()
Return the LLVM function that this machine code represents.
void print(raw_ostream &OS, const SlotIndexes *=nullptr) const
print - Print out the MachineFunction in a format suitable for debugging to the specified stream.
A Module instance is used to store all the information related to an LLVM module.
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
bool shouldRun(StringRef PassName, Any IR)
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
virtual bool isEnabled() const
isEnabled() should return true before calling shouldRunPass().
virtual bool shouldRunPass(const StringRef PassName, StringRef IRDescription)
IRDescription is a textual description of the IR unit the pass is running over.
static void report(const OrderedChangedData &Before, const OrderedChangedData &After, function_ref< void(const T *, const T *)> HandlePair)
StringMap< T > & getData()
std::vector< std::string > & getOrder()
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
void registerAnalysesClearedCallback(CallableT C)
void registerBeforeAnalysisCallback(CallableT C)
void registerAfterPassInvalidatedCallback(CallableT C, bool ToFront=false)
void registerAnalysisInvalidatedCallback(CallableT C)
StringRef getPassNameForClassName(StringRef ClassName)
Get the pass name for a given pass class name.
void registerAfterAnalysisCallback(CallableT C, bool ToFront=false)
void registerBeforeNonSkippedPassCallback(CallableT C)
void registerBeforeSkippedPassCallback(CallableT C)
void registerShouldRunOptionalPassCallback(CallableT C)
void registerAfterPassCallback(CallableT C, bool ToFront=false)
Pass interface - Implemented by all 'passes'.
A set of analyses that are preserved following a run of a transformation pass.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
void registerCallbacks(PassInstrumentationCallbacks &PIC, ModuleAnalysisManager &MAM)
~PrintCrashIRInstrumentation()
void registerCallbacks(PassInstrumentationCallbacks &PIC)
~PrintIRInstrumentation()
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void registerCallbacks(PassInstrumentationCallbacks &PIC, ModuleAnalysisManager *MAM=nullptr)
StandardInstrumentations(LLVMContext &Context, bool DebugLogging, bool VerifyEach=false, PrintPassOptions PrintPassOpts=PrintPassOptions())
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
StringRef - Represent a constant reference to a string, i.e.
std::string str() const
str - Get the contents as an std::string.
constexpr bool empty() const
empty - Check if the string is empty.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
StringRef drop_until(function_ref< bool(char)> F) const
Return a StringRef equal to 'this', but with all characters not satisfying the given predicate droppe...
constexpr size_t size() const
size - Get the string size.
char front() const
front - Get the first character in the string.
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
StringRef take_until(function_ref< bool(char)> F) const
Return the longest prefix of 'this' such that no character in the prefix satisfies the given predicat...
std::pair< StringRef, StringRef > rsplit(StringRef Separator) const
Split into two substrings around the last occurrence of a separator string.
void handleInitialIR(Any IR) override
void handleInvalidated(StringRef PassID) override
TextChangeReporter(bool Verbose)
void omitAfter(StringRef PassID, std::string &Name) override
void handleIgnored(StringRef PassID, std::string &Name) override
void handleFiltered(StringRef PassID, std::string &Name) override
void registerCallbacks(PassInstrumentationCallbacks &PIC)
void registerCallbacks(PassInstrumentationCallbacks &PIC)
TimeProfilingPassesHandler()
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
std::string str() const
Return the twine contents as a std::string.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
StringRef getName() const
Return a constant reference to the value's name.
void registerCallbacks(PassInstrumentationCallbacks &PIC, ModuleAnalysisManager *MAM)
An efficient, type-erasing, non-owning reference to a callable.
A raw_ostream that writes to a file descriptor.
This class implements an extremely fast bulk output stream that can only output to a stream.
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
A raw_ostream that writes to an std::string.
A raw_ostream that writes to an SmallVector or SmallString.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
DiagnosticInfoOptimizationBase::Argument NV
void make_absolute(const Twine ¤t_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
std::error_code openFile(const Twine &Name, int &ResultFD, CreationDisposition Disp, FileAccess Access, OpenFlags Flags, unsigned Mode=0666)
Opens a file with the specified creation disposition, access mode, and flags and returns a file descr...
void expand_tilde(const Twine &path, SmallVectorImpl< char > &output)
Expands ~ expressions to the user's home directory.
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
std::error_code remove(const Twine &path, bool IgnoreNonExisting=true)
Remove path.
@ CD_OpenAlways
CD_OpenAlways - When opening a file:
void createUniquePath(const Twine &Model, SmallVectorImpl< char > &ResultPath, bool MakeAbsolute)
Create a potentially unique file name but does not create it.
std::error_code create_directories(const Twine &path, bool IgnoreExisting=true, perms Perms=owner_all|group_all)
Create all the non-existent directories in path.
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
void AddSignalHandler(SignalHandlerCallback FnPtr, void *Cookie)
Add a function to be called when an abort/kill signal is delivered to the process.
int ExecuteAndWait(StringRef Program, ArrayRef< StringRef > Args, std::optional< ArrayRef< StringRef > > Env=std::nullopt, ArrayRef< std::optional< StringRef > > Redirects={}, unsigned SecondsToWait=0, unsigned MemoryLimit=0, std::string *ErrMsg=nullptr, bool *ExecutionFailed=nullptr, std::optional< ProcessStatistics > *ProcStat=nullptr, BitVector *AffinityMask=nullptr)
This function executes the program using the arguments provided.
ErrorOr< std::string > findProgramByName(StringRef Name, ArrayRef< StringRef > Paths={})
Find the first executable file Name in Paths.
This is an optimization pass for GlobalISel generic memory operations.
std::error_code prepareTempFiles(SmallVector< int > &FD, ArrayRef< StringRef > SR, SmallVector< std::string > &FileName)
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool forcePrintModuleIR()
std::vector< std::string > printAfterPasses()
bool verifyFunction(const Function &F, raw_ostream *OS=nullptr)
Check a function for errors, useful for use when debugging a pass.
auto successors(const MachineBasicBlock *BB)
bool DisplayGraph(StringRef Filename, bool wait=true, GraphProgram::Name program=GraphProgram::DOT)
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
bool shouldPrintBeforeAll()
raw_ostream & WriteGraph(raw_ostream &O, const GraphType &G, bool ShortNames=false, const Twine &Title="")
bool shouldPrintAfterAll()
cl::opt< ChangePrinter > PrintChanged
TimeTraceProfiler * getTimeTraceProfilerInstance()
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
std::vector< std::string > printBeforePasses()
bool shouldPrintBeforeSomePass()
This is a helper to determine whether to print IR before or after a pass.
bool shouldPrintAfterSomePass()
void verifyMachineFunction(const std::string &Banner, const MachineFunction &MF)
IRHash StructuralHash(const Function &F, bool DetailedHash=false)
Returns a hash of the function F.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool isFunctionInPrintList(StringRef FunctionName)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
bool isPassInPrintList(StringRef PassName)
bool isSpecialPass(StringRef PassID, const std::vector< StringRef > &Specials)
void timeTraceProfilerEnd()
Manually end the last time section.
std::error_code cleanUpTempFiles(ArrayRef< std::string > FileName)
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, std::optional< size_t > Width=std::nullopt)
std::string doSystemDiff(StringRef Before, StringRef After, StringRef OldLineFormat, StringRef NewLineFormat, StringRef UnchangedLineFormat)
stable_hash stable_hash_combine_string(const StringRef &S)
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
uint64_t stable_hash
An opaque object representing a stable hash code.
std::string demangle(std::string_view MangledName)
Attempt to demangle a string using different demangling schemes.
void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner="")
Function to print a loop's contents as LLVM's text IR assembly.
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
TimeTraceProfilerEntry * timeTraceProfilerBegin(StringRef Name, StringRef Detail)
Manually begin a time section, with the given Name and Detail.
Result run(Function &F, FunctionAnalysisManager &FAM)
Run the analysis pass over a function and produce CFG.
Result run(Function &F, FunctionAnalysisManager &FAM)
Result run(Module &F, ModuleAnalysisManager &FAM)
A CRTP mix-in that provides informational APIs needed for analysis passes.
A special type used by analysis passes to provide an address that identifies that particular analysis...
static std::string getEdgeAttributes(const DisplayNode *From, DisplayNode::ChildIterator &To, const DotCfgDiffDisplayGraph *DiffData)
static std::string getGraphName(const DotCfgDiffDisplayGraph *DiffData)
static std::string getEdgeSourceLabel(const DisplayNode *From, DisplayNode::ChildIterator &To)
static std::string getNodeAttributes(const DisplayNode *Node, const DotCfgDiffDisplayGraph *DiffData)
static std::string getNodeLabel(const DisplayNode *Node, const DotCfgDiffDisplayGraph *DiffData)
static bool renderNodesUsingHTML()
static std::string getGraphProperties(const DotCfgDiffDisplayGraph *DiffData)
DOTGraphTraits(bool Simple=false)
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
static ChildEdgeIterator child_edge_end(NodeRef N)
static unsigned size(const DotCfgDiffDisplayGraph *G)
static NodeRef getEntryNode(const DotCfgDiffDisplayGraph *G)
DisplayNode::EdgeIterator ChildEdgeIterator
static ChildIteratorType child_begin(NodeRef N)
const DisplayEdge * EdgeRef
static ChildIteratorType child_end(NodeRef N)
const DisplayNode * NodeRef
static NodeRef edge_dest(EdgeRef E)
DotCfgDiffDisplayGraph::NodeIterator nodes_iterator
DisplayNode::ChildIterator ChildIteratorType
static nodes_iterator nodes_begin(const DotCfgDiffDisplayGraph *G)
static ChildEdgeIterator child_edge_begin(NodeRef N)
static nodes_iterator nodes_end(const DotCfgDiffDisplayGraph *G)
std::optional< DenseMap< intptr_t, BBGuard > > BBGuards
static void printDiff(raw_ostream &out, const CFG &Before, const CFG &After)
CFG(const Function *F, bool TrackBBLifetime)
bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &)
DenseMap< const BasicBlock *, DenseMap< const BasicBlock *, unsigned > > Graph
bool SkipAnalyses
Don't print information for analyses.
bool Verbose
Print adaptors and pass managers.
bool Indent
Indent based on hierarchy.