contrib/llvm-project/llvm/tools/llvm-profdata/llvm-profdata.cpp

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