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 int merge_main(int argc, const char *argv[]) {
227   cl::list<std::string> InputFilenames(cl::Positional,
228                                        cl::desc("<filename...>"));
229   cl::list<std::string> WeightedInputFilenames("weighted-input",
230                                                cl::desc("<weight>,<filename>"));
231   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
232                                       cl::init("-"), cl::Required,
233                                       cl::desc("Output file"));
234   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
235                             cl::aliasopt(OutputFilename));
236   cl::opt<ProfileKinds> ProfileKind(
237       cl::desc("Profile kind:"), cl::init(instr),
238       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
239                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
240   cl::opt<ProfileFormat> OutputFormat(
241       cl::desc("Format of output profile"), cl::init(PF_Binary),
242       cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
243                  clEnumValN(PF_Text, "text", "Text encoding"),
244                  clEnumValN(PF_GCC, "gcc",
245                             "GCC encoding (only meaningful for -sample)"),
246                  clEnumValEnd));
247   cl::opt<bool> OutputSparse("sparse", cl::init(false),
248       cl::desc("Generate a sparse profile (only meaningful for -instr)"));
249 
250   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
251 
252   if (InputFilenames.empty() && WeightedInputFilenames.empty())
253     exitWithError("No input files specified. See " +
254                   sys::path::filename(argv[0]) + " -help");
255 
256   WeightedFileVector WeightedInputs;
257   for (StringRef Filename : InputFilenames)
258     WeightedInputs.push_back(WeightedFile(Filename, 1));
259   for (StringRef WeightedFilename : WeightedInputFilenames)
260     WeightedInputs.push_back(parseWeightedFile(WeightedFilename));
261 
262   if (ProfileKind == instr)
263     mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat,
264                       OutputSparse);
265   else
266     mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat);
267 
268   return 0;
269 }
270 
271 static int showInstrProfile(std::string Filename, bool ShowCounts,
272                             bool ShowIndirectCallTargets,
273                             bool ShowDetailedSummary,
274                             std::vector<uint32_t> DetailedSummaryCutoffs,
275                             bool ShowAllFunctions, std::string ShowFunction,
276                             bool TextFormat, raw_fd_ostream &OS) {
277   auto ReaderOrErr = InstrProfReader::create(Filename);
278   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs);
279   if (ShowDetailedSummary && DetailedSummaryCutoffs.empty()) {
280     Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
281   }
282   InstrProfSummaryBuilder Builder(Cutoffs);
283   if (Error E = ReaderOrErr.takeError())
284     exitWithError(std::move(E), Filename);
285 
286   auto Reader = std::move(ReaderOrErr.get());
287   bool IsIRInstr = Reader->isIRLevelProfile();
288   size_t ShownFunctions = 0;
289   uint64_t TotalNumValueSites = 0;
290   uint64_t TotalNumValueSitesWithValueProfile = 0;
291   uint64_t TotalNumValues = 0;
292   for (const auto &Func : *Reader) {
293     bool Show =
294         ShowAllFunctions || (!ShowFunction.empty() &&
295                              Func.Name.find(ShowFunction) != Func.Name.npos);
296 
297     bool doTextFormatDump = (Show && ShowCounts && TextFormat);
298 
299     if (doTextFormatDump) {
300       InstrProfSymtab &Symtab = Reader->getSymtab();
301       InstrProfWriter::writeRecordInText(Func, Symtab, OS);
302       continue;
303     }
304 
305     assert(Func.Counts.size() > 0 && "function missing entry counter");
306     Builder.addRecord(Func);
307 
308     if (Show) {
309 
310       if (!ShownFunctions)
311         OS << "Counters:\n";
312 
313       ++ShownFunctions;
314 
315       OS << "  " << Func.Name << ":\n"
316          << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
317          << "    Counters: " << Func.Counts.size() << "\n";
318       if (!IsIRInstr)
319         OS << "    Function count: " << Func.Counts[0] << "\n";
320 
321       if (ShowIndirectCallTargets)
322         OS << "    Indirect Call Site Count: "
323            << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";
324 
325       if (ShowCounts) {
326         OS << "    Block counts: [";
327         size_t Start = (IsIRInstr ? 0 : 1);
328         for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
329           OS << (I == Start ? "" : ", ") << Func.Counts[I];
330         }
331         OS << "]\n";
332       }
333 
334       if (ShowIndirectCallTargets) {
335         InstrProfSymtab &Symtab = Reader->getSymtab();
336         uint32_t NS = Func.getNumValueSites(IPVK_IndirectCallTarget);
337         OS << "    Indirect Target Results: \n";
338         TotalNumValueSites += NS;
339         for (size_t I = 0; I < NS; ++I) {
340           uint32_t NV = Func.getNumValueDataForSite(IPVK_IndirectCallTarget, I);
341           std::unique_ptr<InstrProfValueData[]> VD =
342               Func.getValueForSite(IPVK_IndirectCallTarget, I);
343           TotalNumValues += NV;
344           if (NV)
345             TotalNumValueSitesWithValueProfile++;
346           for (uint32_t V = 0; V < NV; V++) {
347             OS << "\t[ " << I << ", ";
348             OS << Symtab.getFuncName(VD[V].Value) << ", " << VD[V].Count
349                << " ]\n";
350           }
351         }
352       }
353     }
354   }
355   if (Reader->hasError())
356     exitWithError(Reader->getError(), Filename);
357 
358   if (ShowCounts && TextFormat)
359     return 0;
360   std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
361   if (ShowAllFunctions || !ShowFunction.empty())
362     OS << "Functions shown: " << ShownFunctions << "\n";
363   OS << "Total functions: " << PS->getNumFunctions() << "\n";
364   OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
365   OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
366   if (ShownFunctions && ShowIndirectCallTargets) {
367     OS << "Total Number of Indirect Call Sites : " << TotalNumValueSites
368        << "\n";
369     OS << "Total Number of Sites With Values : "
370        << TotalNumValueSitesWithValueProfile << "\n";
371     OS << "Total Number of Profiled Values : " << TotalNumValues << "\n";
372   }
373 
374   if (ShowDetailedSummary) {
375     OS << "Detailed summary:\n";
376     OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
377     OS << "Total count: " << PS->getTotalCount() << "\n";
378     for (auto Entry : PS->getDetailedSummary()) {
379       OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount
380          << " account for "
381          << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100)
382          << " percentage of the total counts.\n";
383     }
384   }
385   return 0;
386 }
387 
388 static int showSampleProfile(std::string Filename, bool ShowCounts,
389                              bool ShowAllFunctions, std::string ShowFunction,
390                              raw_fd_ostream &OS) {
391   using namespace sampleprof;
392   LLVMContext Context;
393   auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
394   if (std::error_code EC = ReaderOrErr.getError())
395     exitWithErrorCode(EC, Filename);
396 
397   auto Reader = std::move(ReaderOrErr.get());
398   if (std::error_code EC = Reader->read())
399     exitWithErrorCode(EC, Filename);
400 
401   if (ShowAllFunctions || ShowFunction.empty())
402     Reader->dump(OS);
403   else
404     Reader->dumpFunctionProfile(ShowFunction, OS);
405 
406   return 0;
407 }
408 
409 static int show_main(int argc, const char *argv[]) {
410   cl::opt<std::string> Filename(cl::Positional, cl::Required,
411                                 cl::desc("<profdata-file>"));
412 
413   cl::opt<bool> ShowCounts("counts", cl::init(false),
414                            cl::desc("Show counter values for shown functions"));
415   cl::opt<bool> TextFormat(
416       "text", cl::init(false),
417       cl::desc("Show instr profile data in text dump format"));
418   cl::opt<bool> ShowIndirectCallTargets(
419       "ic-targets", cl::init(false),
420       cl::desc("Show indirect call site target values for shown functions"));
421   cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
422                                     cl::desc("Show detailed profile summary"));
423   cl::list<uint32_t> DetailedSummaryCutoffs(
424       cl::CommaSeparated, "detailed-summary-cutoffs",
425       cl::desc(
426           "Cutoff percentages (times 10000) for generating detailed summary"),
427       cl::value_desc("800000,901000,999999"));
428   cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
429                                  cl::desc("Details for every function"));
430   cl::opt<std::string> ShowFunction("function",
431                                     cl::desc("Details for matching functions"));
432 
433   cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
434                                       cl::init("-"), cl::desc("Output file"));
435   cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
436                             cl::aliasopt(OutputFilename));
437   cl::opt<ProfileKinds> ProfileKind(
438       cl::desc("Profile kind:"), cl::init(instr),
439       cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
440                  clEnumVal(sample, "Sample profile"), clEnumValEnd));
441 
442   cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
443 
444   if (OutputFilename.empty())
445     OutputFilename = "-";
446 
447   std::error_code EC;
448   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
449   if (EC)
450     exitWithErrorCode(EC, OutputFilename);
451 
452   if (ShowAllFunctions && !ShowFunction.empty())
453     errs() << "warning: -function argument ignored: showing all functions\n";
454 
455   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs.begin(),
456                                 DetailedSummaryCutoffs.end());
457   if (ProfileKind == instr)
458     return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets,
459                             ShowDetailedSummary, DetailedSummaryCutoffs,
460                             ShowAllFunctions, ShowFunction, TextFormat, OS);
461   else
462     return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
463                              ShowFunction, OS);
464 }
465 
466 int main(int argc, const char *argv[]) {
467   // Print a stack trace if we signal out.
468   sys::PrintStackTraceOnErrorSignal();
469   PrettyStackTraceProgram X(argc, argv);
470   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
471 
472   StringRef ProgName(sys::path::filename(argv[0]));
473   if (argc > 1) {
474     int (*func)(int, const char *[]) = nullptr;
475 
476     if (strcmp(argv[1], "merge") == 0)
477       func = merge_main;
478     else if (strcmp(argv[1], "show") == 0)
479       func = show_main;
480 
481     if (func) {
482       std::string Invocation(ProgName.str() + " " + argv[1]);
483       argv[1] = Invocation.c_str();
484       return func(argc - 1, argv + 1);
485     }
486 
487     if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
488         strcmp(argv[1], "--help") == 0) {
489 
490       errs() << "OVERVIEW: LLVM profile data tools\n\n"
491              << "USAGE: " << ProgName << " <command> [args...]\n"
492              << "USAGE: " << ProgName << " <command> -help\n\n"
493              << "Available commands: merge, show\n";
494       return 0;
495     }
496   }
497 
498   if (argc < 2)
499     errs() << ProgName << ": No command specified!\n";
500   else
501     errs() << ProgName << ": Unknown command!\n";
502 
503   errs() << "USAGE: " << ProgName << " <merge|show> [args...]\n";
504   return 1;
505 }
506