1 //===------------------ llvm-opt-report/OptReport.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 /// \file
10 /// This file implements a tool that can parse the YAML optimization
11 /// records and generate an optimization summary annotated source listing
12 /// report.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm-c/Remarks.h"
17 #include "llvm/Demangle/Demangle.h"
18 #include "llvm/Remarks/RemarkFormat.h"
19 #include "llvm/Remarks/RemarkParser.h"
20 #include "llvm/Support/CommandLine.h"
21 #include "llvm/Support/Error.h"
22 #include "llvm/Support/ErrorOr.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/Format.h"
25 #include "llvm/Support/InitLLVM.h"
26 #include "llvm/Support/LineIterator.h"
27 #include "llvm/Support/MemoryBuffer.h"
28 #include "llvm/Support/Path.h"
29 #include "llvm/Support/Program.h"
30 #include "llvm/Support/WithColor.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <cstdlib>
33 #include <map>
34 #include <set>
35 
36 using namespace llvm;
37 
38 // Mark all our options with this category, everything else (except for -version
39 // and -help) will be hidden.
40 static cl::OptionCategory
41     OptReportCategory("llvm-opt-report options");
42 
43 static cl::opt<std::string>
44   InputFileName(cl::Positional, cl::desc("<input>"), cl::init("-"),
45                 cl::cat(OptReportCategory));
46 
47 static cl::opt<std::string>
48   OutputFileName("o", cl::desc("Output file"), cl::init("-"),
49                  cl::cat(OptReportCategory));
50 
51 static cl::opt<std::string>
52   InputRelDir("r", cl::desc("Root for relative input paths"), cl::init(""),
53               cl::cat(OptReportCategory));
54 
55 static cl::opt<bool>
56   Succinct("s", cl::desc("Don't include vectorization factors, etc."),
57            cl::init(false), cl::cat(OptReportCategory));
58 
59 static cl::opt<bool>
60   NoDemangle("no-demangle", cl::desc("Don't demangle function names"),
61              cl::init(false), cl::cat(OptReportCategory));
62 
63 static cl::opt<std::string> ParserFormat("format",
64                                          cl::desc("The format of the remarks."),
65                                          cl::init("yaml"),
66                                          cl::cat(OptReportCategory));
67 
68 namespace {
69 // For each location in the source file, the common per-transformation state
70 // collected.
71 struct OptReportLocationItemInfo {
72   bool Analyzed = false;
73   bool Transformed = false;
74 
75   OptReportLocationItemInfo &operator |= (
76     const OptReportLocationItemInfo &RHS) {
77     Analyzed |= RHS.Analyzed;
78     Transformed |= RHS.Transformed;
79 
80     return *this;
81   }
82 
83   bool operator < (const OptReportLocationItemInfo &RHS) const {
84     if (Analyzed < RHS.Analyzed)
85       return true;
86     else if (Analyzed > RHS.Analyzed)
87       return false;
88     else if (Transformed < RHS.Transformed)
89       return true;
90     return false;
91   }
92 };
93 
94 // The per-location information collected for producing an optimization report.
95 struct OptReportLocationInfo {
96   OptReportLocationItemInfo Inlined;
97   OptReportLocationItemInfo Unrolled;
98   OptReportLocationItemInfo Vectorized;
99 
100   int VectorizationFactor = 1;
101   int InterleaveCount = 1;
102   int UnrollCount = 1;
103 
104   OptReportLocationInfo &operator |= (const OptReportLocationInfo &RHS) {
105     Inlined |= RHS.Inlined;
106     Unrolled |= RHS.Unrolled;
107     Vectorized |= RHS.Vectorized;
108 
109     VectorizationFactor =
110       std::max(VectorizationFactor, RHS.VectorizationFactor);
111     InterleaveCount = std::max(InterleaveCount, RHS.InterleaveCount);
112     UnrollCount = std::max(UnrollCount, RHS.UnrollCount);
113 
114     return *this;
115   }
116 
117   bool operator < (const OptReportLocationInfo &RHS) const {
118     if (Inlined < RHS.Inlined)
119       return true;
120     else if (RHS.Inlined < Inlined)
121       return false;
122     else if (Unrolled < RHS.Unrolled)
123       return true;
124     else if (RHS.Unrolled < Unrolled)
125       return false;
126     else if (Vectorized < RHS.Vectorized)
127       return true;
128     else if (RHS.Vectorized < Vectorized || Succinct)
129       return false;
130     else if (VectorizationFactor < RHS.VectorizationFactor)
131       return true;
132     else if (VectorizationFactor > RHS.VectorizationFactor)
133       return false;
134     else if (InterleaveCount < RHS.InterleaveCount)
135       return true;
136     else if (InterleaveCount > RHS.InterleaveCount)
137       return false;
138     else if (UnrollCount < RHS.UnrollCount)
139       return true;
140     return false;
141   }
142 };
143 
144 typedef std::map<std::string, std::map<int, std::map<std::string, std::map<int,
145           OptReportLocationInfo>>>> LocationInfoTy;
146 } // anonymous namespace
147 
148 static bool readLocationInfo(LocationInfoTy &LocationInfo) {
149   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
150       MemoryBuffer::getFile(InputFileName.c_str());
151   if (std::error_code EC = Buf.getError()) {
152     WithColor::error() << "Can't open file " << InputFileName << ": "
153                        << EC.message() << "\n";
154     return false;
155   }
156 
157   Expected<remarks::Format> Format = remarks::parseFormat(ParserFormat);
158   if (!Format) {
159     handleAllErrors(Format.takeError(), [&](const ErrorInfoBase &PE) {
160       PE.log(WithColor::error());
161       errs() << '\n';
162     });
163     return false;
164   }
165 
166   Expected<std::unique_ptr<remarks::RemarkParser>> MaybeParser =
167       remarks::createRemarkParserFromMeta(*Format, (*Buf)->getBuffer());
168   if (!MaybeParser) {
169     handleAllErrors(MaybeParser.takeError(), [&](const ErrorInfoBase &PE) {
170       PE.log(WithColor::error());
171       errs() << '\n';
172     });
173     return false;
174   }
175   remarks::RemarkParser &Parser = **MaybeParser;
176 
177   while (true) {
178     Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
179     if (!MaybeRemark) {
180       Error E = MaybeRemark.takeError();
181       if (E.isA<remarks::EndOfFileError>()) {
182         // EOF.
183         consumeError(std::move(E));
184         break;
185       }
186       handleAllErrors(std::move(E), [&](const ErrorInfoBase &PE) {
187         PE.log(WithColor::error());
188         errs() << '\n';
189       });
190       return false;
191     }
192 
193     const remarks::Remark &Remark = **MaybeRemark;
194 
195     bool Transformed = Remark.RemarkType == remarks::Type::Passed;
196 
197     int VectorizationFactor = 1;
198     int InterleaveCount = 1;
199     int UnrollCount = 1;
200 
201     for (const remarks::Argument &Arg : Remark.Args) {
202       if (Arg.Key == "VectorizationFactor")
203         Arg.Val.getAsInteger(10, VectorizationFactor);
204       else if (Arg.Key == "InterleaveCount")
205         Arg.Val.getAsInteger(10, InterleaveCount);
206       else if (Arg.Key == "UnrollCount")
207         Arg.Val.getAsInteger(10, UnrollCount);
208     }
209 
210     const Optional<remarks::RemarkLocation> &Loc = Remark.Loc;
211     if (!Loc)
212       continue;
213 
214     StringRef File = Loc->SourceFilePath;
215     unsigned Line = Loc->SourceLine;
216     unsigned Column = Loc->SourceColumn;
217 
218     // We track information on both actual and potential transformations. This
219     // way, if there are multiple possible things on a line that are, or could
220     // have been transformed, we can indicate that explicitly in the output.
221     auto UpdateLLII = [Transformed](OptReportLocationItemInfo &LLII) {
222       LLII.Analyzed = true;
223       if (Transformed)
224         LLII.Transformed = true;
225     };
226 
227     if (Remark.PassName == "inline") {
228       auto &LI = LocationInfo[std::string(File)][Line]
229                              [std::string(Remark.FunctionName)][Column];
230       UpdateLLII(LI.Inlined);
231     } else if (Remark.PassName == "loop-unroll") {
232       auto &LI = LocationInfo[std::string(File)][Line]
233                              [std::string(Remark.FunctionName)][Column];
234       LI.UnrollCount = UnrollCount;
235       UpdateLLII(LI.Unrolled);
236     } else if (Remark.PassName == "loop-vectorize") {
237       auto &LI = LocationInfo[std::string(File)][Line]
238                              [std::string(Remark.FunctionName)][Column];
239       LI.VectorizationFactor = VectorizationFactor;
240       LI.InterleaveCount = InterleaveCount;
241       UpdateLLII(LI.Vectorized);
242     }
243   }
244 
245   return true;
246 }
247 
248 static bool writeReport(LocationInfoTy &LocationInfo) {
249   std::error_code EC;
250   llvm::raw_fd_ostream OS(OutputFileName, EC, llvm::sys::fs::OF_TextWithCRLF);
251   if (EC) {
252     WithColor::error() << "Can't open file " << OutputFileName << ": "
253                        << EC.message() << "\n";
254     return false;
255   }
256 
257   bool FirstFile = true;
258   for (auto &FI : LocationInfo) {
259     SmallString<128> FileName(FI.first);
260     if (!InputRelDir.empty())
261       sys::fs::make_absolute(InputRelDir, FileName);
262 
263     const auto &FileInfo = FI.second;
264 
265     ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
266         MemoryBuffer::getFile(FileName);
267     if (std::error_code EC = Buf.getError()) {
268       WithColor::error() << "Can't open file " << FileName << ": "
269                          << EC.message() << "\n";
270       return false;
271     }
272 
273     if (FirstFile)
274       FirstFile = false;
275     else
276       OS << "\n";
277 
278     OS << "< " << FileName << "\n";
279 
280     // Figure out how many characters we need for the vectorization factors
281     // and similar.
282     OptReportLocationInfo MaxLI;
283     for (auto &FLI : FileInfo)
284       for (auto &FI : FLI.second)
285         for (auto &LI : FI.second)
286           MaxLI |= LI.second;
287 
288     bool NothingInlined = !MaxLI.Inlined.Transformed;
289     bool NothingUnrolled = !MaxLI.Unrolled.Transformed;
290     bool NothingVectorized = !MaxLI.Vectorized.Transformed;
291 
292     unsigned VFDigits = llvm::utostr(MaxLI.VectorizationFactor).size();
293     unsigned ICDigits = llvm::utostr(MaxLI.InterleaveCount).size();
294     unsigned UCDigits = llvm::utostr(MaxLI.UnrollCount).size();
295 
296     // Figure out how many characters we need for the line numbers.
297     int64_t NumLines = 0;
298     for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI)
299       ++NumLines;
300 
301     unsigned LNDigits = llvm::utostr(NumLines).size();
302 
303     for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI) {
304       int64_t L = LI.line_number();
305       auto LII = FileInfo.find(L);
306 
307       auto PrintLine = [&](bool PrintFuncName,
308                            const std::set<std::string> &FuncNameSet) {
309         OptReportLocationInfo LLI;
310 
311         std::map<int, OptReportLocationInfo> ColsInfo;
312         unsigned InlinedCols = 0, UnrolledCols = 0, VectorizedCols = 0;
313 
314         if (LII != FileInfo.end() && !FuncNameSet.empty()) {
315           const auto &LineInfo = LII->second;
316 
317           for (auto &CI : LineInfo.find(*FuncNameSet.begin())->second) {
318             int Col = CI.first;
319             ColsInfo[Col] = CI.second;
320             InlinedCols += CI.second.Inlined.Analyzed;
321             UnrolledCols += CI.second.Unrolled.Analyzed;
322             VectorizedCols += CI.second.Vectorized.Analyzed;
323             LLI |= CI.second;
324           }
325         }
326 
327         if (PrintFuncName) {
328           OS << "  > ";
329 
330           bool FirstFunc = true;
331           for (const auto &FuncName : FuncNameSet) {
332             if (FirstFunc)
333               FirstFunc = false;
334             else
335               OS << ", ";
336 
337             bool Printed = false;
338             if (!NoDemangle) {
339               int Status = 0;
340               char *Demangled =
341                 itaniumDemangle(FuncName.c_str(), nullptr, nullptr, &Status);
342               if (Demangled && Status == 0) {
343                 OS << Demangled;
344                 Printed = true;
345               }
346 
347               if (Demangled)
348                 std::free(Demangled);
349             }
350 
351             if (!Printed)
352               OS << FuncName;
353           }
354 
355           OS << ":\n";
356         }
357 
358         // We try to keep the output as concise as possible. If only one thing on
359         // a given line could have been inlined, vectorized, etc. then we can put
360         // the marker on the source line itself. If there are multiple options
361         // then we want to distinguish them by placing the marker for each
362         // transformation on a separate line following the source line. When we
363         // do this, we use a '^' character to point to the appropriate column in
364         // the source line.
365 
366         std::string USpaces(Succinct ? 0 : UCDigits, ' ');
367         std::string VSpaces(Succinct ? 0 : VFDigits + ICDigits + 1, ' ');
368 
369         auto UStr = [UCDigits](OptReportLocationInfo &LLI) {
370           std::string R;
371           raw_string_ostream RS(R);
372 
373           if (!Succinct) {
374             RS << LLI.UnrollCount;
375             RS << std::string(UCDigits - RS.str().size(), ' ');
376           }
377 
378           return RS.str();
379         };
380 
381         auto VStr = [VFDigits,
382                      ICDigits](OptReportLocationInfo &LLI) -> std::string {
383           std::string R;
384           raw_string_ostream RS(R);
385 
386           if (!Succinct) {
387             RS << LLI.VectorizationFactor << "," << LLI.InterleaveCount;
388             RS << std::string(VFDigits + ICDigits + 1 - RS.str().size(), ' ');
389           }
390 
391           return RS.str();
392         };
393 
394         OS << llvm::format_decimal(L, LNDigits) << " ";
395         OS << (LLI.Inlined.Transformed && InlinedCols < 2 ? "I" :
396                 (NothingInlined ? "" : " "));
397         OS << (LLI.Unrolled.Transformed && UnrolledCols < 2 ?
398                 "U" + UStr(LLI) : (NothingUnrolled ? "" : " " + USpaces));
399         OS << (LLI.Vectorized.Transformed && VectorizedCols < 2 ?
400                 "V" + VStr(LLI) : (NothingVectorized ? "" : " " + VSpaces));
401 
402         OS << " | " << *LI << "\n";
403 
404         for (auto &J : ColsInfo) {
405           if ((J.second.Inlined.Transformed && InlinedCols > 1) ||
406               (J.second.Unrolled.Transformed && UnrolledCols > 1) ||
407               (J.second.Vectorized.Transformed && VectorizedCols > 1)) {
408             OS << std::string(LNDigits + 1, ' ');
409             OS << (J.second.Inlined.Transformed &&
410                    InlinedCols > 1 ? "I" : (NothingInlined ? "" : " "));
411             OS << (J.second.Unrolled.Transformed &&
412                    UnrolledCols > 1 ? "U" + UStr(J.second) :
413                      (NothingUnrolled ? "" : " " + USpaces));
414             OS << (J.second.Vectorized.Transformed &&
415                    VectorizedCols > 1 ? "V" + VStr(J.second) :
416                      (NothingVectorized ? "" : " " + VSpaces));
417 
418             OS << " | " << std::string(J.first - 1, ' ') << "^\n";
419           }
420         }
421       };
422 
423       // We need to figure out if the optimizations for this line were the same
424       // in each function context. If not, then we want to group the similar
425       // function contexts together and display each group separately. If
426       // they're all the same, then we only display the line once without any
427       // additional markings.
428       std::map<std::map<int, OptReportLocationInfo>,
429                std::set<std::string>> UniqueLIs;
430 
431       OptReportLocationInfo AllLI;
432       if (LII != FileInfo.end()) {
433         const auto &FuncLineInfo = LII->second;
434         for (const auto &FLII : FuncLineInfo) {
435           UniqueLIs[FLII.second].insert(FLII.first);
436 
437           for (const auto &OI : FLII.second)
438             AllLI |= OI.second;
439         }
440       }
441 
442       bool NothingHappened = !AllLI.Inlined.Transformed &&
443                              !AllLI.Unrolled.Transformed &&
444                              !AllLI.Vectorized.Transformed;
445       if (UniqueLIs.size() > 1 && !NothingHappened) {
446         OS << " [[\n";
447         for (const auto &FSLI : UniqueLIs)
448           PrintLine(true, FSLI.second);
449         OS << " ]]\n";
450       } else if (UniqueLIs.size() == 1) {
451         PrintLine(false, UniqueLIs.begin()->second);
452       } else {
453         PrintLine(false, std::set<std::string>());
454       }
455     }
456   }
457 
458   return true;
459 }
460 
461 int main(int argc, const char **argv) {
462   InitLLVM X(argc, argv);
463 
464   cl::HideUnrelatedOptions(OptReportCategory);
465   cl::ParseCommandLineOptions(
466       argc, argv,
467       "A tool to generate an optimization report from YAML optimization"
468       " record files.\n");
469 
470   LocationInfoTy LocationInfo;
471   if (!readLocationInfo(LocationInfo))
472     return 1;
473   if (!writeReport(LocationInfo))
474     return 1;
475 
476   return 0;
477 }
478