[xray] Remove cl::sub from alias options

[rmansfield]

Summary

Currently running the xray tools generates a number of errors:

$ ./bin/llvm-xray
: for the -k option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -d option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -o option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -f option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -s option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -r option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -p option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
: for the -m option: cl::alias must not have cl::sub(), aliased option's cl::sub() will be used!
<snip>

[dberris]

LGTM -- Thanks!

[rmansfield]

Thanks for the review. I don't have commit access, is someone able to commit the change?

[rmansfield]

Is someone able to commit this change on my behalf?

[ianlevesque]

@smeenai or @hiraditya we could use this too, maybe one of you can merge?

[smeenai]

Sorry for the delay. Committed this.

llvm/tools/llvm-xray/xray-account.cpp

 static cl::SubCommand Account("account", "Function call accounting");
 static cl::opt<std::string> AccountInput(cl::Positional,
                                          cl::desc("<xray log file>"),
                                          cl::Required, cl::sub(Account));
 static cl::opt<bool>
     AccountKeepGoing("keep-going", cl::desc("Keep going on errors encountered"),
                      cl::sub(Account), cl::init(false));
 static cl::alias AccountKeepGoing2("k", cl::aliasopt(AccountKeepGoing),
-                                   cl::desc("Alias for -keep_going"),
-                                   cl::sub(Account));
+                                   cl::desc("Alias for -keep_going"));
 static cl::opt<bool> AccountDeduceSiblingCalls(
     "deduce-sibling-calls",
     cl::desc("Deduce sibling calls when unrolling function call stacks"),
     cl::sub(Account), cl::init(false));
 static cl::alias
     AccountDeduceSiblingCalls2("d", cl::aliasopt(AccountDeduceSiblingCalls),
-                               cl::desc("Alias for -deduce_sibling_calls"),
-                               cl::sub(Account));
+                               cl::desc("Alias for -deduce_sibling_calls"));
 static cl::opt<std::string>
     AccountOutput("output", cl::value_desc("output file"), cl::init("-"),
                   cl::desc("output file; use '-' for stdout"),
                   cl::sub(Account));
 static cl::alias AccountOutput2("o", cl::aliasopt(AccountOutput),
-                                cl::desc("Alias for -output"),
-                                cl::sub(Account));
+                                cl::desc("Alias for -output"));
 enum class AccountOutputFormats { TEXT, CSV };
 static cl::opt<AccountOutputFormats>
     AccountOutputFormat("format", cl::desc("output format"),
                         cl::values(clEnumValN(AccountOutputFormats::TEXT,
                                               "text", "report stats in text"),
                                    clEnumValN(AccountOutputFormats::CSV, "csv",
                                               "report stats in csv")),
                         cl::sub(Account));
 static cl::alias AccountOutputFormat2("f", cl::desc("Alias of -format"),
-                                      cl::aliasopt(AccountOutputFormat),
-                                      cl::sub(Account));
+                                      cl::aliasopt(AccountOutputFormat));
 
 enum class SortField {
   FUNCID,
   COUNT,
   MIN,
   MED,
   PCT90,
   PCT99,
cl::values(clEnumValN(SortField::FUNCID, "funcid", "function id"),
                clEnumValN(SortField::MIN, "min", "minimum function durations"),
                clEnumValN(SortField::MED, "med", "median function durations"),
                clEnumValN(SortField::PCT90, "90p", "90th percentile durations"),
                clEnumValN(SortField::PCT99, "99p", "99th percentile durations"),
                clEnumValN(SortField::MAX, "max", "maximum function durations"),
                clEnumValN(SortField::SUM, "sum", "sum of call durations"),
                clEnumValN(SortField::FUNC, "func", "function names")));
 static cl::alias AccountSortOutput2("s", cl::aliasopt(AccountSortOutput),
-                                    cl::desc("Alias for -sort"),
-                                    cl::sub(Account));
+                                    cl::desc("Alias for -sort"));
 
 enum class SortDirection {
   ASCENDING,
   DESCENDING,
 };
 static cl::opt<SortDirection> AccountSortOrder(
     "sortorder", cl::desc("sort ordering"), cl::init(SortDirection::ASCENDING),
     cl::values(clEnumValN(SortDirection::ASCENDING, "asc", "ascending"),
                clEnumValN(SortDirection::DESCENDING, "dsc", "descending")),
     cl::sub(Account));
 static cl::alias AccountSortOrder2("r", cl::aliasopt(AccountSortOrder),
-                                   cl::desc("Alias for -sortorder"),
-                                   cl::sub(Account));
+                                   cl::desc("Alias for -sortorder"));
 
 static cl::opt<int> AccountTop("top", cl::desc("only show the top N results"),
                                cl::value_desc("N"), cl::sub(Account),
                                cl::init(-1));
 static cl::alias AccountTop2("p", cl::desc("Alias for -top"),
-                             cl::aliasopt(AccountTop), cl::sub(Account));
+                             cl::aliasopt(AccountTop));
 
 static cl::opt<std::string>
     AccountInstrMap("instr_map",
                     cl::desc("binary with the instrumentation map, or "
                              "a separate instrumentation map"),
                     cl::value_desc("binary with xray_instr_map"),
                     cl::sub(Account), cl::init(""));
 static cl::alias AccountInstrMap2("m", cl::aliasopt(AccountInstrMap),
-                                  cl::desc("Alias for -instr_map"),
-                                  cl::sub(Account));
+                                  cl::desc("Alias for -instr_map"));
 
 namespace {
 
 template <class T, class U> void setMinMax(std::pair<T, T> &MM, U &&V) {
   if (MM.first == 0 || MM.second == 0)
     MM = std::make_pair(std::forward<U>(V), std::forward<U>(V));
   else
     MM = std::make_pair(std::min(MM.first, V), std::max(MM.second, V));

llvm/tools/llvm-xray/xray-converter.cpp

static cl::opt<ConvertFormats> ConvertOutputFormat(
     "output-format", cl::desc("output format"),
     cl::values(clEnumValN(ConvertFormats::BINARY, "raw", "output in binary"),
                clEnumValN(ConvertFormats::YAML, "yaml", "output in yaml"),
                clEnumValN(ConvertFormats::CHROME_TRACE_EVENT, "trace_event",
                           "Output in chrome's trace event format. "
                           "May be visualized with the Catapult trace viewer.")),
     cl::sub(Convert));
 static cl::alias ConvertOutputFormat2("f", cl::aliasopt(ConvertOutputFormat),
-                                      cl::desc("Alias for -output-format"),
-                                      cl::sub(Convert));
+                                      cl::desc("Alias for -output-format"));
 static cl::opt<std::string>
     ConvertOutput("output", cl::value_desc("output file"), cl::init("-"),
                   cl::desc("output file; use '-' for stdout"),
                   cl::sub(Convert));
 static cl::alias ConvertOutput2("o", cl::aliasopt(ConvertOutput),
-                                cl::desc("Alias for -output"),
-                                cl::sub(Convert));
+                                cl::desc("Alias for -output"));
 
 static cl::opt<bool>
     ConvertSymbolize("symbolize",
                      cl::desc("symbolize function ids from the input log"),
                      cl::init(false), cl::sub(Convert));
 static cl::alias ConvertSymbolize2("y", cl::aliasopt(ConvertSymbolize),
-                                   cl::desc("Alias for -symbolize"),
-                                   cl::sub(Convert));
+                                   cl::desc("Alias for -symbolize"));
 
 static cl::opt<std::string>
     ConvertInstrMap("instr_map",
                     cl::desc("binary with the instrumentation map, or "
                              "a separate instrumentation map"),
                     cl::value_desc("binary with xray_instr_map"),
                     cl::sub(Convert), cl::init(""));
 static cl::alias ConvertInstrMap2("m", cl::aliasopt(ConvertInstrMap),
-                                  cl::desc("Alias for -instr_map"),
-                                  cl::sub(Convert));
+                                  cl::desc("Alias for -instr_map"));
 static cl::opt<bool> ConvertSortInput(
     "sort",
     cl::desc("determines whether to sort input log records by timestamp"),
     cl::sub(Convert), cl::init(true));
 static cl::alias ConvertSortInput2("s", cl::aliasopt(ConvertSortInput),
-                                   cl::desc("Alias for -sort"),
-                                   cl::sub(Convert));
+                                   cl::desc("Alias for -sort"));
 
 using llvm::yaml::Output;
 
 void TraceConverter::exportAsYAML(const Trace &Records, raw_ostream &OS) {
   YAMLXRayTrace Trace;
   const auto &FH = Records.getFileHeader();
   Trace.Header = {FH.Version, FH.Type, FH.ConstantTSC, FH.NonstopTSC,
                   FH.CycleFrequency};

llvm/tools/llvm-xray/xray-extract.cpp

 static cl::opt<std::string> ExtractInput(cl::Positional,
                                          cl::desc("<input file>"), cl::Required,
                                          cl::sub(Extract));
 static cl::opt<std::string>
     ExtractOutput("output", cl::value_desc("output file"), cl::init("-"),
                   cl::desc("output file; use '-' for stdout"),
                   cl::sub(Extract));
 static cl::alias ExtractOutput2("o", cl::aliasopt(ExtractOutput),
-                                cl::desc("Alias for -output"),
-                                cl::sub(Extract));
+                                cl::desc("Alias for -output"));
 static cl::opt<bool> ExtractSymbolize("symbolize", cl::value_desc("symbolize"),
                                       cl::init(false),
                                       cl::desc("symbolize functions"),
                                       cl::sub(Extract));
 static cl::alias ExtractSymbolize2("s", cl::aliasopt(ExtractSymbolize),
-                                   cl::desc("alias for -symbolize"),
-                                   cl::sub(Extract));
+                                   cl::desc("alias for -symbolize"));
 
 namespace {
 
 void exportAsYAML(const InstrumentationMap &Map, raw_ostream &OS,
                   FuncIdConversionHelper &FH) {
   // First we translate the sleds into the YAMLXRaySledEntry objects in a deque.
   std::vector<YAMLXRaySledEntry> YAMLSleds;
   auto Sleds = Map.sleds();

llvm/tools/llvm-xray/xray-graph-diff.cpp

static cl::opt<std::string> GraphDiffInput2(cl::Positional,
                                             cl::desc("<xray log file 2>"),
                                             cl::Required, cl::sub(GraphDiff));
 
 static cl::opt<bool>
     GraphDiffKeepGoing("keep-going",
                        cl::desc("Keep going on errors encountered"),
                        cl::sub(GraphDiff), cl::init(false));
 static cl::alias GraphDiffKeepGoingA("k", cl::aliasopt(GraphDiffKeepGoing),
-                                     cl::desc("Alias for -keep-going"),
-                                     cl::sub(GraphDiff));
+                                     cl::desc("Alias for -keep-going"));
 static cl::opt<bool>
     GraphDiffKeepGoing1("keep-going-1",
                         cl::desc("Keep going on errors encountered in trace 1"),
                         cl::sub(GraphDiff), cl::init(false));
 static cl::alias GraphDiffKeepGoing1A("k1", cl::aliasopt(GraphDiffKeepGoing1),
-                                      cl::desc("Alias for -keep-going-1"),
-                                      cl::sub(GraphDiff));
+                                      cl::desc("Alias for -keep-going-1"));
 static cl::opt<bool>
     GraphDiffKeepGoing2("keep-going-2",
                         cl::desc("Keep going on errors encountered in trace 2"),
                         cl::sub(GraphDiff), cl::init(false));
 static cl::alias GraphDiffKeepGoing2A("k2", cl::aliasopt(GraphDiffKeepGoing2),
-                                      cl::desc("Alias for -keep-going-2"),
-                                      cl::sub(GraphDiff));
+                                      cl::desc("Alias for -keep-going-2"));
 
 static cl::opt<std::string>
     GraphDiffInstrMap("instr-map",
                       cl::desc("binary with the instrumentation map, or "
                                "a separate instrumentation map for graph"),
                       cl::value_desc("binary with xray_instr_map or yaml"),
                       cl::sub(GraphDiff), cl::init(""));
 static cl::alias GraphDiffInstrMapA("m", cl::aliasopt(GraphDiffInstrMap),
-                                    cl::desc("Alias for -instr-map"),
-                                    cl::sub(GraphDiff));
+                                    cl::desc("Alias for -instr-map"));
 static cl::opt<std::string>
     GraphDiffInstrMap1("instr-map-1",
                        cl::desc("binary with the instrumentation map, or "
                                 "a separate instrumentation map for graph 1"),
                        cl::value_desc("binary with xray_instr_map or yaml"),
                        cl::sub(GraphDiff), cl::init(""));
 static cl::alias GraphDiffInstrMap1A("m1", cl::aliasopt(GraphDiffInstrMap1),
-                                     cl::desc("Alias for -instr-map-1"),
-                                     cl::sub(GraphDiff));
+                                     cl::desc("Alias for -instr-map-1"));
 static cl::opt<std::string>
     GraphDiffInstrMap2("instr-map-2",
                        cl::desc("binary with the instrumentation map, or "
                                 "a separate instrumentation map for graph 2"),
                        cl::value_desc("binary with xray_instr_map or yaml"),
                        cl::sub(GraphDiff), cl::init(""));
 static cl::alias GraphDiffInstrMap2A("m2", cl::aliasopt(GraphDiffInstrMap2),
-                                     cl::desc("Alias for -instr-map-2"),
-                                     cl::sub(GraphDiff));
+                                     cl::desc("Alias for -instr-map-2"));
 
 static cl::opt<bool> GraphDiffDeduceSiblingCalls(
     "deduce-sibling-calls",
     cl::desc("Deduce sibling calls when unrolling function call stacks"),
     cl::sub(GraphDiff), cl::init(false));
 static cl::alias
     GraphDiffDeduceSiblingCallsA("d", cl::aliasopt(GraphDiffDeduceSiblingCalls),
-                                 cl::desc("Alias for -deduce-sibling-calls"),
-                                 cl::sub(GraphDiff));
+                                 cl::desc("Alias for -deduce-sibling-calls"));
 static cl::opt<bool> GraphDiffDeduceSiblingCalls1(
     "deduce-sibling-calls-1",
     cl::desc("Deduce sibling calls when unrolling function call stacks"),
     cl::sub(GraphDiff), cl::init(false));
 static cl::alias GraphDiffDeduceSiblingCalls1A(
     "d1", cl::aliasopt(GraphDiffDeduceSiblingCalls1),
-    cl::desc("Alias for -deduce-sibling-calls-1"), cl::sub(GraphDiff));
+    cl::desc("Alias for -deduce-sibling-calls-1"));
 static cl::opt<bool> GraphDiffDeduceSiblingCalls2(
     "deduce-sibling-calls-2",
     cl::desc("Deduce sibling calls when unrolling function call stacks"),
     cl::sub(GraphDiff), cl::init(false));
 static cl::alias GraphDiffDeduceSiblingCalls2A(
     "d2", cl::aliasopt(GraphDiffDeduceSiblingCalls2),
-    cl::desc("Alias for -deduce-sibling-calls-2"), cl::sub(GraphDiff));
+    cl::desc("Alias for -deduce-sibling-calls-2"));
 
 static cl::opt<GraphRenderer::StatType> GraphDiffEdgeLabel(
     "edge-label", cl::desc("Output graphs with edges labeled with this field"),
     cl::value_desc("field"), cl::sub(GraphDiff),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not label Edges"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphDiffEdgeLabelA("e", cl::aliasopt(GraphDiffEdgeLabel),
-                                     cl::desc("Alias for -edge-label"),
-                                     cl::sub(GraphDiff));
+                                     cl::desc("Alias for -edge-label"));
 
 static cl::opt<GraphRenderer::StatType> GraphDiffEdgeColor(
     "edge-color", cl::desc("Output graphs with edges colored by this field"),
     cl::value_desc("field"), cl::sub(GraphDiff),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not color Edges"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphDiffEdgeColorA("c", cl::aliasopt(GraphDiffEdgeColor),
-                                     cl::desc("Alias for -edge-color"),
-                                     cl::sub(GraphDiff));
+                                     cl::desc("Alias for -edge-color"));
 
 static cl::opt<GraphRenderer::StatType> GraphDiffVertexLabel(
     "vertex-label",
     cl::desc("Output graphs with vertices labeled with this field"),
     cl::value_desc("field"), cl::sub(GraphDiff),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not label Vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphDiffVertexLabelA("v", cl::aliasopt(GraphDiffVertexLabel),
-                                       cl::desc("Alias for -vertex-label"),
-                                       cl::sub(GraphDiff));
+                                       cl::desc("Alias for -vertex-label"));
 
 static cl::opt<GraphRenderer::StatType> GraphDiffVertexColor(
     "vertex-color",
     cl::desc("Output graphs with vertices colored by this field"),
     cl::value_desc("field"), cl::sub(GraphDiff),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not color Vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphDiffVertexColorA("b", cl::aliasopt(GraphDiffVertexColor),
-                                       cl::desc("Alias for -vertex-color"),
-                                       cl::sub(GraphDiff));
+                                       cl::desc("Alias for -vertex-color"));
 
 static cl::opt<int> GraphDiffVertexLabelTrunc(
     "vertex-label-trun", cl::desc("What length to truncate vertex labels to "),
     cl::sub(GraphDiff), cl::init(40));
 static cl::alias
     GraphDiffVertexLabelTrunc1("t", cl::aliasopt(GraphDiffVertexLabelTrunc),
-                               cl::desc("Alias for -vertex-label-trun"),
-                               cl::sub(GraphDiff));
+                               cl::desc("Alias for -vertex-label-trun"));
 
 static cl::opt<std::string>
     GraphDiffOutput("output", cl::value_desc("Output file"), cl::init("-"),
                     cl::desc("output file; use '-' for stdout"),
                     cl::sub(GraphDiff));
 static cl::alias GraphDiffOutputA("o", cl::aliasopt(GraphDiffOutput),
-                                  cl::desc("Alias for -output"),
-                                  cl::sub(GraphDiff));
+                                  cl::desc("Alias for -output"));
 
 Expected<GraphDiffRenderer> GraphDiffRenderer::Factory::getGraphDiffRenderer() {
   GraphDiffRenderer R;
 
   for (int i = 0; i < N; ++i) {
     const auto &G = this->G[i].get();
     for (const auto &V : G.vertices()) {
       const auto &VAttr = V.second;

llvm/tools/llvm-xray/xray-graph.cpp

 static cl::opt<std::string> GraphInput(cl::Positional,
                                        cl::desc("<xray log file>"),
                                        cl::Required, cl::sub(GraphC));
 
 static cl::opt<bool>
     GraphKeepGoing("keep-going", cl::desc("Keep going on errors encountered"),
                    cl::sub(GraphC), cl::init(false));
 static cl::alias GraphKeepGoing2("k", cl::aliasopt(GraphKeepGoing),
-                                 cl::desc("Alias for -keep-going"),
-                                 cl::sub(GraphC));
+                                 cl::desc("Alias for -keep-going"));
 
 static cl::opt<std::string>
     GraphOutput("output", cl::value_desc("Output file"), cl::init("-"),
                 cl::desc("output file; use '-' for stdout"), cl::sub(GraphC));
 static cl::alias GraphOutput2("o", cl::aliasopt(GraphOutput),
-                              cl::desc("Alias for -output"), cl::sub(GraphC));
+                              cl::desc("Alias for -output"));
 
 static cl::opt<std::string>
     GraphInstrMap("instr_map",
                   cl::desc("binary with the instrumrntation map, or "
                            "a separate instrumentation map"),
                   cl::value_desc("binary with xray_instr_map"), cl::sub(GraphC),
                   cl::init(""));
 static cl::alias GraphInstrMap2("m", cl::aliasopt(GraphInstrMap),
-                                cl::desc("alias for -instr_map"),
-                                cl::sub(GraphC));
+                                cl::desc("alias for -instr_map"));
 
 static cl::opt<bool> GraphDeduceSiblingCalls(
     "deduce-sibling-calls",
     cl::desc("Deduce sibling calls when unrolling function call stacks"),
     cl::sub(GraphC), cl::init(false));
 static cl::alias
     GraphDeduceSiblingCalls2("d", cl::aliasopt(GraphDeduceSiblingCalls),
-                             cl::desc("Alias for -deduce-sibling-calls"),
-                             cl::sub(GraphC));
+                             cl::desc("Alias for -deduce-sibling-calls"));
 
 static cl::opt<GraphRenderer::StatType>
     GraphEdgeLabel("edge-label",
                    cl::desc("Output graphs with edges labeled with this field"),
                    cl::value_desc("field"), cl::sub(GraphC),
                    cl::init(GraphRenderer::StatType::NONE),
                    cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                                          "Do not label Edges"),
                               clEnumValN(GraphRenderer::StatType::COUNT,
                                          "count", "function call counts"),
                               clEnumValN(GraphRenderer::StatType::MIN, "min",
                                          "minimum function durations"),
                               clEnumValN(GraphRenderer::StatType::MED, "med",
                                          "median function durations"),
                               clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                                          "90th percentile durations"),
                               clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                                          "99th percentile durations"),
                               clEnumValN(GraphRenderer::StatType::MAX, "max",
                                          "maximum function durations"),
                               clEnumValN(GraphRenderer::StatType::SUM, "sum",
                                          "sum of call durations")));
 static cl::alias GraphEdgeLabel2("e", cl::aliasopt(GraphEdgeLabel),
-                                 cl::desc("Alias for -edge-label"),
-                                 cl::sub(GraphC));
+                                 cl::desc("Alias for -edge-label"));
 
 static cl::opt<GraphRenderer::StatType> GraphVertexLabel(
     "vertex-label",
     cl::desc("Output graphs with vertices labeled with this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not label Vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphVertexLabel2("v", cl::aliasopt(GraphVertexLabel),
-                                   cl::desc("Alias for -edge-label"),
-                                   cl::sub(GraphC));
+                                   cl::desc("Alias for -edge-label"));
 
 static cl::opt<GraphRenderer::StatType> GraphEdgeColorType(
     "color-edges",
     cl::desc("Output graphs with edge colors determined by this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not color Edges"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphEdgeColorType2("c", cl::aliasopt(GraphEdgeColorType),
-                                     cl::desc("Alias for -color-edges"),
-                                     cl::sub(GraphC));
+                                     cl::desc("Alias for -color-edges"));
 
 static cl::opt<GraphRenderer::StatType> GraphVertexColorType(
     "color-vertices",
     cl::desc("Output graphs with vertex colors determined by this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
                           "Do not color vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphVertexColorType2("b", cl::aliasopt(GraphVertexColorType),
-                                       cl::desc("Alias for -edge-label"),
-                                       cl::sub(GraphC));
+                                       cl::desc("Alias for -edge-label"));
 
 template <class T> T diff(T L, T R) { return std::max(L, R) - std::min(L, R); }
 
 // Updates the statistics for a GraphRenderer::TimeStat
 static void updateStat(GraphRenderer::TimeStat &S, int64_t L) {
   S.Count++;
   if (S.Min > L || S.Min == 0)
     S.Min = L;

llvm/tools/llvm-xray/xray-stacks.cpp

 static cl::list<std::string> StackInputs(cl::Positional,
                                          cl::desc("<xray trace>"), cl::Required,
                                          cl::sub(Stack), cl::OneOrMore);
 
 static cl::opt<bool>
     StackKeepGoing("keep-going", cl::desc("Keep going on errors encountered"),
                    cl::sub(Stack), cl::init(false));
 static cl::alias StackKeepGoing2("k", cl::aliasopt(StackKeepGoing),
-                                 cl::desc("Alias for -keep-going"),
-                                 cl::sub(Stack));
+                                 cl::desc("Alias for -keep-going"));
 
 // TODO: Does there need to be an option to deduce tail or sibling calls?
 
 static cl::opt<std::string> StacksInstrMap(
     "instr_map",
     cl::desc("instrumentation map used to identify function ids. "
              "Currently supports elf file instrumentation maps."),
     cl::sub(Stack), cl::init(""));
 static cl::alias StacksInstrMap2("m", cl::aliasopt(StacksInstrMap),
-                                 cl::desc("Alias for -instr_map"),
-                                 cl::sub(Stack));
+                                 cl::desc("Alias for -instr_map"));
 
 static cl::opt<bool>
     SeparateThreadStacks("per-thread-stacks",
                          cl::desc("Report top stacks within each thread id"),
                          cl::sub(Stack), cl::init(false));
 
 static cl::opt<bool>
     AggregateThreads("aggregate-threads",
                      cl::desc("Aggregate stack times across threads"),
                      cl::sub(Stack), cl::init(false));
 
 static cl::opt<bool>
     DumpAllStacks("all-stacks",
                   cl::desc("Dump sum of timings for all stacks. "
                            "By default separates stacks per-thread."),
                   cl::sub(Stack), cl::init(false));
 static cl::alias DumpAllStacksShort("all", cl::aliasopt(DumpAllStacks),
-                                    cl::desc("Alias for -all-stacks"),
-                                    cl::sub(Stack));
+                                    cl::desc("Alias for -all-stacks"));
 
 // TODO(kpw): Add other interesting formats. Perhaps chrome trace viewer format
 // possibly with aggregations or just a linear trace of timings.
 enum StackOutputFormat { HUMAN, FLAMETOOL };
 
 static cl::opt<StackOutputFormat> StacksOutputFormat(
     "stack-format",
     cl::desc("The format that output stacks should be "