1 //===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // llvm-profdata merges .profdata files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/SmallSet.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/IR/LLVMContext.h"
18 #include "llvm/ProfileData/InstrProfReader.h"
19 #include "llvm/ProfileData/InstrProfWriter.h"
20 #include "llvm/ProfileData/ProfileCommon.h"
21 #include "llvm/ProfileData/SampleProfReader.h"
22 #include "llvm/ProfileData/SampleProfWriter.h"
23 #include "llvm/Support/CommandLine.h"
24 #include "llvm/Support/Errc.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/Format.h"
27 #include "llvm/Support/ManagedStatic.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/PrettyStackTrace.h"
31 #include "llvm/Support/Signals.h"
32 #include "llvm/Support/raw_ostream.h"
33 #include <algorithm>
34 
35 using namespace llvm;
36 
37 enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC };
38 
39 static void exitWithError(const Twine &Message, StringRef Whence = "",
40                           StringRef Hint = "") {
41   errs() << "error: ";
42   if (!Whence.empty())
43     errs() << Whence << ": ";
44   errs() << Message << "\n";
45   if (!Hint.empty())
46     errs() << Hint << "\n";
47   ::exit(1);
48 }
49 
50 static void exitWithError(Error E, StringRef Whence = "") {
51   if (E.isA<InstrProfError>()) {
52     handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
53       instrprof_error instrError = IPE.get();
54       StringRef Hint = "";
55       if (instrError == instrprof_error::unrecognized_format) {
56         // Hint for common error of forgetting -sample for sample profiles.
57         Hint = "Perhaps you forgot to use the -sample option?";
58       }
59       exitWithError(IPE.message(), Whence, Hint);
60     });
61   }
62 
63   exitWithError(toString(std::move(E)), Whence);
64 }
65 
66 static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
67   exitWithError(EC.message(), Whence);
68 }
69 
70 namespace {
71 enum ProfileKinds { instr, sample };
72 }
73 
74 static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
75                                    StringRef WhenceFunction = "",
76                                    bool ShowHint = true) {
77   if (!WhenceFile.empty())
78     errs() << WhenceFile << ": ";
79   if (!WhenceFunction.empty())
80     errs() << WhenceFunction << ": ";
81 
82   auto IPE = instrprof_error::success;
83   E = handleErrors(std::move(E),
84                    [&IPE](std::unique_ptr<InstrProfError> E) -> Error {
85                      IPE = E->get();
86                      return Error(std::move(E));
87                    });
88   errs() << toString(std::move(E)) << "\n";
89 
90   if (ShowHint) {
91     StringRef Hint = "";
92     if (IPE != instrprof_error::success) {
93       switch (IPE) {
94       case instrprof_error::hash_mismatch:
95       case instrprof_error::count_mismatch:
96       case instrprof_error::value_site_count_mismatch:
97         Hint = "Make sure that all profile data to be merged is generated "
98                "from the same binary.";
99         break;
100       default:
101         break;
102       }
103     }
104 
105     if (!Hint.empty())
106       errs() << Hint << "\n";
107   }
108 }
109 
110 struct WeightedFile {
111   StringRef Filename;
112   uint64_t Weight;
113 
114   WeightedFile() {}
115 
116   WeightedFile(StringRef F, uint64_t W) : Filename{F}, Weight{W} {}
117 };
118 typedef SmallVector<WeightedFile, 5> WeightedFileVector;
119 
120 static void mergeInstrProfile(const WeightedFileVector &Inputs,
121                               StringRef OutputFilename,
122                               ProfileFormat OutputFormat, bool OutputSparse) {
123   if (OutputFilename.compare("-") == 0)
124     exitWithError("Cannot write indexed profdata format to stdout.");
125 
126   if (OutputFormat != PF_Binary && OutputFormat != PF_Text)
127     exitWithError("Unknown format is specified.");
128 
129   std::error_code EC;
130   raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None);
131   if (EC)
132     exitWithErrorCode(EC, OutputFilename);
133 
134   InstrProfWriter Writer(OutputSparse);
135   SmallSet<instrprof_error, 4> WriterErrorCodes;
136   for (const auto &Input : Inputs) {
137     auto ReaderOrErr = InstrProfReader::create(Input.Filename);
138     if (Error E = ReaderOrErr.takeError())
139       exitWithError(std::move(E), Input.Filename);
140 
141     auto Reader = std::move(ReaderOrErr.get());
142     bool IsIRProfile = Reader->isIRLevelProfile();
143     if (Writer.setIsIRLevelProfile(IsIRProfile))
144       exitWithError("Merge IR generated profile with Clang generated profile.");
145 
146     for (auto &I : *Reader) {
147       if (Error E = Writer.addRecord(std::move(I), Input.Weight)) {
148         // Only show hint the first time an error occurs.
149         instrprof_error IPE = InstrProfError::take(std::move(E));
150         bool firstTime = WriterErrorCodes.insert(IPE).second;
151         handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
152                                I.Name, firstTime);
153       }
154     }
155     if (Reader->hasError())
156       exitWithError(Reader->getError(), Input.Filename);
157   }
158   if (OutputFormat == PF_Text)
159     Writer.writeText(Output);
160   else
161     Writer.write(Output);
162 }
163 
164 static sampleprof::SampleProfileFormat FormatMap[] = {
165     sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary,
166     sampleprof::SPF_GCC};
167 
168 static void mergeSampleProfile(const WeightedFileVector &Inputs,
169                                StringRef OutputFilename,
170                                ProfileFormat OutputFormat) {
171   using namespace sampleprof;
172   auto WriterOrErr =
173       SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
174   if (std::error_code EC = WriterOrErr.getError())
175     exitWithErrorCode(EC, OutputFilename);
176 
177   auto Writer = std::move(WriterOrErr.get());
178   StringMap<FunctionSamples> ProfileMap;
179   SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
180   LLVMContext Context;
181   for (const auto &Input : Inputs) {
182     auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context);
183     if (std::error_code EC = ReaderOrErr.getError())
184       exitWithErrorCode(EC, Input.Filename);
185 
186     // We need to keep the readers around until after all the files are
187     // read so that we do not lose the function names stored in each
188     // reader's memory. The function names are needed to write out the
189     // merged profile map.
190     Readers.push_back(std::move(ReaderOrErr.get()));
191     const auto Reader = Readers.back().get();
192     if (std::error_code EC = Reader->read())
193       exitWithErrorCode(EC, Input.Filename);
194 
195     StringMap<FunctionSamples> &Profiles = Reader->getProfiles();
196     for (StringMap<FunctionSamples>::iterator I = Profiles.begin(),
197                                               E = Profiles.end();
198          I != E; ++I) {
199       StringRef FName = I->first();
200       FunctionSamples &Samples = I->second;
201       sampleprof_error Result = ProfileMap[FName].merge(Samples, Input.Weight);
202       if (Result != sampleprof_error::success) {
203         std::error_code EC = make_error_code(Result);
204         handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName);
205       }
206     }
207   }
208   Writer->write(ProfileMap);
209 }
210 
211 static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
212   StringRef WeightStr, FileName;
213   std::tie(WeightStr, FileName) = WeightedFilename.split(',');
214 
215   uint64_t Weight;
216   if (WeightStr.getAsInteger(10, Weight) || Weight < 1)
217     exitWithError("Input weight must be a positive integer.");
218 
219   if (!sys::fs::exists(FileName))
220     exitWithErrorCode(make_error_code(errc::no_such_file_or_directory),
221                       FileName);
222 
223   return WeightedFile(FileName, Weight);
224 }
225 
226 static void parseInputFilenamesFile(const StringRef &InputFilenamesFile,
227                                     WeightedFileVector &WFV) {
228   if (InputFilenamesFile == "")
229     return;
230 
231   auto Buf = MemoryBuffer::getFileOrSTDIN(InputFilenamesFile);
232   if (!Buf)
233     exitWithErrorCode(Buf.getError(), InputFilenamesFile);
234 
235   StringRef Data = Buf.get()->getBuffer();
236   SmallVector<StringRef, 8> Entries;
237   Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
238   for (const StringRef &FileWeightEntry : Entries) {
239     StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r");
240     // Skip comments.
241     if (SanitizedEntry.startswith("#"))
242       continue;
243     // If there's no comma, it's an unweighted profile.
244     else if (SanitizedEntry.rfind(',') == StringRef::npos)
245       WFV.emplace_back(SanitizedEntry, 1);
246     else
247       WFV.emplace_back(parseWeightedFile(SanitizedEntry));
248   }
249 }
250 
251 static int merge_main(int argc, const char *argv[]) {
252   cl::list<std::string> InputFilenames(cl::Positional,
253                                        cl::desc("<filename...>"));
254   cl::list<std::string> WeightedInputFilenames("weighted-input",
255                                                cl::desc("<weight>,<filename>"));
256   cl::opt<std::string> InputFilenamesFile(
257       "input-files", cl::init(""),
258       cl::desc("Path to file containing newline-separated "
259                "[<weight>,]<filename> entries"));
260   cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
261                                 cl::aliasopt(InputFilenamesFile));
262   cl::opt<bool> DumpInputFileList(
263       "dump-input-file-list", cl::init(false), cl::Hidden,
264       cl::desc("Dump the list of input files and their weights, then exit"));
265   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
266                                       cl::init("-"), cl::Required,
267                                       cl::desc("Output file"));
268   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
269                             cl::aliasopt(OutputFilename));
270   cl::opt<ProfileKinds> ProfileKind(
271       cl::desc("Profile kind:"), cl::init(instr),
272       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
273                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
274   cl::opt<ProfileFormat> OutputFormat(
275       cl::desc("Format of output profile"), cl::init(PF_Binary),
276       cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
277                  clEnumValN(PF_Text, "text", "Text encoding"),
278                  clEnumValN(PF_GCC, "gcc",
279                             "GCC encoding (only meaningful for -sample)"),
280                  clEnumValEnd));
281   cl::opt<bool> OutputSparse("sparse", cl::init(false),
282       cl::desc("Generate a sparse profile (only meaningful for -instr)"));
283 
284   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
285 
286   WeightedFileVector WeightedInputs;
287   for (StringRef Filename : InputFilenames)
288     WeightedInputs.push_back(WeightedFile(Filename, 1));
289   for (StringRef WeightedFilename : WeightedInputFilenames)
290     WeightedInputs.push_back(parseWeightedFile(WeightedFilename));
291   parseInputFilenamesFile(InputFilenamesFile, WeightedInputs);
292 
293   if (WeightedInputs.empty())
294     exitWithError("No input files specified. See " +
295                   sys::path::filename(argv[0]) + " -help");
296 
297   if (DumpInputFileList) {
298     for (auto &WF : WeightedInputs)
299       outs() << WF.Weight << "," << WF.Filename << "\n";
300     return 0;
301   }
302 
303   if (ProfileKind == instr)
304     mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat,
305                       OutputSparse);
306   else
307     mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat);
308 
309   return 0;
310 }
311 
312 static int showInstrProfile(std::string Filename, bool ShowCounts,
313                             bool ShowIndirectCallTargets,
314                             bool ShowDetailedSummary,
315                             std::vector<uint32_t> DetailedSummaryCutoffs,
316                             bool ShowAllFunctions, std::string ShowFunction,
317                             bool TextFormat, raw_fd_ostream &OS) {
318   auto ReaderOrErr = InstrProfReader::create(Filename);
319   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs);
320   if (ShowDetailedSummary && DetailedSummaryCutoffs.empty()) {
321     Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
322   }
323   InstrProfSummaryBuilder Builder(Cutoffs);
324   if (Error E = ReaderOrErr.takeError())
325     exitWithError(std::move(E), Filename);
326 
327   auto Reader = std::move(ReaderOrErr.get());
328   bool IsIRInstr = Reader->isIRLevelProfile();
329   size_t ShownFunctions = 0;
330   uint64_t TotalNumValueSites = 0;
331   uint64_t TotalNumValueSitesWithValueProfile = 0;
332   uint64_t TotalNumValues = 0;
333   for (const auto &Func : *Reader) {
334     bool Show =
335         ShowAllFunctions || (!ShowFunction.empty() &&
336                              Func.Name.find(ShowFunction) != Func.Name.npos);
337 
338     bool doTextFormatDump = (Show && ShowCounts && TextFormat);
339 
340     if (doTextFormatDump) {
341       InstrProfSymtab &Symtab = Reader->getSymtab();
342       InstrProfWriter::writeRecordInText(Func, Symtab, OS);
343       continue;
344     }
345 
346     assert(Func.Counts.size() > 0 && "function missing entry counter");
347     Builder.addRecord(Func);
348 
349     if (Show) {
350 
351       if (!ShownFunctions)
352         OS << "Counters:\n";
353 
354       ++ShownFunctions;
355 
356       OS << "  " << Func.Name << ":\n"
357          << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
358          << "    Counters: " << Func.Counts.size() << "\n";
359       if (!IsIRInstr)
360         OS << "    Function count: " << Func.Counts[0] << "\n";
361 
362       if (ShowIndirectCallTargets)
363         OS << "    Indirect Call Site Count: "
364            << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";
365 
366       if (ShowCounts) {
367         OS << "    Block counts: [";
368         size_t Start = (IsIRInstr ? 0 : 1);
369         for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
370           OS << (I == Start ? "" : ", ") << Func.Counts[I];
371         }
372         OS << "]\n";
373       }
374 
375       if (ShowIndirectCallTargets) {
376         InstrProfSymtab &Symtab = Reader->getSymtab();
377         uint32_t NS = Func.getNumValueSites(IPVK_IndirectCallTarget);
378         OS << "    Indirect Target Results: \n";
379         TotalNumValueSites += NS;
380         for (size_t I = 0; I < NS; ++I) {
381           uint32_t NV = Func.getNumValueDataForSite(IPVK_IndirectCallTarget, I);
382           std::unique_ptr<InstrProfValueData[]> VD =
383               Func.getValueForSite(IPVK_IndirectCallTarget, I);
384           TotalNumValues += NV;
385           if (NV)
386             TotalNumValueSitesWithValueProfile++;
387           for (uint32_t V = 0; V < NV; V++) {
388             OS << "\t[ " << I << ", ";
389             OS << Symtab.getFuncName(VD[V].Value) << ", " << VD[V].Count
390                << " ]\n";
391           }
392         }
393       }
394     }
395   }
396   if (Reader->hasError())
397     exitWithError(Reader->getError(), Filename);
398 
399   if (ShowCounts && TextFormat)
400     return 0;
401   std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
402   if (ShowAllFunctions || !ShowFunction.empty())
403     OS << "Functions shown: " << ShownFunctions << "\n";
404   OS << "Total functions: " << PS->getNumFunctions() << "\n";
405   OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
406   OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
407   if (ShownFunctions && ShowIndirectCallTargets) {
408     OS << "Total Number of Indirect Call Sites : " << TotalNumValueSites
409        << "\n";
410     OS << "Total Number of Sites With Values : "
411        << TotalNumValueSitesWithValueProfile << "\n";
412     OS << "Total Number of Profiled Values : " << TotalNumValues << "\n";
413   }
414 
415   if (ShowDetailedSummary) {
416     OS << "Detailed summary:\n";
417     OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
418     OS << "Total count: " << PS->getTotalCount() << "\n";
419     for (auto Entry : PS->getDetailedSummary()) {
420       OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount
421          << " account for "
422          << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100)
423          << " percentage of the total counts.\n";
424     }
425   }
426   return 0;
427 }
428 
429 static int showSampleProfile(std::string Filename, bool ShowCounts,
430                              bool ShowAllFunctions, std::string ShowFunction,
431                              raw_fd_ostream &OS) {
432   using namespace sampleprof;
433   LLVMContext Context;
434   auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
435   if (std::error_code EC = ReaderOrErr.getError())
436     exitWithErrorCode(EC, Filename);
437 
438   auto Reader = std::move(ReaderOrErr.get());
439   if (std::error_code EC = Reader->read())
440     exitWithErrorCode(EC, Filename);
441 
442   if (ShowAllFunctions || ShowFunction.empty())
443     Reader->dump(OS);
444   else
445     Reader->dumpFunctionProfile(ShowFunction, OS);
446 
447   return 0;
448 }
449 
450 static int show_main(int argc, const char *argv[]) {
451   cl::opt<std::string> Filename(cl::Positional, cl::Required,
452                                 cl::desc("<profdata-file>"));
453 
454   cl::opt<bool> ShowCounts("counts", cl::init(false),
455                            cl::desc("Show counter values for shown functions"));
456   cl::opt<bool> TextFormat(
457       "text", cl::init(false),
458       cl::desc("Show instr profile data in text dump format"));
459   cl::opt<bool> ShowIndirectCallTargets(
460       "ic-targets", cl::init(false),
461       cl::desc("Show indirect call site target values for shown functions"));
462   cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
463                                     cl::desc("Show detailed profile summary"));
464   cl::list<uint32_t> DetailedSummaryCutoffs(
465       cl::CommaSeparated, "detailed-summary-cutoffs",
466       cl::desc(
467           "Cutoff percentages (times 10000) for generating detailed summary"),
468       cl::value_desc("800000,901000,999999"));
469   cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
470                                  cl::desc("Details for every function"));
471   cl::opt<std::string> ShowFunction("function",
472                                     cl::desc("Details for matching functions"));
473 
474   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
475                                       cl::init("-"), cl::desc("Output file"));
476   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
477                             cl::aliasopt(OutputFilename));
478   cl::opt<ProfileKinds> ProfileKind(
479       cl::desc("Profile kind:"), cl::init(instr),
480       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
481                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
482 
483   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
484 
485   if (OutputFilename.empty())
486     OutputFilename = "-";
487 
488   std::error_code EC;
489   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
490   if (EC)
491     exitWithErrorCode(EC, OutputFilename);
492 
493   if (ShowAllFunctions && !ShowFunction.empty())
494     errs() << "warning: -function argument ignored: showing all functions\n";
495 
496   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs.begin(),
497                                 DetailedSummaryCutoffs.end());
498   if (ProfileKind == instr)
499     return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets,
500                             ShowDetailedSummary, DetailedSummaryCutoffs,
501                             ShowAllFunctions, ShowFunction, TextFormat, OS);
502   else
503     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
504                              ShowFunction, OS);
505 }
506 
507 int main(int argc, const char *argv[]) {
508   // Print a stack trace if we signal out.
509   sys::PrintStackTraceOnErrorSignal();
510   PrettyStackTraceProgram X(argc, argv);
511   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
512 
513   StringRef ProgName(sys::path::filename(argv[0]));
514   if (argc > 1) {
515     int (*func)(int, const char *[]) = nullptr;
516 
517     if (strcmp(argv[1], "merge") == 0)
518       func = merge_main;
519     else if (strcmp(argv[1], "show") == 0)
520       func = show_main;
521 
522     if (func) {
523       std::string Invocation(ProgName.str() + " " + argv[1]);
524       argv[1] = Invocation.c_str();
525       return func(argc - 1, argv + 1);
526     }
527 
528     if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
529         strcmp(argv[1], "--help") == 0) {
530 
531       errs() << "OVERVIEW: LLVM profile data tools\n\n"
532              << "USAGE: " << ProgName << " <command> [args...]\n"
533              << "USAGE: " << ProgName << " <command> -help\n\n"
534              << "Available commands: merge, show\n";
535       return 0;
536     }
537   }
538 
539   if (argc < 2)
540     errs() << ProgName << ": No command specified!\n";
541   else
542     errs() << ProgName << ": Unknown command!\n";
543 
544   errs() << "USAGE: " << ProgName << " <merge|show> [args...]\n";
545   return 1;
546 }
547