[llvm-profdata] Use SubCommands to simplify code

[ellis]

Summary

Use cl::SubCommand to improve the code in llvm-profdata.cpp in a few ways.

• Removes arg parsing code to pick which subcommand to run
• Removes custom help message code
• Emits a more standard help message
• Removes redundant options used by multiple subcommands
• Moves all options to one place at the top of the file

Unfortunately, there are a few top-level options that llvm-profdata and llvm-profgen use. That is why MergeSubcommand is defined in InstrProf.cpp, so that the subcommand can add these top-level options.

[wenlei]

llvm/lib/ProfileData/InstrProf.cpp

59–66

The commands used by tools shouldn't live in ProfileData library.

llvm/lib/ProfileData/SampleProf.cpp

36

This creates a dependency from profile data to llvm-profdata, and ideally should be avoided.

Same for other changes in ProfileData

[ellis]

llvm/lib/ProfileData/SampleProf.cpp

36

Yeah, I kind of agree. I think there is a lot of value in this patch, but these options caused a lot of trouble. This patch was the cleanest solution I could come up with.

IMO there already is a dependency between SampleProf and llvm-profdata. The llvm-profdata tool calls into SampleProf and reads a global option (profile-symbol-list-cutoff). When I switched to using SubCommands, the global option was no longer recognized so I had to add the subcommands here. It might be better to add these as arguments to SampleProfileReader::create(), but that might require redundant tool options since multiple tool use this. Also this would require significant refactoring since there are several options like this.

This patch isn't necessary, but it does make the llvm-profdata tool easier to maintain and use and I'd like to find some way to do this.

llvm/include/llvm/ProfileData/InstrProf.h

 class MDNode;
 class Module;
 
 enum InstrProfSectKind {
 #define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix) Kind,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
+namespace llvm_profdata {
+extern cl::SubCommand MergeSubCommand;
+extern cl::SubCommand ShowSubCommand;
+} // namespace llvm_profdata
+
 /// Return the name of the profile section corresponding to \p IPSK.
 ///
 /// The name of the section depends on the object format type \p OF. If
 /// \p AddSegmentInfo is true, a segment prefix and additional linker hints may
 /// be added to the section name (this is the default).
 std::string getInstrProfSectionName(InstrProfSectKind IPSK,
                                     Triple::ObjectFormatType OF,
                                     bool AddSegmentInfo = true);

llvm/lib/ProfileData/InstrProf.cpp

 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
+namespace llvm {
+namespace llvm_profdata {
+// We define these llvm-profdata subcommands here so that we can add them to the
+// top-level options that they depend on, which are outside of llvm-profdata.cpp
+cl::SubCommand MergeSubCommand("merge", "LLVM profile data merger tool");
+cl::SubCommand ShowSubCommand("show", "LLVM profile data summary tool");
+} // namespace llvm_profdata
+} // namespace llvm
+
 static cl::opt<bool> StaticFuncFullModulePrefix(
     "static-func-full-module-prefix", cl::init(true), cl::Hidden,
     cl::desc("Use full module build paths in the profile counter names for "
              "static functions."));
 
 // This option is tailored to users that have different top-level directory in
 // profile-gen and profile-use compilation. Users need to specific the number
 // of levels to strip. A value larger than the number of directories in the

llvm/lib/ProfileData/ProfileSummaryBuilder.cpp

 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 cl::opt<bool> UseContextLessSummary(
     "profile-summary-contextless", cl::Hidden, cl::init(false), cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("Merge context profiles before calculating thresholds."));
 
 // The following two parameters determine the threshold for a count to be
 // considered hot/cold. These two parameters are percentile values (multiplied
 // by 10000). If the counts are sorted in descending order, the minimum count to
 // reach ProfileSummaryCutoffHot gives the threshold to determine a hot count.
 // Similarly, the minimum count to reach ProfileSummaryCutoffCold gives the
 // threshold for determining cold count (everything <= this threshold is
 // considered cold).
 cl::opt<int> ProfileSummaryCutoffHot(
     "profile-summary-cutoff-hot", cl::Hidden, cl::init(990000), cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("A count is hot if it exceeds the minimum count to"
              " reach this percentile of total counts."));
 
 cl::opt<int> ProfileSummaryCutoffCold(
     "profile-summary-cutoff-cold", cl::Hidden, cl::init(999999), cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("A count is cold if it is below the minimum count"
              " to reach this percentile of total counts."));
 
 cl::opt<unsigned> ProfileSummaryHugeWorkingSetSizeThreshold(
     "profile-summary-huge-working-set-size-threshold", cl::Hidden,
-    cl::init(15000), cl::ZeroOrMore,
+    cl::init(15000), cl::ZeroOrMore, cl::sub(*cl::TopLevelSubCommand),
+    cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("The code working set size is considered huge if the number of"
              " blocks required to reach the -profile-summary-cutoff-hot"
              " percentile exceeds this count."));
 
 cl::opt<unsigned> ProfileSummaryLargeWorkingSetSizeThreshold(
     "profile-summary-large-working-set-size-threshold", cl::Hidden,
-    cl::init(12500), cl::ZeroOrMore,
+    cl::init(12500), cl::ZeroOrMore, cl::sub(*cl::TopLevelSubCommand),
+    cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("The code working set size is considered large if the number of"
              " blocks required to reach the -profile-summary-cutoff-hot"
              " percentile exceeds this count."));
 
 // The next two options override the counts derived from summary computation and
 // are useful for debugging purposes.
 cl::opt<int> ProfileSummaryHotCount(
     "profile-summary-hot-count", cl::ReallyHidden, cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("A fixed hot count that overrides the count derived from"
              " profile-summary-cutoff-hot"));
 
 cl::opt<int> ProfileSummaryColdCount(
     "profile-summary-cold-count", cl::ReallyHidden, cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("A fixed cold count that overrides the count derived from"
              " profile-summary-cutoff-cold"));
 
 // A set of cutoff values. Each value, when divided by ProfileSummary::Scale
 // (which is 1000000) is a desired percentile of total counts.
 static const uint32_t DefaultCutoffsData[] = {
     10000,  /*  1% */
     100000, /* 10% */

llvm/lib/ProfileData/SampleProf.cpp

 // sample profile data.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/SampleProf.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/PseudoProbe.h"
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace sampleprof;
 
 static cl::opt<uint64_t> ProfileSymbolListCutOff(
     "profile-symbol-list-cutoff", cl::Hidden, cl::init(-1), cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
+    cl::sub(llvm_profdata::ShowSubCommand),
     cl::desc("Cutoff value about how many symbols in profile symbol list "
              "will be used. This is very useful for performance debugging"));
 
 cl::opt<bool> GenerateMergedBaseProfiles(
     "generate-merged-base-profiles", cl::init(true), cl::ZeroOrMore,
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
     cl::desc("When generating nested context-sensitive profiles, always "
              "generate extra base profile for function with all its context "
              "profiles merged into it."));
 
 namespace llvm {
 namespace sampleprof {
 SampleProfileFormat FunctionSamples::Format;
 bool FunctionSamples::ProfileIsProbeBased = false;

llvm/lib/ProfileData/SampleProfReader.cpp

 
 #define DEBUG_TYPE "samplepgo-reader"
 
 // This internal option specifies if the profile uses FS discriminators.
 // It only applies to text, binary and compact binary format profiles.
 // For ext-binary format profiles, the flag is set in the summary.
 static cl::opt<bool> ProfileIsFSDisciminator(
     "profile-isfs", cl::Hidden, cl::init(false),
+    cl::sub(*cl::TopLevelSubCommand), cl::sub(llvm_profdata::MergeSubCommand),
+    cl::sub(llvm_profdata::ShowSubCommand),
     cl::desc("Profile uses flow sensitive discriminators"));
 
 /// Dump the function profile for \p FName.
 ///
 /// \param FContext Name + context of the function to print.
 /// \param OS Stream to emit the output to.
 void SampleProfileReader::dumpFunctionProfile(SampleContext FContext,
                                               raw_ostream &OS) {

llvm/test/tools/llvm-profdata/same-filename.test

 Test the input file names overlap with the output file names.
 
 This is OK for merging instrument profiles.
 RUN: cp %S/Inputs/same-name-1.proftext %t.0.proftext
 RUN: llvm-profdata merge -o %t.0.profdata -text %t.0.proftext %t.0.proftext
 RUN: llvm-profdata show -counts -all-functions %t.0.profdata -o %t_show_0
 RUN: llvm-profdata show -counts -all-functions %S/Inputs/same-name-2.proftext -o %t_show_1
 RUN: diff %t_show_0 %t_show_1
 RUN: llvm-profdata merge -o %t.1.profdata %S/Inputs/same-name-1.proftext
 RUN: llvm-profdata merge -o %t.1.profdata %t.1.profdata %t.1.profdata
 RUN: llvm-profdata show -counts -all-functions %t.1.profdata -o %t_show_2
 RUN: diff %t_show_2 %t_show_1
 
 We report error for the show command.
 RUN: not llvm-profdata show -o %t.1.profdata %t.1.profdata 2>&1 | FileCheck %s
-CHECK: llvm-profdata{{.*}} show: Input file name cannot be the same as the output file name!
+CHECK: Input file name cannot be the same as the output file name!
 
 This is OK for merging sample fdo profiles.
 RUN: cp %S/Inputs/same-name-3.proftext %t.3.proftext
 RUN: llvm-profdata merge --sample -o %t.3.profdata -text %t.3.proftext %t.3.proftext
 RUN: llvm-profdata show --sample -counts -all-functions %t.3.profdata -o %t_show_3
 RUN: llvm-profdata show --sample -counts -all-functions %S/Inputs/same-name-4.proftext -o %t_show_4
 RUN: diff %t_show_3 %t_show_4
 RUN: llvm-profdata merge --sample -o %t.5.profdata %S/Inputs/same-name-3.proftext
 RUN: llvm-profdata merge --sample -o %t.5.profdata %t.5.profdata %t.5.profdata
 RUN: llvm-profdata show --sample -counts -all-functions %t.5.profdata -o %t_show_6
 RUN: diff %t_show_6 %t_show_4

llvm/test/tools/llvm-profdata/weight-instr.test

 INVALID_WEIGHT: error: input weight must be a positive integer
 
 4- Bad merge: input path does not exist
 RUN: not llvm-profdata merge -instr -weighted-input=3,%p/Inputs/does-not-exist.profdata -weighted-input=2,%p/Inputs/does-not-exist-either.profdata -o %t.out 2>&1 | FileCheck -DMSG=%errc_ENOENT %s -check-prefix=INVALID_INPUT
 INVALID_INPUT: {{.*}}: {{.*}}does-not-exist.profdata: [[MSG]]
 
 5- No inputs
 RUN: not llvm-profdata merge -instr -o %t.out 2>&1 | FileCheck %s -check-prefix=NO_INPUT
-NO_INPUT: error: no input files specified. See llvm-profdata{{(\.EXE|\.exe)?}} merge -help
+NO_INPUT: error: no input files specified. See --help option.

llvm/test/tools/llvm-profdata/weight-sample.test

 INVALID_WEIGHT: error: input weight must be a positive integer
 
 4- Bad merge: input path does not exist
 RUN: not llvm-profdata merge -sample -weighted-input=3,%p/Inputs/does-not-exist.proftext -weighted-input=2,%p/Inputs/does-not-exist-either.proftext -o %t.out 2>&1 | FileCheck -DMSG=%errc_ENOENT %s -check-prefix=INVALID_INPUT
 INVALID_INPUT: {{.*}}: {{.*}}does-not-exist.proftext: [[MSG]]
 
 5- No inputs
 RUN: not llvm-profdata merge -sample -o %t.out 2>&1 | FileCheck %s -check-prefix=NO_INPUT
-NO_INPUT: {{.*}}: no input files specified. See llvm-profdata{{(\.EXE|\.exe)?}} merge -help
+NO_INPUT: {{.*}}: no input files specified. See --help option.

llvm/tools/llvm-profdata/llvm-profdata.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
 using namespace llvm;
+using namespace llvm_profdata;
 
+namespace {
+enum ProfileKinds { instr, sample, memory };
+enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
 enum ProfileFormat {
   PF_None = 0,
   PF_Text,
   PF_Compact_Binary,
   PF_Ext_Binary,
   PF_GCC,
   PF_Binary
 };
+} // namespace
+
+cl::SubCommand OverlapSubCommand("overlap", "LLVM profile data overlap tool");
+
+// Shared options.
+cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
+                                    cl::sub(MergeSubCommand),
+                                    cl::sub(ShowSubCommand),
+                                    cl::sub(OverlapSubCommand), cl::init("-"),
+                                    cl::desc("Output file"));
+cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
+                          cl::aliasopt(OutputFilename));
+cl::opt<ProfileKinds> ProfileKind(
+    cl::desc("Profile kind:"), cl::init(instr), cl::sub(MergeSubCommand),
+    cl::sub(ShowSubCommand), cl::sub(OverlapSubCommand),
+    cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
+               clEnumVal(sample, "Sample profile"),
+               clEnumVal(memory, "MemProf memory access profile")));
+// Internal options to set FSDiscriminatorPass. Used in merge and show
+// commands.
+static cl::opt<sampleprof::FSDiscriminatorPass> FSDiscriminatorPassOption(
+    "fs-discriminator-pass", cl::init(PassLast), cl::Hidden,
+    cl::sub(MergeSubCommand), cl::sub(ShowSubCommand),
+    cl::desc("Zero out the discriminator bits for the FS discrimiantor "
+             "pass beyond this value. The enum values are defined in "
+             "Support/Discriminator.h"),
+    cl::values(clEnumVal(Base, "Use base discriminators only"),
+               clEnumVal(Pass1, "Use base and pass 1 discriminators"),
+               clEnumVal(Pass2, "Use base and pass 1-2 discriminators"),
+               clEnumVal(Pass3, "Use base and pass 1-3 discriminators"),
+               clEnumVal(PassLast, "Use all discriminator bits (default)")));
+
+// Merge options.
+cl::list<std::string> InputFilenames(cl::Positional, cl::sub(MergeSubCommand),
+                                     cl::desc("<filename...>"));
+cl::list<std::string> WeightedInputFilenames("weighted-input",
+                                             cl::sub(MergeSubCommand),
+                                             cl::desc("<weight>,<filename>"));
+cl::opt<std::string>
+    InputFilenamesFile("input-files", cl::init(""), cl::sub(MergeSubCommand),
+                       cl::desc("Path to file containing newline-separated "
+                                "[<weight>,]<filename> entries"));
+cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
+                              cl::aliasopt(InputFilenamesFile));
+cl::opt<bool> DumpInputFileList(
+    "dump-input-file-list", cl::init(false), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("Dump the list of input files and their weights, then exit"));
+cl::opt<std::string> RemappingFile("remapping-file", cl::value_desc("file"),
+                                   cl::sub(MergeSubCommand),
+                                   cl::desc("Symbol remapping file"));
+cl::alias RemappingFileA("r", cl::desc("Alias for --remapping-file"),
+                         cl::aliasopt(RemappingFile));
+cl::opt<ProfileFormat> OutputFormat(
+    cl::sub(MergeSubCommand), cl::desc("Format of output profile"),
+    cl::init(PF_Binary),
+    cl::values(
+        clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
+        clEnumValN(PF_Compact_Binary, "compbinary", "Compact binary encoding"),
+        clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding"),
+        clEnumValN(PF_Text, "text", "Text encoding"),
+        clEnumValN(PF_GCC, "gcc",
+                   "GCC encoding (only meaningful for -sample)")));
+cl::opt<FailureMode> FailureModeOption(
+    "failure-mode", cl::init(failIfAnyAreInvalid), cl::sub(MergeSubCommand),
+    cl::desc("Failure mode:"),
+    cl::values(clEnumValN(failIfAnyAreInvalid, "any",
+                          "Fail if any profile is invalid."),
+               clEnumValN(failIfAllAreInvalid, "all",
+                          "Fail only if all profiles are invalid.")));
+cl::opt<bool> OutputSparse(
+    "sparse", cl::init(false), cl::sub(MergeSubCommand),
+    cl::desc("Generate a sparse profile (only meaningful for -instr)"));
+cl::opt<unsigned> NumThreads(
+    "num-threads", cl::init(0), cl::sub(MergeSubCommand),
+    cl::desc("Number of merge threads to use (default: autodetect)"));
+cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
+                      cl::aliasopt(NumThreads));
+cl::opt<std::string> ProfileSymbolListFile(
+    "prof-sym-list", cl::init(""), cl::sub(MergeSubCommand),
+    cl::desc("Path to file containing the list of function symbols "
+             "used to populate profile symbol list"));
+cl::opt<bool> CompressAllSections(
+    "compress-all-sections", cl::init(false), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("Compress all sections when writing the profile (only "
+             "meaningful for -extbinary)"));
+cl::opt<bool>
+    UseMD5("use-md5", cl::init(false), cl::Hidden, cl::sub(MergeSubCommand),
+           cl::desc("Choose to use MD5 to represent string in name table (only "
+                    "meaningful for -extbinary)"));
+cl::opt<bool> SampleMergeColdContext(
+    "sample-merge-cold-context", cl::init(false), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc(
+        "Merge context sample profiles whose count is below cold threshold"));
+cl::opt<bool> SampleTrimColdContext(
+    "sample-trim-cold-context", cl::init(false), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc(
+        "Trim context sample profiles whose count is below cold threshold"));
+cl::opt<uint32_t> SampleColdContextFrameDepth(
+    "sample-frame-depth-for-cold-context", cl::init(1), cl::ZeroOrMore,
+    cl::sub(MergeSubCommand),
+    cl::desc("Keep the last K frames while merging cold profile. 1 means the "
+             "context-less base profile"));
+cl::opt<bool> GenPartialProfile(
+    "gen-partial-profile", cl::init(false), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("Generate a partial profile (only meaningful for -extbinary)"));
+cl::opt<std::string> SupplInstrWithSample(
+    "supplement-instr-with-sample", cl::init(""), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("Supplement an instr profile with sample profile, to correct "
+             "the profile unrepresentativeness issue. The sample "
+             "profile is the input of the flag. Output will be in instr "
+             "format (The flag only works with -instr)"));
+cl::opt<float> ZeroCounterThreshold(
+    "zero-counter-threshold", cl::init(0.7), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("For the function which is cold in instr profile but hot in "
+             "sample profile, if the ratio of the number of zero counters "
+             "divided by the the total number of counters is above the "
+             "threshold, the profile of the function will be regarded as "
+             "being harmful for performance and will be dropped."));
+cl::opt<unsigned> SupplMinSizeThreshold(
+    "suppl-min-size-threshold", cl::init(10), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("If the size of a function is smaller than the threshold, "
+             "assume it can be inlined by PGO early inliner and it won't "
+             "be adjusted based on sample profile."));
+cl::opt<unsigned> InstrProfColdThreshold(
+    "instr-prof-cold-threshold", cl::init(0), cl::Hidden,
+    cl::sub(MergeSubCommand),
+    cl::desc("User specified cold threshold for instr profile which will "
+             "override the cold threshold got from profile summary. "));
+cl::opt<bool> GenCSNestedProfile(
+    "gen-cs-nested-profile", cl::Hidden, cl::init(false),
+    cl::sub(MergeSubCommand),
+    cl::desc("Generate nested function profiles for CSSPGO"));
+cl::opt<std::string> DebugInfoFilename(
+    "debug-info", cl::init(""), cl::sub(MergeSubCommand),
+    cl::desc("Use the provided debug info to correlate the raw profile."));
+
+// Show options.
+cl::opt<std::string> Filename(cl::Positional, cl::Required,
+                              cl::sub(ShowSubCommand),
+                              cl::desc("<profdata-file>"));
+
+cl::opt<bool> ShowCounts("counts", cl::init(false), cl::sub(ShowSubCommand),
+                         cl::desc("Show counter values for shown functions"));
+cl::opt<bool>
+    TextFormat("text", cl::init(false), cl::sub(ShowSubCommand),
+               cl::desc("Show instr profile data in text dump format"));
+cl::opt<bool> ShowIndirectCallTargets(
+    "ic-targets", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Show indirect call site target values for shown functions"));
+cl::opt<bool> ShowMemOPSizes(
+    "memop-sizes", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Show the profiled sizes of the memory intrinsic calls "
+             "for shown functions"));
+cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
+                                  cl::sub(ShowSubCommand),
+                                  cl::desc("Show detailed profile summary"));
+cl::list<uint32_t> DetailedSummaryCutoffs(
+    cl::CommaSeparated, "detailed-summary-cutoffs", cl::sub(ShowSubCommand),
+    cl::desc(
+        "Cutoff percentages (times 10000) for generating detailed summary"),
+    cl::value_desc("800000,901000,999999"));
+cl::opt<bool> ShowHotFuncList(
+    "hot-func-list", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Show profile summary of a list of hot functions"));
+cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
+                               cl::sub(ShowSubCommand),
+                               cl::desc("Details for every function"));
+cl::opt<bool> ShowCS("showcs", cl::init(false), cl::sub(ShowSubCommand),
+                     cl::desc("Show context sensitive counts"));
+cl::opt<std::string> ShowFunction("function", cl::sub(ShowSubCommand),
+                                  cl::desc("Details for matching functions"));
+
+cl::opt<uint32_t> TopNFunctions(
+    "topn", cl::init(0), cl::sub(ShowSubCommand),
+    cl::desc("Show the list of functions with the largest internal counts"));
+cl::opt<uint32_t> ValueCutoff(
+    "value-cutoff", cl::init(0), cl::sub(ShowSubCommand),
+    cl::desc("Set the count value cutoff. Functions with the maximum count "
+             "less than this value will not be printed out. (Default is 0)"));
+cl::opt<bool> OnlyListBelow(
+    "list-below-cutoff", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Only output names of functions whose max count values are "
+             "below the cutoff value"));
+cl::opt<bool> ShowProfileSymbolList(
+    "show-prof-sym-list", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Show profile symbol list if it exists in the profile. "));
+cl::opt<bool> ShowSectionInfoOnly(
+    "show-sec-info-only", cl::init(false), cl::sub(ShowSubCommand),
+    cl::desc("Show the information of each section in the sample profile. "
+             "The flag is only usable when the sample profile is in "
+             "extbinary format"));
+cl::opt<bool> ShowBinaryIds("binary-ids", cl::init(false),
+                            cl::sub(ShowSubCommand),
+                            cl::desc("Show binary ids in the profile. "));
+
+// Overlap options.
+cl::opt<std::string> BaseFilename(cl::Positional, cl::Required,
+                                  cl::sub(OverlapSubCommand),
+                                  cl::desc("<base profile file>"));
+cl::opt<std::string> TestFilename(cl::Positional, cl::Required,
+                                  cl::sub(OverlapSubCommand),
+                                  cl::desc("<test profile file>"));
+cl::opt<bool> IsCS(
+    "cs", cl::init(false), cl::sub(OverlapSubCommand),
+    cl::desc("For context sensitive PGO counts. Does not work with CSSPGO."));
+cl::opt<unsigned long long> OverlapValueCutoff(
+    "value-cutoff", cl::init(-1), cl::sub(OverlapSubCommand),
+    cl::desc(
+        "Function level overlap information for every function (with calling "
+        "context for csspgo) in test "
+        "profile with max count value greater then the parameter value"));
+cl::opt<std::string> FuncNameFilter(
+    "function", cl::sub(OverlapSubCommand),
+    cl::desc("Function level overlap information for matching functions. For "
+             "CSSPGO this takes a a function name with calling context"));
+cl::opt<unsigned long long> SimilarityCutoff(
+    "similarity-cutoff", cl::init(0), cl::sub(OverlapSubCommand),
+    cl::desc("For sample profiles, list function names (with calling context "
+             "for csspgo) for overlapped functions "
+             "with similarities below the cutoff (percentage times 10000)."));
 
 static void warn(Twine Message, std::string Whence = "",
                  std::string Hint = "") {
   WithColor::warning();
   if (!Whence.empty())
     errs() << Whence << ": ";
   errs() << Message << "\n";
   if (!Hint.empty())
static void exitWithError(Error E, StringRef Whence = "") {
 
   exitWithError(toString(std::move(E)), std::string(Whence));
 }
 
 static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
   exitWithError(EC.message(), std::string(Whence));
 }
 
-namespace {
-enum ProfileKinds { instr, sample, memory };
-enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
-}
-
 static void warnOrExitGivenError(FailureMode FailMode, std::error_code EC,
                                  StringRef Whence = "") {
   if (FailMode == failIfAnyAreInvalid)
     exitWithErrorCode(EC, Whence);
   else
     warn(EC.message(), std::string(Whence));
 }
 
static void updateInstrProfileEntry(InstrProfileEntry &IFE,
   ProfRecord->scale(Numerator, Denominator, [&](instrprof_error E) {
     warn(toString(make_error<InstrProfError>(E)));
   });
 }
 
 const uint64_t ColdPercentileIdx = 15;
 const uint64_t HotPercentileIdx = 11;
 
-using sampleprof::FSDiscriminatorPass;
-
-// Internal options to set FSDiscriminatorPass. Used in merge and show
-// commands.
-static cl::opt<FSDiscriminatorPass> FSDiscriminatorPassOption(
-    "fs-discriminator-pass", cl::init(PassLast), cl::Hidden,
-    cl::desc("Zero out the discriminator bits for the FS discrimiantor "
-             "pass beyond this value. The enum values are defined in "
-             "Support/Discriminator.h"),
-    cl::values(clEnumVal(Base, "Use base discriminators only"),
-               clEnumVal(Pass1, "Use base and pass 1 discriminators"),
-               clEnumVal(Pass2, "Use base and pass 1-2 discriminators"),
-               clEnumVal(Pass3, "Use base and pass 1-3 discriminators"),
-               clEnumVal(PassLast, "Use all discriminator bits (default)")));
-
 static unsigned getDiscriminatorMask() {
   return getN1Bits(getFSPassBitEnd(FSDiscriminatorPassOption.getValue()));
 }
 
 /// Adjust the instr profile in \p WC based on the sample profile in
 /// \p Reader.
 static void
 adjustInstrProfile(std::unique_ptr<WriterContext> &WC,
for (const StringRef &FileWeightEntry : Entries) {
     // If there's no comma, it's an unweighted profile.
     else if (!SanitizedEntry.contains(','))
       addWeightedInput(WFV, {std::string(SanitizedEntry), 1});
     else
       addWeightedInput(WFV, parseWeightedFile(SanitizedEntry));
   }
 }
 
-static int merge_main(int argc, const char *argv[]) {
-  cl::list<std::string> InputFilenames(cl::Positional,
-                                       cl::desc("<filename...>"));
-  cl::list<std::string> WeightedInputFilenames("weighted-input",
-                                               cl::desc("<weight>,<filename>"));
-  cl::opt<std::string> InputFilenamesFile(
-      "input-files", cl::init(""),
-      cl::desc("Path to file containing newline-separated "
-               "[<weight>,]<filename> entries"));
-  cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
-                                cl::aliasopt(InputFilenamesFile));
-  cl::opt<bool> DumpInputFileList(
-      "dump-input-file-list", cl::init(false), cl::Hidden,
-      cl::desc("Dump the list of input files and their weights, then exit"));
-  cl::opt<std::string> RemappingFile("remapping-file", cl::value_desc("file"),
-                                     cl::desc("Symbol remapping file"));
-  cl::alias RemappingFileA("r", cl::desc("Alias for --remapping-file"),
-                           cl::aliasopt(RemappingFile));
-  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
-                                      cl::init("-"), cl::desc("Output file"));
-  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
-                            cl::aliasopt(OutputFilename));
-  cl::opt<ProfileKinds> ProfileKind(
-      cl::desc("Profile kind:"), cl::init(instr),
-      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
-                 clEnumVal(sample, "Sample profile")));
-  cl::opt<ProfileFormat> OutputFormat(
-      cl::desc("Format of output profile"), cl::init(PF_Binary),
-      cl::values(
-          clEnumValN(PF_Binary, "binary", "Binary encoding (default)"),
-          clEnumValN(PF_Compact_Binary, "compbinary",
-                     "Compact binary encoding"),
-          clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding"),
-          clEnumValN(PF_Text, "text", "Text encoding"),
-          clEnumValN(PF_GCC, "gcc",
-                     "GCC encoding (only meaningful for -sample)")));
-  cl::opt<FailureMode> FailureMode(
-      "failure-mode", cl::init(failIfAnyAreInvalid), cl::desc("Failure mode:"),
-      cl::values(clEnumValN(failIfAnyAreInvalid, "any",
-                            "Fail if any profile is invalid."),
-                 clEnumValN(failIfAllAreInvalid, "all",
-                            "Fail only if all profiles are invalid.")));
-  cl::opt<bool> OutputSparse("sparse", cl::init(false),
-      cl::desc("Generate a sparse profile (only meaningful for -instr)"));
-  cl::opt<unsigned> NumThreads(
-      "num-threads", cl::init(0),
-      cl::desc("Number of merge threads to use (default: autodetect)"));
-  cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
-                        cl::aliasopt(NumThreads));
-  cl::opt<std::string> ProfileSymbolListFile(
-      "prof-sym-list", cl::init(""),
-      cl::desc("Path to file containing the list of function symbols "
-               "used to populate profile symbol list"));
-  cl::opt<bool> CompressAllSections(
-      "compress-all-sections", cl::init(false), cl::Hidden,
-      cl::desc("Compress all sections when writing the profile (only "
-               "meaningful for -extbinary)"));
-  cl::opt<bool> UseMD5(
-      "use-md5", cl::init(false), cl::Hidden,
-      cl::desc("Choose to use MD5 to represent string in name table (only "
-               "meaningful for -extbinary)"));
-  cl::opt<bool> SampleMergeColdContext(
-      "sample-merge-cold-context", cl::init(false), cl::Hidden,
-      cl::desc(
-          "Merge context sample profiles whose count is below cold threshold"));
-  cl::opt<bool> SampleTrimColdContext(
-      "sample-trim-cold-context", cl::init(false), cl::Hidden,
-      cl::desc(
-          "Trim context sample profiles whose count is below cold threshold"));
-  cl::opt<uint32_t> SampleColdContextFrameDepth(
-      "sample-frame-depth-for-cold-context", cl::init(1), cl::ZeroOrMore,
-      cl::desc("Keep the last K frames while merging cold profile. 1 means the "
-               "context-less base profile"));
-  cl::opt<bool> GenPartialProfile(
-      "gen-partial-profile", cl::init(false), cl::Hidden,
-      cl::desc("Generate a partial profile (only meaningful for -extbinary)"));
-  cl::opt<std::string> SupplInstrWithSample(
-      "supplement-instr-with-sample", cl::init(""), cl::Hidden,
-      cl::desc("Supplement an instr profile with sample profile, to correct "
-               "the profile unrepresentativeness issue. The sample "
-               "profile is the input of the flag. Output will be in instr "
-               "format (The flag only works with -instr)"));
-  cl::opt<float> ZeroCounterThreshold(
-      "zero-counter-threshold", cl::init(0.7), cl::Hidden,
-      cl::desc("For the function which is cold in instr profile but hot in "
-               "sample profile, if the ratio of the number of zero counters "
-               "divided by the the total number of counters is above the "
-               "threshold, the profile of the function will be regarded as "
-               "being harmful for performance and will be dropped."));
-  cl::opt<unsigned> SupplMinSizeThreshold(
-      "suppl-min-size-threshold", cl::init(10), cl::Hidden,
-      cl::desc("If the size of a function is smaller than the threshold, "
-               "assume it can be inlined by PGO early inliner and it won't "
-               "be adjusted based on sample profile."));
-  cl::opt<unsigned> InstrProfColdThreshold(
-      "instr-prof-cold-threshold", cl::init(0), cl::Hidden,
-      cl::desc("User specified cold threshold for instr profile which will "
-               "override the cold threshold got from profile summary. "));
-  cl::opt<bool> GenCSNestedProfile(
-      "gen-cs-nested-profile", cl::Hidden, cl::init(false),
-      cl::desc("Generate nested function profiles for CSSPGO"));
-  cl::opt<std::string> DebugInfoFilename(
-      "debug-info", cl::init(""),
-      cl::desc("Use the provided debug info to correlate the raw profile."));
-
-  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");
-
+static int merge_main() {
   WeightedFileVector WeightedInputs;
   for (StringRef Filename : InputFilenames)
     addWeightedInput(WeightedInputs, {std::string(Filename), 1});
   for (StringRef WeightedFilename : WeightedInputFilenames)
     addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename));
 
   // Make sure that the file buffer stays alive for the duration of the
   // weighted input vector's lifetime.
   auto Buffer = getInputFileBuf(InputFilenamesFile);
   parseInputFilenamesFile(Buffer.get(), WeightedInputs);
 
   if (WeightedInputs.empty())
-    exitWithError("no input files specified. See " +
-                  sys::path::filename(argv[0]) + " -help");
+    exitWithError("no input files specified. See --help option.");
 
   if (DumpInputFileList) {
     for (auto &WF : WeightedInputs)
       outs() << WF.Weight << "," << WF.Filename << "\n";
     return 0;
   }
 
   std::unique_ptr<SymbolRemapper> Remapper;
supplementInstrProfile(WeightedInputs, SupplInstrWithSample, OutputFilename,
                            OutputFormat, OutputSparse, SupplMinSizeThreshold,
                            ZeroCounterThreshold, InstrProfColdThreshold);
     return 0;
   }
 
   if (ProfileKind == instr)
     mergeInstrProfile(WeightedInputs, DebugInfoFilename, Remapper.get(),
                       OutputFilename, OutputFormat, OutputSparse, NumThreads,
-                      FailureMode);
-  else
+                      FailureModeOption);
+  else if (ProfileKind == sample)
     mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
                        OutputFormat, ProfileSymbolListFile, CompressAllSections,
                        UseMD5, GenPartialProfile, GenCSNestedProfile,
                        SampleMergeColdContext, SampleTrimColdContext,
-                       SampleColdContextFrameDepth, FailureMode);
+                       SampleColdContextFrameDepth, FailureModeOption);
+  else
+    exitWithError("Unsupported ProfileKind");
   return 0;
 }
 
 /// Computer the overlap b/w profile BaseFilename and profile TestFilename.
 static void overlapInstrProfile(const std::string &BaseFilename,
                                 const std::string &TestFilename,
                                 const OverlapFuncFilters &FuncFilter,
                                 raw_fd_ostream &OS, bool IsCS) {
void overlapSampleProfile(const std::string &BaseFilename,
 
   OverlapAggr.computeSampleProfileOverlap(OS);
 
   OverlapAggr.dumpProgramSummary(OS);
   OverlapAggr.dumpHotFuncAndBlockOverlap(OS);
   OverlapAggr.dumpFuncSimilarity(OS);
 }
 
-static int overlap_main(int argc, const char *argv[]) {
-  cl::opt<std::string> BaseFilename(cl::Positional, cl::Required,
-                                    cl::desc("<base profile file>"));
-  cl::opt<std::string> TestFilename(cl::Positional, cl::Required,
-                                    cl::desc("<test profile file>"));
-  cl::opt<std::string> Output("output", cl::value_desc("output"), cl::init("-"),
-                              cl::desc("Output file"));
-  cl::alias OutputA("o", cl::desc("Alias for --output"), cl::aliasopt(Output));
-  cl::opt<bool> IsCS(
-      "cs", cl::init(false),
-      cl::desc("For context sensitive PGO counts. Does not work with CSSPGO."));
-  cl::opt<unsigned long long> ValueCutoff(
-      "value-cutoff", cl::init(-1),
-      cl::desc(
-          "Function level overlap information for every function (with calling "
-          "context for csspgo) in test "
-          "profile with max count value greater then the parameter value"));
-  cl::opt<std::string> FuncNameFilter(
-      "function",
-      cl::desc("Function level overlap information for matching functions. For "
-               "CSSPGO this takes a a function name with calling context"));
-  cl::opt<unsigned long long> SimilarityCutoff(
-      "similarity-cutoff", cl::init(0),
-      cl::desc("For sample profiles, list function names (with calling context "
-               "for csspgo) for overlapped functions "
-               "with similarities below the cutoff (percentage times 10000)."));
-  cl::opt<ProfileKinds> ProfileKind(
-      cl::desc("Profile kind:"), cl::init(instr),
-      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
-                 clEnumVal(sample, "Sample profile")));
-  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data overlap tool\n");
-
+static int overlap_main() {
   std::error_code EC;
-  raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_TextWithCRLF);
+  raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
-    exitWithErrorCode(EC, Output);
+    exitWithErrorCode(EC, OutputFilename);
 
   if (ProfileKind == instr)
     overlapInstrProfile(BaseFilename, TestFilename,
-                        OverlapFuncFilters{ValueCutoff, FuncNameFilter}, OS,
-                        IsCS);
+                        OverlapFuncFilters{OverlapValueCutoff, FuncNameFilter},
+                        OS, IsCS);
   else
     overlapSampleProfile(BaseFilename, TestFilename,
-                         OverlapFuncFilters{ValueCutoff, FuncNameFilter},
+                         OverlapFuncFilters{OverlapValueCutoff, FuncNameFilter},
                          SimilarityCutoff, OS);
 
   return 0;
 }
 
 namespace {
 struct ValueSitesStats {
   ValueSitesStats()
if (Error E = ReaderOr.takeError())
     exitWithError(std::move(E), Filename);
 
   std::unique_ptr<llvm::memprof::RawMemProfReader> Reader(
       ReaderOr.get().release());
   Reader->printSummaries(OS);
   return 0;
 }
 
-static int show_main(int argc, const char *argv[]) {
-  cl::opt<std::string> Filename(cl::Positional, cl::Required,
-                                cl::desc("<profdata-file>"));
-
-  cl::opt<bool> ShowCounts("counts", cl::init(false),
-                           cl::desc("Show counter values for shown functions"));
-  cl::opt<bool> TextFormat(
-      "text", cl::init(false),
-      cl::desc("Show instr profile data in text dump format"));
-  cl::opt<bool> ShowIndirectCallTargets(
-      "ic-targets", cl::init(false),
-      cl::desc("Show indirect call site target values for shown functions"));
-  cl::opt<bool> ShowMemOPSizes(
-      "memop-sizes", cl::init(false),
-      cl::desc("Show the profiled sizes of the memory intrinsic calls "
-               "for shown functions"));
-  cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
-                                    cl::desc("Show detailed profile summary"));
-  cl::list<uint32_t> DetailedSummaryCutoffs(
-      cl::CommaSeparated, "detailed-summary-cutoffs",
-      cl::desc(
-          "Cutoff percentages (times 10000) for generating detailed summary"),
-      cl::value_desc("800000,901000,999999"));
-  cl::opt<bool> ShowHotFuncList(
-      "hot-func-list", cl::init(false),
-      cl::desc("Show profile summary of a list of hot functions"));
-  cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
-                                 cl::desc("Details for every function"));
-  cl::opt<bool> ShowCS("showcs", cl::init(false),
-                       cl::desc("Show context sensitive counts"));
-  cl::opt<std::string> ShowFunction("function",
-                                    cl::desc("Details for matching functions"));
-
-  cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
-                                      cl::init("-"), cl::desc("Output file"));
-  cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
-                            cl::aliasopt(OutputFilename));
-  cl::opt<ProfileKinds> ProfileKind(
-      cl::desc("Profile kind:"), cl::init(instr),
-      cl::values(clEnumVal(instr, "Instrumentation profile (default)"),
-                 clEnumVal(sample, "Sample profile"),
-                 clEnumVal(memory, "MemProf memory access profile")));
-  cl::opt<uint32_t> TopNFunctions(
-      "topn", cl::init(0),
-      cl::desc("Show the list of functions with the largest internal counts"));
-  cl::opt<uint32_t> ValueCutoff(
-      "value-cutoff", cl::init(0),
-      cl::desc("Set the count value cutoff. Functions with the maximum count "
-               "less than this value will not be printed out. (Default is 0)"));
-  cl::opt<bool> OnlyListBelow(
-      "list-below-cutoff", cl::init(false),
-      cl::desc("Only output names of functions whose max count values are "
-               "below the cutoff value"));
-  cl::opt<bool> ShowProfileSymbolList(
-      "show-prof-sym-list", cl::init(false),
-      cl::desc("Show profile symbol list if it exists in the profile. "));
-  cl::opt<bool> ShowSectionInfoOnly(
-      "show-sec-info-only", cl::init(false),
-      cl::desc("Show the information of each section in the sample profile. "
-               "The flag is only usable when the sample profile is in "
-               "extbinary format"));
-  cl::opt<bool> ShowBinaryIds("binary-ids", cl::init(false),
-                              cl::desc("Show binary ids in the profile. "));
-
-  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");
-
+static int show_main() {
   if (Filename == OutputFilename) {
-    errs() << sys::path::filename(argv[0])
-           << ": Input file name cannot be the same as the output file name!\n";
+    errs() << "Input file name cannot be the same as the output file name!\n";
     return 1;
   }
 
   std::error_code EC;
   raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
return showSampleProfile(Filename, ShowCounts, TopNFunctions,
                              ShowAllFunctions, ShowDetailedSummary,
                              ShowFunction, ShowProfileSymbolList,
                              ShowSectionInfoOnly, ShowHotFuncList, OS);
   return showMemProfProfile(Filename, OS);
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
+  cl::ParseCommandLineOptions(argc, argv, "LLVM profile data tools");
 
-  StringRef ProgName(sys::path::filename(argv[0]));
-  if (argc > 1) {
-    int (*func)(int, const char *[]) = nullptr;
-
-    if (strcmp(argv[1], "merge") == 0)
-      func = merge_main;
-    else if (strcmp(argv[1], "show") == 0)
-      func = show_main;
-    else if (strcmp(argv[1], "overlap") == 0)
-      func = overlap_main;
-
-    if (func) {
-      std::string Invocation(ProgName.str() + " " + argv[1]);
-      argv[1] = Invocation.c_str();
-      return func(argc - 1, argv + 1);
-    }
-
-    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
-        strcmp(argv[1], "--help") == 0) {
-
-      errs() << "OVERVIEW: LLVM profile data tools\n\n"
-             << "USAGE: " << ProgName << " <command> [args...]\n"
-             << "USAGE: " << ProgName << " <command> -help\n\n"
-             << "See each individual command --help for more details.\n"
-             << "Available commands: merge, show, overlap\n";
-      return 0;
-    }
+  if (MergeSubCommand) {
+    return merge_main();
+  } else if (ShowSubCommand) {
+    return show_main();
+  } else if (OverlapSubCommand) {
+    return overlap_main();
   }
 
-  if (argc < 2)
-    errs() << ProgName << ": No command specified!\n";
-  else
-    errs() << ProgName << ": Unknown command!\n";
-
-  errs() << "USAGE: " << ProgName << " <merge|show|overlap> [args...]\n";
+  WithColor::error() << "No command specified!\n";
+  cl::PrintHelpMessage();
   return 1;
 }