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[File][Line][Remark.FunctionName][Column];
229       UpdateLLII(LI.Inlined);
230     } else if (Remark.PassName == "loop-unroll") {
231       auto &LI = LocationInfo[File][Line][Remark.FunctionName][Column];
232       LI.UnrollCount = UnrollCount;
233       UpdateLLII(LI.Unrolled);
234     } else if (Remark.PassName == "loop-vectorize") {
235       auto &LI = LocationInfo[File][Line][Remark.FunctionName][Column];
236       LI.VectorizationFactor = VectorizationFactor;
237       LI.InterleaveCount = InterleaveCount;
238       UpdateLLII(LI.Vectorized);
239     }
240   }
241 
242   return true;
243 }
244 
245 static bool writeReport(LocationInfoTy &LocationInfo) {
246   std::error_code EC;
247   llvm::raw_fd_ostream OS(OutputFileName, EC, llvm::sys::fs::OF_Text);
248   if (EC) {
249     WithColor::error() << "Can't open file " << OutputFileName << ": "
250                        << EC.message() << "\n";
251     return false;
252   }
253 
254   bool FirstFile = true;
255   for (auto &FI : LocationInfo) {
256     SmallString<128> FileName(FI.first);
257     if (!InputRelDir.empty())
258       sys::fs::make_absolute(InputRelDir, FileName);
259 
260     const auto &FileInfo = FI.second;
261 
262     ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
263         MemoryBuffer::getFile(FileName);
264     if (std::error_code EC = Buf.getError()) {
265       WithColor::error() << "Can't open file " << FileName << ": "
266                          << EC.message() << "\n";
267       return false;
268     }
269 
270     if (FirstFile)
271       FirstFile = false;
272     else
273       OS << "\n";
274 
275     OS << "< " << FileName << "\n";
276 
277     // Figure out how many characters we need for the vectorization factors
278     // and similar.
279     OptReportLocationInfo MaxLI;
280     for (auto &FLI : FileInfo)
281       for (auto &FI : FLI.second)
282         for (auto &LI : FI.second)
283           MaxLI |= LI.second;
284 
285     bool NothingInlined = !MaxLI.Inlined.Transformed;
286     bool NothingUnrolled = !MaxLI.Unrolled.Transformed;
287     bool NothingVectorized = !MaxLI.Vectorized.Transformed;
288 
289     unsigned VFDigits = llvm::utostr(MaxLI.VectorizationFactor).size();
290     unsigned ICDigits = llvm::utostr(MaxLI.InterleaveCount).size();
291     unsigned UCDigits = llvm::utostr(MaxLI.UnrollCount).size();
292 
293     // Figure out how many characters we need for the line numbers.
294     int64_t NumLines = 0;
295     for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI)
296       ++NumLines;
297 
298     unsigned LNDigits = llvm::utostr(NumLines).size();
299 
300     for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI) {
301       int64_t L = LI.line_number();
302       auto LII = FileInfo.find(L);
303 
304       auto PrintLine = [&](bool PrintFuncName,
305                            const std::set<std::string> &FuncNameSet) {
306         OptReportLocationInfo LLI;
307 
308         std::map<int, OptReportLocationInfo> ColsInfo;
309         unsigned InlinedCols = 0, UnrolledCols = 0, VectorizedCols = 0;
310 
311         if (LII != FileInfo.end() && !FuncNameSet.empty()) {
312           const auto &LineInfo = LII->second;
313 
314           for (auto &CI : LineInfo.find(*FuncNameSet.begin())->second) {
315             int Col = CI.first;
316             ColsInfo[Col] = CI.second;
317             InlinedCols += CI.second.Inlined.Analyzed;
318             UnrolledCols += CI.second.Unrolled.Analyzed;
319             VectorizedCols += CI.second.Vectorized.Analyzed;
320             LLI |= CI.second;
321           }
322         }
323 
324         if (PrintFuncName) {
325           OS << "  > ";
326 
327           bool FirstFunc = true;
328           for (const auto &FuncName : FuncNameSet) {
329             if (FirstFunc)
330               FirstFunc = false;
331             else
332               OS << ", ";
333 
334             bool Printed = false;
335             if (!NoDemangle) {
336               int Status = 0;
337               char *Demangled =
338                 itaniumDemangle(FuncName.c_str(), nullptr, nullptr, &Status);
339               if (Demangled && Status == 0) {
340                 OS << Demangled;
341                 Printed = true;
342               }
343 
344               if (Demangled)
345                 std::free(Demangled);
346             }
347 
348             if (!Printed)
349               OS << FuncName;
350           }
351 
352           OS << ":\n";
353         }
354 
355         // We try to keep the output as concise as possible. If only one thing on
356         // a given line could have been inlined, vectorized, etc. then we can put
357         // the marker on the source line itself. If there are multiple options
358         // then we want to distinguish them by placing the marker for each
359         // transformation on a separate line following the source line. When we
360         // do this, we use a '^' character to point to the appropriate column in
361         // the source line.
362 
363         std::string USpaces(Succinct ? 0 : UCDigits, ' ');
364         std::string VSpaces(Succinct ? 0 : VFDigits + ICDigits + 1, ' ');
365 
366         auto UStr = [UCDigits](OptReportLocationInfo &LLI) {
367           std::string R;
368           raw_string_ostream RS(R);
369 
370           if (!Succinct) {
371             RS << LLI.UnrollCount;
372             RS << std::string(UCDigits - RS.str().size(), ' ');
373           }
374 
375           return RS.str();
376         };
377 
378         auto VStr = [VFDigits,
379                      ICDigits](OptReportLocationInfo &LLI) -> std::string {
380           std::string R;
381           raw_string_ostream RS(R);
382 
383           if (!Succinct) {
384             RS << LLI.VectorizationFactor << "," << LLI.InterleaveCount;
385             RS << std::string(VFDigits + ICDigits + 1 - RS.str().size(), ' ');
386           }
387 
388           return RS.str();
389         };
390 
391         OS << llvm::format_decimal(L, LNDigits) << " ";
392         OS << (LLI.Inlined.Transformed && InlinedCols < 2 ? "I" :
393                 (NothingInlined ? "" : " "));
394         OS << (LLI.Unrolled.Transformed && UnrolledCols < 2 ?
395                 "U" + UStr(LLI) : (NothingUnrolled ? "" : " " + USpaces));
396         OS << (LLI.Vectorized.Transformed && VectorizedCols < 2 ?
397                 "V" + VStr(LLI) : (NothingVectorized ? "" : " " + VSpaces));
398 
399         OS << " | " << *LI << "\n";
400 
401         for (auto &J : ColsInfo) {
402           if ((J.second.Inlined.Transformed && InlinedCols > 1) ||
403               (J.second.Unrolled.Transformed && UnrolledCols > 1) ||
404               (J.second.Vectorized.Transformed && VectorizedCols > 1)) {
405             OS << std::string(LNDigits + 1, ' ');
406             OS << (J.second.Inlined.Transformed &&
407                    InlinedCols > 1 ? "I" : (NothingInlined ? "" : " "));
408             OS << (J.second.Unrolled.Transformed &&
409                    UnrolledCols > 1 ? "U" + UStr(J.second) :
410                      (NothingUnrolled ? "" : " " + USpaces));
411             OS << (J.second.Vectorized.Transformed &&
412                    VectorizedCols > 1 ? "V" + VStr(J.second) :
413                      (NothingVectorized ? "" : " " + VSpaces));
414 
415             OS << " | " << std::string(J.first - 1, ' ') << "^\n";
416           }
417         }
418       };
419 
420       // We need to figure out if the optimizations for this line were the same
421       // in each function context. If not, then we want to group the similar
422       // function contexts together and display each group separately. If
423       // they're all the same, then we only display the line once without any
424       // additional markings.
425       std::map<std::map<int, OptReportLocationInfo>,
426                std::set<std::string>> UniqueLIs;
427 
428       OptReportLocationInfo AllLI;
429       if (LII != FileInfo.end()) {
430         const auto &FuncLineInfo = LII->second;
431         for (const auto &FLII : FuncLineInfo) {
432           UniqueLIs[FLII.second].insert(FLII.first);
433 
434           for (const auto &OI : FLII.second)
435             AllLI |= OI.second;
436         }
437       }
438 
439       bool NothingHappened = !AllLI.Inlined.Transformed &&
440                              !AllLI.Unrolled.Transformed &&
441                              !AllLI.Vectorized.Transformed;
442       if (UniqueLIs.size() > 1 && !NothingHappened) {
443         OS << " [[\n";
444         for (const auto &FSLI : UniqueLIs)
445           PrintLine(true, FSLI.second);
446         OS << " ]]\n";
447       } else if (UniqueLIs.size() == 1) {
448         PrintLine(false, UniqueLIs.begin()->second);
449       } else {
450         PrintLine(false, std::set<std::string>());
451       }
452     }
453   }
454 
455   return true;
456 }
457 
458 int main(int argc, const char **argv) {
459   InitLLVM X(argc, argv);
460 
461   cl::HideUnrelatedOptions(OptReportCategory);
462   cl::ParseCommandLineOptions(
463       argc, argv,
464       "A tool to generate an optimization report from YAML optimization"
465       " record files.\n");
466 
467   LocationInfoTy LocationInfo;
468   if (!readLocationInfo(LocationInfo))
469     return 1;
470   if (!writeReport(LocationInfo))
471     return 1;
472 
473   return 0;
474 }
475