[cl] Teach cl to support the notion of sub commands (e.g. "git checkout <foo>")

[zturner]

Summary

This patch improves cl to support sub commands. For example, "git checkout", "git status", etc where each subcommand has an unrelated set of options.

An example of how to use this new functionality is included in this patch where the llvm-pdbdump tool is updated to use this new functionality. If / when this patch is accepted, I will only submit with the changes to cl, and then submit the changes to llvm-pdbdump as a followup. It's only included here as an example.

Any code which was previously written against cl will continue to work unmodified. If you don't specify a subcommand for an option, commands go into the "top level" subcommand, which is searched when no subcommand is specified.

There is another special subcommand called AllSubcommands which, when specified, will inject an option into every sub command. This is useful, for example, to make foo.exe --help and foo.exe command --help both work and do the right thing.

options can also have multiple subcommands, so that the same option will appear in multiple subcommands.

Help output is updated as well to print info about supported subcommands, and also to print the list of options for individual subcommands.

Not sure who to include as a reviewer, feel free to add others as appropriate.

[zturner]

Make the usage in llvm-pdbdump a little cleaner and separate the responsibilities of the different sub-commands a little better.

[zturner]

Added some unit tests. It wasn't easy to test this because the normal paradigm for using llvm::cl is using globals, which doesn't allow you to set up a clean test case each time through. So I had to go through and add some hooks in llvm::cl for basically wiping the slate clean on each test. This allows me to set up new subcommands and options on the stack for each test.

The good news is, adding these unit tests caught a couple of bugs in the implementation of AllSubCommands, which are now fixed.

[zturner]

Fixed one last set of issues causing some tests to fail. I may work on adding some more unit tests if I come up with good things to test, but for now I think this is complete functionality and bugfix wise.

[silvas]

Does this need an update to http://llvm.org/docs/CommandLine.html ?

[zturner]

Yes, i was not aware of that. Will do on Monday

[ruiu]

Can you split this patch into two patches -- one is to add the subcommand system and the other is to use it in llvm-pdbdump. Since the feature itself is pretty generic, I don't think it is a good idea to mix it with other change.

[zturner]

I mentioned in the description that I would eventually submit the two
separately, I included it here to show an example of the syntax to use the
new feature. If you prefer i can remove it entirely from this review

[amccarth]

lib/Support/CommandLine.cpp

142

addOption seems very similar to addLiteralOption. Is it possible to reduce the code duplication by having addOption just forward to addLiteralOption with O->ArgStr as the Name argument? Am I missing some subtle difference?

193

It appears this method should never be called with AllSubCommands. Is that true? If not, can you document that and maybe have the code check to prevent it.

[ruiu]

If it takes time, you don't need to do it, but it is easier to review if it were split into two because I don't need to find out which diffs are "real" parts and which are "examples".

[zturner]

This reverts the llvm-pdbdump part of the changes so that the diff is much smaller. Anyone interested in seeing that can just look at an earlier revision of this diff.

[beanz]

lib/Support/CommandLine.cpp

142

Yes, addOption could call addLiteralOption and reduce duplication. The methods do serve different purposes, so they both need to be present. The, poorly named (by me), addLiteralOption adds the option's string and cl::Option to the global option mapping.

193

It needs to work if it is used with AllSubCommands, and TopLevelSubCommand. If it doesn't that will regress functionality.

[ruiu]

include/llvm/Support/CommandLine.h

206

You can write = nullptr here.

lib/Support/CommandLine.cpp

114

Early return.

1724–1725

You can merge the two if conditions.

unittests/Support/CommandLineTest.cpp

287–288

Why don't you use EXPECT_FALSE and EXPECT_TRUE?

325

Remove.

[zturner]

Sorry for the delay, I was out the second half of last week. This takes all the previous suggestions into account, and adds unit tests to make sure that removing from AllSubCommands and TopLevelSubCommand works as expected.

[zturner]

@beanz, are you ok with this change now given that there is a unit test
verifying that removeOption works with AllSubCommands and
TopLevelSubCommand?

[beanz]

Yep. LGTM!

Thanks for doing this, I think it will be very useful.

-Chris

include/llvm/Support/CommandLine.h

 // the many example usages in tools/*/*.cpp
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_COMMANDLINE_H
 #define LLVM_SUPPORT_COMMANDLINE_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/ManagedStatic.h"
 #include <cassert>
 #include <climits>
 #include <cstdarg>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
public:
   const char *getName() const { return Name; }
   const char *getDescription() const { return Description; }
 };
 
 // The general Option Category (used as default category).
 extern OptionCategory GeneralCategory;
 
 //===----------------------------------------------------------------------===//
+// SubCommand class
+//
+class SubCommand {
+private:
+  const char *const Name;
+  const char *const Description;
+
+  void registerSubCommand();
+
+public:
+  SubCommand(const char *const Name, const char *const Description = nullptr)
+      : Name(Name), Description(Description), ConsumeAfterOpt(nullptr) {
+    registerSubCommand();
+  }
+  SubCommand()
+      : Name(nullptr), Description(nullptr), ConsumeAfterOpt(nullptr) {}
+
+  operator bool() const;
+
+  const char *getName() const { return Name; }
+  const char *getDescription() const { return Description; }
+
+  SmallVector<Option *, 4> PositionalOpts;
+  SmallVector<Option *, 4> SinkOpts;
+  StringMap<Option *> OptionsMap;
+
+  Option *ConsumeAfterOpt; // The ConsumeAfter option if it exists.
+};
+
+// A special subcommand representing no subcommand
+extern ManagedStatic<SubCommand> TopLevelSubCommand;
+
+// A special subcommand that can be used to put an option into all subcommands.
+extern ManagedStatic<SubCommand> AllSubCommands;
+
+//===----------------------------------------------------------------------===//
 // Option Base class
 //
 class alias;
 class Option {
   friend class alias;
 
   // handleOccurrences - Overriden by subclasses to handle the value passed into
   // an argument.  Should return true if there was an error processing the
class Option {
   unsigned Position;       // Position of last occurrence of the option
   unsigned AdditionalVals; // Greater than 0 for multi-valued option.
 
 public:
   StringRef ArgStr;   // The argument string itself (ex: "help", "o")
   StringRef HelpStr;  // The descriptive text message for -help
   StringRef ValueStr; // String describing what the value of this option is
   OptionCategory *Category; // The Category this option belongs to
+  SmallPtrSet<SubCommand *, 4> Subs; // The subcommands this option belongs to.
   bool FullyInitialized;    // Has addArguemnt been called?
 
   inline enum NumOccurrencesFlag getNumOccurrencesFlag() const {
     return (enum NumOccurrencesFlag)Occurrences;
   }
   inline enum ValueExpected getValueExpectedFlag() const {
     return Value ? ((enum ValueExpected)Value) : getValueExpectedFlagDefault();
   }
   inline enum OptionHidden getOptionHiddenFlag() const {
     return (enum OptionHidden)HiddenFlag;
   }
   inline enum FormattingFlags getFormattingFlag() const {
     return (enum FormattingFlags)Formatting;
   }
   inline unsigned getMiscFlags() const { return Misc; }
   inline unsigned getPosition() const { return Position; }
   inline unsigned getNumAdditionalVals() const { return AdditionalVals; }
 
   // hasArgStr - Return true if the argstr != ""
   bool hasArgStr() const { return !ArgStr.empty(); }
+  bool isPositional() const { return getFormattingFlag() == cl::Positional; }
+  bool isSink() const { return getMiscFlags() & cl::Sink; }
+  bool isConsumeAfter() const {
+    return getNumOccurrencesFlag() == cl::ConsumeAfter;
+  }
 
   //-------------------------------------------------------------------------===
   // Accessor functions set by OptionModifiers
   //
   void setArgStr(StringRef S);
   void setDescription(StringRef S) { HelpStr = S; }
   void setValueStr(StringRef S) { ValueStr = S; }
   void setNumOccurrencesFlag(enum NumOccurrencesFlag Val) { Occurrences = Val; }
   void setValueExpectedFlag(enum ValueExpected Val) { Value = Val; }
   void setHiddenFlag(enum OptionHidden Val) { HiddenFlag = Val; }
   void setFormattingFlag(enum FormattingFlags V) { Formatting = V; }
   void setMiscFlag(enum MiscFlags M) { Misc |= M; }
   void setPosition(unsigned pos) { Position = pos; }
   void setCategory(OptionCategory &C) { Category = &C; }
+  void addSubCommand(SubCommand &S) { Subs.insert(&S); }
 
 protected:
   explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
                   enum OptionHidden Hidden)
       : NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
         HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0), Position(0),
         AdditionalVals(0), ArgStr(""), HelpStr(""), ValueStr(""),
         Category(&GeneralCategory), FullyInitialized(false) {}

 // to.
 struct cat {
   OptionCategory &Category;
   cat(OptionCategory &c) : Category(c) {}
 
   template <class Opt> void apply(Opt &O) const { O.setCategory(Category); }
 };
 
+// sub - Specify the subcommand that this option belongs to.
+struct sub {
+  SubCommand &Sub;
+  sub(SubCommand &S) : Sub(S) {}
+
+  template <class Opt> void apply(Opt &O) const { O.addSubCommand(Sub); }
+};
+
 //===----------------------------------------------------------------------===//
 // OptionValue class
 
 // Support value comparison outside the template.
 struct GenericOptionValue {
   virtual bool compare(const GenericOptionValue &V) const = 0;
 
 protected:
ValueExpected getValueExpectedFlagDefault() const override {
     return AliasFor->getValueExpectedFlag();
   }
 
   void done() {
     if (!hasArgStr())
       error("cl::alias must have argument name specified!");
     if (!AliasFor)
       error("cl::alias must have an cl::aliasopt(option) specified!");
+    Subs = AliasFor->Subs;
     addArgument();
   }
 
   // Command line options should not be copyable
   alias(const alias &) = delete;
   alias &operator=(const alias &) = delete;
 
 public:

 ///
 /// This interface is useful for modifying options in libraries that are out of
 /// the control of the client. The options should be modified before calling
 /// llvm::cl::ParseCommandLineOptions().
 ///
 /// Hopefully this API can be depricated soon. Any situation where options need
 /// to be modified by tools or libraries should be handled by sane APIs rather
 /// than just handing around a global list.
-StringMap<Option *> &getRegisteredOptions();
+StringMap<Option *> &getRegisteredOptions(SubCommand &Sub);
 
 //===----------------------------------------------------------------------===//
 // Standalone command line processing utilities.
 //
 
 /// \brief Tokenizes a command line that can contain escapes and quotes.
 //
 /// The quoting rules match those used by GCC and other tools that use

 
 /// \brief Mark all options not part of this category as cl::ReallyHidden.
 ///
 /// \param Category the category of options to keep displaying
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(cl::OptionCategory &Category);
+void HideUnrelatedOptions(cl::OptionCategory &Category,
+                          SubCommand &Sub = *TopLevelSubCommand);
 
 /// \brief Mark all options not part of the categories as cl::ReallyHidden.
 ///
 /// \param Categories the categories of options to keep displaying.
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single
 /// option category to display in the -help output.
-void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories);
+void HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
+                          SubCommand &Sub = *TopLevelSubCommand);
 
 } // End namespace cl
 
 } // End namespace llvm
 
 #endif

lib/Support/CommandLine.cpp

 // Note that rather than trying to figure out what this code does, you could try
 // reading the library documentation located in docs/CommandLine.html
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm-c/Support.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Debug.h"
public:
   // Globals for name and overview of program.  Program name is not a string to
   // avoid static ctor/dtor issues.
   std::string ProgramName;
   const char *ProgramOverview;
 
   // This collects additional help to be printed.
   std::vector<const char *> MoreHelp;
 
-  SmallVector<Option *, 4> PositionalOpts;
-  SmallVector<Option *, 4> SinkOpts;
-  StringMap<Option *> OptionsMap;
-
-  Option *ConsumeAfterOpt; // The ConsumeAfter option if it exists.
-
   // This collects the different option categories that have been registered.
   SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
 
-  CommandLineParser() : ProgramOverview(nullptr), ConsumeAfterOpt(nullptr) {}
+  // This collects the different subcommands that have been registered.
+  SmallPtrSet<SubCommand *, 16> RegisteredSubCommands;
+
+  CommandLineParser()
+      : ProgramOverview(nullptr), ActiveSubCommand(&*TopLevelSubCommand) {
+    registerSubCommand(&*TopLevelSubCommand);
+    registerSubCommand(&*AllSubCommands);
+  }
 
   void ParseCommandLineOptions(int argc, const char *const *argv,
                                const char *Overview);
 
-  void addLiteralOption(Option &Opt, const char *Name) {
+  void addLiteralOption(Option &Opt, SubCommand *SC, const char *Name) {
     if (!Opt.hasArgStr()) {
-      if (!OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
+      if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
         errs() << ProgramName << ": CommandLine Error: Option '" << Name
                << "' registered more than once!\n";
         report_fatal_error("inconsistency in registered CommandLine options");
       }
+
+      // If we're adding this to all sub-commands, add it to the ones that have
+      // already been registered.
+      if (SC == &*AllSubCommands) {
+        for (const auto &Sub : RegisteredSubCommands) {
+          if (SC == Sub)
+            continue;
+          addLiteralOption(Opt, Sub, Name);
+        }
+      }
     }
   }
 
-  void addOption(Option *O) {
+  void addLiteralOption(Option &Opt, const char *Name) {
+    if (Opt.Subs.empty())
+      addLiteralOption(Opt, &*TopLevelSubCommand, Name);
+    else {
+      for (auto SC : Opt.Subs)
+        addLiteralOption(Opt, SC, Name);
+    }
+  }
+
+  void addOption(Option *O, SubCommand *SC) {
     bool HadErrors = false;
     if (O->hasArgStr()) {
       // Add argument to the argument map!
-      if (!OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
+      if (!SC->OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
         errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
                << "' registered more than once!\n";
         HadErrors = true;
       }
     }
 
     // Remember information about positional options.
     if (O->getFormattingFlag() == cl::Positional)
-      PositionalOpts.push_back(O);
+      SC->PositionalOpts.push_back(O);
     else if (O->getMiscFlags() & cl::Sink) // Remember sink options
-      SinkOpts.push_back(O);
+      SC->SinkOpts.push_back(O);
     else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
-      if (ConsumeAfterOpt) {
+      if (SC->ConsumeAfterOpt) {
         O->error("Cannot specify more than one option with cl::ConsumeAfter!");
         HadErrors = true;
       }
-      ConsumeAfterOpt = O;
+      SC->ConsumeAfterOpt = O;
     }
 
     // Fail hard if there were errors. These are strictly unrecoverable and
     // indicate serious issues such as conflicting option names or an
     // incorrectly
     // linked LLVM distribution.
     if (HadErrors)
       report_fatal_error("inconsistency in registered CommandLine options");
+
+    // If we're adding this to all sub-commands, add it to the ones that have
+    // already been registered.
+    if (SC == &*AllSubCommands) {
+      for (const auto &Sub : RegisteredSubCommands) {
+        if (SC == Sub)
+          continue;
+        addOption(O, Sub);
+      }
+    }
   }
 
-  void removeOption(Option *O) {
+  void addOption(Option *O) {
+    if (O->Subs.empty()) {
+      addOption(O, &*TopLevelSubCommand);
+    } else {
+      for (auto SC : O->Subs)
+        addOption(O, SC);
+    }
+  }
+
+  void removeOption(Option *O, SubCommand *SC) {
     SmallVector<StringRef, 16> OptionNames;
     O->getExtraOptionNames(OptionNames);
     if (O->hasArgStr())
       OptionNames.push_back(O->ArgStr);
+
+    SubCommand &Sub = *SC;
     for (auto Name : OptionNames)
-      OptionsMap.erase(Name);
+      Sub.OptionsMap.erase(Name);
 
     if (O->getFormattingFlag() == cl::Positional)
-      for (auto Opt = PositionalOpts.begin(); Opt != PositionalOpts.end();
-           ++Opt) {
+      for (auto Opt = Sub.PositionalOpts.begin();
+           Opt != Sub.PositionalOpts.end(); ++Opt) {
         if (*Opt == O) {
-          PositionalOpts.erase(Opt);
+          Sub.PositionalOpts.erase(Opt);
           break;
         }
       }
     else if (O->getMiscFlags() & cl::Sink)
-      for (auto Opt = SinkOpts.begin(); Opt != SinkOpts.end(); ++Opt) {
+      for (auto Opt = Sub.SinkOpts.begin(); Opt != Sub.SinkOpts.end(); ++Opt) {
         if (*Opt == O) {
-          SinkOpts.erase(Opt);
+          Sub.SinkOpts.erase(Opt);
           break;
         }
       }
-    else if (O == ConsumeAfterOpt)
-      ConsumeAfterOpt = nullptr;
+    else if (O == Sub.ConsumeAfterOpt)
+      Sub.ConsumeAfterOpt = nullptr;
   }
 
-  bool hasOptions() {
-    return (!OptionsMap.empty() || !PositionalOpts.empty() ||
-            nullptr != ConsumeAfterOpt);
+  void removeOption(Option *O) {
+    if (O->Subs.empty())
+      removeOption(O, &*TopLevelSubCommand);
+    else {
+      for (auto SC : O->Subs)
+        removeOption(O, SC);
+    }
   }
 
-  void updateArgStr(Option *O, StringRef NewName) {
-    if (!OptionsMap.insert(std::make_pair(NewName, O)).second) {
+  bool hasOptions(const SubCommand &Sub) const {
+    return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() ||
+            nullptr != Sub.ConsumeAfterOpt);
+  }
+
+  bool hasOptions() const {
+    for (const auto &S : RegisteredSubCommands) {
+      if (hasOptions(*S))
+        return true;
+    }
+    return false;
+  }
+
+  SubCommand *getActiveSubCommand() { return ActiveSubCommand; }
+
+  void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) {
+    SubCommand &Sub = *SC;
+    if (!Sub.OptionsMap.insert(std::make_pair(NewName, O)).second) {
       errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
     }
-    OptionsMap.erase(O->ArgStr);
+    Sub.OptionsMap.erase(O->ArgStr);
+  }
+
+  void updateArgStr(Option *O, StringRef NewName) {
+    if (O->Subs.empty())
+      updateArgStr(O, NewName, &*TopLevelSubCommand);
+    else {
+      for (auto SC : O->Subs)
+        updateArgStr(O, NewName, SC);
+    }
   }
 
   void printOptionValues();
 
   void registerCategory(OptionCategory *cat) {
     assert(count_if(RegisteredOptionCategories,
                     [cat](const OptionCategory *Category) {
              return cat->getName() == Category->getName();
            }) == 0 &&
            "Duplicate option categories");
 
     RegisteredOptionCategories.insert(cat);
   }
 
+  void registerSubCommand(SubCommand *sub) {
+    assert(count_if(RegisteredSubCommands,
+                    [sub](const SubCommand *Sub) {
+                      return (sub->getName() != nullptr) &&
+                             (Sub->getName() == sub->getName());
+                    }) == 0 &&
+           "Duplicate subcommands");
+    RegisteredSubCommands.insert(sub);
+
+    // For all options that have been registered for all subcommands, add the
+    // option to this subcommand now.
+    if (sub != &*AllSubCommands) {
+      for (auto &E : AllSubCommands->OptionsMap) {
+        Option *O = E.second;
+        if (O->isPositional() || O->isSink() || O->isConsumeAfter())
+          addOption(O, sub);
+        else
+          addLiteralOption(*O, sub, E.first().str().c_str());
+      }
+    }
+  }
+
 private:
-  Option *LookupOption(StringRef &Arg, StringRef &Value);
+  SubCommand *ActiveSubCommand;
+
+  Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value);
+  SubCommand *LookupSubCommand(const char *Name);
 };
 
 } // namespace
 
 static ManagedStatic<CommandLineParser> GlobalParser;
 
 void cl::AddLiteralOption(Option &O, const char *Name) {
   GlobalParser->addLiteralOption(O, Name);

 
 // Initialise the general option category.
 OptionCategory llvm::cl::GeneralCategory("General options");
 
 void OptionCategory::registerCategory() {
   GlobalParser->registerCategory(this);
 }
 
+// A special subcommand representing no subcommand
+ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
+
+// A special subcommand that can be used to put an option into all subcommands.
+ManagedStatic<SubCommand> llvm::cl::AllSubCommands;
+
+void SubCommand::registerSubCommand() {
+  GlobalParser->registerSubCommand(this);
+}
+
+SubCommand::operator bool() const {
+  return (GlobalParser->getActiveSubCommand() == this);
+}
+
 //===----------------------------------------------------------------------===//
 // Basic, shared command line option processing machinery.
 //
 
 /// LookupOption - Lookup the option specified by the specified option on the
 /// command line.  If there is a value specified (after an equal sign) return
 /// that as well.  This assumes that leading dashes have already been stripped.
-Option *CommandLineParser::LookupOption(StringRef &Arg, StringRef &Value) {
+Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg,
+                                        StringRef &Value) {
   // Reject all dashes.
   if (Arg.empty())
     return nullptr;
+  assert(&Sub != &*AllSubCommands);
 
   size_t EqualPos = Arg.find('=');
 
   // If we have an equals sign, remember the value.
   if (EqualPos == StringRef::npos) {
     // Look up the option.
-    StringMap<Option *>::const_iterator I = OptionsMap.find(Arg);
-    return I != OptionsMap.end() ? I->second : nullptr;
+    auto I = Sub.OptionsMap.find(Arg);
+    if (I == Sub.OptionsMap.end())
+      return nullptr;
+
+    return I != Sub.OptionsMap.end() ? I->second : nullptr;
   }
 
   // If the argument before the = is a valid option name, we match.  If not,
   // return Arg unmolested.
-  StringMap<Option *>::const_iterator I =
-      OptionsMap.find(Arg.substr(0, EqualPos));
-  if (I == OptionsMap.end())
+  auto I = Sub.OptionsMap.find(Arg.substr(0, EqualPos));
+  if (I == Sub.OptionsMap.end())
     return nullptr;
 
   Value = Arg.substr(EqualPos + 1);
   Arg = Arg.substr(0, EqualPos);
   return I->second;
 }
 
+SubCommand *CommandLineParser::LookupSubCommand(const char *Name) {
+  if (Name == nullptr)
+    return &*TopLevelSubCommand;
+  for (auto S : RegisteredSubCommands) {
+    if (S == &*AllSubCommands)
+      continue;
+    if (S->getName() == nullptr)
+      continue;
+
+    if (StringRef(S->getName()) == StringRef(Name))
+      return S;
+  }
+  return &*TopLevelSubCommand;
+}
+
 /// LookupNearestOption - Lookup the closest match to the option specified by
 /// the specified option on the command line.  If there is a value specified
 /// (after an equal sign) return that as well.  This assumes that leading dashes
 /// have already been stripped.
 static Option *LookupNearestOption(StringRef Arg,
                                    const StringMap<Option *> &OptionsMap,
                                    std::string &NearestString) {
   // Reject all dashes.
void CommandLineParser::ParseCommandLineOptions(int argc,
   bool ErrorParsing = false;
 
   // Check out the positional arguments to collect information about them.
   unsigned NumPositionalRequired = 0;
 
   // Determine whether or not there are an unlimited number of positionals
   bool HasUnlimitedPositionals = false;
 
+  int FirstArg = 1;
+  SubCommand *ChosenSubCommand = &*TopLevelSubCommand;
+  if (argc >= 2 && argv[FirstArg][0] != '-') {
+    // If the first argument specifies a valid subcommand, start processing
+    // options from the second argument.
+    ChosenSubCommand = LookupSubCommand(argv[FirstArg]);
+    if (ChosenSubCommand != &*TopLevelSubCommand)
+      FirstArg = 2;
+  }
+  GlobalParser->ActiveSubCommand = ChosenSubCommand;
+
+  assert(ChosenSubCommand);
+  auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
+  auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
+  auto &SinkOpts = ChosenSubCommand->SinkOpts;
+  auto &OptionsMap = ChosenSubCommand->OptionsMap;
+
   if (ConsumeAfterOpt) {
     assert(PositionalOpts.size() > 0 &&
            "Cannot specify cl::ConsumeAfter without a positional argument!");
   }
   if (!PositionalOpts.empty()) {
 
     // Calculate how many positional values are _required_.
     bool UnboundedFound = false;
void CommandLineParser::ParseCommandLineOptions(int argc,
 
   // If the program has named positional arguments, and the name has been run
   // across, keep track of which positional argument was named.  Otherwise put
   // the positional args into the PositionalVals list...
   Option *ActivePositionalArg = nullptr;
 
   // Loop over all of the arguments... processing them.
   bool DashDashFound = false; // Have we read '--'?
-  for (int i = 1; i < argc; ++i) {
+  for (int i = FirstArg; i < argc; ++i) {
     Option *Handler = nullptr;
     Option *NearestHandler = nullptr;
     std::string NearestHandlerString;
     StringRef Value;
     StringRef ArgName = "";
 
     // Check to see if this is a positional argument.  This argument is
     // considered to be positional if it doesn't start with '-', if it is "-"
if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
       // If there is a positional argument eating options, check to see if this
       // option is another positional argument.  If so, treat it as an argument,
       // otherwise feed it to the eating positional.
       ArgName = argv[i] + 1;
       // Eat leading dashes.
       while (!ArgName.empty() && ArgName[0] == '-')
         ArgName = ArgName.substr(1);
 
-      Handler = LookupOption(ArgName, Value);
+      Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
       if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
         ProvidePositionalOption(ActivePositionalArg, argv[i], i);
         continue; // We are done!
       }
 
     } else { // We start with a '-', must be an argument.
       ArgName = argv[i] + 1;
       // Eat leading dashes.
       while (!ArgName.empty() && ArgName[0] == '-')
         ArgName = ArgName.substr(1);
 
-      Handler = LookupOption(ArgName, Value);
+      Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
 
       // Check to see if this "option" is really a prefixed or grouped argument.
       if (!Handler)
         Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing,
                                                 OptionsMap);
 
       // Otherwise, look for the closest available option to report to the user
       // in the upcoming error.

 // -help and -help-hidden option implementation
 //
 
 static int OptNameCompare(const std::pair<const char *, Option *> *LHS,
                           const std::pair<const char *, Option *> *RHS) {
   return strcmp(LHS->first, RHS->first);
 }
 
+static int SubNameCompare(const std::pair<const char *, SubCommand *> *LHS,
+                          const std::pair<const char *, SubCommand *> *RHS) {
+  return strcmp(LHS->first, RHS->first);
+}
+
 // Copy Options into a vector so we can sort them as we like.
 static void sortOpts(StringMap<Option *> &OptMap,
                      SmallVectorImpl<std::pair<const char *, Option *>> &Opts,
                      bool ShowHidden) {
   SmallPtrSet<Option *, 32> OptionSet; // Duplicate option detection.
 
   for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
        I != E; ++I) {
for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
     Opts.push_back(
         std::pair<const char *, Option *>(I->getKey().data(), I->second));
   }
 
   // Sort the options list alphabetically.
   array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare);
 }
 
+static void
+sortSubCommands(const SmallPtrSetImpl<SubCommand *> &SubMap,
+                SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) {
+  for (const auto &S : SubMap) {
+    if (S->getName() == nullptr)
+      continue;
+    Subs.push_back(std::make_pair(S->getName(), S));
+  }
+  array_pod_sort(Subs.begin(), Subs.end(), SubNameCompare);
+}
+
 namespace {
 
 class HelpPrinter {
 protected:
   const bool ShowHidden;
   typedef SmallVector<std::pair<const char *, Option *>, 128>
       StrOptionPairVector;
+  typedef SmallVector<std::pair<const char *, SubCommand *>, 128>
+      StrSubCommandPairVector;
   // Print the options. Opts is assumed to be alphabetically sorted.
   virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
     for (size_t i = 0, e = Opts.size(); i != e; ++i)
       Opts[i].second->printOptionInfo(MaxArgLen);
   }
 
+  void printSubCommands(StrSubCommandPairVector &Subs, size_t MaxSubLen) {
+    for (const auto &S : Subs) {
+      outs() << "  " << S.first;
+      if (S.second->getDescription()) {
+        outs().indent(MaxSubLen - strlen(S.first));
+        outs() << " - " << S.second->getDescription();
+      }
+      outs() << "\n";
+    }
+  }
+
 public:
   explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
   virtual ~HelpPrinter() {}
 
   // Invoke the printer.
   void operator=(bool Value) {
     if (!Value)
       return;
 
+    SubCommand *Sub = GlobalParser->getActiveSubCommand();
+    auto &OptionsMap = Sub->OptionsMap;
+    auto &PositionalOpts = Sub->PositionalOpts;
+    auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
+
     StrOptionPairVector Opts;
-    sortOpts(GlobalParser->OptionsMap, Opts, ShowHidden);
+    sortOpts(OptionsMap, Opts, ShowHidden);
+
+    StrSubCommandPairVector Subs;
+    sortSubCommands(GlobalParser->RegisteredSubCommands, Subs);
 
     if (GlobalParser->ProgramOverview)
       outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
 
-    outs() << "USAGE: " << GlobalParser->ProgramName << " [options]";
+    if (Sub == &*TopLevelSubCommand)
+      outs() << "USAGE: " << GlobalParser->ProgramName
+             << " [subcommand] [options]";
+    else {
+      if (Sub->getDescription() != nullptr) {
+        outs() << "SUBCOMMAND '" << Sub->getName()
+               << "': " << Sub->getDescription() << "\n\n";
+      }
+      outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()
+             << " [options]";
+    }
 
-    for (auto Opt : GlobalParser->PositionalOpts) {
+    for (auto Opt : PositionalOpts) {
       if (Opt->hasArgStr())
         outs() << " --" << Opt->ArgStr;
       outs() << " " << Opt->HelpStr;
     }
 
     // Print the consume after option info if it exists...
-    if (GlobalParser->ConsumeAfterOpt)
-      outs() << " " << GlobalParser->ConsumeAfterOpt->HelpStr;
+    if (ConsumeAfterOpt)
+      outs() << " " << ConsumeAfterOpt->HelpStr;
+
+    if (Sub == &*TopLevelSubCommand) {
+      if (Subs.size() > 2) {
+        // Compute the maximum subcommand length...
+        size_t MaxSubLen = 0;
+        for (size_t i = 0, e = Subs.size(); i != e; ++i)
+          MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first));
+
+        outs() << "\n\n";
+        outs() << "SUBCOMMANDS:\n\n";
+        printSubCommands(Subs, MaxSubLen);
+        outs() << "\n";
+        outs() << "  Type \"" << GlobalParser->ProgramName
+               << " <subcommand> -help\" to get more help on a specific "
+                  "subcommand";
+      }
+    }
 
     outs() << "\n\n";
 
     // Compute the maximum argument length...
     size_t MaxArgLen = 0;
     for (size_t i = 0, e = Opts.size(); i != e; ++i)
       MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 

 
 // Define uncategorized help printers.
 // -help-list is hidden by default because if Option categories are being used
 // then -help behaves the same as -help-list.
 static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
     "help-list",
     cl::desc("Display list of available options (-help-list-hidden for more)"),
     cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
-    cl::cat(GenericCategory));
+    cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<HelpPrinter, true, parser<bool>>
     HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
           cl::location(UncategorizedHiddenPrinter), cl::Hidden,
-          cl::ValueDisallowed, cl::cat(GenericCategory));
+          cl::ValueDisallowed, cl::cat(GenericCategory),
+          cl::sub(*AllSubCommands));
 
 // Define uncategorized/categorized help printers. These printers change their
 // behaviour at runtime depending on whether one or more Option categories have
 // been declared.
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HOp("help", cl::desc("Display available options (-help-hidden for more)"),
         cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
-        cl::cat(GenericCategory));
+        cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<HelpPrinterWrapper, true, parser<bool>>
     HHOp("help-hidden", cl::desc("Display all available options"),
          cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
-         cl::cat(GenericCategory));
+         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 static cl::opt<bool> PrintOptions(
     "print-options",
     cl::desc("Print non-default options after command line parsing"),
-    cl::Hidden, cl::init(false), cl::cat(GenericCategory));
+    cl::Hidden, cl::init(false), cl::cat(GenericCategory),
+    cl::sub(*AllSubCommands));
 
 static cl::opt<bool> PrintAllOptions(
     "print-all-options",
     cl::desc("Print all option values after command line parsing"), cl::Hidden,
-    cl::init(false), cl::cat(GenericCategory));
+    cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 
 void HelpPrinterWrapper::operator=(bool Value) {
   if (!Value)
     return;
 
   // Decide which printer to invoke. If more than one option category is
   // registered then it is useful to show the categorized help instead of
   // uncategorized help.

 // Print the value of each option.
 void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
 
 void CommandLineParser::printOptionValues() {
   if (!PrintOptions && !PrintAllOptions)
     return;
 
   SmallVector<std::pair<const char *, Option *>, 128> Opts;
-  sortOpts(OptionsMap, Opts, /*ShowHidden*/ true);
+  sortOpts(ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true);
 
   // Compute the maximum argument length...
   size_t MaxArgLen = 0;
   for (size_t i = 0, e = Opts.size(); i != e; ++i)
     MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
 
   for (size_t i = 0, e = Opts.size(); i != e; ++i)
     Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions);

 
 void cl::AddExtraVersionPrinter(void (*func)()) {
   if (!ExtraVersionPrinters)
     ExtraVersionPrinters = new std::vector<void (*)()>;
 
   ExtraVersionPrinters->push_back(func);
 }
 
-StringMap<Option *> &cl::getRegisteredOptions() {
-  return GlobalParser->OptionsMap;
+StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
+  auto &Subs = GlobalParser->RegisteredSubCommands;
+  assert(std::find(Subs.begin(), Subs.end(), &Sub) != Subs.end());
+  return Sub.OptionsMap;
 }
 
-void cl::HideUnrelatedOptions(cl::OptionCategory &Category) {
-  for (auto &I : GlobalParser->OptionsMap) {
+void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
+  for (auto &I : Sub.OptionsMap) {
     if (I.second->Category != &Category &&
         I.second->Category != &GenericCategory)
       I.second->setHiddenFlag(cl::ReallyHidden);
   }
 }
 
-void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories) {
+void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
+                              SubCommand &Sub) {
   auto CategoriesBegin = Categories.begin();
   auto CategoriesEnd = Categories.end();
-  for (auto &I : GlobalParser->OptionsMap) {
+  for (auto &I : Sub.OptionsMap) {
     if (std::find(CategoriesBegin, CategoriesEnd, I.second->Category) ==
             CategoriesEnd &&
         I.second->Category != &GenericCategory)
       I.second->setHiddenFlag(cl::ReallyHidden);
   }
 }
 
 void LLVMParseCommandLineOptions(int argc, const char *const *argv,
                                  const char *Overview) {
   llvm::cl::ParseCommandLineOptions(argc, argv, Overview);
 }

test/DebugInfo/PDB/DIA/pdbdump-flags.test

-; RUN: llvm-pdbdump %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=NO_ARGS
-; RUN: llvm-pdbdump -types %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=TYPES
-; RUN: llvm-pdbdump -compilands %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=COMPILANDS
-; RUN: llvm-pdbdump -types -compilands %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=MULTIPLE
+; RUN: llvm-pdbdump pretty %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=NO_ARGS
+; RUN: llvm-pdbdump pretty -types %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=TYPES
+; RUN: llvm-pdbdump pretty -compilands %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=COMPILANDS
+; RUN: llvm-pdbdump pretty -types -compilands %p/../Inputs/empty.pdb | FileCheck %s -check-prefix=MULTIPLE
 
 ; Check that neither symbols nor compilands are dumped when neither argument specified.
 ; NO_ARGS: empty.pdb
 ; NO_ARGS: Guid: {0B355641-86A0-A249-896F-9988FAE52FF0}
 ; NO_ARGS: Attributes: HasPrivateSymbols
 ; NO_ARGS-NOT: ---TYPES---
 ; NO_ARGS-NOT: ---COMPILANDS---
 ; NO_ARGS-NOT: ---GLOBALS---

test/DebugInfo/PDB/DIA/pdbdump-linenumbers.test

-; RUN: llvm-pdbdump -lines %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=LINE_NUMS %s
+; RUN: llvm-pdbdump pretty -lines %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=LINE_NUMS %s
 
 ; LINE_NUMS: llvm\test\debuginfo\pdb\inputs\symbolformat-fpo.cpp
 ; LINE_NUMS: Line 5, Address: [0x000011a0 - 0x000011a5] (6 bytes)
 ; LINE_NUMS: Line 6, Address: [0x000011a6 - 0x000011a6] (1 bytes)
 ; LINE_NUMS: llvm\test\debuginfo\pdb\inputs\symbolformat.cpp
 ; LINE_NUMS: Line 6, Address: [0x00001060 - 0x00001066] (7 bytes)
 ; LINE_NUMS: Line 72, Address: [0x000010d0 - 0x000010d1] (2 bytes)
 ; LINE_NUMS: Line 73, Address: [0x000010d2 - 0x000010d5] (4 bytes)
 ; LINE_NUMS: Line 28, Address: [0x00001170 - 0x0000117a] (11 bytes)
 ; LINE_NUMS: Line 21, Address: [0x00001180 - 0x0000118a] (11 bytes)
 ; LINE_NUMS: Line 20, Address: [0x00001190 - 0x0000119a] (11 bytes)
 No newline at end of file

test/DebugInfo/PDB/DIA/pdbdump-symbol-format.test

-; RUN: llvm-pdbdump -symbols %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=SYM_FORMAT %s
-; RUN: llvm-pdbdump -types %p/../Inputs/symbolformat.pdb > %t.types
+; RUN: llvm-pdbdump pretty -symbols %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=SYM_FORMAT %s
+; RUN: llvm-pdbdump pretty -types %p/../Inputs/symbolformat.pdb > %t.types
 ; RUN: FileCheck --check-prefix=TYPES_FORMAT %s < %t.types
 ; RUN: FileCheck --check-prefix=TYPES_1 %s < %t.types
 ; RUN: FileCheck --check-prefix=TYPES_2 %s < %t.types
-; RUN: llvm-pdbdump -types %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=TYPES_FORMAT %s
-; RUN: llvm-pdbdump -globals %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=GLOBALS %s
+; RUN: llvm-pdbdump pretty -types %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=TYPES_FORMAT %s
+; RUN: llvm-pdbdump pretty -globals %p/../Inputs/symbolformat.pdb | FileCheck --check-prefix=GLOBALS %s
 
 ; The format is func [0x<rva_start>+<prologue_length> - 0x<rva_end>-<epilogue_length>]
 ; SYM_FORMAT: ---SYMBOLS---
 ; SYM_FORMAT: symbolformat-fpo.obj
 ; SYM_FORMAT-DAG: func [{{.*}}] (FPO) unsigned int __cdecl fpo_func(unsigned int n)
 ; SYM_FORMAT: symbolformat.obj
 ; SYM_FORMAT-DAG: func [{{.*}}] (EBP) int __cdecl _purecall()
 ; SYM_FORMAT-DAG: func [{{.*}}] (EBP) int __cdecl main(int argc, char** argv)

test/DebugInfo/PDB/pdbdump-headers.test

-; RUN: llvm-pdbdump -raw-headers -raw-tpi-records -raw-tpi-record-bytes -raw-module-syms \
-; RUN:              -raw-sym-record-bytes -raw-publics -raw-module-files -raw-stream-name=/names \
-; RUN:              -raw-stream-summary -raw-stream-blocks -raw-ipi-records -raw-ipi-record-bytes \
-; RUN:              -raw-section-contribs -raw-section-map -raw-section-headers -raw-line-info \
-; RUN:              -raw-tpi-hash -raw-fpo %p/Inputs/empty.pdb | FileCheck -check-prefix=EMPTY %s
-; RUN: llvm-pdbdump -raw-all %p/Inputs/empty.pdb | FileCheck -check-prefix=ALL %s
-; RUN: llvm-pdbdump -raw-headers -raw-stream-name=/names -raw-modules -raw-module-files \
+; RUN: llvm-pdbdump raw -headers -tpi-records -tpi-record-bytes -module-syms \
+; RUN:              -sym-record-bytes -publics -module-files -stream-name=/names \
+; RUN:              -stream-summary -stream-blocks -ipi-records -ipi-record-bytes \
+; RUN:              -section-contribs -section-map -section-headers -line-info \
+; RUN:              -tpi-hash -fpo %p/Inputs/empty.pdb | FileCheck -check-prefix=EMPTY %s
+; RUN: llvm-pdbdump raw -all %p/Inputs/empty.pdb | FileCheck -check-prefix=ALL %s
+; RUN: llvm-pdbdump raw -headers -stream-name=/names -modules -module-files \
 ; RUN:              %p/Inputs/big-read.pdb | FileCheck -check-prefix=BIG %s
-; RUN: not llvm-pdbdump -raw-headers %p/Inputs/bad-block-size.pdb 2>&1 | FileCheck -check-prefix=BAD-BLOCK-SIZE %s
+; RUN: not llvm-pdbdump raw -headers %p/Inputs/bad-block-size.pdb 2>&1 | FileCheck -check-prefix=BAD-BLOCK-SIZE %s
 
 ; EMPTY:      FileHeaders {
 ; EMPTY-NEXT:   BlockSize: 4096
 ; EMPTY-NEXT:   Unknown0: 2
 ; EMPTY-NEXT:   NumBlocks: 25
 ; EMPTY-NEXT:   NumDirectoryBytes: 136
 ; EMPTY-NEXT:   Unknown1: 0
 ; EMPTY-NEXT:   BlockMapAddr: 24

test/DebugInfo/PDB/pdbdump-yaml.test

-; RUN: llvm-pdbdump -raw-headers -raw-output-style=YAML %p/Inputs/empty.pdb \
-; RUN:               | FileCheck -check-prefix=YAML %s
+; RUN: llvm-pdbdump pdb2yaml -headers %p/Inputs/empty.pdb | FileCheck -check-prefix=YAML %s
 
 ; YAML:      ---
 ; YAML-NEXT: MSF:
 ; YAML-NEXT:   SuperBlock:
 ; YAML-NEXT:     BlockSize:       4096
 ; YAML-NEXT:     Unknown0:        2
 ; YAML-NEXT:     NumBlocks:       25
 ; YAML-NEXT:     NumDirectoryBytes: 136

test/tools/llvm-pdbdump/class-layout.test

-; RUN: llvm-pdbdump -all %p/Inputs/ClassLayoutTest.pdb > %t
+; RUN: llvm-pdbdump pretty -all %p/Inputs/ClassLayoutTest.pdb > %t
 ; RUN: FileCheck -input-file=%t %s -check-prefix=GLOBALS_TEST
 ; RUN: FileCheck -input-file=%t %s -check-prefix=MEMBERS_TEST
 ; RUN: FileCheck -input-file=%t %s -check-prefix=BASE_CLASS_A
 ; RUN: FileCheck -input-file=%t %s -check-prefix=BASE_CLASS_B
 ; RUN: FileCheck -input-file=%t %s -check-prefix=BASE_CLASS_C
 ; RUN: FileCheck -input-file=%t %s -check-prefix=BASE_CLASS_D
 ; RUN: FileCheck -input-file=%t %s -check-prefix=UDT_KIND_TEST
 ; RUN: FileCheck -input-file=%t %s -check-prefix=BITFIELD_TEST

test/tools/llvm-pdbdump/enum-layout.test

-; RUN: llvm-pdbdump -types %p/Inputs/ClassLayoutTest.pdb > %t
+; RUN: llvm-pdbdump pretty -types %p/Inputs/ClassLayoutTest.pdb > %t
 ; RUN: FileCheck -input-file=%t %s -check-prefix=GLOBAL_ENUM
 ; RUN: FileCheck -input-file=%t %s -check-prefix=MEMBER_ENUM
 
 ; GLOBAL_ENUM: ---TYPES---
 ; GLOBAL_ENUM: Enums:
 ; GLOBAL_ENUM: enum GlobalsTest::Enum {
 ; GLOBAL_ENUM-NEXT: Val1 = 0
 ; GLOBAL_ENUM-NEXT: }

test/tools/llvm-pdbdump/load-address.test

-; RUN: llvm-pdbdump -externals %p/Inputs/LoadAddressTest.pdb \
+; RUN: llvm-pdbdump pretty -externals %p/Inputs/LoadAddressTest.pdb \
 ; RUN:    | FileCheck --check-prefix=RVA %s
-; RUN: llvm-pdbdump -externals -load-address=0x40000000 \
+; RUN: llvm-pdbdump pretty -externals -load-address=0x40000000 \
 ; RUN: %p/Inputs/LoadAddressTest.pdb | FileCheck --check-prefix=VA %s
 
 ; RVA: ---EXTERNALS---
 ; RVA: [0x00001010] _main
 
 ; VA: ---EXTERNALS---
 ; VA: [0x40001010] _main

test/tools/llvm-pdbdump/regex-filter.test

-; RUN: llvm-pdbdump -symbols -globals -types %p/Inputs/FilterTest.pdb \
+; RUN: llvm-pdbdump pretty -symbols -globals -types %p/Inputs/FilterTest.pdb \
 ; RUN:    | FileCheck --check-prefix=NO_FILTER %s
-; RUN: llvm-pdbdump -types -exclude-types="GlobalTypedef|NestedTypedef" \
+; RUN: llvm-pdbdump pretty -types -exclude-types="GlobalTypedef|NestedTypedef" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck --check-prefix=EXCLUDE_TYPEDEFS %s
-; RUN: llvm-pdbdump -types -exclude-types="GlobalEnum|NestedEnum" \
+; RUN: llvm-pdbdump pretty -types -exclude-types="GlobalEnum|NestedEnum" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck --check-prefix=EXCLUDE_ENUMS %s
-; RUN: llvm-pdbdump -types -symbols -globals -exclude-symbols="MemberVar|GlobalVar" \
+; RUN: llvm-pdbdump pretty -types -symbols -globals -exclude-symbols="MemberVar|GlobalVar" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck --check-prefix=EXCLUDE_VARS %s
-; RUN: llvm-pdbdump -types -exclude-types="FilterTestClass" \
+; RUN: llvm-pdbdump pretty -types -exclude-types="FilterTestClass" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck  --check-prefix=EXCLUDE_WHOLE_CLASS %s
-; RUN: llvm-pdbdump -symbols -globals -exclude-compilands="FilterTest.obj"  \
+; RUN: llvm-pdbdump pretty -symbols -globals -exclude-compilands="FilterTest.obj"  \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck  --check-prefix=EXCLUDE_COMPILAND %s
-; RUN: llvm-pdbdump -types -include-types="FilterTestClass" \
+; RUN: llvm-pdbdump pretty -types -include-types="FilterTestClass" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck --check-prefix=INCLUDE_ONLY_TYPES %s
-; RUN: llvm-pdbdump -types -symbols -globals -include-symbols="[[:<:]](IntGlobalVar|DoubleGlobalVar)[[:>:]]" \
+; RUN: llvm-pdbdump pretty -types -symbols -globals -include-symbols="[[:<:]](IntGlobalVar|DoubleGlobalVar)[[:>:]]" \
 ; RUN:    %p/Inputs/FilterTest.pdb | FileCheck --check-prefix=INCLUDE_ONLY_VARS %s
 
 ; NO_FILTER: ---TYPES---
 ; NO_FILTER: Enums:
 ; NO_FILTER: enum GlobalEnum
 ; NO_FILTER: Typedefs
 ; NO_FILTER: typedef int GlobalTypedef
 ; NO_FILTER: Classes:

tools/llvm-pdbdump/ClassDefinitionDumper.cpp

void ClassDefinitionDumper::start(const PDBSymbolTypeUDT &Class) {
   while (auto Child = Children->getNext()) {
     PDB_MemberAccess Access = Child->getRawSymbol().getAccess();
     if (isa<PDBSymbolTypeBaseClass>(*Child))
       continue;
 
     auto &AccessGroup = Groups.find((int)Access)->second;
 
     if (auto Func = dyn_cast<PDBSymbolFunc>(Child.get())) {
-      if (Func->isCompilerGenerated() && opts::ExcludeCompilerGenerated)
+      if (Func->isCompilerGenerated() && opts::pretty::ExcludeCompilerGenerated)
         continue;
       if (Func->getLength() == 0 && !Func->isPureVirtual() &&
           !Func->isIntroVirtualFunction())
         continue;
       Child.release();
       AccessGroup.Functions.push_back(std::unique_ptr<PDBSymbolFunc>(Func));
     } else if (auto Data = dyn_cast<PDBSymbolData>(Child.get())) {
       Child.release();

tools/llvm-pdbdump/EnumDumper.cpp

 using namespace llvm;
 using namespace llvm::pdb;
 
 EnumDumper::EnumDumper(LinePrinter &P) : PDBSymDumper(true), Printer(P) {}
 
 void EnumDumper::start(const PDBSymbolTypeEnum &Symbol) {
   WithColor(Printer, PDB_ColorItem::Keyword).get() << "enum ";
   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
-  if (!opts::NoEnumDefs) {
+  if (!opts::pretty::NoEnumDefs) {
     auto BuiltinType = Symbol.getUnderlyingType();
     if (BuiltinType->getBuiltinType() != PDB_BuiltinType::Int ||
         BuiltinType->getLength() != 4) {
       Printer << " : ";
       BuiltinDumper Dumper(Printer);
       Dumper.start(*BuiltinType);
     }
     Printer << " {";

tools/llvm-pdbdump/LLVMOutputStyle.cpp

static void printSectionOffset(llvm::raw_ostream &OS,
                                const SectionOffset &Off) {
   OS << Off.Off << ", " << Off.Isect;
 }
 
 LLVMOutputStyle::LLVMOutputStyle(PDBFile &File)
     : File(File), P(outs()), TD(&P, false) {}
 
 Error LLVMOutputStyle::dumpFileHeaders() {
-  if (!opts::DumpHeaders)
+  if (!opts::raw::DumpHeaders)
     return Error::success();
 
   DictScope D(P, "FileHeaders");
   P.printNumber("BlockSize", File.getBlockSize());
   P.printNumber("Unknown0", File.getUnknown0());
   P.printNumber("NumBlocks", File.getBlockCount());
   P.printNumber("NumDirectoryBytes", File.getNumDirectoryBytes());
   P.printNumber("Unknown1", File.getUnknown1());
   P.printNumber("BlockMapAddr", File.getBlockMapIndex());
   P.printNumber("NumDirectoryBlocks", File.getNumDirectoryBlocks());
   P.printNumber("BlockMapOffset", File.getBlockMapOffset());
 
   // The directory is not contiguous.  Instead, the block map contains a
   // contiguous list of block numbers whose contents, when concatenated in
   // order, make up the directory.
   P.printList("DirectoryBlocks", File.getDirectoryBlockArray());
   P.printNumber("NumStreams", File.getNumStreams());
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpStreamSummary() {
-  if (!opts::DumpStreamSummary)
+  if (!opts::raw::DumpStreamSummary)
     return Error::success();
 
   // It's OK if we fail to load some of these streams, we still attempt to print
   // what we can.
   auto Dbi = File.getPDBDbiStream();
   auto Tpi = File.getPDBTpiStream();
   auto Ipi = File.getPDBIpiStream();
   auto Info = File.getPDBInfoStream();
Error LLVMOutputStyle::dumpStreamSummary() {
   if (!Info)
     consumeError(Info.takeError());
 
   P.flush();
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpStreamBlocks() {
-  if (!opts::DumpStreamBlocks)
+  if (!opts::raw::DumpStreamBlocks)
     return Error::success();
 
   ListScope L(P, "StreamBlocks");
   uint32_t StreamCount = File.getNumStreams();
   for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
     std::string Name("Stream ");
     Name += to_string(StreamIdx);
     auto StreamBlocks = File.getStreamBlockList(StreamIdx);
     P.printList(Name, StreamBlocks);
   }
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpStreamData() {
   uint32_t StreamCount = File.getNumStreams();
-  StringRef DumpStreamStr = opts::DumpStreamDataIdx;
+  StringRef DumpStreamStr = opts::raw::DumpStreamDataIdx;
   uint32_t DumpStreamNum;
   if (DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum))
     return Error::success();
 
   if (DumpStreamNum >= StreamCount)
     return make_error<RawError>(raw_error_code::no_stream);
 
   auto S = MappedBlockStream::createIndexedStream(DumpStreamNum, File);
while (R.bytesRemaining() > 0) {
     P.printBinaryBlock(
         "Data",
         StringRef(reinterpret_cast<const char *>(Data.begin()), Data.size()));
   }
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpInfoStream() {
-  if (!opts::DumpHeaders)
+  if (!opts::raw::DumpHeaders)
     return Error::success();
   auto IS = File.getPDBInfoStream();
   if (!IS)
     return IS.takeError();
 
   DictScope D(P, "PDB Stream");
   P.printNumber("Version", IS->getVersion());
   P.printHex("Signature", IS->getSignature());
   P.printNumber("Age", IS->getAge());
   P.printObject("Guid", IS->getGuid());
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpNamedStream() {
-  if (opts::DumpStreamDataName.empty())
+  if (opts::raw::DumpStreamDataName.empty())
     return Error::success();
 
   auto IS = File.getPDBInfoStream();
   if (!IS)
     return IS.takeError();
 
-  uint32_t NameStreamIndex = IS->getNamedStreamIndex(opts::DumpStreamDataName);
+  uint32_t NameStreamIndex =
+      IS->getNamedStreamIndex(opts::raw::DumpStreamDataName);
   if (NameStreamIndex == 0 || NameStreamIndex >= File.getNumStreams())
     return make_error<RawError>(raw_error_code::no_stream);
 
   if (NameStreamIndex != 0) {
     std::string Name("Stream '");
-    Name += opts::DumpStreamDataName;
+    Name += opts::raw::DumpStreamDataName;
     Name += "'";
     DictScope D(P, Name);
     P.printNumber("Index", NameStreamIndex);
 
     auto NameStream =
         MappedBlockStream::createIndexedStream(NameStreamIndex, File);
     if (!NameStream)
       return NameStream.takeError();

 }
 
 static void printTypeIndexOffset(raw_ostream &OS,
                                  const TypeIndexOffset &TIOff) {
   OS << "{" << TIOff.Type.getIndex() << ", " << TIOff.Offset << "}";
 }
 
 static void dumpTpiHash(ScopedPrinter &P, TpiStream &Tpi) {
-  if (!opts::DumpTpiHash)
+  if (!opts::raw::DumpTpiHash)
     return;
   DictScope DD(P, "Hash");
   P.printNumber("Number of Hash Buckets", Tpi.NumHashBuckets());
   P.printNumber("Hash Key Size", Tpi.getHashKeySize());
   codeview::FixedStreamArray<support::ulittle32_t> S = Tpi.getHashValues();
   P.printList("Values", Tpi.getHashValues());
   P.printList("Type Index Offsets", Tpi.getTypeIndexOffsets(),
               printTypeIndexOffset);
   P.printList("Hash Adjustments", Tpi.getHashAdjustments(),
               printTypeIndexOffset);
 }
 
 Error LLVMOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 
   bool DumpRecordBytes = false;
   bool DumpRecords = false;
   StringRef Label;
   StringRef VerLabel;
   if (StreamIdx == StreamTPI) {
-    DumpRecordBytes = opts::DumpTpiRecordBytes;
-    DumpRecords = opts::DumpTpiRecords;
+    DumpRecordBytes = opts::raw::DumpTpiRecordBytes;
+    DumpRecords = opts::raw::DumpTpiRecords;
     Label = "Type Info Stream (TPI)";
     VerLabel = "TPI Version";
   } else if (StreamIdx == StreamIPI) {
-    DumpRecordBytes = opts::DumpIpiRecordBytes;
-    DumpRecords = opts::DumpIpiRecords;
+    DumpRecordBytes = opts::raw::DumpIpiRecordBytes;
+    DumpRecords = opts::raw::DumpIpiRecords;
     Label = "Type Info Stream (IPI)";
     VerLabel = "IPI Version";
   }
-  if (!DumpRecordBytes && !DumpRecords && !opts::DumpModuleSyms)
+  if (!DumpRecordBytes && !DumpRecords && !opts::raw::DumpModuleSyms)
     return Error::success();
 
   auto Tpi = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
                                       : File.getPDBIpiStream();
   if (!Tpi)
     return Tpi.takeError();
 
   if (DumpRecords || DumpRecordBytes) {
for (auto &Type : Tpi->types(&HadError)) {
 
       if (DumpRecordBytes)
         P.printBinaryBlock("Bytes", Type.Data);
     }
     dumpTpiHash(P, *Tpi);
     if (HadError)
       return make_error<RawError>(raw_error_code::corrupt_file,
                                   "TPI stream contained corrupt record");
-  } else if (opts::DumpModuleSyms) {
+  } else if (opts::raw::DumpModuleSyms) {
     // Even if the user doesn't want to dump type records, we still need to
     // iterate them in order to build the list of types so that we can print
     // them when dumping module symbols. So when they want to dump symbols
     // but not types, use a null output stream.
     ScopedPrinter *OldP = TD.getPrinter();
     TD.setPrinter(nullptr);
 
     bool HadError = false;
     for (auto &Type : Tpi->types(&HadError)) {
       if (auto EC = TD.dump(Type))
         return EC;
     }
 
     TD.setPrinter(OldP);
     dumpTpiHash(P, *Tpi);
     if (HadError)
       return make_error<RawError>(raw_error_code::corrupt_file,
                                   "TPI stream contained corrupt record");
   }
   P.flush();
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpDbiStream() {
-  bool DumpModules = opts::DumpModules || opts::DumpModuleSyms ||
-                     opts::DumpModuleFiles || opts::DumpLineInfo;
-  if (!opts::DumpHeaders && !DumpModules)
+  bool DumpModules = opts::raw::DumpModules || opts::raw::DumpModuleSyms ||
+                     opts::raw::DumpModuleFiles || opts::raw::DumpLineInfo;
+  if (!opts::raw::DumpHeaders && !DumpModules)
     return Error::success();
 
   auto DS = File.getPDBDbiStream();
   if (!DS)
     return DS.takeError();
 
   DictScope D(P, "DBI Stream");
   P.printNumber("Dbi Version", DS->getDbiVersion());
for (auto &Modi : DS->modules()) {
       P.printNumber("Source File Name Idx", Modi.Info.getSourceFileNameIndex());
       P.printNumber("Pdb File Name Idx", Modi.Info.getPdbFilePathNameIndex());
       P.printNumber("Line Info Byte Size", Modi.Info.getLineInfoByteSize());
       P.printNumber("C13 Line Info Byte Size",
                     Modi.Info.getC13LineInfoByteSize());
       P.printNumber("Symbol Byte Size", Modi.Info.getSymbolDebugInfoByteSize());
       P.printNumber("Type Server Index", Modi.Info.getTypeServerIndex());
       P.printBoolean("Has EC Info", Modi.Info.hasECInfo());
-      if (opts::DumpModuleFiles) {
+      if (opts::raw::DumpModuleFiles) {
         std::string FileListName =
             to_string(Modi.SourceFiles.size()) + " Contributing Source Files";
         ListScope LL(P, FileListName);
         for (auto File : Modi.SourceFiles)
           P.printString(File.str());
       }
       bool HasModuleDI =
           (Modi.Info.getModuleStreamIndex() < File.getNumStreams());
       bool ShouldDumpSymbols =
-          (opts::DumpModuleSyms || opts::DumpSymRecordBytes);
-      if (HasModuleDI && (ShouldDumpSymbols || opts::DumpLineInfo)) {
+          (opts::raw::DumpModuleSyms || opts::raw::DumpSymRecordBytes);
+      if (HasModuleDI && (ShouldDumpSymbols || opts::raw::DumpLineInfo)) {
         auto ModStreamData = MappedBlockStream::createIndexedStream(
             Modi.Info.getModuleStreamIndex(), File);
         if (!ModStreamData)
           return ModStreamData.takeError();
         ModStream ModS(Modi.Info, std::move(*ModStreamData));
         if (auto EC = ModS.reload())
           return EC;
 
         if (ShouldDumpSymbols) {
           ListScope SS(P, "Symbols");
           codeview::CVSymbolDumper SD(P, TD, nullptr, false);
           bool HadError = false;
           for (const auto &S : ModS.symbols(&HadError)) {
             DictScope DD(P, "");
 
-            if (opts::DumpModuleSyms)
+            if (opts::raw::DumpModuleSyms)
               SD.dump(S);
-            if (opts::DumpSymRecordBytes)
+            if (opts::raw::DumpSymRecordBytes)
               P.printBinaryBlock("Bytes", S.Data);
           }
           if (HadError)
             return make_error<RawError>(
                 raw_error_code::corrupt_file,
                 "DBI stream contained corrupt symbol record");
         }
-        if (opts::DumpLineInfo) {
+        if (opts::raw::DumpLineInfo) {
           ListScope SS(P, "LineInfo");
           bool HadError = false;
           // Define a locally scoped visitor to print the different
           // substream types types.
           class RecordVisitor : public codeview::IModuleSubstreamVisitor {
           public:
             RecordVisitor(ScopedPrinter &P, PDBFile &F) : P(P), F(F) {}
             Error visitUnknown(ModuleSubstreamKind Kind,
for (auto &Modi : DS->modules()) {
         }
       }
     }
   }
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpSectionContribs() {
-  if (!opts::DumpSectionContribs)
+  if (!opts::raw::DumpSectionContribs)
     return Error::success();
 
   auto Dbi = File.getPDBDbiStream();
   if (!Dbi)
     return Dbi.takeError();
 
   ListScope L(P, "Section Contributions");
   class Visitor : public ISectionContribVisitor {
private:
     DbiStream &DS;
   };
   Visitor V(P, *Dbi);
   Dbi->visitSectionContributions(V);
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpSectionMap() {
-  if (!opts::DumpSectionMap)
+  if (!opts::raw::DumpSectionMap)
     return Error::success();
 
   auto Dbi = File.getPDBDbiStream();
   if (!Dbi)
     return Dbi.takeError();
 
   ListScope L(P, "Section Map");
   for (auto &M : Dbi->getSectionMap()) {
     DictScope D(P, "Entry");
     P.printFlags("Flags", M.Flags, getOMFSegMapDescFlagNames());
     P.printNumber("Flags", M.Flags);
     P.printNumber("Ovl", M.Ovl);
     P.printNumber("Group", M.Group);
     P.printNumber("Frame", M.Frame);
     P.printNumber("SecName", M.SecName);
     P.printNumber("ClassName", M.ClassName);
     P.printNumber("Offset", M.Offset);
     P.printNumber("SecByteLength", M.SecByteLength);
     P.flush();
   }
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpPublicsStream() {
-  if (!opts::DumpPublics)
+  if (!opts::raw::DumpPublics)
     return Error::success();
 
   DictScope D(P, "Publics Stream");
   auto Publics = File.getPDBPublicsStream();
   if (!Publics)
     return Publics.takeError();
 
   auto Dbi = File.getPDBDbiStream();
P.printList("Section Offsets", Publics->getSectionOffsets(),
               printSectionOffset);
   ListScope L(P, "Symbols");
   codeview::CVSymbolDumper SD(P, TD, nullptr, false);
   bool HadError = false;
   for (auto S : Publics->getSymbols(&HadError)) {
     DictScope DD(P, "");
 
     SD.dump(S);
-    if (opts::DumpSymRecordBytes)
+    if (opts::raw::DumpSymRecordBytes)
       P.printBinaryBlock("Bytes", S.Data);
   }
   if (HadError)
     return make_error<RawError>(
         raw_error_code::corrupt_file,
         "Public symbol stream contained corrupt record");
 
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpSectionHeaders() {
-  if (!opts::DumpSectionHeaders)
+  if (!opts::raw::DumpSectionHeaders)
     return Error::success();
 
   auto Dbi = File.getPDBDbiStream();
   if (!Dbi)
     return Dbi.takeError();
 
   ListScope D(P, "Section Headers");
   for (const object::coff_section &Section : Dbi->getSectionHeaders()) {
for (const object::coff_section &Section : Dbi->getSectionHeaders()) {
     P.printNumber("Number of Linenumbers", Section.NumberOfLinenumbers);
     P.printFlags("Characteristics", Section.Characteristics,
                  getImageSectionCharacteristicNames());
   }
   return Error::success();
 }
 
 Error LLVMOutputStyle::dumpFpoStream() {
-  if (!opts::DumpFpo)
+  if (!opts::raw::DumpFpo)
     return Error::success();
 
   auto Dbi = File.getPDBDbiStream();
   if (!Dbi)
     return Dbi.takeError();
 
   ListScope D(P, "New FPO");
   for (const object::FpoData &Fpo : Dbi->getFpoRecords()) {

tools/llvm-pdbdump/LinePrinter.cpp

bool IsItemExcluded(llvm::StringRef Item,
   return false;
 }
 }
 
 using namespace llvm;
 
 LinePrinter::LinePrinter(int Indent, llvm::raw_ostream &Stream)
     : OS(Stream), IndentSpaces(Indent), CurrentIndent(0) {
-  SetFilters(ExcludeTypeFilters, opts::ExcludeTypes.begin(),
-             opts::ExcludeTypes.end());
-  SetFilters(ExcludeSymbolFilters, opts::ExcludeSymbols.begin(),
-             opts::ExcludeSymbols.end());
-  SetFilters(ExcludeCompilandFilters, opts::ExcludeCompilands.begin(),
-             opts::ExcludeCompilands.end());
-
-  SetFilters(IncludeTypeFilters, opts::IncludeTypes.begin(),
-             opts::IncludeTypes.end());
-  SetFilters(IncludeSymbolFilters, opts::IncludeSymbols.begin(),
-             opts::IncludeSymbols.end());
-  SetFilters(IncludeCompilandFilters, opts::IncludeCompilands.begin(),
-             opts::IncludeCompilands.end());
+  SetFilters(ExcludeTypeFilters, opts::pretty::ExcludeTypes.begin(),
+             opts::pretty::ExcludeTypes.end());
+  SetFilters(ExcludeSymbolFilters, opts::pretty::ExcludeSymbols.begin(),
+             opts::pretty::ExcludeSymbols.end());
+  SetFilters(ExcludeCompilandFilters, opts::pretty::ExcludeCompilands.begin(),
+             opts::pretty::ExcludeCompilands.end());
+
+  SetFilters(IncludeTypeFilters, opts::pretty::IncludeTypes.begin(),
+             opts::pretty::IncludeTypes.end());
+  SetFilters(IncludeSymbolFilters, opts::pretty::IncludeSymbols.begin(),
+             opts::pretty::IncludeSymbols.end());
+  SetFilters(IncludeCompilandFilters, opts::pretty::IncludeCompilands.begin(),
+             opts::pretty::IncludeCompilands.end());
 }
 
 void LinePrinter::Indent() { CurrentIndent += IndentSpaces; }
 
 void LinePrinter::Unindent() {
   CurrentIndent = std::max(0, CurrentIndent - IndentSpaces);
 }
 

tools/llvm-pdbdump/TypeDumper.cpp

 void TypeDumper::dump(const PDBSymbolTypeUDT &Symbol) {
   if (Symbol.getUnmodifiedTypeId() != 0)
     return;
   if (Printer.IsTypeExcluded(Symbol.getName()))
     return;
 
   Printer.NewLine();
 
-  if (opts::NoClassDefs) {
+  if (opts::pretty::NoClassDefs) {
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "class ";
     WithColor(Printer, PDB_ColorItem::Identifier).get() << Symbol.getName();
   } else {
     ClassDefinitionDumper Dumper(Printer);
     Dumper.start(Symbol);
   }
 }

tools/llvm-pdbdump/VariableDumper.cpp

 
 using namespace llvm;
 using namespace llvm::pdb;
 
 VariableDumper::VariableDumper(LinePrinter &P)
     : PDBSymDumper(true), Printer(P) {}
 
 void VariableDumper::start(const PDBSymbolData &Var) {
-  if (Var.isCompilerGenerated() && opts::ExcludeCompilerGenerated)
+  if (Var.isCompilerGenerated() && opts::pretty::ExcludeCompilerGenerated)
     return;
   if (Printer.IsSymbolExcluded(Var.getName()))
     return;
 
   auto VarType = Var.getType();
 
   switch (auto LocType = Var.getLocationType()) {
   case PDB_LocType::Static:

tools/llvm-pdbdump/YAMLOutputStyle.cpp

 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 YAMLOutputStyle::YAMLOutputStyle(PDBFile &File) : File(File), Out(outs()) {}
 
 Error YAMLOutputStyle::dumpFileHeaders() {
-  if (!opts::DumpHeaders)
+  if (!opts::raw::DumpHeaders)
     return Error::success();
 
   yaml::MsfHeaders Headers;
   Obj.Headers.SuperBlock.NumBlocks = File.getBlockCount();
   Obj.Headers.SuperBlock.BlockMapAddr = File.getBlockMapIndex();
   Obj.Headers.BlockMapOffset = File.getBlockMapOffset();
   Obj.Headers.SuperBlock.BlockSize = File.getBlockSize();
   auto Blocks = File.getDirectoryBlockArray();
   Obj.Headers.DirectoryBlocks.assign(Blocks.begin(), Blocks.end());
   Obj.Headers.NumDirectoryBlocks = File.getNumDirectoryBlocks();
   Obj.Headers.SuperBlock.NumDirectoryBytes = File.getNumDirectoryBytes();
   Obj.Headers.NumStreams = File.getNumStreams();
   Obj.Headers.SuperBlock.Unknown0 = File.getUnknown0();
   Obj.Headers.SuperBlock.Unknown1 = File.getUnknown1();
   Obj.Headers.FileSize = File.getFileSize();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamSummary() {
-  if (!opts::DumpStreamSummary)
+  if (!opts::raw::DumpStreamSummary)
     return Error::success();
 
   Obj.StreamSizes = File.getStreamSizes();
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamBlocks() {
-  if (!opts::DumpStreamBlocks)
+  if (!opts::raw::DumpStreamBlocks)
     return Error::success();
 
   auto StreamMap = File.getStreamMap();
   Obj.StreamMap.emplace();
   for (auto &Stream : StreamMap) {
     pdb::yaml::StreamBlockList BlockList;
     BlockList.Blocks = Stream;
     Obj.StreamMap->push_back(BlockList);
   }
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpStreamData() {
   uint32_t StreamCount = File.getNumStreams();
-  StringRef DumpStreamStr = opts::DumpStreamDataIdx;
+  StringRef DumpStreamStr = opts::raw::DumpStreamDataIdx;
   uint32_t DumpStreamNum;
   if (DumpStreamStr.getAsInteger(/*Radix=*/0U, DumpStreamNum) ||
       DumpStreamNum >= StreamCount)
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpInfoStream() {
-  if (!opts::DumpHeaders)
+  if (!opts::raw::DumpHeaders)
     return Error::success();
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpNamedStream() {
-  if (opts::DumpStreamDataName.empty())
+  if (opts::raw::DumpStreamDataName.empty())
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpDbiStream() { return Error::success(); }
 
 Error YAMLOutputStyle::dumpSectionContribs() {
-  if (!opts::DumpSectionContribs)
+  if (!opts::raw::DumpSectionContribs)
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpSectionMap() {
-  if (!opts::DumpSectionMap)
+  if (!opts::raw::DumpSectionMap)
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpPublicsStream() {
-  if (!opts::DumpPublics)
+  if (!opts::raw::DumpPublics)
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpSectionHeaders() {
-  if (!opts::DumpSectionHeaders)
+  if (!opts::raw::DumpSectionHeaders)
     return Error::success();
 
   return Error::success();
 }
 
 Error YAMLOutputStyle::dumpFpoStream() {
-  if (!opts::DumpFpo)
+  if (!opts::raw::DumpFpo)
     return Error::success();
 
   return Error::success();
 }
 
 void YAMLOutputStyle::flush() {
   Out << Obj;
   outs().flush();
 }

tools/llvm-pdbdump/llvm-pdbdump.h

 #ifndef LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
 #define LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
 
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace opts {
 
-enum OutputStyleTy { LLVM, YAML };
-
+namespace pretty {
 extern llvm::cl::opt<bool> Compilands;
 extern llvm::cl::opt<bool> Symbols;
 extern llvm::cl::opt<bool> Globals;
 extern llvm::cl::opt<bool> Types;
 extern llvm::cl::opt<bool> All;
+extern llvm::cl::opt<bool> ExcludeCompilerGenerated;
+
+extern llvm::cl::opt<bool> NoClassDefs;
+extern llvm::cl::opt<bool> NoEnumDefs;
+extern llvm::cl::list<std::string> ExcludeTypes;
+extern llvm::cl::list<std::string> ExcludeSymbols;
+extern llvm::cl::list<std::string> ExcludeCompilands;
+extern llvm::cl::list<std::string> IncludeTypes;
+extern llvm::cl::list<std::string> IncludeSymbols;
+extern llvm::cl::list<std::string> IncludeCompilands;
+}
 
-extern llvm::cl::opt<OutputStyleTy> RawOutputStyle;
+namespace raw {
 extern llvm::cl::opt<bool> DumpHeaders;
 extern llvm::cl::opt<bool> DumpStreamBlocks;
 extern llvm::cl::opt<bool> DumpStreamSummary;
 extern llvm::cl::opt<bool> DumpTpiHash;
 extern llvm::cl::opt<bool> DumpTpiRecordBytes;
 extern llvm::cl::opt<bool> DumpTpiRecords;
 extern llvm::cl::opt<bool> DumpIpiRecords;
 extern llvm::cl::opt<bool> DumpIpiRecordBytes;
 extern llvm::cl::opt<std::string> DumpStreamDataIdx;
 extern llvm::cl::opt<std::string> DumpStreamDataName;
 extern llvm::cl::opt<bool> DumpModules;
 extern llvm::cl::opt<bool> DumpModuleFiles;
 extern llvm::cl::opt<bool> DumpModuleSyms;
 extern llvm::cl::opt<bool> DumpPublics;
 extern llvm::cl::opt<bool> DumpSectionContribs;
 extern llvm::cl::opt<bool> DumpLineInfo;
 extern llvm::cl::opt<bool> DumpSectionMap;
 extern llvm::cl::opt<bool> DumpSymRecordBytes;
 extern llvm::cl::opt<bool> DumpSectionHeaders;
 extern llvm::cl::opt<bool> DumpFpo;
-
-extern llvm::cl::opt<bool> ExcludeCompilerGenerated;
-
-extern llvm::cl::opt<bool> NoClassDefs;
-extern llvm::cl::opt<bool> NoEnumDefs;
-extern llvm::cl::list<std::string> ExcludeTypes;
-extern llvm::cl::list<std::string> ExcludeSymbols;
-extern llvm::cl::list<std::string> ExcludeCompilands;
-extern llvm::cl::list<std::string> IncludeTypes;
-extern llvm::cl::list<std::string> IncludeSymbols;
-extern llvm::cl::list<std::string> IncludeCompilands;
+}
 }
 
 #endif

tools/llvm-pdbdump/llvm-pdbdump.cpp

 
 private:
   std::unique_ptr<FileOutputBuffer> FileBuffer;
 };
 }
 
 namespace opts {
 
-enum class PDB_DumpType { ByType, ByObjFile, Both };
-
-cl::list<std::string> InputFilenames(cl::Positional,
-                                     cl::desc("<input PDB files>"),
-                                     cl::OneOrMore);
+cl::SubCommand RawSubcommand("raw", "Dump raw structure of the PDB file");
+cl::SubCommand
+    PrettySubcommand("pretty",
+                     "Dump semantic information about types and symbols");
+cl::SubCommand YamlToPdbSubcommand("yaml2pdb", "Generate YAML from a PDB File");
+cl::SubCommand
+    PdbToYamlSubcommand("pdb2yaml",
+                        "Generate a PDB file from a YAML description");
 
 cl::OptionCategory TypeCategory("Symbol Type Options");
 cl::OptionCategory FilterCategory("Filtering Options");
 cl::OptionCategory OtherOptions("Other Options");
 cl::OptionCategory NativeOptions("Native Options");
 
+namespace pretty {
+cl::list<std::string> InputFilenames(cl::Positional,
+                                     cl::desc("<input PDB files>"),
+                                     cl::OneOrMore, cl::sub(PrettySubcommand));
+
 cl::opt<bool> Compilands("compilands", cl::desc("Display compilands"),
-                         cl::cat(TypeCategory));
+                         cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Symbols("symbols", cl::desc("Display symbols for each compiland"),
-                      cl::cat(TypeCategory));
+                      cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Globals("globals", cl::desc("Dump global symbols"),
-                      cl::cat(TypeCategory));
+                      cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 cl::opt<bool> Externals("externals", cl::desc("Dump external symbols"),
-                        cl::cat(TypeCategory));
-cl::opt<bool> Types("types", cl::desc("Display types"), cl::cat(TypeCategory));
-cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory));
+                        cl::cat(TypeCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> Types("types", cl::desc("Display types"), cl::cat(TypeCategory),
+                    cl::sub(PrettySubcommand));
+cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory),
+                    cl::sub(PrettySubcommand));
 cl::opt<bool>
     All("all", cl::desc("Implies all other options in 'Symbol Types' category"),
-        cl::cat(TypeCategory));
+        cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 
 cl::opt<uint64_t> LoadAddress(
     "load-address",
     cl::desc("Assume the module is loaded at the specified address"),
-    cl::cat(OtherOptions));
+    cl::cat(OtherOptions), cl::sub(PrettySubcommand));
+cl::list<std::string> ExcludeTypes(
+    "exclude-types", cl::desc("Exclude types by regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::list<std::string> ExcludeSymbols(
+    "exclude-symbols", cl::desc("Exclude symbols by regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::list<std::string> ExcludeCompilands(
+    "exclude-compilands", cl::desc("Exclude compilands by regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+
+cl::list<std::string> IncludeTypes(
+    "include-types",
+    cl::desc("Include only types which match a regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::list<std::string> IncludeSymbols(
+    "include-symbols",
+    cl::desc("Include only symbols which match a regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::list<std::string> IncludeCompilands(
+    "include-compilands",
+    cl::desc("Include only compilands those which match a regular expression"),
+    cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 
-cl::opt<OutputStyleTy>
-    RawOutputStyle("raw-output-style", cl::desc("Specify dump outpout style"),
-                   cl::values(clEnumVal(LLVM, "LLVM default style"),
-                              clEnumVal(YAML, "YAML style"), clEnumValEnd),
-                   cl::init(LLVM), cl::cat(NativeOptions));
-
-cl::opt<bool> DumpHeaders("raw-headers", cl::desc("dump PDB headers"),
-                          cl::cat(NativeOptions));
-cl::opt<bool> DumpStreamBlocks("raw-stream-blocks",
+cl::opt<bool> ExcludeCompilerGenerated(
+    "no-compiler-generated",
+    cl::desc("Don't show compiler generated types and symbols"),
+    cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::opt<bool>
+    ExcludeSystemLibraries("no-system-libs",
+                           cl::desc("Don't show symbols from system libraries"),
+                           cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> NoClassDefs("no-class-definitions",
+                          cl::desc("Don't display full class definitions"),
+                          cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+cl::opt<bool> NoEnumDefs("no-enum-definitions",
+                         cl::desc("Don't display full enum definitions"),
+                         cl::cat(FilterCategory), cl::sub(PrettySubcommand));
+}
+
+namespace raw {
+
+cl::opt<bool> DumpHeaders("headers", cl::desc("dump PDB headers"),
+                          cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                          cl::sub(RawSubcommand), cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpStreamBlocks("stream-blocks",
                                cl::desc("dump PDB stream blocks"),
-                               cl::cat(NativeOptions));
-cl::opt<bool> DumpStreamSummary("raw-stream-summary",
+                               cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                               cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpStreamSummary("stream-summary",
                                 cl::desc("dump summary of the PDB streams"),
-                                cl::cat(NativeOptions));
+                                cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                                cl::sub(PdbToYamlSubcommand));
 cl::opt<bool>
-    DumpTpiRecords("raw-tpi-records",
+    DumpTpiRecords("tpi-records",
                    cl::desc("dump CodeView type records from TPI stream"),
-                   cl::cat(NativeOptions));
+                   cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                   cl::sub(PdbToYamlSubcommand));
 cl::opt<bool> DumpTpiRecordBytes(
-    "raw-tpi-record-bytes",
+    "tpi-record-bytes",
     cl::desc("dump CodeView type record raw bytes from TPI stream"),
-    cl::cat(NativeOptions));
-cl::opt<bool> DumpTpiHash("raw-tpi-hash",
-                          cl::desc("dump CodeView TPI hash stream"),
-                          cl::cat(NativeOptions));
+    cl::cat(NativeOptions), cl::sub(RawSubcommand),
+    cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpTpiHash("tpi-hash", cl::desc("dump CodeView TPI hash stream"),
+                          cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                          cl::sub(PdbToYamlSubcommand));
 cl::opt<bool>
-    DumpIpiRecords("raw-ipi-records",
+    DumpIpiRecords("ipi-records",
                    cl::desc("dump CodeView type records from IPI stream"),
-                   cl::cat(NativeOptions));
+                   cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                   cl::sub(PdbToYamlSubcommand));
 cl::opt<bool> DumpIpiRecordBytes(
-    "raw-ipi-record-bytes",
+    "ipi-record-bytes",
     cl::desc("dump CodeView type record raw bytes from IPI stream"),
-    cl::cat(NativeOptions));
-cl::opt<std::string> DumpStreamDataIdx("raw-stream",
+    cl::cat(NativeOptions), cl::sub(RawSubcommand));
+cl::opt<std::string> DumpStreamDataIdx("stream", cl::desc("dump stream data"),
+                                       cl::cat(NativeOptions),
+                                       cl::sub(RawSubcommand),
+                                       cl::sub(PdbToYamlSubcommand));
+cl::opt<std::string> DumpStreamDataName("stream-name",
                                         cl::desc("dump stream data"),
-                                       cl::cat(NativeOptions));
-cl::opt<std::string> DumpStreamDataName("raw-stream-name",
-                                        cl::desc("dump stream data"),
-                                        cl::cat(NativeOptions));
-cl::opt<bool> DumpModules("raw-modules", cl::desc("dump compiland information"),
-                          cl::cat(NativeOptions));
-cl::opt<bool> DumpModuleFiles("raw-module-files",
-                              cl::desc("dump file information"),
-                              cl::cat(NativeOptions));
-cl::opt<bool> DumpModuleSyms("raw-module-syms", cl::desc("dump module symbols"),
-                             cl::cat(NativeOptions));
-cl::opt<bool> DumpPublics("raw-publics", cl::desc("dump Publics stream data"),
-                          cl::cat(NativeOptions));
-cl::opt<bool> DumpSectionContribs("raw-section-contribs",
+                                        cl::cat(NativeOptions),
+                                        cl::sub(RawSubcommand),
+                                        cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"),
+                          cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                          cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpModuleFiles("module-files", cl::desc("dump file information"),
+                              cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                              cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpModuleSyms("module-syms", cl::desc("dump module symbols"),
+                             cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                             cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpPublics("publics", cl::desc("dump Publics stream data"),
+                          cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                          cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpSectionContribs("section-contribs",
                                   cl::desc("dump section contributions"),
-                                  cl::cat(NativeOptions));
-cl::opt<bool> DumpLineInfo("raw-line-info",
+                                  cl::cat(NativeOptions),
+                                  cl::sub(RawSubcommand),
+                                  cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpLineInfo("line-info",
                            cl::desc("dump file and line information"),
-                           cl::cat(NativeOptions));
-cl::opt<bool> DumpSectionMap("raw-section-map", cl::desc("dump section map"),
-                             cl::cat(NativeOptions));
+                           cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                           cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpSectionMap("section-map", cl::desc("dump section map"),
+                             cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                             cl::sub(PdbToYamlSubcommand));
 cl::opt<bool>
-    DumpSymRecordBytes("raw-sym-record-bytes",
+    DumpSymRecordBytes("sym-record-bytes",
                        cl::desc("dump CodeView symbol record raw bytes"),
-                       cl::cat(NativeOptions));
-cl::opt<bool> DumpSectionHeaders("raw-section-headers",
+                       cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                       cl::sub(PdbToYamlSubcommand));
+cl::opt<bool> DumpSectionHeaders("section-headers",
                                  cl::desc("dump section headers"),
-                                 cl::cat(NativeOptions));
-cl::opt<bool> DumpFpo("raw-fpo", cl::desc("dump FPO records"),
-                      cl::cat(NativeOptions));
+                                 cl::cat(NativeOptions),
+                                 cl::sub(RawSubcommand));
+cl::opt<bool> DumpFpo("fpo", cl::desc("dump FPO records"),
+                      cl::cat(NativeOptions), cl::sub(RawSubcommand),
+                      cl::sub(PdbToYamlSubcommand));
 
 cl::opt<bool>
-    RawAll("raw-all",
+    RawAll("all",
            cl::desc("Implies most other options in 'Native Options' category"),
-           cl::cat(NativeOptions));
+           cl::cat(NativeOptions), cl::sub(RawSubcommand),
+           cl::sub(PdbToYamlSubcommand));
 
-cl::opt<bool>
-    YamlToPdb("yaml-to-pdb",
-              cl::desc("The input file is yaml, and the tool outputs a pdb"),
-              cl::cat(NativeOptions));
-cl::opt<std::string> YamlPdbOutputFile(
-    "pdb-output", cl::desc("When yaml-to-pdb is specified, the output file"),
-    cl::cat(NativeOptions));
-
-cl::list<std::string>
-    ExcludeTypes("exclude-types",
-                 cl::desc("Exclude types by regular expression"),
-                 cl::ZeroOrMore, cl::cat(FilterCategory));
-cl::list<std::string>
-    ExcludeSymbols("exclude-symbols",
-                   cl::desc("Exclude symbols by regular expression"),
-                   cl::ZeroOrMore, cl::cat(FilterCategory));
-cl::list<std::string>
-    ExcludeCompilands("exclude-compilands",
-                      cl::desc("Exclude compilands by regular expression"),
-                      cl::ZeroOrMore, cl::cat(FilterCategory));
+cl::list<std::string> InputFilenames(cl::Positional,
+                                     cl::desc("<input PDB files>"),
+                                     cl::OneOrMore, cl::sub(RawSubcommand));
+}
 
-cl::list<std::string> IncludeTypes(
-    "include-types",
-    cl::desc("Include only types which match a regular expression"),
-    cl::ZeroOrMore, cl::cat(FilterCategory));
-cl::list<std::string> IncludeSymbols(
-    "include-symbols",
-    cl::desc("Include only symbols which match a regular expression"),
-    cl::ZeroOrMore, cl::cat(FilterCategory));
-cl::list<std::string> IncludeCompilands(
-    "include-compilands",
-    cl::desc("Include only compilands those which match a regular expression"),
-    cl::ZeroOrMore, cl::cat(FilterCategory));
+namespace yaml2pdb {
+cl::opt<std::string>
+    YamlPdbOutputFile("pdb", cl::desc("the name of the PDB file to write"),
+                      cl::cat(NativeOptions), cl::sub(YamlToPdbSubcommand));
 
-cl::opt<bool> ExcludeCompilerGenerated(
-    "no-compiler-generated",
-    cl::desc("Don't show compiler generated types and symbols"),
-    cl::cat(FilterCategory));
-cl::opt<bool>
-    ExcludeSystemLibraries("no-system-libs",
-                           cl::desc("Don't show symbols from system libraries"),
-                           cl::cat(FilterCategory));
-cl::opt<bool> NoClassDefs("no-class-definitions",
-                          cl::desc("Don't display full class definitions"),
-                          cl::cat(FilterCategory));
-cl::opt<bool> NoEnumDefs("no-enum-definitions",
-                         cl::desc("Don't display full enum definitions"),
-                         cl::cat(FilterCategory));
+cl::list<std::string> InputFilename(cl::Positional,
+                                    cl::desc("<input YAML file>"), cl::Required,
+                                    cl::sub(YamlToPdbSubcommand));
+}
+
+namespace pdb2yaml {
+cl::list<std::string> InputFilename(cl::Positional,
+                                    cl::desc("<input PDB file>"), cl::Required,
+                                    cl::sub(PdbToYamlSubcommand));
+}
 }
 
 static ExitOnError ExitOnErr;
 
 static Error dumpStructure(RawSession &RS) {
   PDBFile &File = RS.getPDBFile();
   std::unique_ptr<OutputStyle> O;
-  if (opts::RawOutputStyle == opts::OutputStyleTy::LLVM)
-    O = llvm::make_unique<LLVMOutputStyle>(File);
-  else if (opts::RawOutputStyle == opts::OutputStyleTy::YAML)
+  if (opts::PdbToYamlSubcommand)
     O = llvm::make_unique<YAMLOutputStyle>(File);
   else
-    return make_error<RawError>(raw_error_code::feature_unsupported,
-                                "Requested output style unsupported");
+    O = llvm::make_unique<LLVMOutputStyle>(File);
 
   if (auto EC = O->dumpFileHeaders())
     return EC;
 
   if (auto EC = O->dumpStreamSummary())
     return EC;
 
   if (auto EC = O->dumpStreamBlocks())
static Error dumpStructure(RawSession &RS) {
 
   if (auto EC = O->dumpFpoStream())
     return EC;
   O->flush();
   return Error::success();
 }
 
 bool isRawDumpEnabled() {
-  if (opts::DumpHeaders)
+  if (opts::raw::DumpHeaders)
     return true;
-  if (opts::DumpModules)
+  if (opts::raw::DumpModules)
     return true;
-  if (opts::DumpModuleFiles)
+  if (opts::raw::DumpModuleFiles)
     return true;
-  if (opts::DumpModuleSyms)
+  if (opts::raw::DumpModuleSyms)
     return true;
-  if (!opts::DumpStreamDataIdx.empty())
+  if (!opts::raw::DumpStreamDataIdx.empty())
     return true;
-  if (!opts::DumpStreamDataName.empty())
+  if (!opts::raw::DumpStreamDataName.empty())
     return true;
-  if (opts::DumpPublics)
+  if (opts::raw::DumpPublics)
     return true;
-  if (opts::DumpStreamSummary)
+  if (opts::raw::DumpStreamSummary)
     return true;
-  if (opts::DumpStreamBlocks)
+  if (opts::raw::DumpStreamBlocks)
     return true;
-  if (opts::DumpSymRecordBytes)
+  if (opts::raw::DumpSymRecordBytes)
     return true;
-  if (opts::DumpTpiRecordBytes)
+  if (opts::raw::DumpTpiRecordBytes)
     return true;
-  if (opts::DumpTpiRecords)
+  if (opts::raw::DumpTpiRecords)
     return true;
-  if (opts::DumpTpiHash)
+  if (opts::raw::DumpTpiHash)
     return true;
-  if (opts::DumpIpiRecords)
+  if (opts::raw::DumpIpiRecords)
     return true;
-  if (opts::DumpIpiRecordBytes)
+  if (opts::raw::DumpIpiRecordBytes)
     return true;
-  if (opts::DumpSectionHeaders)
+  if (opts::raw::DumpSectionHeaders)
     return true;
-  if (opts::DumpSectionContribs)
+  if (opts::raw::DumpSectionContribs)
     return true;
-  if (opts::DumpSectionMap)
+  if (opts::raw::DumpSectionMap)
     return true;
-  if (opts::DumpLineInfo)
+  if (opts::raw::DumpLineInfo)
     return true;
-  if (opts::DumpFpo)
+  if (opts::raw::DumpFpo)
     return true;
   return false;
 }
 
 static void yamlToPdb(StringRef Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
                                    /*RequiresNullTerminator=*/false);
 
   if (ErrorOrBuffer.getError()) {
     ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path, Path));
   }
 
   std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
 
   llvm::yaml::Input In(Buffer->getBuffer());
   pdb::yaml::PdbObject YamlObj;
   In >> YamlObj;
 
-  auto OutFileOrError = FileOutputBuffer::create(opts::YamlPdbOutputFile,
-                                                 YamlObj.Headers.FileSize);
+  auto OutFileOrError = FileOutputBuffer::create(
+      opts::yaml2pdb::YamlPdbOutputFile, YamlObj.Headers.FileSize);
   if (OutFileOrError.getError())
     ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path,
-                                       opts::YamlPdbOutputFile));
+                                       opts::yaml2pdb::YamlPdbOutputFile));
 
   auto FileByteStream =
       llvm::make_unique<FileBufferByteStream>(std::move(*OutFileOrError));
   PDBFile Pdb(std::move(FileByteStream));
   Pdb.setSuperBlock(&YamlObj.Headers.SuperBlock);
   if (YamlObj.StreamMap.hasValue()) {
     std::vector<ArrayRef<support::ulittle32_t>> StreamMap;
     for (auto &E : YamlObj.StreamMap.getValue()) {
       StreamMap.push_back(E.Blocks);
     }
     Pdb.setStreamMap(StreamMap);
   }
   if (YamlObj.StreamSizes.hasValue()) {
     Pdb.setStreamSizes(YamlObj.StreamSizes.getValue());
   }
 
   Pdb.commit();
 }
 
-static void dumpInput(StringRef Path) {
+static void dumpRaw(StringRef Path) {
   std::unique_ptr<IPDBSession> Session;
-  if (isRawDumpEnabled()) {
-    ExitOnErr(loadDataForPDB(PDB_ReaderType::Raw, Path, Session));
 
-    RawSession *RS = static_cast<RawSession *>(Session.get());
-    ExitOnErr(dumpStructure(*RS));
-    return;
-  }
 
+static void dumpPretty(StringRef Path) {
+  std::unique_ptr<IPDBSession> Session;
+
   ExitOnErr(loadDataForPDB(PDB_ReaderType::DIA, Path, Session));
 
-  if (opts::LoadAddress)
-    Session->setLoadAddress(opts::LoadAddress);
+  if (opts::pretty::LoadAddress)
+    Session->setLoadAddress(opts::pretty::LoadAddress);
 
   LinePrinter Printer(2, outs());
 
   auto GlobalScope(Session->getGlobalScope());
   std::string FileName(GlobalScope->getSymbolsFileName());
 
   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
static void dumpPretty(StringRef Path) {
   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Attributes";
   Printer << ": ";
   if (GlobalScope->hasCTypes())
     outs() << "HasCTypes ";
   if (GlobalScope->hasPrivateSymbols())
     outs() << "HasPrivateSymbols ";
   Printer.Unindent();
 
-  if (opts::Compilands) {
+  if (opts::pretty::Compilands) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get()
         << "---COMPILANDS---";
     Printer.Indent();
     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
     CompilandDumper Dumper(Printer);
     CompilandDumpFlags options = CompilandDumper::Flags::None;
-    if (opts::Lines)
+    if (opts::pretty::Lines)
       options = options | CompilandDumper::Flags::Lines;
     while (auto Compiland = Compilands->getNext())
       Dumper.start(*Compiland, options);
     Printer.Unindent();
   }
 
-  if (opts::Types) {
+  if (opts::pretty::Types) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
     Printer.Indent();
     TypeDumper Dumper(Printer);
     Dumper.start(*GlobalScope);
     Printer.Unindent();
   }
 
-  if (opts::Symbols) {
+  if (opts::pretty::Symbols) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
     Printer.Indent();
     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
     CompilandDumper Dumper(Printer);
     while (auto Compiland = Compilands->getNext())
       Dumper.start(*Compiland, true);
     Printer.Unindent();
   }
 
-  if (opts::Globals) {
+  if (opts::pretty::Globals) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
     Printer.Indent();
     {
       FunctionDumper Dumper(Printer);
       auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>();
       while (auto Function = Functions->getNext()) {
         Printer.NewLine();
if (opts::pretty::Globals) {
     {
       auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>();
       CompilandDumper Dumper(Printer);
       while (auto Thunk = Thunks->getNext())
         Dumper.dump(*Thunk);
     }
     Printer.Unindent();
   }
-  if (opts::Externals) {
+  if (opts::pretty::Externals) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---";
     Printer.Indent();
     ExternalSymbolDumper Dumper(Printer);
     Dumper.start(*GlobalScope);
   }
-  if (opts::Lines) {
+  if (opts::pretty::Lines) {
     Printer.NewLine();
   }
   outs().flush();
 }
 
 int main(int argc_, const char *argv_[]) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv_[0]);
   PrettyStackTraceProgram X(argc_, argv_);
 
   ExitOnErr.setBanner("llvm-pdbdump: ");
 
   SmallVector<const char *, 256> argv;
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
-  if (opts::Lines)
-    opts::Compilands = true;
 
-  if (opts::All) {
-    opts::Compilands = true;
-    opts::Symbols = true;
-    opts::Globals = true;
-    opts::Types = true;
-    opts::Externals = true;
-    opts::Lines = true;
-  }
-
-  if (opts::RawAll) {
-    opts::DumpHeaders = true;
-    opts::DumpModules = true;
-    opts::DumpModuleFiles = true;
-    opts::DumpModuleSyms = true;
-    opts::DumpPublics = true;
-    opts::DumpSectionHeaders = true;
-    opts::DumpStreamSummary = true;
-    opts::DumpStreamBlocks = true;
-    opts::DumpTpiRecords = true;
-    opts::DumpTpiHash = true;
-    opts::DumpIpiRecords = true;
-    opts::DumpSectionMap = true;
-    opts::DumpSectionContribs = true;
-    opts::DumpLineInfo = true;
-    opts::DumpFpo = true;
+  // These options are shared by two subcommands.
+  if ((opts::PdbToYamlSubcommand || opts::RawSubcommand) && opts::raw::RawAll) {
+    opts::raw::DumpHeaders = true;
+    opts::raw::DumpModules = true;
+    opts::raw::DumpModuleFiles = true;
+    opts::raw::DumpModuleSyms = true;
+    opts::raw::DumpPublics = true;
+    opts::raw::DumpSectionHeaders = true;
+    opts::raw::DumpStreamSummary = true;
+    opts::raw::DumpStreamBlocks = true;
+    opts::raw::DumpTpiRecords = true;
+    opts::raw::DumpTpiHash = true;
+    opts::raw::DumpIpiRecords = true;
+    opts::raw::DumpSectionMap = true;
+    opts::raw::DumpSectionContribs = true;
+    opts::raw::DumpLineInfo = true;
+    opts::raw::DumpFpo = true;
   }
 
-  // When adding filters for excluded compilands and types, we need to remember
+  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
+
+  if (opts::PdbToYamlSubcommand) {
+    dumpRaw(opts::pdb2yaml::InputFilename.front());
+  } else if (opts::YamlToPdbSubcommand) {
+    yamlToPdb(opts::yaml2pdb::InputFilename.front());
+  } else if (opts::PrettySubcommand) {
+    if (opts::pretty::Lines)
+      opts::pretty::Compilands = true;
+
+    if (opts::pretty::All) {
+      opts::pretty::Compilands = true;
+      opts::pretty::Symbols = true;
+      opts::pretty::Globals = true;
+      opts::pretty::Types = true;
+      opts::pretty::Externals = true;
+      opts::pretty::Lines = true;
+    }
+
+    // When adding filters for excluded compilands and types, we need to
+    // remember
     // that these are regexes.  So special characters such as * and \ need to be
     // escaped in the regex.  In the case of a literal \, this means it needs to
-  // be escaped again in the C++.  So matching a single \ in the input requires
+    // be escaped again in the C++.  So matching a single \ in the input
+    // requires
     // 4 \es in the C++.
-  if (opts::ExcludeCompilerGenerated) {
-    opts::ExcludeTypes.push_back("__vc_attributes");
-    opts::ExcludeCompilands.push_back("\\* Linker \\*");
+    if (opts::pretty::ExcludeCompilerGenerated) {
+      opts::pretty::ExcludeTypes.push_back("__vc_attributes");
+      opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");
     }
-  if (opts::ExcludeSystemLibraries) {
-    opts::ExcludeCompilands.push_back(
+    if (opts::pretty::ExcludeSystemLibraries) {
+      opts::pretty::ExcludeCompilands.push_back(
           "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
-    opts::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
-    opts::ExcludeCompilands.push_back("d:\\\\th.obj.x86fre\\\\minkernel");
-  }
-
-  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
-
-  if (opts::YamlToPdb) {
-    std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
-                  yamlToPdb);
-  } else {
-    std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
-                  dumpInput);
+      opts::pretty::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
+      opts::pretty::ExcludeCompilands.push_back(
+          "d:\\\\th.obj.x86fre\\\\minkernel");
+    }
+    std::for_each(opts::pretty::InputFilenames.begin(),
+                  opts::pretty::InputFilenames.end(), dumpPretty);
+  } else if (opts::RawSubcommand) {
+    std::for_each(opts::raw::InputFilenames.begin(),
+                  opts::raw::InputFilenames.end(), dumpRaw);
   }
 
   outs().flush();
   return 0;
 }

unittests/Support/CommandLineTest.cpp

 cl::OptionCategory TestCategory("Test Options", "Description");
 TEST(CommandLineTest, ModifyExisitingOption) {
   StackOption<int> TestOption("test-option", cl::desc("old description"));
 
   const char Description[] = "New description";
   const char ArgString[] = "new-test-option";
   const char ValueString[] = "Integer";
 
-  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
+  StringMap<cl::Option *> &Map =
+      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
 
   ASSERT_TRUE(Map.count("test-option") == 1) <<
     "Could not find option in map.";
 
   cl::Option *Retrieved = Map["test-option"];
   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 
   ASSERT_EQ(&cl::GeneralCategory,Retrieved->Category) <<
TEST(CommandLineTest, HideUnrelatedOptions) {
 
   cl::HideUnrelatedOptions(TestCategory);
 
   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
       << "Failed to hide extra option.";
   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
 
-  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
+  StringMap<cl::Option *> &Map =
+      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
       << "Hid default option that should be visable.";
 }
 
 cl::OptionCategory TestCategory2("Test Options set 2", "Description");
 
 TEST(CommandLineTest, HideUnrelatedOptionsMulti) {
   StackOption<int> TestOption1("multi-hide-option-1");
   StackOption<int> TestOption2("multi-hide-option-2", cl::cat(TestCategory));
   StackOption<int> TestOption3("multi-hide-option-3", cl::cat(TestCategory2));
 
   const cl::OptionCategory *VisibleCategories[] = {&TestCategory,
                                                    &TestCategory2};
 
   cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories));
 
   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
       << "Failed to hide extra option.";
   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
   ASSERT_EQ(cl::NotHidden, TestOption3.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
 
-  StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
+  StringMap<cl::Option *> &Map =
+      cl::getRegisteredOptions(*cl::TopLevelSubCommand);
   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
       << "Hid default option that should be visable.";
 }
 
 }  // anonymous namespace

unittests/Support/ProgramTest.cpp

TEST_F(ProgramEnvTest, TestExecuteNoWait) {
   ASSERT_NE(PI1.Pid, ProcessInfo::InvalidPid) << "Invalid process id";
 
   unsigned LoopCount = 0;
 
   // Test that Wait() with WaitUntilTerminates=true works. In this case,
   // LoopCount should only be incremented once.
   while (true) {
     ++LoopCount;
-    ProcessInfo WaitResult = Wait(PI1, 0, true, &Error);
+    ProcessInfo WaitResult = llvm::sys::Wait(PI1, 0, true, &Error);
     ASSERT_TRUE(Error.empty());
     if (WaitResult.Pid == PI1.Pid)
       break;
   }
 
   EXPECT_EQ(LoopCount, 1u) << "LoopCount should be 1";
 
   ProcessInfo PI2 = ExecuteNoWait(Executable, argv, getEnviron(), nullptr, 0,
                                   &Error, &ExecutionFailed);
   ASSERT_FALSE(ExecutionFailed) << Error;
   ASSERT_NE(PI2.Pid, ProcessInfo::InvalidPid) << "Invalid process id";
 
   // Test that Wait() with SecondsToWait=0 performs a non-blocking wait. In this
   // cse, LoopCount should be greater than 1 (more than one increment occurs).
   while (true) {
     ++LoopCount;
-    ProcessInfo WaitResult = Wait(PI2, 0, false, &Error);
+    ProcessInfo WaitResult = llvm::sys::Wait(PI2, 0, false, &Error);
     ASSERT_TRUE(Error.empty());
     if (WaitResult.Pid == PI2.Pid)
       break;
   }
 
   ASSERT_GT(LoopCount, 1u) << "LoopCount should be >1";
 }