llvm/lib/IR/PrintPasses.cpp

   1 //===- PrintPasses.cpp ----------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/IR/PrintPasses.h"
  10 #include "llvm/Support/CommandLine.h"
  11 #include "llvm/Support/Errc.h"
  12 #include "llvm/Support/FileSystem.h"
  13 #include "llvm/Support/MemoryBuffer.h"
  14 #include "llvm/Support/Program.h"
  15 #include <unordered_set>
  16
  17 using namespace llvm;
  18
  19 // Print IR out before/after specified passes.
  20 static cl::list<std::string>
  21     PrintBefore("print-before",
  22                 llvm::cl::desc("Print IR before specified passes"),
  23                 cl::CommaSeparated, cl::Hidden);
  24
  25 static cl::list<std::string>
  26     PrintAfter("print-after", llvm::cl::desc("Print IR after specified passes"),
  27                cl::CommaSeparated, cl::Hidden);
  28
  29 static cl::opt<bool> PrintBeforeAll("print-before-all",
  30                                     llvm::cl::desc("Print IR before each pass"),
  31                                     cl::init(false), cl::Hidden);
  32 static cl::opt<bool> PrintAfterAll("print-after-all",
  33                                    llvm::cl::desc("Print IR after each pass"),
  34                                    cl::init(false), cl::Hidden);
  35
  36 // Print out the IR after passes, similar to -print-after-all except that it
  37 // only prints the IR after passes that change the IR. Those passes that do not
  38 // make changes to the IR are reported as not making any changes. In addition,
  39 // the initial IR is also reported.  Other hidden options affect the output from
  40 // this option. -filter-passes will limit the output to the named passes that
  41 // actually change the IR and other passes are reported as filtered out. The
  42 // specified passes will either be reported as making no changes (with no IR
  43 // reported) or the changed IR will be reported. Also, the -filter-print-funcs
  44 // and -print-module-scope options will do similar filtering based on function
  45 // name, reporting changed IRs as functions(or modules if -print-module-scope is
  46 // specified) for a particular function or indicating that the IR has been
  47 // filtered out. The extra options can be combined, allowing only changed IRs
  48 // for certain passes on certain functions to be reported in different formats,
  49 // with the rest being reported as filtered out.  The -print-before-changed
  50 // option will print the IR as it was before each pass that changed it. The
  51 // optional value of quiet will only report when the IR changes, suppressing all
  52 // other messages, including the initial IR. The values "diff" and "diff-quiet"
  53 // will present the changes in a form similar to a patch, in either verbose or
  54 // quiet mode, respectively. The lines that are removed and added are prefixed
  55 // with '-' and '+', respectively. The -filter-print-funcs and -filter-passes
  56 // can be used to filter the output.  This reporter relies on the linux diff
  57 // utility to do comparisons and insert the prefixes. For systems that do not
  58 // have the necessary facilities, the error message will be shown in place of
  59 // the expected output.
  60 cl::opt<ChangePrinter> llvm::PrintChanged(
  61     "print-changed", cl::desc("Print changed IRs"), cl::Hidden,
  62     cl::ValueOptional, cl::init(ChangePrinter::None),
  63     cl::values(
  64         clEnumValN(ChangePrinter::Quiet, "quiet", "Run in quiet mode"),
  65         clEnumValN(ChangePrinter::DiffVerbose, "diff",
  66                    "Display patch-like changes"),
  67         clEnumValN(ChangePrinter::DiffQuiet, "diff-quiet",
  68                    "Display patch-like changes in quiet mode"),
  69         clEnumValN(ChangePrinter::ColourDiffVerbose, "cdiff",
  70                    "Display patch-like changes with color"),
  71         clEnumValN(ChangePrinter::ColourDiffQuiet, "cdiff-quiet",
  72                    "Display patch-like changes in quiet mode with color"),
  73         clEnumValN(ChangePrinter::DotCfgVerbose, "dot-cfg",
  74                    "Create a website with graphical changes"),
  75         clEnumValN(ChangePrinter::DotCfgQuiet, "dot-cfg-quiet",
  76                    "Create a website with graphical changes in quiet mode"),
  77         // Sentinel value for unspecified option.
  78         clEnumValN(ChangePrinter::Verbose, "", "")));
  79
  80 // An option for specifying the diff used by print-changed=[diff | diff-quiet]
  81 static cl::opt<std::string>
  82     DiffBinary("print-changed-diff-path", cl::Hidden, cl::init("diff"),
  83                cl::desc("system diff used by change reporters"));
  84
  85 static cl::opt<bool>
  86     PrintModuleScope("print-module-scope",
  87                      cl::desc("When printing IR for print-[before|after]{-all} "
  88                               "always print a module IR"),
  89                      cl::init(false), cl::Hidden);
  90
  91 static cl::opt<bool> LoopPrintFuncScope(
  92     "print-loop-func-scope",
  93     cl::desc("When printing IR for print-[before|after]{-all} "
  94              "for a loop pass, always print function IR"),
  95     cl::init(false), cl::Hidden);
  96
  97 // See the description for -print-changed for an explanation of the use
  98 // of this option.
  99 static cl::list<std::string> FilterPasses(
 100     "filter-passes", cl::value_desc("pass names"),
 101     cl::desc("Only consider IR changes for passes whose names "
 102              "match the specified value. No-op without -print-changed"),
 103     cl::CommaSeparated, cl::Hidden);
 104
 105 static cl::list<std::string>
 106     PrintFuncsList("filter-print-funcs", cl::value_desc("function names"),
 107                    cl::desc("Only print IR for functions whose name "
 108                             "match this for all print-[before|after][-all] "
 109                             "options"),
 110                    cl::CommaSeparated, cl::Hidden);
 111
 112 /// This is a helper to determine whether to print IR before or
 113 /// after a pass.
 114
 115 bool llvm::shouldPrintBeforeSomePass() {
 116   return PrintBeforeAll || !PrintBefore.empty();
 117 }
 118
 119 bool llvm::shouldPrintAfterSomePass() {
 120   return PrintAfterAll || !PrintAfter.empty();
 121 }
 122
 123 static bool shouldPrintBeforeOrAfterPass(StringRef PassID,
 124                                          ArrayRef<std::string> PassesToPrint) {
 125   return llvm::is_contained(PassesToPrint, PassID);
 126 }
 127
 128 bool llvm::shouldPrintBeforeAll() { return PrintBeforeAll; }
 129
 130 bool llvm::shouldPrintAfterAll() { return PrintAfterAll; }
 131
 132 bool llvm::shouldPrintBeforePass(StringRef PassID) {
 133   return PrintBeforeAll || shouldPrintBeforeOrAfterPass(PassID, PrintBefore);
 134 }
 135
 136 bool llvm::shouldPrintAfterPass(StringRef PassID) {
 137   return PrintAfterAll || shouldPrintBeforeOrAfterPass(PassID, PrintAfter);
 138 }
 139
 140 std::vector<std::string> llvm::printBeforePasses() {
 141   return std::vector<std::string>(PrintBefore);
 142 }
 143
 144 std::vector<std::string> llvm::printAfterPasses() {
 145   return std::vector<std::string>(PrintAfter);
 146 }
 147
 148 bool llvm::forcePrintModuleIR() { return PrintModuleScope; }
 149
 150 bool llvm::forcePrintFuncIR() { return LoopPrintFuncScope; }
 151
 152 bool llvm::isPassInPrintList(StringRef PassName) {
 153   static std::unordered_set<std::string> Set(FilterPasses.begin(),
 154                                              FilterPasses.end());
 155   return Set.empty() || Set.count(std::string(PassName));
 156 }
 157
 158 bool llvm::isFilterPassesEmpty() { return FilterPasses.empty(); }
 159
 160 bool llvm::isFunctionInPrintList(StringRef FunctionName) {
 161   static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
 162                                                         PrintFuncsList.end());
 163   return PrintFuncNames.empty() ||
 164          PrintFuncNames.count(std::string(FunctionName));
 165 }
 166
 167 std::error_code cleanUpTempFilesImpl(ArrayRef<std::string> FileName,
 168                                      unsigned N) {
 169   std::error_code RC;
 170   for (unsigned I = 0; I < N; ++I) {
 171     std::error_code EC = sys::fs::remove(FileName[I]);
 172     if (EC)
 173       RC = EC;
 174   }
 175   return RC;
 176 }
 177
 178 std::error_code llvm::prepareTempFiles(SmallVector<int> &FD,
 179                                        ArrayRef<StringRef> SR,
 180                                        SmallVector<std::string> &FileName) {
 181   assert(FD.size() >= SR.size() && FileName.size() == FD.size() &&
 182          "Unexpected array sizes");
 183   std::error_code EC;
 184   unsigned I = 0;
 185   for (; I < FD.size(); ++I) {
 186     if (FD[I] == -1) {
 187       SmallVector<char, 200> SV;
 188       EC = sys::fs::createTemporaryFile("tmpfile", "txt", FD[I], SV);
 189       if (EC)
 190         break;
 191       FileName[I] = Twine(SV).str();
 192     }
 193     if (I < SR.size()) {
 194       EC = sys::fs::openFileForWrite(FileName[I], FD[I]);
 195       if (EC)
 196         break;
 197       raw_fd_ostream OutStream(FD[I], /*shouldClose=*/true);
 198       if (FD[I] == -1) {
 199         EC = make_error_code(errc::io_error);
 200         break;
 201       }
 202       OutStream << SR[I];
 203     }
 204   }
 205   if (EC && I > 0)
 206     // clean up created temporary files
 207     cleanUpTempFilesImpl(FileName, I);
 208   return EC;
 209 }
 210
 211 std::error_code llvm::cleanUpTempFiles(ArrayRef<std::string> FileName) {
 212   return cleanUpTempFilesImpl(FileName, FileName.size());
 213 }
 214
 215 std::string llvm::doSystemDiff(StringRef Before, StringRef After,
 216                                StringRef OldLineFormat, StringRef NewLineFormat,
 217                                StringRef UnchangedLineFormat) {
 218   // Store the 2 bodies into temporary files and call diff on them
 219   // to get the body of the node.
 220   static SmallVector<int> FD{-1, -1, -1};
 221   SmallVector<StringRef> SR{Before, After};
 222   static SmallVector<std::string> FileName{"", "", ""};
 223   if (prepareTempFiles(FD, SR, FileName))
 224     return "Unable to create temporary file.";
 225
 226   static ErrorOr<std::string> DiffExe = sys::findProgramByName(DiffBinary);
 227   if (!DiffExe)
 228     return "Unable to find diff executable.";
 229
 230   SmallString<128> OLF, NLF, ULF;
 231   ("--old-line-format=" + OldLineFormat).toVector(OLF);
 232   ("--new-line-format=" + NewLineFormat).toVector(NLF);
 233   ("--unchanged-line-format=" + UnchangedLineFormat).toVector(ULF);
 234
 235   StringRef Args[] = {DiffBinary, "-w", "-d",        OLF,
 236                       NLF,        ULF,  FileName[0], FileName[1]};
 237   std::optional<StringRef> Redirects[] = {std::nullopt, StringRef(FileName[2]),
 238                                           std::nullopt};
 239   int Result = sys::ExecuteAndWait(*DiffExe, Args, std::nullopt, Redirects);
 240   if (Result < 0)
 241     return "Error executing system diff.";
 242   std::string Diff;
 243   auto B = MemoryBuffer::getFile(FileName[2]);
 244   if (B && *B)
 245     Diff = (*B)->getBuffer().str();
 246   else
 247     return "Unable to read result.";
 248
 249   if (cleanUpTempFiles(FileName))
 250     return "Unable to remove temporary file.";
 251
 252   return Diff;
 253 }