llvm-profdata.cpp revision 360784 
1//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
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// llvm-profdata merges .profdata files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/SmallSet.h"
14#include "llvm/ADT/SmallVector.h"
15#include "llvm/ADT/StringRef.h"
16#include "llvm/IR/LLVMContext.h"
17#include "llvm/ProfileData/InstrProfReader.h"
18#include "llvm/ProfileData/InstrProfWriter.h"
19#include "llvm/ProfileData/ProfileCommon.h"
20#include "llvm/ProfileData/SampleProfReader.h"
21#include "llvm/ProfileData/SampleProfWriter.h"
22#include "llvm/Support/CommandLine.h"
23#include "llvm/Support/Errc.h"
24#include "llvm/Support/FileSystem.h"
25#include "llvm/Support/Format.h"
26#include "llvm/Support/InitLLVM.h"
27#include "llvm/Support/MemoryBuffer.h"
28#include "llvm/Support/Path.h"
29#include "llvm/Support/Threading.h"
30#include "llvm/Support/ThreadPool.h"
31#include "llvm/Support/WithColor.h"
32#include "llvm/Support/raw_ostream.h"
33#include <algorithm>
34
35using namespace llvm;
36
37enum ProfileFormat {
38  PF_None = 0,
39  PF_Text,
40  PF_Compact_Binary,
41  PF_Ext_Binary,
42  PF_GCC,
43  PF_Binary
44};
45
46static void warn(Twine Message, std::string Whence = "",
47                 std::string Hint = "") {
48  WithColor::warning();
49  if (!Whence.empty())
50    errs() << Whence << ": ";
51  errs() << Message << "\n";
52  if (!Hint.empty())
53    WithColor::note() << Hint << "\n";
54}
55
56static void exitWithError(Twine Message, std::string Whence = "",
57                          std::string Hint = "") {
58  WithColor::error();
59  if (!Whence.empty())
60    errs() << Whence << ": ";
61  errs() << Message << "\n";
62  if (!Hint.empty())
63    WithColor::note() << Hint << "\n";
64  ::exit(1);
65}
66
67static void exitWithError(Error E, StringRef Whence = "") {
68  if (E.isA<InstrProfError>()) {
69    handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
70      instrprof_error instrError = IPE.get();
71      StringRef Hint = "";
72      if (instrError == instrprof_error::unrecognized_format) {
73        // Hint for common error of forgetting -sample for sample profiles.
74        Hint = "Perhaps you forgot to use the -sample option?";
75      }
76      exitWithError(IPE.message(), Whence, Hint);
77    });
78  }
79
80  exitWithError(toString(std::move(E)), Whence);
81}
82
83static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
84  exitWithError(EC.message(), Whence);
85}
86
87namespace {
88enum ProfileKinds { instr, sample };
89enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
90}
91
92static void warnOrExitGivenError(FailureMode FailMode, std::error_code EC,
93                                 StringRef Whence = "") {
94  if (FailMode == failIfAnyAreInvalid)
95    exitWithErrorCode(EC, Whence);
96  else
97    warn(EC.message(), Whence);
98}
99
100static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
101                                   StringRef WhenceFunction = "",
102                                   bool ShowHint = true) {
103  if (!WhenceFile.empty())
104    errs() << WhenceFile << ": ";
105  if (!WhenceFunction.empty())
106    errs() << WhenceFunction << ": ";
107
108  auto IPE = instrprof_error::success;
109  E = handleErrors(std::move(E),
110                   [&IPE](std::unique_ptr<InstrProfError> E) -> Error {
111                     IPE = E->get();
112                     return Error(std::move(E));
113                   });
114  errs() << toString(std::move(E)) << "\n";
115
116  if (ShowHint) {
117    StringRef Hint = "";
118    if (IPE != instrprof_error::success) {
119      switch (IPE) {
120      case instrprof_error::hash_mismatch:
121      case instrprof_error::count_mismatch:
122      case instrprof_error::value_site_count_mismatch:
123        Hint = "Make sure that all profile data to be merged is generated "
124               "from the same binary.";
125        break;
126      default:
127        break;
128      }
129    }
130
131    if (!Hint.empty())
132      errs() << Hint << "\n";
133  }
134}
135
136namespace {
137/// A remapper from original symbol names to new symbol names based on a file
138/// containing a list of mappings from old name to new name.
139class SymbolRemapper {
140  std::unique_ptr<MemoryBuffer> File;
141  DenseMap<StringRef, StringRef> RemappingTable;
142
143public:
144  /// Build a SymbolRemapper from a file containing a list of old/new symbols.
145  static std::unique_ptr<SymbolRemapper> create(StringRef InputFile) {
146    auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
147    if (!BufOrError)
148      exitWithErrorCode(BufOrError.getError(), InputFile);
149
150    auto Remapper = std::make_unique<SymbolRemapper>();
151    Remapper->File = std::move(BufOrError.get());
152
153    for (line_iterator LineIt(*Remapper->File, /*SkipBlanks=*/true, '#');
154         !LineIt.is_at_eof(); ++LineIt) {
155      std::pair<StringRef, StringRef> Parts = LineIt->split(' ');
156      if (Parts.first.empty() || Parts.second.empty() ||
157          Parts.second.count(' ')) {
158        exitWithError("unexpected line in remapping file",
159                      (InputFile + ":" + Twine(LineIt.line_number())).str(),
160                      "expected 'old_symbol new_symbol'");
161      }
162      Remapper->RemappingTable.insert(Parts);
163    }
164    return Remapper;
165  }
166
167  /// Attempt to map the given old symbol into a new symbol.
168  ///
169  /// \return The new symbol, or \p Name if no such symbol was found.
170  StringRef operator()(StringRef Name) {
171    StringRef New = RemappingTable.lookup(Name);
172    return New.empty() ? Name : New;
173  }
174};
175}
176
177struct WeightedFile {
178  std::string Filename;
179  uint64_t Weight;
180};
181typedef SmallVector<WeightedFile, 5> WeightedFileVector;
182
183/// Keep track of merged data and reported errors.
184struct WriterContext {
185  std::mutex Lock;
186  InstrProfWriter Writer;
187  std::vector<std::pair<Error, std::string>> Errors;
188  std::mutex &ErrLock;
189  SmallSet<instrprof_error, 4> &WriterErrorCodes;
190
191  WriterContext(bool IsSparse, std::mutex &ErrLock,
192                SmallSet<instrprof_error, 4> &WriterErrorCodes)
193      : Lock(), Writer(IsSparse), Errors(), ErrLock(ErrLock),
194        WriterErrorCodes(WriterErrorCodes) {}
195};
196
197/// Computer the overlap b/w profile BaseFilename and TestFileName,
198/// and store the program level result to Overlap.
199static void overlapInput(const std::string &BaseFilename,
200                         const std::string &TestFilename, WriterContext *WC,
201                         OverlapStats &Overlap,
202                         const OverlapFuncFilters &FuncFilter,
203                         raw_fd_ostream &OS, bool IsCS) {
204  auto ReaderOrErr = InstrProfReader::create(TestFilename);
205  if (Error E = ReaderOrErr.takeError()) {
206    // Skip the empty profiles by returning sliently.
207    instrprof_error IPE = InstrProfError::take(std::move(E));
208    if (IPE != instrprof_error::empty_raw_profile)
209      WC->Errors.emplace_back(make_error<InstrProfError>(IPE), TestFilename);
210    return;
211  }
212
213  auto Reader = std::move(ReaderOrErr.get());
214  for (auto &I : *Reader) {
215    OverlapStats FuncOverlap(OverlapStats::FunctionLevel);
216    FuncOverlap.setFuncInfo(I.Name, I.Hash);
217
218    WC->Writer.overlapRecord(std::move(I), Overlap, FuncOverlap, FuncFilter);
219    FuncOverlap.dump(OS);
220  }
221}
222
223/// Load an input into a writer context.
224static void loadInput(const WeightedFile &Input, SymbolRemapper *Remapper,
225                      WriterContext *WC) {
226  std::unique_lock<std::mutex> CtxGuard{WC->Lock};
227
228  // Copy the filename, because llvm::ThreadPool copied the input "const
229  // WeightedFile &" by value, making a reference to the filename within it
230  // invalid outside of this packaged task.
231  std::string Filename = Input.Filename;
232
233  auto ReaderOrErr = InstrProfReader::create(Input.Filename);
234  if (Error E = ReaderOrErr.takeError()) {
235    // Skip the empty profiles by returning sliently.
236    instrprof_error IPE = InstrProfError::take(std::move(E));
237    if (IPE != instrprof_error::empty_raw_profile)
238      WC->Errors.emplace_back(make_error<InstrProfError>(IPE), Filename);
239    return;
240  }
241
242  auto Reader = std::move(ReaderOrErr.get());
243  bool IsIRProfile = Reader->isIRLevelProfile();
244  bool HasCSIRProfile = Reader->hasCSIRLevelProfile();
245  if (WC->Writer.setIsIRLevelProfile(IsIRProfile, HasCSIRProfile)) {
246    WC->Errors.emplace_back(
247        make_error<StringError>(
248            "Merge IR generated profile with Clang generated profile.",
249            std::error_code()),
250        Filename);
251    return;
252  }
253
254  for (auto &I : *Reader) {
255    if (Remapper)
256      I.Name = (*Remapper)(I.Name);
257    const StringRef FuncName = I.Name;
258    bool Reported = false;
259    WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
260      if (Reported) {
261        consumeError(std::move(E));
262        return;
263      }
264      Reported = true;
265      // Only show hint the first time an error occurs.
266      instrprof_error IPE = InstrProfError::take(std::move(E));
267      std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
268      bool firstTime = WC->WriterErrorCodes.insert(IPE).second;
269      handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
270                             FuncName, firstTime);
271    });
272  }
273  if (Reader->hasError())
274    if (Error E = Reader->getError())
275      WC->Errors.emplace_back(std::move(E), Filename);
276}
277
278/// Merge the \p Src writer context into \p Dst.
279static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
280  for (auto &ErrorPair : Src->Errors)
281    Dst->Errors.push_back(std::move(ErrorPair));
282  Src->Errors.clear();
283
284  Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) {
285    instrprof_error IPE = InstrProfError::take(std::move(E));
286    std::unique_lock<std::mutex> ErrGuard{Dst->ErrLock};
287    bool firstTime = Dst->WriterErrorCodes.insert(IPE).second;
288    if (firstTime)
289      warn(toString(make_error<InstrProfError>(IPE)));
290  });
291}
292
293static void mergeInstrProfile(const WeightedFileVector &Inputs,
294                              SymbolRemapper *Remapper,
295                              StringRef OutputFilename,
296                              ProfileFormat OutputFormat, bool OutputSparse,
297                              unsigned NumThreads, FailureMode FailMode) {
298  if (OutputFilename.compare("-") == 0)
299    exitWithError("Cannot write indexed profdata format to stdout.");
300
301  if (OutputFormat != PF_Binary && OutputFormat != PF_Compact_Binary &&
302      OutputFormat != PF_Ext_Binary && OutputFormat != PF_Text)
303    exitWithError("Unknown format is specified.");
304
305  std::mutex ErrorLock;
306  SmallSet<instrprof_error, 4> WriterErrorCodes;
307
308  // If NumThreads is not specified, auto-detect a good default.
309  if (NumThreads == 0)
310    NumThreads =
311        std::min(hardware_concurrency(), unsigned((Inputs.size() + 1) / 2));
312
313  // Initialize the writer contexts.
314  SmallVector<std::unique_ptr<WriterContext>, 4> Contexts;
315  for (unsigned I = 0; I < NumThreads; ++I)
316    Contexts.emplace_back(std::make_unique<WriterContext>(
317        OutputSparse, ErrorLock, WriterErrorCodes));
318
319  if (NumThreads == 1) {
320    for (const auto &Input : Inputs)
321      loadInput(Input, Remapper, Contexts[0].get());
322  } else {
323    ThreadPool Pool(NumThreads);
324
325    // Load the inputs in parallel (N/NumThreads serial steps).
326    unsigned Ctx = 0;
327    for (const auto &Input : Inputs) {
328      Pool.async(loadInput, Input, Remapper, Contexts[Ctx].get());
329      Ctx = (Ctx + 1) % NumThreads;
330    }
331    Pool.wait();
332
333    // Merge the writer contexts together (~ lg(NumThreads) serial steps).
334    unsigned Mid = Contexts.size() / 2;
335    unsigned End = Contexts.size();
336    assert(Mid > 0 && "Expected more than one context");
337    do {
338      for (unsigned I = 0; I < Mid; ++I)
339        Pool.async(mergeWriterContexts, Contexts[I].get(),
340                   Contexts[I + Mid].get());
341      Pool.wait();
342      if (End & 1) {
343        Pool.async(mergeWriterContexts, Contexts[0].get(),
344                   Contexts[End - 1].get());
345        Pool.wait();
346      }
347      End = Mid;
348      Mid /= 2;
349    } while (Mid > 0);
350  }
351
352  // Handle deferred errors encountered during merging. If the number of errors
353  // is equal to the number of inputs the merge failed.
354  unsigned NumErrors = 0;
355  for (std::unique_ptr<WriterContext> &WC : Contexts) {
356    for (auto &ErrorPair : WC->Errors) {
357      ++NumErrors;
358      warn(toString(std::move(ErrorPair.first)), ErrorPair.second);
359    }
360  }
361  if (NumErrors == Inputs.size() ||
362      (NumErrors > 0 && FailMode == failIfAnyAreInvalid))
363    exitWithError("No profiles could be merged.");
364
365  std::error_code EC;
366  raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::OF_None);
367  if (EC)
368    exitWithErrorCode(EC, OutputFilename);
369
370  InstrProfWriter &Writer = Contexts[0]->Writer;
371  if (OutputFormat == PF_Text) {
372    if (Error E = Writer.writeText(Output))
373      exitWithError(std::move(E));
374  } else {
375    Writer.write(Output);
376  }
377}
378
379/// Make a copy of the given function samples with all symbol names remapped
380/// by the provided symbol remapper.
381static sampleprof::FunctionSamples
382remapSamples(const sampleprof::FunctionSamples &Samples,
383             SymbolRemapper &Remapper, sampleprof_error &Error) {
384  sampleprof::FunctionSamples Result;
385  Result.setName(Remapper(Samples.getName()));
386  Result.addTotalSamples(Samples.getTotalSamples());
387  Result.addHeadSamples(Samples.getHeadSamples());
388  for (const auto &BodySample : Samples.getBodySamples()) {
389    Result.addBodySamples(BodySample.first.LineOffset,
390                          BodySample.first.Discriminator,
391                          BodySample.second.getSamples());
392    for (const auto &Target : BodySample.second.getCallTargets()) {
393      Result.addCalledTargetSamples(BodySample.first.LineOffset,
394                                    BodySample.first.Discriminator,
395                                    Remapper(Target.first()), Target.second);
396    }
397  }
398  for (const auto &CallsiteSamples : Samples.getCallsiteSamples()) {
399    sampleprof::FunctionSamplesMap &Target =
400        Result.functionSamplesAt(CallsiteSamples.first);
401    for (const auto &Callsite : CallsiteSamples.second) {
402      sampleprof::FunctionSamples Remapped =
403          remapSamples(Callsite.second, Remapper, Error);
404      MergeResult(Error, Target[Remapped.getName()].merge(Remapped));
405    }
406  }
407  return Result;
408}
409
410static sampleprof::SampleProfileFormat FormatMap[] = {
411    sampleprof::SPF_None,
412    sampleprof::SPF_Text,
413    sampleprof::SPF_Compact_Binary,
414    sampleprof::SPF_Ext_Binary,
415    sampleprof::SPF_GCC,
416    sampleprof::SPF_Binary};
417
418static std::unique_ptr<MemoryBuffer>
419getInputFileBuf(const StringRef &InputFile) {
420  if (InputFile == "")
421    return {};
422
423  auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
424  if (!BufOrError)
425    exitWithErrorCode(BufOrError.getError(), InputFile);
426
427  return std::move(*BufOrError);
428}
429
430static void populateProfileSymbolList(MemoryBuffer *Buffer,
431                                      sampleprof::ProfileSymbolList &PSL) {
432  if (!Buffer)
433    return;
434
435  SmallVector<StringRef, 32> SymbolVec;
436  StringRef Data = Buffer->getBuffer();
437  Data.split(SymbolVec, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
438
439  for (StringRef symbol : SymbolVec)
440    PSL.add(symbol);
441}
442
443static void handleExtBinaryWriter(sampleprof::SampleProfileWriter &Writer,
444                                  ProfileFormat OutputFormat,
445                                  MemoryBuffer *Buffer,
446                                  sampleprof::ProfileSymbolList &WriterList,
447                                  bool CompressAllSections) {
448  populateProfileSymbolList(Buffer, WriterList);
449  if (WriterList.size() > 0 && OutputFormat != PF_Ext_Binary)
450    warn("Profile Symbol list is not empty but the output format is not "
451         "ExtBinary format. The list will be lost in the output. ");
452
453  Writer.setProfileSymbolList(&WriterList);
454
455  if (CompressAllSections) {
456    if (OutputFormat != PF_Ext_Binary) {
457      warn("-compress-all-section is ignored. Specify -extbinary to enable it");
458    } else {
459      auto ExtBinaryWriter =
460          static_cast<sampleprof::SampleProfileWriterExtBinary *>(&Writer);
461      ExtBinaryWriter->setToCompressAllSections();
462    }
463  }
464}
465
466static void mergeSampleProfile(const WeightedFileVector &Inputs,
467                               SymbolRemapper *Remapper,
468                               StringRef OutputFilename,
469                               ProfileFormat OutputFormat,
470                               StringRef ProfileSymbolListFile,
471                               bool CompressAllSections, FailureMode FailMode) {
472  using namespace sampleprof;
473  StringMap<FunctionSamples> ProfileMap;
474  SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
475  LLVMContext Context;
476  sampleprof::ProfileSymbolList WriterList;
477  for (const auto &Input : Inputs) {
478    auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context);
479    if (std::error_code EC = ReaderOrErr.getError()) {
480      warnOrExitGivenError(FailMode, EC, Input.Filename);
481      continue;
482    }
483
484    // We need to keep the readers around until after all the files are
485    // read so that we do not lose the function names stored in each
486    // reader's memory. The function names are needed to write out the
487    // merged profile map.
488    Readers.push_back(std::move(ReaderOrErr.get()));
489    const auto Reader = Readers.back().get();
490    if (std::error_code EC = Reader->read()) {
491      warnOrExitGivenError(FailMode, EC, Input.Filename);
492      Readers.pop_back();
493      continue;
494    }
495
496    StringMap<FunctionSamples> &Profiles = Reader->getProfiles();
497    for (StringMap<FunctionSamples>::iterator I = Profiles.begin(),
498                                              E = Profiles.end();
499         I != E; ++I) {
500      sampleprof_error Result = sampleprof_error::success;
501      FunctionSamples Remapped =
502          Remapper ? remapSamples(I->second, *Remapper, Result)
503                   : FunctionSamples();
504      FunctionSamples &Samples = Remapper ? Remapped : I->second;
505      StringRef FName = Samples.getName();
506      MergeResult(Result, ProfileMap[FName].merge(Samples, Input.Weight));
507      if (Result != sampleprof_error::success) {
508        std::error_code EC = make_error_code(Result);
509        handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName);
510      }
511    }
512
513    std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
514        Reader->getProfileSymbolList();
515    if (ReaderList)
516      WriterList.merge(*ReaderList);
517  }
518  auto WriterOrErr =
519      SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
520  if (std::error_code EC = WriterOrErr.getError())
521    exitWithErrorCode(EC, OutputFilename);
522
523  auto Writer = std::move(WriterOrErr.get());
524  // WriterList will have StringRef refering to string in Buffer.
525  // Make sure Buffer lives as long as WriterList.
526  auto Buffer = getInputFileBuf(ProfileSymbolListFile);
527  handleExtBinaryWriter(*Writer, OutputFormat, Buffer.get(), WriterList,
528                        CompressAllSections);
529  Writer->write(ProfileMap);
530}
531
532static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
533  StringRef WeightStr, FileName;
534  std::tie(WeightStr, FileName) = WeightedFilename.split(',');
535
536  uint64_t Weight;
537  if (WeightStr.getAsInteger(10, Weight) || Weight < 1)
538    exitWithError("Input weight must be a positive integer.");
539
540  return {FileName, Weight};
541}
542
543static void addWeightedInput(WeightedFileVector &WNI, const WeightedFile &WF) {
544  StringRef Filename = WF.Filename;
545  uint64_t Weight = WF.Weight;
546
547  // If it's STDIN just pass it on.
548  if (Filename == "-") {
549    WNI.push_back({Filename, Weight});
550    return;
551  }
552
553  llvm::sys::fs::file_status Status;
554  llvm::sys::fs::status(Filename, Status);
555  if (!llvm::sys::fs::exists(Status))
556    exitWithErrorCode(make_error_code(errc::no_such_file_or_directory),
557                      Filename);
558  // If it's a source file, collect it.
559  if (llvm::sys::fs::is_regular_file(Status)) {
560    WNI.push_back({Filename, Weight});
561    return;
562  }
563
564  if (llvm::sys::fs::is_directory(Status)) {
565    std::error_code EC;
566    for (llvm::sys::fs::recursive_directory_iterator F(Filename, EC), E;
567         F != E && !EC; F.increment(EC)) {
568      if (llvm::sys::fs::is_regular_file(F->path())) {
569        addWeightedInput(WNI, {F->path(), Weight});
570      }
571    }
572    if (EC)
573      exitWithErrorCode(EC, Filename);
574  }
575}
576
577static void parseInputFilenamesFile(MemoryBuffer *Buffer,
578                                    WeightedFileVector &WFV) {
579  if (!Buffer)
580    return;
581
582  SmallVector<StringRef, 8> Entries;
583  StringRef Data = Buffer->getBuffer();
584  Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
585  for (const StringRef &FileWeightEntry : Entries) {
586    StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r");
587    // Skip comments.
588    if (SanitizedEntry.startswith("#"))
589      continue;
590    // If there's no comma, it's an unweighted profile.
591    else if (SanitizedEntry.find(',') == StringRef::npos)
592      addWeightedInput(WFV, {SanitizedEntry, 1});
593    else
594      addWeightedInput(WFV, parseWeightedFile(SanitizedEntry));
595  }
596}
597
598static int merge_main(int argc, const char *argv[]) {
599  cl::list<std::string> InputFilenames(cl::Positional,
600                                       cl::desc("<filename...>"));
601  cl::list<std::string> WeightedInputFilenames("weighted-input",
602                                               cl::desc("<weight>,<filename>"));
603  cl::opt<std::string> InputFilenamesFile(
604      "input-files", cl::init(""),
605      cl::desc("Path to file containing newline-separated "
606               "[<weight>,]<filename> entries"));
607  cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
608                                cl::aliasopt(InputFilenamesFile));
609  cl::opt<bool> DumpInputFileList(
610      "dump-input-file-list", cl::init(false), cl::Hidden,
611      cl::desc("Dump the list of input files and their weights, then exit"));
612  cl::opt<std::string> RemappingFile("remapping-file", cl::value_desc("file"),
613                                     cl::desc("Symbol remapping file"));
614  cl::alias RemappingFileA("r", cl::desc("Alias for --remapping-file"),
615                           cl::aliasopt(RemappingFile));
616  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
617                                      cl::init("-"), cl::Required,
618                                      cl::desc("Output file"));
619  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
620                            cl::aliasopt(OutputFilename));
621  cl::opt<ProfileKinds> ProfileKind(
622      cl::desc("Profile kind:"), cl::init(instr),
623      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
624                 clEnumVal(sample, "Sample profile")));
625  cl::opt<ProfileFormat> OutputFormat(
626      cl::desc("Format of output profile"), cl::init(PF_Binary),
627      cl::values(
628          clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
629          clEnumValN(PF_Compact_Binary, "compbinary",
630                     "Compact binary encoding"),
631          clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding"),
632          clEnumValN(PF_Text, "text", "Text encoding"),
633          clEnumValN(PF_GCC, "gcc",
634                     "GCC encoding (only meaningful for -sample)")));
635  cl::opt<FailureMode> FailureMode(
636      "failure-mode", cl::init(failIfAnyAreInvalid), cl::desc("Failure mode:"),
637      cl::values(clEnumValN(failIfAnyAreInvalid, "any",
638                            "Fail if any profile is invalid."),
639                 clEnumValN(failIfAllAreInvalid, "all",
640                            "Fail only if all profiles are invalid.")));
641  cl::opt<bool> OutputSparse("sparse", cl::init(false),
642      cl::desc("Generate a sparse profile (only meaningful for -instr)"));
643  cl::opt<unsigned> NumThreads(
644      "num-threads", cl::init(0),
645      cl::desc("Number of merge threads to use (default: autodetect)"));
646  cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
647                        cl::aliasopt(NumThreads));
648  cl::opt<std::string> ProfileSymbolListFile(
649      "prof-sym-list", cl::init(""),
650      cl::desc("Path to file containing the list of function symbols "
651               "used to populate profile symbol list"));
652  cl::opt<bool> CompressAllSections(
653      "compress-all-sections", cl::init(false), cl::Hidden,
654      cl::desc("Compress all sections when writing the profile (only "
655               "meaningful for -extbinary)"));
656
657  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
658
659  WeightedFileVector WeightedInputs;
660  for (StringRef Filename : InputFilenames)
661    addWeightedInput(WeightedInputs, {Filename, 1});
662  for (StringRef WeightedFilename : WeightedInputFilenames)
663    addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename));
664
665  // Make sure that the file buffer stays alive for the duration of the
666  // weighted input vector's lifetime.
667  auto Buffer = getInputFileBuf(InputFilenamesFile);
668  parseInputFilenamesFile(Buffer.get(), WeightedInputs);
669
670  if (WeightedInputs.empty())
671    exitWithError("No input files specified. See " +
672                  sys::path::filename(argv[0]) + " -help");
673
674  if (DumpInputFileList) {
675    for (auto &WF : WeightedInputs)
676      outs() << WF.Weight << "," << WF.Filename << "\n";
677    return 0;
678  }
679
680  std::unique_ptr<SymbolRemapper> Remapper;
681  if (!RemappingFile.empty())
682    Remapper = SymbolRemapper::create(RemappingFile);
683
684  if (ProfileKind == instr)
685    mergeInstrProfile(WeightedInputs, Remapper.get(), OutputFilename,
686                      OutputFormat, OutputSparse, NumThreads, FailureMode);
687  else
688    mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
689                       OutputFormat, ProfileSymbolListFile, CompressAllSections,
690                       FailureMode);
691
692  return 0;
693}
694
695/// Computer the overlap b/w profile BaseFilename and profile TestFilename.
696static void overlapInstrProfile(const std::string &BaseFilename,
697                                const std::string &TestFilename,
698                                const OverlapFuncFilters &FuncFilter,
699                                raw_fd_ostream &OS, bool IsCS) {
700  std::mutex ErrorLock;
701  SmallSet<instrprof_error, 4> WriterErrorCodes;
702  WriterContext Context(false, ErrorLock, WriterErrorCodes);
703  WeightedFile WeightedInput{BaseFilename, 1};
704  OverlapStats Overlap;
705  Error E = Overlap.accumulateCounts(BaseFilename, TestFilename, IsCS);
706  if (E)
707    exitWithError(std::move(E), "Error in getting profile count sums");
708  if (Overlap.Base.CountSum < 1.0f) {
709    OS << "Sum of edge counts for profile " << BaseFilename << " is 0.\n";
710    exit(0);
711  }
712  if (Overlap.Test.CountSum < 1.0f) {
713    OS << "Sum of edge counts for profile " << TestFilename << " is 0.\n";
714    exit(0);
715  }
716  loadInput(WeightedInput, nullptr, &Context);
717  overlapInput(BaseFilename, TestFilename, &Context, Overlap, FuncFilter, OS,
718               IsCS);
719  Overlap.dump(OS);
720}
721
722static int overlap_main(int argc, const char *argv[]) {
723  cl::opt<std::string> BaseFilename(cl::Positional, cl::Required,
724                                    cl::desc("<base profile file>"));
725  cl::opt<std::string> TestFilename(cl::Positional, cl::Required,
726                                    cl::desc("<test profile file>"));
727  cl::opt<std::string> Output("output", cl::value_desc("output"), cl::init("-"),
728                              cl::desc("Output file"));
729  cl::alias OutputA("o", cl::desc("Alias for --output"), cl::aliasopt(Output));
730  cl::opt<bool> IsCS("cs", cl::init(false),
731                     cl::desc("For context sensitive counts"));
732  cl::opt<unsigned long long> ValueCutoff(
733      "value-cutoff", cl::init(-1),
734      cl::desc(
735          "Function level overlap information for every function in test "
736          "profile with max count value greater then the parameter value"));
737  cl::opt<std::string> FuncNameFilter(
738      "function",
739      cl::desc("Function level overlap information for matching functions"));
740  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data overlap tool\n");
741
742  std::error_code EC;
743  raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_Text);
744  if (EC)
745    exitWithErrorCode(EC, Output);
746
747  overlapInstrProfile(BaseFilename, TestFilename,
748                      OverlapFuncFilters{ValueCutoff, FuncNameFilter}, OS,
749                      IsCS);
750
751  return 0;
752}
753
754typedef struct ValueSitesStats {
755  ValueSitesStats()
756      : TotalNumValueSites(0), TotalNumValueSitesWithValueProfile(0),
757        TotalNumValues(0) {}
758  uint64_t TotalNumValueSites;
759  uint64_t TotalNumValueSitesWithValueProfile;
760  uint64_t TotalNumValues;
761  std::vector<unsigned> ValueSitesHistogram;
762} ValueSitesStats;
763
764static void traverseAllValueSites(const InstrProfRecord &Func, uint32_t VK,
765                                  ValueSitesStats &Stats, raw_fd_ostream &OS,
766                                  InstrProfSymtab *Symtab) {
767  uint32_t NS = Func.getNumValueSites(VK);
768  Stats.TotalNumValueSites += NS;
769  for (size_t I = 0; I < NS; ++I) {
770    uint32_t NV = Func.getNumValueDataForSite(VK, I);
771    std::unique_ptr<InstrProfValueData[]> VD = Func.getValueForSite(VK, I);
772    Stats.TotalNumValues += NV;
773    if (NV) {
774      Stats.TotalNumValueSitesWithValueProfile++;
775      if (NV > Stats.ValueSitesHistogram.size())
776        Stats.ValueSitesHistogram.resize(NV, 0);
777      Stats.ValueSitesHistogram[NV - 1]++;
778    }
779
780    uint64_t SiteSum = 0;
781    for (uint32_t V = 0; V < NV; V++)
782      SiteSum += VD[V].Count;
783    if (SiteSum == 0)
784      SiteSum = 1;
785
786    for (uint32_t V = 0; V < NV; V++) {
787      OS << "\t[ " << format("%2u", I) << ", ";
788      if (Symtab == nullptr)
789        OS << format("%4" PRIu64, VD[V].Value);
790      else
791        OS << Symtab->getFuncName(VD[V].Value);
792      OS << ", " << format("%10" PRId64, VD[V].Count) << " ] ("
793         << format("%.2f%%", (VD[V].Count * 100.0 / SiteSum)) << ")\n";
794    }
795  }
796}
797
798static void showValueSitesStats(raw_fd_ostream &OS, uint32_t VK,
799                                ValueSitesStats &Stats) {
800  OS << "  Total number of sites: " << Stats.TotalNumValueSites << "\n";
801  OS << "  Total number of sites with values: "
802     << Stats.TotalNumValueSitesWithValueProfile << "\n";
803  OS << "  Total number of profiled values: " << Stats.TotalNumValues << "\n";
804
805  OS << "  Value sites histogram:\n\tNumTargets, SiteCount\n";
806  for (unsigned I = 0; I < Stats.ValueSitesHistogram.size(); I++) {
807    if (Stats.ValueSitesHistogram[I] > 0)
808      OS << "\t" << I + 1 << ", " << Stats.ValueSitesHistogram[I] << "\n";
809  }
810}
811
812static int showInstrProfile(const std::string &Filename, bool ShowCounts,
813                            uint32_t TopN, bool ShowIndirectCallTargets,
814                            bool ShowMemOPSizes, bool ShowDetailedSummary,
815                            std::vector<uint32_t> DetailedSummaryCutoffs,
816                            bool ShowAllFunctions, bool ShowCS,
817                            uint64_t ValueCutoff, bool OnlyListBelow,
818                            const std::string &ShowFunction, bool TextFormat,
819                            raw_fd_ostream &OS) {
820  auto ReaderOrErr = InstrProfReader::create(Filename);
821  std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
822  if (ShowDetailedSummary && Cutoffs.empty()) {
823    Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
824  }
825  InstrProfSummaryBuilder Builder(std::move(Cutoffs));
826  if (Error E = ReaderOrErr.takeError())
827    exitWithError(std::move(E), Filename);
828
829  auto Reader = std::move(ReaderOrErr.get());
830  bool IsIRInstr = Reader->isIRLevelProfile();
831  size_t ShownFunctions = 0;
832  size_t BelowCutoffFunctions = 0;
833  int NumVPKind = IPVK_Last - IPVK_First + 1;
834  std::vector<ValueSitesStats> VPStats(NumVPKind);
835
836  auto MinCmp = [](const std::pair<std::string, uint64_t> &v1,
837                   const std::pair<std::string, uint64_t> &v2) {
838    return v1.second > v2.second;
839  };
840
841  std::priority_queue<std::pair<std::string, uint64_t>,
842                      std::vector<std::pair<std::string, uint64_t>>,
843                      decltype(MinCmp)>
844      HottestFuncs(MinCmp);
845
846  if (!TextFormat && OnlyListBelow) {
847    OS << "The list of functions with the maximum counter less than "
848       << ValueCutoff << ":\n";
849  }
850
851  // Add marker so that IR-level instrumentation round-trips properly.
852  if (TextFormat && IsIRInstr)
853    OS << ":ir\n";
854
855  for (const auto &Func : *Reader) {
856    if (Reader->isIRLevelProfile()) {
857      bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
858      if (FuncIsCS != ShowCS)
859        continue;
860    }
861    bool Show =
862        ShowAllFunctions || (!ShowFunction.empty() &&
863                             Func.Name.find(ShowFunction) != Func.Name.npos);
864
865    bool doTextFormatDump = (Show && TextFormat);
866
867    if (doTextFormatDump) {
868      InstrProfSymtab &Symtab = Reader->getSymtab();
869      InstrProfWriter::writeRecordInText(Func.Name, Func.Hash, Func, Symtab,
870                                         OS);
871      continue;
872    }
873
874    assert(Func.Counts.size() > 0 && "function missing entry counter");
875    Builder.addRecord(Func);
876
877    uint64_t FuncMax = 0;
878    uint64_t FuncSum = 0;
879    for (size_t I = 0, E = Func.Counts.size(); I < E; ++I) {
880      FuncMax = std::max(FuncMax, Func.Counts[I]);
881      FuncSum += Func.Counts[I];
882    }
883
884    if (FuncMax < ValueCutoff) {
885      ++BelowCutoffFunctions;
886      if (OnlyListBelow) {
887        OS << "  " << Func.Name << ": (Max = " << FuncMax
888           << " Sum = " << FuncSum << ")\n";
889      }
890      continue;
891    } else if (OnlyListBelow)
892      continue;
893
894    if (TopN) {
895      if (HottestFuncs.size() == TopN) {
896        if (HottestFuncs.top().second < FuncMax) {
897          HottestFuncs.pop();
898          HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
899        }
900      } else
901        HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
902    }
903
904    if (Show) {
905      if (!ShownFunctions)
906        OS << "Counters:\n";
907
908      ++ShownFunctions;
909
910      OS << "  " << Func.Name << ":\n"
911         << "    Hash: " << format("0x%016" PRIx64, Func.Hash) << "\n"
912         << "    Counters: " << Func.Counts.size() << "\n";
913      if (!IsIRInstr)
914        OS << "    Function count: " << Func.Counts[0] << "\n";
915
916      if (ShowIndirectCallTargets)
917        OS << "    Indirect Call Site Count: "
918           << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";
919
920      uint32_t NumMemOPCalls = Func.getNumValueSites(IPVK_MemOPSize);
921      if (ShowMemOPSizes && NumMemOPCalls > 0)
922        OS << "    Number of Memory Intrinsics Calls: " << NumMemOPCalls
923           << "\n";
924
925      if (ShowCounts) {
926        OS << "    Block counts: [";
927        size_t Start = (IsIRInstr ? 0 : 1);
928        for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
929          OS << (I == Start ? "" : ", ") << Func.Counts[I];
930        }
931        OS << "]\n";
932      }
933
934      if (ShowIndirectCallTargets) {
935        OS << "    Indirect Target Results:\n";
936        traverseAllValueSites(Func, IPVK_IndirectCallTarget,
937                              VPStats[IPVK_IndirectCallTarget], OS,
938                              &(Reader->getSymtab()));
939      }
940
941      if (ShowMemOPSizes && NumMemOPCalls > 0) {
942        OS << "    Memory Intrinsic Size Results:\n";
943        traverseAllValueSites(Func, IPVK_MemOPSize, VPStats[IPVK_MemOPSize], OS,
944                              nullptr);
945      }
946    }
947  }
948  if (Reader->hasError())
949    exitWithError(Reader->getError(), Filename);
950
951  if (TextFormat)
952    return 0;
953  std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
954  OS << "Instrumentation level: "
955     << (Reader->isIRLevelProfile() ? "IR" : "Front-end") << "\n";
956  if (ShowAllFunctions || !ShowFunction.empty())
957    OS << "Functions shown: " << ShownFunctions << "\n";
958  OS << "Total functions: " << PS->getNumFunctions() << "\n";
959  if (ValueCutoff > 0) {
960    OS << "Number of functions with maximum count (< " << ValueCutoff
961       << "): " << BelowCutoffFunctions << "\n";
962    OS << "Number of functions with maximum count (>= " << ValueCutoff
963       << "): " << PS->getNumFunctions() - BelowCutoffFunctions << "\n";
964  }
965  OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
966  OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";
967
968  if (TopN) {
969    std::vector<std::pair<std::string, uint64_t>> SortedHottestFuncs;
970    while (!HottestFuncs.empty()) {
971      SortedHottestFuncs.emplace_back(HottestFuncs.top());
972      HottestFuncs.pop();
973    }
974    OS << "Top " << TopN
975       << " functions with the largest internal block counts: \n";
976    for (auto &hotfunc : llvm::reverse(SortedHottestFuncs))
977      OS << "  " << hotfunc.first << ", max count = " << hotfunc.second << "\n";
978  }
979
980  if (ShownFunctions && ShowIndirectCallTargets) {
981    OS << "Statistics for indirect call sites profile:\n";
982    showValueSitesStats(OS, IPVK_IndirectCallTarget,
983                        VPStats[IPVK_IndirectCallTarget]);
984  }
985
986  if (ShownFunctions && ShowMemOPSizes) {
987    OS << "Statistics for memory intrinsic calls sizes profile:\n";
988    showValueSitesStats(OS, IPVK_MemOPSize, VPStats[IPVK_MemOPSize]);
989  }
990
991  if (ShowDetailedSummary) {
992    OS << "Detailed summary:\n";
993    OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
994    OS << "Total count: " << PS->getTotalCount() << "\n";
995    for (auto Entry : PS->getDetailedSummary()) {
996      OS << Entry.NumCounts << " blocks with count >= " << Entry.MinCount
997         << " account for "
998         << format("%0.6g", (float)Entry.Cutoff / ProfileSummary::Scale * 100)
999         << " percentage of the total counts.\n";
1000    }
1001  }
1002  return 0;
1003}
1004
1005static void showSectionInfo(sampleprof::SampleProfileReader *Reader,
1006                            raw_fd_ostream &OS) {
1007  if (!Reader->dumpSectionInfo(OS)) {
1008    WithColor::warning() << "-show-sec-info-only is only supported for "
1009                         << "sample profile in extbinary format and is "
1010                         << "ignored for other formats.\n";
1011    return;
1012  }
1013}
1014
1015static int showSampleProfile(const std::string &Filename, bool ShowCounts,
1016                             bool ShowAllFunctions,
1017                             const std::string &ShowFunction,
1018                             bool ShowProfileSymbolList,
1019                             bool ShowSectionInfoOnly, raw_fd_ostream &OS) {
1020  using namespace sampleprof;
1021  LLVMContext Context;
1022  auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
1023  if (std::error_code EC = ReaderOrErr.getError())
1024    exitWithErrorCode(EC, Filename);
1025
1026  auto Reader = std::move(ReaderOrErr.get());
1027
1028  if (ShowSectionInfoOnly) {
1029    showSectionInfo(Reader.get(), OS);
1030    return 0;
1031  }
1032
1033  if (std::error_code EC = Reader->read())
1034    exitWithErrorCode(EC, Filename);
1035
1036  if (ShowAllFunctions || ShowFunction.empty())
1037    Reader->dump(OS);
1038  else
1039    Reader->dumpFunctionProfile(ShowFunction, OS);
1040
1041  if (ShowProfileSymbolList) {
1042    std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
1043        Reader->getProfileSymbolList();
1044    ReaderList->dump(OS);
1045  }
1046
1047  return 0;
1048}
1049
1050static int show_main(int argc, const char *argv[]) {
1051  cl::opt<std::string> Filename(cl::Positional, cl::Required,
1052                                cl::desc("<profdata-file>"));
1053
1054  cl::opt<bool> ShowCounts("counts", cl::init(false),
1055                           cl::desc("Show counter values for shown functions"));
1056  cl::opt<bool> TextFormat(
1057      "text", cl::init(false),
1058      cl::desc("Show instr profile data in text dump format"));
1059  cl::opt<bool> ShowIndirectCallTargets(
1060      "ic-targets", cl::init(false),
1061      cl::desc("Show indirect call site target values for shown functions"));
1062  cl::opt<bool> ShowMemOPSizes(
1063      "memop-sizes", cl::init(false),
1064      cl::desc("Show the profiled sizes of the memory intrinsic calls "
1065               "for shown functions"));
1066  cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
1067                                    cl::desc("Show detailed profile summary"));
1068  cl::list<uint32_t> DetailedSummaryCutoffs(
1069      cl::CommaSeparated, "detailed-summary-cutoffs",
1070      cl::desc(
1071          "Cutoff percentages (times 10000) for generating detailed summary"),
1072      cl::value_desc("800000,901000,999999"));
1073  cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
1074                                 cl::desc("Details for every function"));
1075  cl::opt<bool> ShowCS("showcs", cl::init(false),
1076                       cl::desc("Show context sensitive counts"));
1077  cl::opt<std::string> ShowFunction("function",
1078                                    cl::desc("Details for matching functions"));
1079
1080  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
1081                                      cl::init("-"), cl::desc("Output file"));
1082  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
1083                            cl::aliasopt(OutputFilename));
1084  cl::opt<ProfileKinds> ProfileKind(
1085      cl::desc("Profile kind:"), cl::init(instr),
1086      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
1087                 clEnumVal(sample, "Sample profile")));
1088  cl::opt<uint32_t> TopNFunctions(
1089      "topn", cl::init(0),
1090      cl::desc("Show the list of functions with the largest internal counts"));
1091  cl::opt<uint32_t> ValueCutoff(
1092      "value-cutoff", cl::init(0),
1093      cl::desc("Set the count value cutoff. Functions with the maximum count "
1094               "less than this value will not be printed out. (Default is 0)"));
1095  cl::opt<bool> OnlyListBelow(
1096      "list-below-cutoff", cl::init(false),
1097      cl::desc("Only output names of functions whose max count values are "
1098               "below the cutoff value"));
1099  cl::opt<bool> ShowProfileSymbolList(
1100      "show-prof-sym-list", cl::init(false),
1101      cl::desc("Show profile symbol list if it exists in the profile. "));
1102  cl::opt<bool> ShowSectionInfoOnly(
1103      "show-sec-info-only", cl::init(false),
1104      cl::desc("Show the information of each section in the sample profile. "
1105               "The flag is only usable when the sample profile is in "
1106               "extbinary format"));
1107
1108  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
1109
1110  if (OutputFilename.empty())
1111    OutputFilename = "-";
1112
1113  if (!Filename.compare(OutputFilename)) {
1114    errs() << sys::path::filename(argv[0])
1115           << ": Input file name cannot be the same as the output file name!\n";
1116    return 1;
1117  }
1118
1119  std::error_code EC;
1120  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_Text);
1121  if (EC)
1122    exitWithErrorCode(EC, OutputFilename);
1123
1124  if (ShowAllFunctions && !ShowFunction.empty())
1125    WithColor::warning() << "-function argument ignored: showing all functions\n";
1126
1127  if (ProfileKind == instr)
1128    return showInstrProfile(Filename, ShowCounts, TopNFunctions,
1129                            ShowIndirectCallTargets, ShowMemOPSizes,
1130                            ShowDetailedSummary, DetailedSummaryCutoffs,
1131                            ShowAllFunctions, ShowCS, ValueCutoff,
1132                            OnlyListBelow, ShowFunction, TextFormat, OS);
1133  else
1134    return showSampleProfile(Filename, ShowCounts, ShowAllFunctions,
1135                             ShowFunction, ShowProfileSymbolList,
1136                             ShowSectionInfoOnly, OS);
1137}
1138
1139int main(int argc, const char *argv[]) {
1140  InitLLVM X(argc, argv);
1141
1142  StringRef ProgName(sys::path::filename(argv[0]));
1143  if (argc > 1) {
1144    int (*func)(int, const char *[]) = nullptr;
1145
1146    if (strcmp(argv[1], "merge") == 0)
1147      func = merge_main;
1148    else if (strcmp(argv[1], "show") == 0)
1149      func = show_main;
1150    else if (strcmp(argv[1], "overlap") == 0)
1151      func = overlap_main;
1152
1153    if (func) {
1154      std::string Invocation(ProgName.str() + " " + argv[1]);
1155      argv[1] = Invocation.c_str();
1156      return func(argc - 1, argv + 1);
1157    }
1158
1159    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
1160        strcmp(argv[1], "--help") == 0) {
1161
1162      errs() << "OVERVIEW: LLVM profile data tools\n\n"
1163             << "USAGE: " << ProgName << " <command> [args...]\n"
1164             << "USAGE: " << ProgName << " <command> -help\n\n"
1165             << "See each individual command --help for more details.\n"
1166             << "Available commands: merge, show, overlap\n";
1167      return 0;
1168    }
1169  }
1170
1171  if (argc < 2)
1172    errs() << ProgName << ": No command specified!\n";
1173  else
1174    errs() << ProgName << ": Unknown command!\n";
1175
1176  errs() << "USAGE: " << ProgName << " <merge|show|overlap> [args...]\n";
1177  return 1;
1178}
1179