Refactoring cl::parser construction and initialization.

[beanz]

Summary

Some parsers need references back to the option they are members of. This is used for handling the argument string as well as by the various pass name parsers for making pass names into flags.

Making parsers that need to refer back to the option have a reference to the option eliminates some of the members of various parsers, and enables further code cleanup.

[dexonsmith]

LGTM.

llvm/trunk/include/llvm/CodeGen/MachinePassRegistry.h

 ///
 /// RegisterPassParser class - Handle the addition of new machine passes.
 ///
 //===----------------------------------------------------------------------===//
 template<class RegistryClass>
 class RegisterPassParser : public MachinePassRegistryListener,
                    public cl::parser<typename RegistryClass::FunctionPassCtor> {
 public:
-  RegisterPassParser() {}
+  RegisterPassParser(cl::Option &O)
+      : cl::parser<typename RegistryClass::FunctionPassCtor>(O) {}
   ~RegisterPassParser() { RegistryClass::setListener(nullptr); }
 
-  void initialize(cl::Option &O) {
-    cl::parser<typename RegistryClass::FunctionPassCtor>::initialize(O);
+  void initialize() {
+    cl::parser<typename RegistryClass::FunctionPassCtor>::initialize();
 
     // Add existing passes to option.
     for (RegistryClass *Node = RegistryClass::getList();
          Node; Node = Node->getNext()) {
       this->addLiteralOption(Node->getName(),
                       (typename RegistryClass::FunctionPassCtor)Node->getCtor(),
                              Node->getDescription());
     }

llvm/trunk/include/llvm/IR/LegacyPassNameParser.h

 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // PassNameParser class - Make use of the pass registration mechanism to
 // automatically add a command line argument to opt for each pass.
 //
 class PassNameParser : public PassRegistrationListener,
                        public cl::parser<const PassInfo*> {
-  cl::Option *Opt;
 public:
-  PassNameParser();
+  PassNameParser(cl::Option &O);
   virtual ~PassNameParser();
 
-  void initialize(cl::Option &O) {
-    Opt = &O;
-    cl::parser<const PassInfo*>::initialize(O);
+  void initialize() {
+    cl::parser<const PassInfo*>::initialize();
 
     // Add all of the passes to the map that got initialized before 'this' did.
     enumeratePasses();
   }
 
   // ignorablePassImpl - Can be overriden in subclasses to refine the list of
   // which passes we want to include.
   //
   virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
 
   inline bool ignorablePass(const PassInfo *P) const {
     // Ignore non-selectable and non-constructible passes!  Ignore
     // non-optimizations.
     return P->getPassArgument() == nullptr || *P->getPassArgument() == 0 ||
            P->getNormalCtor() == nullptr || ignorablePassImpl(P);
   }
 
   // Implement the PassRegistrationListener callbacks used to populate our map
   //
   void passRegistered(const PassInfo *P) override {
-    if (ignorablePass(P) || !Opt) return;
+    if (ignorablePass(P)) return;
     if (findOption(P->getPassArgument()) != getNumOptions()) {
       errs() << "Two passes with the same argument (-"
            << P->getPassArgument() << ") attempted to be registered!\n";
       llvm_unreachable(nullptr);
     }
     addLiteralOption(P->getPassArgument(), P, P->getPassName());
   }
   void passEnumerate(const PassInfo *P) override { passRegistered(P); }

llvm/trunk/include/llvm/Support/CommandLine.h

protected:
   public:
     GenericOptionInfo(const char *name, const char *helpStr)
         : Name(name), HelpStr(helpStr) {}
     const char *Name;
     const char *HelpStr;
   };
 
 public:
+  generic_parser_base(Option &O) : Owner(O) {}
+
   virtual ~generic_parser_base() {} // Base class should have virtual-dtor
 
   // getNumOptions - Virtual function implemented by generic subclass to
   // indicate how many entries are in Values.
   //
   virtual unsigned getNumOptions() const = 0;
 
   // getOption - Return option name N.
public:
   // DataType (via the same AnyOptionValue).
   template <class AnyOptionValue>
   void printOptionDiff(const Option &O, const AnyOptionValue &V,
                        const AnyOptionValue &Default,
                        size_t GlobalWidth) const {
     printGenericOptionDiff(O, V, Default, GlobalWidth);
   }
 
-  void initialize(Option &O) {
-    // All of the modifiers for the option have been processed by now, so the
-    // argstr field should be stable, copy it down now.
-    //
-    hasArgStr = O.hasArgStr();
-  }
+  void initialize() {}
 
   void getExtraOptionNames(SmallVectorImpl<const char *> &OptionNames) {
     // If there has been no argstr specified, that means that we need to add an
     // argument for every possible option.  This ensures that our options are
     // vectored to us.
-    if (!hasArgStr)
+    if (!Owner.hasArgStr())
       for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
         OptionNames.push_back(getOption(i));
   }
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     // If there is an ArgStr specified, then we are of the form:
     //
     //    -opt=O2   or   -opt O2  or  -optO2
     //
     // In which case, the value is required.  Otherwise if an arg str has not
     // been specified, we are of the form:
     //
     //    -O2 or O2 or -la (where -l and -a are separate options)
     //
     // If this is the case, we cannot allow a value.
     //
-    if (hasArgStr)
+    if (Owner.hasArgStr())
       return ValueRequired;
     else
       return ValueDisallowed;
   }
 
   // findOption - Return the option number corresponding to the specified
   // argument string.  If the option is not found, getNumOptions() is returned.
   //
   unsigned findOption(const char *Name);
 
 protected:
-  bool hasArgStr;
+  Option &Owner;
 };
 
 // Default parser implementation - This implementation depends on having a
 // mapping of recognized options to values of some sort.  In addition to this,
 // each entry in the mapping also tracks a help message that is printed with the
 // command line option for -help.  Because this is a simple mapping parser, the
 // data type can be any unsupported type.
 //
 template <class DataType> class parser : public generic_parser_base {
 protected:
   class OptionInfo : public GenericOptionInfo {
   public:
     OptionInfo(const char *name, DataType v, const char *helpStr)
         : GenericOptionInfo(name, helpStr), V(v) {}
     OptionValue<DataType> V;
   };
   SmallVector<OptionInfo, 8> Values;
 
 public:
+  parser(Option &O) : generic_parser_base(O) {}
   typedef DataType parser_data_type;
 
   // Implement virtual functions needed by generic_parser_base
   unsigned getNumOptions() const override { return unsigned(Values.size()); }
   const char *getOption(unsigned N) const override { return Values[N].Name; }
   const char *getDescription(unsigned N) const override {
     return Values[N].HelpStr;
   }
 
   // getOptionValue - Return the value of option name N.
   const GenericOptionValue &getOptionValue(unsigned N) const override {
     return Values[N].V;
   }
 
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
     StringRef ArgVal;
-    if (hasArgStr)
+    if (Owner.hasArgStr())
       ArgVal = Arg;
     else
       ArgVal = ArgName;
 
     for (size_t i = 0, e = Values.size(); i != e; ++i)
       if (Values[i].Name == ArgVal) {
         V = Values[i].V.getValue();
         return false;
public:
   }
 };
 
 //--------------------------------------------------
 // basic_parser - Super class of parsers to provide boilerplate code
 //
 class basic_parser_impl { // non-template implementation of basic_parser<t>
 public:
+  basic_parser_impl(Option &O) {}
+
   virtual ~basic_parser_impl() {}
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     return ValueRequired;
   }
 
   void getExtraOptionNames(SmallVectorImpl<const char *> &) {}
 
-  void initialize(Option &) {}
+  void initialize() {}
 
   // Return the width of the option tag for printing...
   size_t getOptionWidth(const Option &O) const;
 
   // printOptionInfo - Print out information about this option.  The
   // to-be-maintained width is specified.
   //
   void printOptionInfo(const Option &O, size_t GlobalWidth) const;
protected:
   void printOptionName(const Option &O, size_t GlobalWidth) const;
 };
 
 // basic_parser - The real basic parser is just a template wrapper that provides
 // a typedef for the provided data type.
 //
 template <class DataType> class basic_parser : public basic_parser_impl {
 public:
+  basic_parser(Option &O) : basic_parser_impl(O) {}
   typedef DataType parser_data_type;
   typedef OptionValue<DataType> OptVal;
 };
 
 //--------------------------------------------------
 // parser<bool>
 //
 template <> class parser<bool> : public basic_parser<bool> {
-  const char *ArgStr;
-
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, bool &Val);
 
-  template <class Opt> void initialize(Opt &O) { ArgStr = O.ArgStr; }
+  void initialize() {}
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     return ValueOptional;
   }
 
   // getValueName - Do not print =<value> at all.
   const char *getValueName() const override { return nullptr; }
 
   void printOptionDiff(const Option &O, bool V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<bool>);
 
 //--------------------------------------------------
 // parser<boolOrDefault>
 template <> class parser<boolOrDefault> : public basic_parser<boolOrDefault> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, boolOrDefault &Val);
 
   enum ValueExpected getValueExpectedFlagDefault() const {
     return ValueOptional;
   }
 
   // getValueName - Do not print =<value> at all.
   const char *getValueName() const override { return nullptr; }
 
   void printOptionDiff(const Option &O, boolOrDefault V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>);
 
 //--------------------------------------------------
 // parser<int>
 //
 template <> class parser<int> : public basic_parser<int> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, int &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "int"; }
 
   void printOptionDiff(const Option &O, int V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<int>);
 
 //--------------------------------------------------
 // parser<unsigned>
 //
 template <> class parser<unsigned> : public basic_parser<unsigned> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "uint"; }
 
   void printOptionDiff(const Option &O, unsigned V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
 
 //--------------------------------------------------
 // parser<unsigned long long>
 //
 template <>
 class parser<unsigned long long> : public basic_parser<unsigned long long> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg,
              unsigned long long &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "uint"; }
 
   void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>);
 
 //--------------------------------------------------
 // parser<double>
 //
 template <> class parser<double> : public basic_parser<double> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, double &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, double V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<double>);
 
 //--------------------------------------------------
 // parser<float>
 //
 template <> class parser<float> : public basic_parser<float> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg, float &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "number"; }
 
   void printOptionDiff(const Option &O, float V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<float>);
 
 //--------------------------------------------------
 // parser<std::string>
 //
 template <> class parser<std::string> : public basic_parser<std::string> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {
     Value = Arg.str();
     return false;
   }
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "string"; }
 
   void printOptionDiff(const Option &O, StringRef V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 EXTERN_TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
 
 //--------------------------------------------------
 // parser<char>
 //
 template <> class parser<char> : public basic_parser<char> {
 public:
+  parser(Option &O) : basic_parser(O) {}
+
   // parse - Return true on error.
   bool parse(Option &, StringRef, StringRef Arg, char &Value) {
     Value = Arg[0];
     return false;
   }
 
   // getValueName - Overload in subclass to provide a better default value.
   const char *getValueName() const override { return "char"; }
void printOptionValue(size_t GlobalWidth, bool Force) const override {
     if (Force || this->getDefault().compare(this->getValue())) {
       cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
                                        this->getDefault(), GlobalWidth);
     }
   }
 
   void done() {
     addArgument();
-    Parser.initialize(*this);
+    Parser.initialize();
   }
 
   // Command line options should not be copyable
   opt(const opt &) LLVM_DELETED_FUNCTION;
   opt &operator=(const opt &) LLVM_DELETED_FUNCTION;
 
 public:
   // setInitialValue - Used by the cl::init modifier...
   void setInitialValue(const DataType &V) { this->setValue(V, true); }
 
   ParserClass &getParser() { return Parser; }
 
   template <class T> DataType &operator=(const T &Val) {
     this->setValue(Val);
     return this->getValue();
   }
 
   // One option...
   template <class M0t>
   explicit opt(const M0t &M0)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     done();
   }
 
   // Two options...
   template <class M0t, class M1t>
   opt(const M0t &M0, const M1t &M1)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     done();
   }
 
   // Three options...
   template <class M0t, class M1t, class M2t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     done();
   }
   // Four options...
   template <class M0t, class M1t, class M2t, class M3t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     done();
   }
   // Five options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     done();
   }
   // Six options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
       const M5t &M5)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     done();
   }
   // Seven options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
       const M5t &M5, const M6t &M6)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     done();
   }
   // Eight options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t, class M7t>
   opt(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3, const M4t &M4,
       const M5t &M5, const M6t &M6, const M7t &M7)
-      : Option(Optional, NotHidden) {
+      : Option(Optional, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     apply(M7, this);
class list : public Option, public list_storage<DataType, Storage> {
   }
 
   // Unimplemented: list options don't currently store their default value.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
   void done() {
     addArgument();
-    Parser.initialize(*this);
+    Parser.initialize();
   }
 
   // Command line options should not be copyable
   list(const list &) LLVM_DELETED_FUNCTION;
   list &operator=(const list &) LLVM_DELETED_FUNCTION;
 
 public:
   ParserClass &getParser() { return Parser; }
 
   unsigned getPosition(unsigned optnum) const {
     assert(optnum < this->size() && "Invalid option index");
     return Positions[optnum];
   }
 
   void setNumAdditionalVals(unsigned n) { Option::setNumAdditionalVals(n); }
 
   // One option...
   template <class M0t>
   explicit list(const M0t &M0)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     done();
   }
   // Two options...
   template <class M0t, class M1t>
   list(const M0t &M0, const M1t &M1)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     done();
   }
   // Three options...
   template <class M0t, class M1t, class M2t>
   list(const M0t &M0, const M1t &M1, const M2t &M2)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     done();
   }
   // Four options...
   template <class M0t, class M1t, class M2t, class M3t>
   list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     done();
   }
   // Five options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t>
   list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     done();
   }
   // Six options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
   list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     done();
   }
   // Seven options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t>
   list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5, const M6t &M6)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     done();
   }
   // Eight options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t, class M7t>
   list(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5, const M6t &M6, const M7t &M7)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     apply(M7, this);
class bits : public Option, public bits_storage<DataType, Storage> {
   }
 
   // Unimplemented: bits options don't currently store their default values.
   void printOptionValue(size_t /*GlobalWidth*/, bool /*Force*/) const override {
   }
 
   void done() {
     addArgument();
-    Parser.initialize(*this);
+    Parser.initialize();
   }
 
   // Command line options should not be copyable
   bits(const bits &) LLVM_DELETED_FUNCTION;
   bits &operator=(const bits &) LLVM_DELETED_FUNCTION;
 
 public:
   ParserClass &getParser() { return Parser; }
 
   unsigned getPosition(unsigned optnum) const {
     assert(optnum < this->size() && "Invalid option index");
     return Positions[optnum];
   }
 
   // One option...
   template <class M0t>
   explicit bits(const M0t &M0)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     done();
   }
   // Two options...
   template <class M0t, class M1t>
   bits(const M0t &M0, const M1t &M1)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     done();
   }
   // Three options...
   template <class M0t, class M1t, class M2t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     done();
   }
   // Four options...
   template <class M0t, class M1t, class M2t, class M3t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     done();
   }
   // Five options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     done();
   }
   // Six options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     done();
   }
   // Seven options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5, const M6t &M6)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     done();
   }
   // Eight options...
   template <class M0t, class M1t, class M2t, class M3t, class M4t, class M5t,
             class M6t, class M7t>
   bits(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3,
        const M4t &M4, const M5t &M5, const M6t &M6, const M7t &M7)
-      : Option(ZeroOrMore, NotHidden) {
+      : Option(ZeroOrMore, NotHidden), Parser(*this) {
     apply(M0, this);
     apply(M1, this);
     apply(M2, this);
     apply(M3, this);
     apply(M4, this);
     apply(M5, this);
     apply(M6, this);
     apply(M7, this);

llvm/trunk/lib/IR/Pass.cpp

 
 // enumeratePasses - Iterate over the registered passes, calling the
 // passEnumerate callback on each PassInfo object.
 //
 void PassRegistrationListener::enumeratePasses() {
   PassRegistry::getPassRegistry()->enumerateWith(this);
 }
 
-PassNameParser::PassNameParser()
-    : Opt(nullptr) {
+PassNameParser::PassNameParser(cl::Option &O)
+    : cl::parser<const PassInfo *>(O) {
   PassRegistry::getPassRegistry()->addRegistrationListener(this);
 }
 
 PassNameParser::~PassNameParser() {
   // This only gets called during static destruction, in which case the
   // PassRegistry will have already been destroyed by llvm_shutdown().  So
   // attempting to remove the registration listener is an error.
 }