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
35using namespace llvm;
36
37enum ProfileFormat { PF_None = 0, PF_Text, PF_Binary, PF_GCC };
38
39static 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
50static 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
66static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
67  exitWithError(EC.message(), Whence);
68}
69
70namespace {
71enum ProfileKinds { instr, sample };
72}
73
74static 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
110struct WeightedFile {
111  StringRef Filename;
112  uint64_t Weight;
113
114  WeightedFile() {}
115
116  WeightedFile(StringRef F, uint64_t W) : Filename{F}, Weight{W} {}
117};
118typedef SmallVector<WeightedFile, 5> WeightedFileVector;
119
120static 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
164static sampleprof::SampleProfileFormat FormatMap[] = {
165    sampleprof::SPF_None, sampleprof::SPF_Text, sampleprof::SPF_Binary,
166    sampleprof::SPF_GCC};
167
168static 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
211static 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
226static std::unique_ptr<MemoryBuffer>
227getInputFilenamesFileBuf(const StringRef &InputFilenamesFile) {
228  if (InputFilenamesFile == "")
229    return {};
230
231  auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFilenamesFile);
232  if (!BufOrError)
233    exitWithErrorCode(BufOrError.getError(), InputFilenamesFile);
234
235  return std::move(*BufOrError);
236}
237
238static void parseInputFilenamesFile(MemoryBuffer *Buffer,
239                                    WeightedFileVector &WFV) {
240  if (!Buffer)
241    return;
242
243  SmallVector<StringRef, 8> Entries;
244  StringRef Data = Buffer->getBuffer();
245  Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
246  for (const StringRef &FileWeightEntry : Entries) {
247    StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r");
248    // Skip comments.
249    if (SanitizedEntry.startswith("#"))
250      continue;
251    // If there's no comma, it's an unweighted profile.
252    else if (SanitizedEntry.find(',') == StringRef::npos)
253      WFV.emplace_back(SanitizedEntry, 1);
254    else
255      WFV.emplace_back(parseWeightedFile(SanitizedEntry));
256  }
257}
258
259static int merge_main(int argc, const char *argv[]) {
260  cl::list<std::string> InputFilenames(cl::Positional,
261                                       cl::desc("<filename...>"));
262  cl::list<std::string> WeightedInputFilenames("weighted-input",
263                                               cl::desc("<weight>,<filename>"));
264  cl::opt<std::string> InputFilenamesFile(
265      "input-files", cl::init(""),
266      cl::desc("Path to file containing newline-separated "
267               "[<weight>,]<filename> entries"));
268  cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
269                                cl::aliasopt(InputFilenamesFile));
270  cl::opt<bool> DumpInputFileList(
271      "dump-input-file-list", cl::init(false), cl::Hidden,
272      cl::desc("Dump the list of input files and their weights, then exit"));
273  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
274                                      cl::init("-"), cl::Required,
275                                      cl::desc("Output file"));
276  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
277                            cl::aliasopt(OutputFilename));
278  cl::opt<ProfileKinds> ProfileKind(
279      cl::desc("Profile kind:"), cl::init(instr),
280      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
281                 clEnumVal(sample, "Sample profile"), clEnumValEnd));
282  cl::opt<ProfileFormat> OutputFormat(
283      cl::desc("Format of output profile"), cl::init(PF_Binary),
284      cl::values(clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
285                 clEnumValN(PF_Text, "text", "Text encoding"),
286                 clEnumValN(PF_GCC, "gcc",
287                            "GCC encoding (only meaningful for -sample)"),
288                 clEnumValEnd));
289  cl::opt<bool> OutputSparse("sparse", cl::init(false),
290      cl::desc("Generate a sparse profile (only meaningful for -instr)"));
291
292  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
293
294  WeightedFileVector WeightedInputs;
295  for (StringRef Filename : InputFilenames)
296    WeightedInputs.emplace_back(Filename, 1);
297  for (StringRef WeightedFilename : WeightedInputFilenames)
298    WeightedInputs.emplace_back(parseWeightedFile(WeightedFilename));
299
300  // Make sure that the file buffer stays alive for the duration of the
301  // weighted input vector's lifetime.
302  auto Buffer = getInputFilenamesFileBuf(InputFilenamesFile);
303  parseInputFilenamesFile(Buffer.get(), WeightedInputs);
304
305  if (WeightedInputs.empty())
306    exitWithError("No input files specified. See " +
307                  sys::path::filename(argv[0]) + " -help");
308
309  if (DumpInputFileList) {
310    for (auto &WF : WeightedInputs)
311      outs() << WF.Weight << "," << WF.Filename << "\n";
312    return 0;
313  }
314
315  if (ProfileKind == instr)
316    mergeInstrProfile(WeightedInputs, OutputFilename, OutputFormat,
317                      OutputSparse);
318  else
319    mergeSampleProfile(WeightedInputs, OutputFilename, OutputFormat);
320
321  return 0;
322}
323
324static int showInstrProfile(const std::string &Filename, bool ShowCounts,
325                            bool ShowIndirectCallTargets,
326                            bool ShowDetailedSummary,
327                            std::vector<uint32_t> DetailedSummaryCutoffs,
328                            bool ShowAllFunctions,
329                            const std::string &ShowFunction, bool TextFormat,
330                            raw_fd_ostream &OS) {
331  auto ReaderOrErr = InstrProfReader::create(Filename);
332  std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
333  if (ShowDetailedSummary && Cutoffs.empty()) {
334    Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
335  }
336  InstrProfSummaryBuilder Builder(std::move(Cutoffs));
337  if (Error E = ReaderOrErr.takeError())
338    exitWithError(std::move(E), Filename);
339
340  auto Reader = std::move(ReaderOrErr.get());
341  bool IsIRInstr = Reader->isIRLevelProfile();
342  size_t ShownFunctions = 0;
343  uint64_t TotalNumValueSites = 0;
344  uint64_t TotalNumValueSitesWithValueProfile = 0;
345  uint64_t TotalNumValues = 0;
346  for (const auto &Func : *Reader) {
347    bool Show =
348        ShowAllFunctions || (!ShowFunction.empty() &&
349                             Func.Name.find(ShowFunction) != Func.Name.npos);
350
351    bool doTextFormatDump = (Show && ShowCounts && TextFormat);
352
353    if (doTextFormatDump) {
354      InstrProfSymtab &Symtab = Reader->getSymtab();
355      InstrProfWriter::writeRecordInText(Func, Symtab, OS);
356      continue;
357    }
358
359    assert(Func.Counts.size() > 0 && "function missing entry counter");
360    Builder.addRecord(Func);
361
362    if (Show) {
363
364      if (!ShownFunctions)
365        OS << "Counters:\n";
366
367      ++ShownFunctions;
368
369      OS << "  " << Func.Name << ":\n"
370         << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
371         << "    Counters: " << Func.Counts.size() << "\n";
372      if (!IsIRInstr)
373        OS << "    Function count: " << Func.Counts[0] << "\n";
374
375      if (ShowIndirectCallTargets)
376        OS << "    Indirect Call Site Count: "
377           << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";
378
379      if (ShowCounts) {
380        OS << "    Block counts: [";
381        size_t Start = (IsIRInstr ? 0 : 1);
382        for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
383          OS << (I == Start ? "" : ", ") << Func.Counts[I];
384        }
385        OS << "]\n";
386      }
387
388      if (ShowIndirectCallTargets) {
389        InstrProfSymtab &Symtab = Reader->getSymtab();
390        uint32_t NS = Func.getNumValueSites(IPVK_IndirectCallTarget);
391        OS << "    Indirect Target Results: \n";
392        TotalNumValueSites += NS;
393        for (size_t I = 0; I < NS; ++I) {
394          uint32_t NV = Func.getNumValueDataForSite(IPVK_IndirectCallTarget, I);
395          std::unique_ptr<InstrProfValueData[]> VD =
396              Func.getValueForSite(IPVK_IndirectCallTarget, I);
397          TotalNumValues += NV;
398          if (NV)
399            TotalNumValueSitesWithValueProfile++;
400          for (uint32_t V = 0; V < NV; V++) {
401            OS << "\t[ " << I << ", ";
402            OS << Symtab.getFuncName(VD[V].Value) << ", " << VD[V].Count
403               << " ]\n";
404          }
405        }
406      }
407    }
408  }
409  if (Reader->hasError())
410    exitWithError(Reader->getError(), Filename);
411
412  if (ShowCounts && TextFormat)
413    return 0;
414  std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
415  if (ShowAllFunctions || !ShowFunction.empty())
416    OS << "Functions shown: " << ShownFunctions << "\n";
417  OS << "Total functions: " << PS->getNumFunctions() << "\n";
418  OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
419  OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
420  if (ShownFunctions && ShowIndirectCallTargets) {
421    OS << "Total Number of Indirect Call Sites : " << TotalNumValueSites
422       << "\n";
423    OS << "Total Number of Sites With Values : "
424       << TotalNumValueSitesWithValueProfile << "\n";
425    OS << "Total Number of Profiled Values : " << TotalNumValues << "\n";
426  }
427
428  if (ShowDetailedSummary) {
429    OS << "Detailed summary:\n";
430    OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
431    OS << "Total count: " << PS->getTotalCount() << "\n";
432    for (auto Entry : PS->getDetailedSummary()) {
433      OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount
434         << " account for "
435         << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100)
436         << " percentage of the total counts.\n";
437    }
438  }
439  return 0;
440}
441
442static int showSampleProfile(const std::string &Filename, bool ShowCounts,
443                             bool ShowAllFunctions,
444                             const std::string &ShowFunction,
445                             raw_fd_ostream &OS) {
446  using namespace sampleprof;
447  LLVMContext Context;
448  auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
449  if (std::error_code EC = ReaderOrErr.getError())
450    exitWithErrorCode(EC, Filename);
451
452  auto Reader = std::move(ReaderOrErr.get());
453  if (std::error_code EC = Reader->read())
454    exitWithErrorCode(EC, Filename);
455
456  if (ShowAllFunctions || ShowFunction.empty())
457    Reader->dump(OS);
458  else
459    Reader->dumpFunctionProfile(ShowFunction, OS);
460
461  return 0;
462}
463
464static int show_main(int argc, const char *argv[]) {
465  cl::opt<std::string> Filename(cl::Positional, cl::Required,
466                                cl::desc("<profdata-file>"));
467
468  cl::opt<bool> ShowCounts("counts", cl::init(false),
469                           cl::desc("Show counter values for shown functions"));
470  cl::opt<bool> TextFormat(
471      "text", cl::init(false),
472      cl::desc("Show instr profile data in text dump format"));
473  cl::opt<bool> ShowIndirectCallTargets(
474      "ic-targets", cl::init(false),
475      cl::desc("Show indirect call site target values for shown functions"));
476  cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
477                                    cl::desc("Show detailed profile summary"));
478  cl::list<uint32_t> DetailedSummaryCutoffs(
479      cl::CommaSeparated, "detailed-summary-cutoffs",
480      cl::desc(
481          "Cutoff percentages (times 10000) for generating detailed summary"),
482      cl::value_desc("800000,901000,999999"));
483  cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
484                                 cl::desc("Details for every function"));
485  cl::opt<std::string> ShowFunction("function",
486                                    cl::desc("Details for matching functions"));
487
488  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
489                                      cl::init("-"), cl::desc("Output file"));
490  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
491                            cl::aliasopt(OutputFilename));
492  cl::opt<ProfileKinds> ProfileKind(
493      cl::desc("Profile kind:"), cl::init(instr),
494      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
495                 clEnumVal(sample, "Sample profile"), clEnumValEnd));
496
497  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
498
499  if (OutputFilename.empty())
500    OutputFilename = "-";
501
502  std::error_code EC;
503  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::F_Text);
504  if (EC)
505    exitWithErrorCode(EC, OutputFilename);
506
507  if (ShowAllFunctions && !ShowFunction.empty())
508    errs() << "warning: -function argument ignored: showing all functions\n";
509
510  std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs.begin(),
511                                DetailedSummaryCutoffs.end());
512  if (ProfileKind == instr)
513    return showInstrProfile(Filename, ShowCounts, ShowIndirectCallTargets,
514                            ShowDetailedSummary, DetailedSummaryCutoffs,
515                            ShowAllFunctions, ShowFunction, TextFormat, OS);
516  else
517    return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
518                             ShowFunction, OS);
519}
520
521int main(int argc, const char *argv[]) {
522  // Print a stack trace if we signal out.
523  sys::PrintStackTraceOnErrorSignal(argv[0]);
524  PrettyStackTraceProgram X(argc, argv);
525  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
526
527  StringRef ProgName(sys::path::filename(argv[0]));
528  if (argc > 1) {
529    int (*func)(int, const char *[]) = nullptr;
530
531    if (strcmp(argv[1], "merge") == 0)
532      func = merge_main;
533    else if (strcmp(argv[1], "show") == 0)
534      func = show_main;
535
536    if (func) {
537      std::string Invocation(ProgName.str() + " " + argv[1]);
538      argv[1] = Invocation.c_str();
539      return func(argc - 1, argv + 1);
540    }
541
542    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
543        strcmp(argv[1], "--help") == 0) {
544
545      errs() << "OVERVIEW: LLVM profile data tools\n\n"
546             << "USAGE: " << ProgName << " <command> [args...]\n"
547             << "USAGE: " << ProgName << " <command> -help\n\n"
548             << "Available commands: merge, show\n";
549      return 0;
550    }
551  }
552
553  if (argc < 2)
554    errs() << ProgName << ": No command specified!\n";
555  else
556    errs() << ProgName << ": Unknown command!\n";
557
558  errs() << "USAGE: " << ProgName << " <merge|show> [args...]\n";
559  return 1;
560}
561