[Driver] Use libOption with tablegen.

[JDevlieghere]

Summary

This changes the driver to use libOption for option parsing. This means that option are now generated from a tablegen file.

[zturner]

Can you post a short snippet of old help and new help output?

[clayborg]

Would be great to see old and new output like Zach suggested. Is there a reason we need to use TableGen? Other command line tools just use llvm:🆑:opt stuff. Seems a bit obtuse to use TableGen?

[JDevlieghere]

Current output: https://reviews.llvm.org/P8117
Tablegen output: https://reviews.llvm.org/P8118

[zturner]

I actually don't find this too bad, and like Pavel mentioned earlier, it's something that we can fix in LLVM and improve everyone's output. Which is one of the nice things about sharing code like this.

[davide]

In D54692#1308071, @clayborg wrote:

Would be great to see old and new output like Zach suggested. Is there a reason we need to use TableGen? Other command line tools just use llvm:🆑:opt stuff. Seems a bit obtuse to use TableGen?

I'm afraid this is not true. lld uses TableGen and that was a big success. See https://github.com/llvm-mirror/lld/blob/master/ELF/Options.td (considering that linkers have to handle all the annoying cmdline compatibility with gcc, e.g. options which take single or double underscores).

FWIW, I'm in favour of this change.

[labath]

There’s actually been a slow push away from cl::opt. It’s less flexible
and doesn’t support some things that the TableGen approach does.
Recently there’s been a few efforts to port existing tools onto TableGen
options from cl::opt.

I don’t think cl::opt is going away anytime soon so if it works I don’t
have a strong opinion, but it’s kinda nice to standardize on “the one
true method” if that’s the direction things are heading anyway

Another reason for using libOption is that it is also usable as a parser for the lldb command line, whereas cl::opt is definitely not (it uses global variables). And there's value in consistency between the lldb driver and the built-in command line.

[zturner]

In D54692#1308190, @labath wrote:

There’s actually been a slow push away from cl::opt. It’s less flexible
and doesn’t support some things that the TableGen approach does.
Recently there’s been a few efforts to port existing tools onto TableGen
options from cl::opt.

I don’t think cl::opt is going away anytime soon so if it works I don’t
have a strong opinion, but it’s kinda nice to standardize on “the one
true method” if that’s the direction things are heading anyway

Another reason for using libOption is that it is also usable as a parser for the lldb command line, whereas cl::opt is definitely not (it uses global variables). And there's value in consistency between the lldb driver and the built-in command line.

This is true too. Although I believe libOption doesn't support subcommands, which would be required in order to use it for the interactive lldb command line, but again, there would be value in adding that to libOption outside of llvm (cl::opt supports it, so it's required in order to port some remaining llvm tools to libOption)

[labath]

In D54692#1308207, @zturner wrote:

In D54692#1308190, @labath wrote:

Another reason for using libOption is that it is also usable as a parser for the lldb command line, whereas cl::opt is definitely not (it uses global variables). And there's value in consistency between the lldb driver and the built-in command line.

This is true too. Although I believe libOption doesn't support subcommands, which would be required in order to use it for the interactive lldb command line, but again, there would be value in adding that to libOption outside of llvm (cl::opt supports it, so it's required in order to port some remaining llvm tools to libOption)

Adding subcommands is one way. Another would be to simply keep the existing subcommand-parsing code (which we already have, as getopt doesn't support that either), and just replace the getopt part with libOption.

[clayborg]

the old usage:

Usage:

  lldb -h
  lldb -v [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]]
  lldb -a <arch> -f <filename> [-c <filename>] [-s <filename>] [-o <none>] [-S <filename>] [-O <none>] [-k <none>] [-K <filename>] [-Q] [-b] [-e] [-x] [-X] [-l <script-language>] [-d] [-z <filename>] [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]]
  lldb -n <process-name> -w [-s <filename>] [-o <none>] [-S <filename>] [-O <none>] [-k <none>] [-K <filename>] [-Q] [-b] [-e] [-x] [-X] [-l <script-language>] [-d] [-z <filename>]
  lldb -p <pid> [-s <filename>] [-o <none>] [-S <filename>] [-O <none>] [-k <none>] [-K <filename>] [-Q] [-b] [-e] [-x] [-X] [-l <script-language>] [-d] [-z <filename>]
  lldb -P
  lldb -r [<none>] -R <none>

Showed how all the options can be used together. It would be nice to group the options into the following groups:

• general options (--arch, --version, --help, --file, --editor, --no-use-colors, -debug, --reproducer, --repl*)
• scripting options (--python-path, --script-language)
• command options (--no-lldbinit, --batch, --one-line*, --source*)
• attach options (--attach-name, --attach-pid, --wait-for)

[JDevlieghere]

Add old usage.

[clayborg]

Can we still group the options as mentioned in my previous comment?

tools/driver/Driver.cpp

943

Get file base name of this so we don't show a full path to the tool if the user used the full path?

[clayborg]

I know cl::opt had ways to group options and the table gen is more powerful so it must have this feature?

[jingham]

I didn't read the patch in detail yet, these are just meta-comments:

It looks like the libOption approach (or this implementation of it) is missing the notion of option groups. That's what you see in the first section of the lldb --help printout in the current version. That's not that big a deal for the lldb driver command, as it doesn't have all that many disparate groups of options. But Davide mentioned using this for the lldb command line as well, where we do use this to help auto-validate complex commands in a fair number of commands.

One thing that is missing from the SB API's was some way of defining the arguments and options for a command. Because of this, Python based commands can't take part in the completions features and auto-help generation that "real" commands had. If we had such a thing, then the driver could use the same mechanism to define itself as a command, and then just run itself at startup. That would centralize all the argument parsing that we do regardless of how it is backed.

[JDevlieghere]

• Add grouping
• Use basename for help

[clayborg]

Can you attach new output with the grouping and extra usage?

[JDevlieghere]

In D54692#1308604, @clayborg wrote:

Can you attach new output with the grouping and extra usage?

I updated the original snippet, see https://reviews.llvm.org/P8118

[clayborg]

I would wait to get another OK from anyone else just to be sure.

[JDevlieghere]

In D54692#1308640, @clayborg wrote:

I would wait to get another OK from anyone else just to be sure.

Sounds good. Thanks Greg!

[JDevlieghere]

Will land this tomorrow once we've figured out how to integrate tablegen with the Xcode project.

In the meantime I found some issues due to ordering of command options. Their relative order matters and we had tests relying on this. For example consider what happens when you say

lldb -o 'do one thing' -s 'source/some/file'

You'd expect that the one-line is executed before sourcing the file. This wasn't the case with the previous version of this patch and is now fixed.

[jingham]

You have to gather all the -O's and -S's and -Q's and add them to the list of code that gets sourced before the file is loaded in the order in which you find them. There can be more than one of each of these and they can be interspersed anywhere among the other command options. Ditto for the -o's, -s's and -q's (except they get run after the file). I don't know how complicated a set of tests I wrote when I originally added these, so you might want to check that all these cases are covered.

[labath]

tools/driver/Driver.cpp

918–930

I am not entirely thrilled by the hard-coding of the option combinations here. It sounds like the kind of thing that will invariably get out of sync (I think it would be better to just not have it). Instead of trying to exhaustively list all possible option combinations (which I generally find too long to make sense of), and still getting it wrong (Why is there a [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]] after -v in the second option form?), maybe it would be better to just output a short prose here explaining the general principle. Maybe something like "LLDB can be started in several modes. Passing an executable as a positional arguments prepares lldb to debug the given executable. Using one of the attach options causes lldb to immediately attach to the given process. Command options can be combined with either mode and cause lldb to run the specified commands before starting the interactive shell. Using --repl starts lldb in REPL mode. etc."

However, if everyone is happy with the current approach then I won't stand in the way..

[JDevlieghere]

• Add lit test for command options.
• Change usage with prose.

[clayborg]

I would be happy if we just have an EXAMPLES section much like many of the man pages for built in shell commands where we show a few examples.

I would like to see setting up a target a program with arguments that might conflict with the argument parser like:

% lldb --arch x86_64 /path/to/program/a.out -- --arch arvm7

The first arch is for lldb, and any options past the -- are for the inferior program

Attaching examples, loading a core file, printing python path, maybe specifying some lldb commands with -o and -O to show how those work.

[JDevlieghere]

• Add EXAMPLES section

EXAMPLES:
  The debugger can be started in several modes.

  Passing an executable as a positional argument prepares lldb to debug the
  given executable. Arguments passed after -- are considered arguments to the
  debugged executable.

    lldb --arch x86_64 /path/to/program -- --arch arvm7

  Passing one of the attach options causes lldb to immediately attach to the
  given process.

    lldb -p <pid>
    lldb -n <process-name>

  Passing --repl starts lldb in REPL mode.

    lldb -r

  Passing --core causes lldb to debug the core file.

    lldb -c /path/to/core

  Command options can be combined with either mode and cause lldb to run the
  specified commands before or after events, like loading the file or crashing,
  in the order provided on the command line.

    lldb -O 'settings set stop-disassembly-count 20' -o 'run' -o 'bt'
    lldb -S /source/before/file -s /source/after/file
    lldb -K /source/before/crash -k /source/after/crash

[lemo]

I noticed a small problem, this change breaks "lldb -c <corefile>". The inline comment explains the root cause.

Thanks

lldb/trunk/tools/driver/Driver.cpp

310 ↗

(On Diff #175566)

there's a small bug in here: optarg is the global definition, I assume the intention was to use the getValue() instead. as is, it breaks "lldb -c <corefile>"

it would be nice to get rid the global optarg as well since it masks these kind of mistakes.

tools/driver/CMakeLists.txt

+set(LLVM_TARGET_DEFINITIONS Options.td)
+tablegen(LLVM Options.inc -gen-opt-parser-defs)
+add_public_tablegen_target(LLDBOptionsTableGen)
+
 if ((CMAKE_SYSTEM_NAME MATCHES "Windows") OR
     (CMAKE_SYSTEM_NAME MATCHES "NetBSD" ))
   # These targets do not have getopt support, so they rely on the one provided by
   # liblldb. However, getopt is not a part of the liblldb interface, so we have
   # to link against the constituent libraries manually. Note that this is
   # extremely scary as it introduces ODR violations, and it should go away as
   # soon as possible.
   set(host_lib lldbHost)
 endif()
 
 add_lldb_tool(lldb
   Driver.cpp
   Platform.cpp
 
   LINK_LIBS
     liblldb
     ${host_lib}
 
   LINK_COMPONENTS
+    Option
     Support
   )
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   add_definitions( -DIMPORT_LIBLLDB )
 endif()
 
-add_dependencies(lldb ${LLDB_SUITE_TARGET})
+add_dependencies(lldb
+  ${LLDB_SUITE_TARGET}
+  LLDBOptionsTableGen
+  ${tablegen_deps}
+)

tools/driver/Driver.h

 //===-- Driver.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Driver_h_
 #define lldb_Driver_h_
 
 #include "Platform.h"
 
-#include <set>
-#include <string>
-#include <vector>
-
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+
+#include <set>
+#include <string>
+#include <vector>
+
 class Driver : public lldb::SBBroadcaster {
 public:
   typedef enum CommandPlacement {
     eCommandPlacementBeforeFile,
     eCommandPlacementAfterFile,
     eCommandPlacementAfterCrash,
   } CommandPlacement;
 
   Driver();
 
   virtual ~Driver();
 
   /// Runs the main loop.
   ///
   /// @return The exit code that the process should return.
   int MainLoop();
 
-  lldb::SBError ParseArgs(int argc, const char *argv[], FILE *out_fh,
+  lldb::SBError ProcessArgs(const llvm::opt::InputArgList &args, FILE *out_fh,
                             bool &do_exit);
 
   const char *GetFilename() const;
 
   const char *GetCrashLogFilename() const;
 
   const char *GetArchName() const;
 
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   void WriteCommandsForSourcing(CommandPlacement placement,
                                 lldb::SBStream &strm);
 
   bool GetDebugMode() const;
 
   class OptionData {
   public:
     OptionData();
     ~OptionData();
 
     void Clear();
 
-    void AddInitialCommand(const char *command, CommandPlacement placement,
+    void AddInitialCommand(std::string command, CommandPlacement placement,
                            bool is_file, lldb::SBError &error);
 
     struct InitialCmdEntry {
-      InitialCmdEntry(const char *in_contents, bool in_is_file,
+      InitialCmdEntry(std::string contents, bool in_is_file,
                       bool is_cwd_lldbinit_file_read, bool in_quiet = false)
-          : contents(in_contents), is_file(in_is_file),
+          : contents(std::move(contents)), is_file(in_is_file),
             is_cwd_lldbinit_file_read(is_cwd_lldbinit_file_read),
             source_quietly(in_quiet) {}
 
       std::string contents;
       bool is_file;
       bool is_cwd_lldbinit_file_read; // if this is reading ./.lldbinit - so we
                                       // may skip if not permitted
       bool source_quietly;
     };
 
     std::vector<std::string> m_args;
     lldb::ScriptLanguage m_script_lang;
     std::string m_core_file;
     std::string m_crash_log;
     std::vector<InitialCmdEntry> m_initial_commands;
     std::vector<InitialCmdEntry> m_after_file_commands;
     std::vector<InitialCmdEntry> m_after_crash_commands;
     bool m_debug_mode;
     bool m_source_quietly;
     bool m_print_version;
     bool m_print_python_path;
-    bool m_print_help;
     bool m_wait_for;
     bool m_repl;
     lldb::LanguageType m_repl_lang;
     std::string m_repl_options;
     std::string m_process_name;
     lldb::pid_t m_process_pid;
     bool m_use_external_editor; // FIXME: When we have set/show variables we can
                                 // remove this from here.

tools/driver/Driver.cpp

 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 
-#include <algorithm>
-#include <atomic>
-#include <bitset>
-#include <csignal>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-// Includes for pipe()
-#if defined(_WIN32)
-#include <fcntl.h>
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-
-#include <string>
-
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
+
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <algorithm>
+#include <atomic>
+#include <bitset>
+#include <csignal>
+#include <string>
 #include <thread>
 #include <utility>
 
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Includes for pipe()
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
 #if !defined(__APPLE__)
 #include "llvm/Support/DataTypes.h"
 #endif
 
 using namespace lldb;
+using namespace llvm;
+
+namespace {
+enum ID {
+  OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Options.inc"
+#undef PREFIX
+
+static const opt::OptTable::Info InfoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  {                                                                            \
+      PREFIX,      NAME,      HELPTEXT,                                        \
+      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
+      PARAM,       FLAGS,     OPT_##GROUP,                                     \
+      OPT_##ALIAS, ALIASARGS, VALUES},
+#include "Options.inc"
+#undef OPTION
+};
+
+class LLDBOptTable : public opt::OptTable {
+public:
+  LLDBOptTable() : OptTable(InfoTable) {}
+};
+} // namespace
 
 static void reset_stdin_termios();
 static bool g_old_stdin_termios_is_valid = false;
 static struct termios g_old_stdin_termios;
 
 static Driver *g_driver = NULL;
 
 // In the Driver::MainLoop, we change the terminal settings.  This function is
 // added as an atexit handler to make sure we clean them up.
 static void reset_stdin_termios() {
   if (g_old_stdin_termios_is_valid) {
     g_old_stdin_termios_is_valid = false;
     ::tcsetattr(STDIN_FILENO, TCSANOW, &g_old_stdin_termios);
   }
 }
 
-typedef struct {
-  uint32_t usage_mask; // Used to mark options that can be used together.  If (1
-                       // << n & usage_mask) != 0
-                       // then this option belongs to option set n.
-  bool required;       // This option is required (in the current usage level)
-  const char *long_option; // Full name for this option.
-  int short_option;        // Single character for this option.
-  int option_has_arg; // no_argument, required_argument or optional_argument
-  uint32_t completion_type; // Cookie the option class can use to do define the
-                            // argument completion.
-  lldb::CommandArgumentType argument_type; // Type of argument this option takes
-  const char *usage_text; // Full text explaining what this options does and
-                          // what (if any) argument to
-                          // pass it.
-} OptionDefinition;
-
-#define LLDB_3_TO_5 LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5
-#define LLDB_4_TO_5 LLDB_OPT_SET_4 | LLDB_OPT_SET_5
-
-static constexpr OptionDefinition g_options[] = {
-    {LLDB_OPT_SET_1, true, "help", 'h', no_argument, 0, eArgTypeNone,
-     "Prints out the usage information for the LLDB debugger."},
-    {LLDB_OPT_SET_2, true, "version", 'v', no_argument, 0, eArgTypeNone,
-     "Prints out the current version number of the LLDB debugger."},
-    {LLDB_OPT_SET_3, true, "arch", 'a', required_argument, 0,
-     eArgTypeArchitecture,
-     "Tells the debugger to use the specified architecture when starting and "
-     "running the program.  <architecture> must "
-     "be one of the architectures for which the program was compiled."},
-    {LLDB_OPT_SET_3, true, "file", 'f', required_argument, 0, eArgTypeFilename,
-     "Tells the debugger to use the file <filename> as the program to be "
-     "debugged."},
-    {LLDB_OPT_SET_3, false, "core", 'c', required_argument, 0, eArgTypeFilename,
-     "Tells the debugger to use the fullpath to <path> as the core file."},
-    {LLDB_OPT_SET_5, true, "attach-pid", 'p', required_argument, 0, eArgTypePid,
-     "Tells the debugger to attach to a process with the given pid."},
-    {LLDB_OPT_SET_4, true, "attach-name", 'n', required_argument, 0,
-     eArgTypeProcessName,
-     "Tells the debugger to attach to a process with the given name."},
-    {LLDB_OPT_SET_4, true, "wait-for", 'w', no_argument, 0, eArgTypeNone,
-     "Tells the debugger to wait for a process with the given pid or name to "
-     "launch before attaching."},
-    {LLDB_3_TO_5, false, "source", 's', required_argument, 0, eArgTypeFilename,
-     "Tells the debugger to read in and execute the lldb commands in the given "
-     "file, after any file provided on the command line has been loaded."},
-    {LLDB_3_TO_5, false, "one-line", 'o', required_argument, 0, eArgTypeNone,
-     "Tells the debugger to execute this one-line lldb command after any file "
-     "provided on the command line has been loaded."},
-    {LLDB_3_TO_5, false, "source-before-file", 'S', required_argument, 0,
-     eArgTypeFilename,
-     "Tells the debugger to read in and execute the lldb "
-     "commands in the given file, before any file provided "
-     "on the command line has been loaded."},
-    {LLDB_3_TO_5, false, "one-line-before-file", 'O', required_argument, 0,
-     eArgTypeNone,
-     "Tells the debugger to execute this one-line lldb command "
-     "before any file provided on the command line has been "
-     "loaded."},
-    {LLDB_3_TO_5, false, "one-line-on-crash", 'k', required_argument, 0,
-     eArgTypeNone,
-     "When in batch mode, tells the debugger to execute this "
-     "one-line lldb command if the target crashes."},
-    {LLDB_3_TO_5, false, "source-on-crash", 'K', required_argument, 0,
-     eArgTypeFilename,
-     "When in batch mode, tells the debugger to source this "
-     "file of lldb commands if the target crashes."},
-    {LLDB_3_TO_5, false, "source-quietly", 'Q', no_argument, 0, eArgTypeNone,
-     "Tells the debugger to execute this one-line lldb command before any file "
-     "provided on the command line has been loaded."},
-    {LLDB_3_TO_5, false, "batch", 'b', no_argument, 0, eArgTypeNone,
-     "Tells the debugger to run the commands from -s, -S, -o & -O, and "
-     "then quit.  However if any run command stopped due to a signal or crash, "
-     "the debugger will return to the interactive prompt at the place of the "
-     "crash."},
-    {LLDB_3_TO_5, false, "editor", 'e', no_argument, 0, eArgTypeNone,
-     "Tells the debugger to open source files using the host's \"external "
-     "editor\" mechanism."},
-    {LLDB_3_TO_5, false, "no-lldbinit", 'x', no_argument, 0, eArgTypeNone,
-     "Do not automatically parse any '.lldbinit' files."},
-    {LLDB_3_TO_5, false, "no-use-colors", 'X', no_argument, 0, eArgTypeNone,
-     "Do not use colors."},
-    {LLDB_OPT_SET_6, true, "python-path", 'P', no_argument, 0, eArgTypeNone,
-     "Prints out the path to the lldb.py file for this version of lldb."},
-    {LLDB_3_TO_5, false, "script-language", 'l', required_argument, 0,
-     eArgTypeScriptLang,
-     "Tells the debugger to use the specified scripting language for "
-     "user-defined scripts, rather than the default.  "
-     "Valid scripting languages that can be specified include Python, Perl, "
-     "Ruby and Tcl.  Currently only the Python "
-     "extensions have been implemented."},
-    {LLDB_3_TO_5, false, "debug", 'd', no_argument, 0, eArgTypeNone,
-     "Tells the debugger to print out extra information for debugging itself."},
-    {LLDB_3_TO_5, false, "reproducer", 'z', required_argument, 0,
-     eArgTypeFilename,
-     "Tells the debugger to use the fullpath to <path> as a reproducer."},
-    {LLDB_OPT_SET_7, true, "repl", 'r', optional_argument, 0, eArgTypeNone,
-     "Runs lldb in REPL mode with a stub process."},
-    {LLDB_OPT_SET_7, true, "repl-language", 'R', required_argument, 0,
-     eArgTypeNone, "Chooses the language for the REPL."}};
-
-static constexpr auto g_num_options = sizeof(g_options)/sizeof(OptionDefinition);
-
-static const uint32_t last_option_set_with_args = 2;
-
 Driver::Driver()
     : SBBroadcaster("Driver"), m_debugger(SBDebugger::Create(false)),
       m_option_data() {
   // We want to be able to handle CTRL+D in the terminal to have it terminate
   // certain input
   m_debugger.SetCloseInputOnEOF(false);
   g_driver = this;
 }
while (end < final_end) {
       sub_len = end - start;
       std::string substring = text_string.substr(start, sub_len);
       fprintf(out, "%*s%s\n", indent, "", substring.c_str());
       start = end + 1;
     }
   }
 }
 
-static void ShowUsage(FILE *out, Driver::OptionData data) {
-  uint32_t screen_width = 80;
-  uint32_t indent_level = 0;
-  const char *name = "lldb";
-
-  fprintf(out, "\nUsage:\n\n");
-
-  indent_level += 2;
-
-  // First, show each usage level set of options, e.g. <cmd>
-  // [options-for-level-0]
-  //                                                   <cmd>
-  //                                                   [options-for-level-1]
-  //                                                   etc.
-
-  uint32_t num_option_sets = 0;
-
-  for (const auto &opt : g_options) {
-    uint32_t this_usage_mask = opt.usage_mask;
-    if (this_usage_mask == LLDB_OPT_SET_ALL) {
-      if (num_option_sets == 0)
-        num_option_sets = 1;
-    } else {
-      for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) {
-        if (this_usage_mask & 1 << j) {
-          if (num_option_sets <= j)
-            num_option_sets = j + 1;
-        }
-      }
-    }
-  }
-
-  for (uint32_t opt_set = 0; opt_set < num_option_sets; opt_set++) {
-    uint32_t opt_set_mask;
-
-    opt_set_mask = 1 << opt_set;
-
-    if (opt_set > 0)
-      fprintf(out, "\n");
-    fprintf(out, "%*s%s", indent_level, "", name);
-    bool is_help_line = false;
-
-    for (const auto &opt : g_options) {
-      if (opt.usage_mask & opt_set_mask) {
-        CommandArgumentType arg_type = opt.argument_type;
-        const char *arg_name =
-            SBCommandInterpreter::GetArgumentTypeAsCString(arg_type);
-        // This is a bit of a hack, but there's no way to say certain options
-        // don't have arguments yet...
-        // so we do it by hand here.
-        if (opt.short_option == 'h')
-          is_help_line = true;
-
-        if (opt.required) {
-          if (opt.option_has_arg == required_argument)
-            fprintf(out, " -%c <%s>", opt.short_option, arg_name);
-          else if (opt.option_has_arg == optional_argument)
-            fprintf(out, " -%c [<%s>]", opt.short_option, arg_name);
-          else
-            fprintf(out, " -%c", opt.short_option);
-        } else {
-          if (opt.option_has_arg == required_argument)
-            fprintf(out, " [-%c <%s>]", opt.short_option, arg_name);
-          else if (opt.option_has_arg == optional_argument)
-            fprintf(out, " [-%c [<%s>]]", opt.short_option,
-                    arg_name);
-          else
-            fprintf(out, " [-%c]", opt.short_option);
-        }
-      }
-    }
-    if (!is_help_line && (opt_set <= last_option_set_with_args))
-      fprintf(out, " [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]]");
-  }
-
-  fprintf(out, "\n\n");
-
-  // Now print out all the detailed information about the various options:  long
-  // form, short form and help text:
-  //   -- long_name <argument>
-  //   - short <argument>
-  //   help text
-
-  // This variable is used to keep track of which options' info we've printed
-  // out, because some options can be in
-  // more than one usage level, but we only want to print the long form of its
-  // information once.
-
-  Driver::OptionData::OptionSet options_seen;
-  Driver::OptionData::OptionSet::iterator pos;
-
-  indent_level += 5;
-
-  for (const auto &opt : g_options) {
-    // Only print this option if we haven't already seen it.
-    pos = options_seen.find(opt.short_option);
-    if (pos == options_seen.end()) {
-      CommandArgumentType arg_type = opt.argument_type;
-      const char *arg_name =
-          SBCommandInterpreter::GetArgumentTypeAsCString(arg_type);
-
-      options_seen.insert(opt.short_option);
-      fprintf(out, "%*s-%c ", indent_level, "", opt.short_option);
-      if (arg_type != eArgTypeNone)
-        fprintf(out, "<%s>", arg_name);
-      fprintf(out, "\n");
-      fprintf(out, "%*s--%s ", indent_level, "", opt.long_option);
-      if (arg_type != eArgTypeNone)
-        fprintf(out, "<%s>", arg_name);
-      fprintf(out, "\n");
-      indent_level += 5;
-      OutputFormattedUsageText(out, indent_level, opt.usage_text,
-                               screen_width);
-      indent_level -= 5;
-      fprintf(out, "\n");
-    }
-  }
-
-  indent_level -= 5;
-
-  fprintf(out, "\n%*sNotes:\n", indent_level, "");
-  indent_level += 5;
-
-  fprintf(out,
-          "\n%*sMultiple \"-s\" and \"-o\" options can be provided.  They will "
-          "be processed"
-          "\n%*sfrom left to right in order, with the source files and commands"
-          "\n%*sinterleaved.  The same is true of the \"-S\" and \"-O\" "
-          "options.  The before"
-          "\n%*sfile and after file sets can intermixed freely, the command "
-          "parser will"
-          "\n%*ssort them out.  The order of the file specifiers (\"-c\", "
-          "\"-f\", etc.) is"
-          "\n%*snot significant in this regard.\n\n",
-          indent_level, "", indent_level, "", indent_level, "", indent_level,
-          "", indent_level, "", indent_level, "");
-
-  fprintf(
-      out,
-      "\n%*sIf you don't provide -f then the first argument will be the file "
-      "to be"
-      "\n%*sdebugged which means that '%s -- <filename> [<ARG1> [<ARG2>]]' also"
-      "\n%*sworks.  But remember to end the options with \"--\" if any of your"
-      "\n%*sarguments have a \"-\" in them.\n\n",
-      indent_level, "", indent_level, "", name, indent_level, "", indent_level,
-      "");
-}
-
- static void BuildGetOptTable(std::vector<option> &getopt_table) {
-  getopt_table.resize(g_num_options + 1);
-
-  std::bitset<256> option_seen;
-  uint32_t j = 0;
-  for (const auto &opt : g_options) {
-    char short_opt = opt.short_option;
-
-    if (option_seen.test(short_opt) == false) {
-      getopt_table[j].name = opt.long_option;
-      getopt_table[j].has_arg = opt.option_has_arg;
-      getopt_table[j].flag = NULL;
-      getopt_table[j].val = opt.short_option;
-      option_seen.set(short_opt);
-      ++j;
-    }
-  }
-
-  getopt_table[j].name = NULL;
-  getopt_table[j].has_arg = 0;
-  getopt_table[j].flag = NULL;
-  getopt_table[j].val = 0;
-}
-
 Driver::OptionData::OptionData()
     : m_args(), m_script_lang(lldb::eScriptLanguageDefault), m_core_file(),
       m_crash_log(), m_initial_commands(), m_after_file_commands(),
       m_after_crash_commands(), m_debug_mode(false), m_source_quietly(false),
-      m_print_version(false), m_print_python_path(false), m_print_help(false),
-      m_wait_for(false), m_repl(false), m_repl_lang(eLanguageTypeUnknown),
-      m_repl_options(), m_process_name(),
-      m_process_pid(LLDB_INVALID_PROCESS_ID), m_use_external_editor(false),
-      m_batch(false), m_seen_options() {}
+      m_print_version(false), m_print_python_path(false), m_wait_for(false),
+      m_repl(false), m_repl_lang(eLanguageTypeUnknown), m_repl_options(),
+      m_process_name(), m_process_pid(LLDB_INVALID_PROCESS_ID),
+      m_use_external_editor(false), m_batch(false), m_seen_options() {}
 
 Driver::OptionData::~OptionData() {}
 
 void Driver::OptionData::Clear() {
   m_args.clear();
   m_script_lang = lldb::eScriptLanguageDefault;
   m_initial_commands.clear();
   m_after_file_commands.clear();
if (local_lldbinit.Exists() &&
     char path[2048];
     local_lldbinit.GetPath(path, 2047);
     InitialCmdEntry entry(path, true, true, true);
     m_after_file_commands.push_back(entry);
   }
 
   m_debug_mode = false;
   m_source_quietly = false;
-  m_print_help = false;
   m_print_version = false;
   m_print_python_path = false;
   m_use_external_editor = false;
   m_wait_for = false;
   m_process_name.erase();
   m_batch = false;
   m_after_crash_commands.clear();
 
   m_process_pid = LLDB_INVALID_PROCESS_ID;
 }
 
-void Driver::OptionData::AddInitialCommand(const char *command,
+void Driver::OptionData::AddInitialCommand(std::string command,
                                            CommandPlacement placement,
                                            bool is_file, SBError &error) {
   std::vector<InitialCmdEntry> *command_set;
   switch (placement) {
   case eCommandPlacementBeforeFile:
     command_set = &(m_initial_commands);
     break;
   case eCommandPlacementAfterFile:
     command_set = &(m_after_file_commands);
     break;
   case eCommandPlacementAfterCrash:
     command_set = &(m_after_crash_commands);
     break;
   }
 
   if (is_file) {
-    SBFileSpec file(command);
+    SBFileSpec file(command.c_str());
     if (file.Exists())
       command_set->push_back(InitialCmdEntry(command, is_file, false));
     else if (file.ResolveExecutableLocation()) {
       char final_path[PATH_MAX];
       file.GetPath(final_path, sizeof(final_path));
       command_set->push_back(InitialCmdEntry(final_path, is_file, false));
     } else
       error.SetErrorStringWithFormat(
-          "file specified in --source (-s) option doesn't exist: '%s'", optarg);
+          "file specified in --source (-s) option doesn't exist: '%s'",
+          command.c_str());
   } else
     command_set->push_back(InitialCmdEntry(command, is_file, false));
 }
 
 void Driver::ResetOptionValues() { m_option_data.Clear(); }
 
 const char *Driver::GetFilename() const {
   if (m_option_data.m_args.empty())
for (const auto &command_entry : *command_set) {
     } else
       strm.Printf("%s\n", command);
   }
 }
 
 bool Driver::GetDebugMode() const { return m_option_data.m_debug_mode; }
 
 // Check the arguments that were passed to this program to make sure they are
-// valid and to get their
-// argument values (if any).  Return a boolean value indicating whether or not
-// to start up the full
-// debugger (i.e. the Command Interpreter) or not.  Return FALSE if the
-// arguments were invalid OR
-// if the user only wanted help or version information.
-
-SBError Driver::ParseArgs(int argc, const char *argv[], FILE *out_fh,
+// valid and to get their argument values (if any).  Return a boolean value
+// indicating whether or not to start up the full debugger (i.e. the Command
+// Interpreter) or not.  Return FALSE if the arguments were invalid OR if the
+// user only wanted help or version information.
+SBError Driver::ProcessArgs(const opt::InputArgList &args, FILE *out_fh,
                             bool &exiting) {
-  static_assert(g_num_options > 0, "cannot handle arguments");
-
-  ResetOptionValues();
-
   SBError error;
-  std::vector<option> long_options_vector;
-  BuildGetOptTable(long_options_vector);
-  if (long_options_vector.empty()) {
-    error.SetErrorStringWithFormat("invalid long options");
-    return error;
-  }
-
-  // Build the option_string argument for call to getopt_long_only.
-  std::string option_string;
-  auto sentinel_it = std::prev(std::end(long_options_vector));
-  for (auto long_opt_it = std::begin(long_options_vector);
-            long_opt_it != sentinel_it; ++long_opt_it) {
-    if (long_opt_it->flag == nullptr) {
-      option_string.push_back(static_cast<char>(long_opt_it->val));
-      switch (long_opt_it->has_arg) {
-      default:
-      case no_argument:
-        break;
-      case required_argument:
-        option_string.push_back(':');
-        break;
-      case optional_argument:
-        option_string.append("::");
-        break;
-      }
-    }
-  }
+  ResetOptionValues();
 
   // This is kind of a pain, but since we make the debugger in the Driver's
-  // constructor, we can't
-  // know at that point whether we should read in init files yet.  So we don't
-  // read them in in the
-  // Driver constructor, then set the flags back to "read them in" here, and
-  // then if we see the
-  // "-n" flag, we'll turn it off again.  Finally we have to read them in by
-  // hand later in the
-  // main loop.
-
+  // constructor, we can't know at that point whether we should read in init
+  // files yet.  So we don't read them in in the Driver constructor, then set
+  // the flags back to "read them in" here, and then if we see the "-n" flag,
+  // we'll turn it off again.  Finally we have to read them in by hand later in
+  // the main loop.
   m_debugger.SkipLLDBInitFiles(false);
   m_debugger.SkipAppInitFiles(false);
 
-// Prepare for & make calls to getopt_long_only.
-#if __GLIBC__
-  optind = 0;
-#else
-  optreset = 1;
-  optind = 1;
-#endif
-  int val;
-  while (1) {
-    int long_options_index = -1;
-    val = ::getopt_long_only(argc, const_cast<char **>(argv),
-                             option_string.c_str(), long_options_vector.data(),
-                             &long_options_index);
-
-    if (val == -1)
-      break;
-    else if (val == '?') {
-      m_option_data.m_print_help = true;
-      error.SetErrorStringWithFormat("unknown or ambiguous option");
-      break;
-    } else if (val == 0)
-      continue;
-    else {
-      m_option_data.m_seen_options.insert((char)val);
-      if (long_options_index == -1) {
-        auto long_opt_it = std::find_if(std::begin(long_options_vector), sentinel_it,
-            [val](const option &long_option) { return long_option.val == val; });
-        if (std::end(long_options_vector) != long_opt_it)
-          long_options_index =
-              std::distance(std::begin(long_options_vector), long_opt_it);
-      }
-
-      if (long_options_index >= 0) {
-        const int short_option = g_options[long_options_index].short_option;
-
-        switch (short_option) {
-        case 'h':
-          m_option_data.m_print_help = true;
-          break;
-
-        case 'v':
-          m_option_data.m_print_version = true;
-          break;
+  if (args.hasArg(OPT_version)) {
+  }
 
-        case 'P':
-          m_option_data.m_print_python_path = true;
-          break;
+  if (args.hasArg(OPT_python_path)) {
+  }
 
-        case 'b':
-          m_option_data.m_batch = true;
-          break;
+  if (args.hasArg(OPT_batch)) {
+  }
 
-        case 'c': {
-          SBFileSpec file(optarg);
-          if (file.Exists()) {
-            m_option_data.m_core_file = optarg;
-          } else
-            error.SetErrorStringWithFormat(
-                "file specified in --core (-c) option doesn't exist: '%s'",
-                optarg);
-        } break;
+  if (args.hasArg(OPT_core)) {
+    } else {
+          "file specified in --core (-c) option doesn't exist: '%s'", optarg);
+      return error;
+    }
+  }
 
-        case 'e':
-          m_option_data.m_use_external_editor = true;
-          break;
+  if (args.hasArg(OPT_editor)) {
+  }
 
-        case 'x':
-          m_debugger.SkipLLDBInitFiles(true);
-          m_debugger.SkipAppInitFiles(true);
-          break;
+  if (args.hasArg(OPT_no_lldbinit)) {
+  }
 
-        case 'X':
-          m_debugger.SetUseColor(false);
-          break;
+  if (args.hasArg(OPT_no_use_colors)) {
+  }
 
-        case 'f': {
-          SBFileSpec file(optarg);
-          if (file.Exists()) {
-            m_option_data.m_args.push_back(optarg);
-          } else if (file.ResolveExecutableLocation()) {
-            char path[PATH_MAX];
-            file.GetPath(path, sizeof(path));
-            m_option_data.m_args.push_back(path);
-          } else
-            error.SetErrorStringWithFormat(
-                "file specified in --file (-f) option doesn't exist: '%s'",
-                optarg);
-        } break;
+  if (auto *arg = args.getLastArg(OPT_file)) {
+    auto optarg = arg->getValue();
+    } else {
+          "file specified in --file (-f) option doesn't exist: '%s'", optarg);
+      return error;
+    }
+  }
 
-        case 'a':
-          if (!m_debugger.SetDefaultArchitecture(optarg))
-            error.SetErrorStringWithFormat(
-                "invalid architecture in the -a or --arch option: '%s'",
-                optarg);
-          break;
+  if (auto *arg = args.getLastArg(OPT_arch)) {
+    auto optarg = arg->getValue();
+    if (!m_debugger.SetDefaultArchitecture(optarg)) {
+          "invalid architecture in the -a or --arch option: '%s'", optarg);
+      return error;
+    }
+  }
 
-        case 'l':
-          m_option_data.m_script_lang = m_debugger.GetScriptingLanguage(optarg);
-          break;
+  if (auto *arg = args.getLastArg(OPT_script_language)) {
+    auto optarg = arg->getValue();
+  }
 
-        case 'd':
-          m_option_data.m_debug_mode = true;
-          break;
+  if (args.hasArg(OPT_no_use_colors)) {
+  }
 
-        case 'z': {
-          SBFileSpec file(optarg);
-          if (file.Exists()) {
-            m_debugger.SetReproducerPath(optarg);
-          } else
-            error.SetErrorStringWithFormat("file specified in --reproducer "
-                                           "(-z) option doesn't exist: '%s'",
-                                           optarg);
-        } break;
+  if (auto *arg = args.getLastArg(OPT_reproducer)) {
+    auto optarg = arg->getValue();
+    } else {
+      return error;
+    }
+  }
 
-        case 'Q':
-          m_option_data.m_source_quietly = true;
-          break;
-
-        case 'K':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash,
-                                          true, error);
-          break;
-        case 'k':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash,
-                                          false, error);
-          break;
+  if (args.hasArg(OPT_no_use_colors)) {
+  }
 
-        case 'n':
-          m_option_data.m_process_name = optarg;
-          break;
+  if (auto *arg = args.getLastArg(OPT_attach_name)) {
+    auto optarg = arg->getValue();
+  }
 
-        case 'w':
-          m_option_data.m_wait_for = true;
-          break;
+  if (args.hasArg(OPT_wait_for)) {
+  }
 
-        case 'p': {
-          char *remainder;
-          m_option_data.m_process_pid = strtol(optarg, &remainder, 0);
-          if (remainder == optarg || *remainder != '\0')
-            error.SetErrorStringWithFormat(
-                "Could not convert process PID: \"%s\" into a pid.", optarg);
-        } break;
+  if (auto *arg = args.getLastArg(OPT_attach_pid)) {
+    auto optarg = arg->getValue();
+    if (remainder == optarg || *remainder != '\0') {
+      return error;
+    }
+  }
+
+  if (auto *arg = args.getLastArg(OPT_repl_language)) {
+    auto optarg = arg->getValue();
+    m_option_data.m_repl_lang =
+        SBLanguageRuntime::GetLanguageTypeFromString(optarg);
+    if (m_option_data.m_repl_lang == eLanguageTypeUnknown) {
+      error.SetErrorStringWithFormat("Unrecognized language name: \"%s\"",
+                                     optarg);
+      return error;
+    }
+  }
 
-        case 'r':
-          m_option_data.m_repl = true;
-          if (optarg && optarg[0])
-            m_option_data.m_repl_options = optarg;
-          else
-            m_option_data.m_repl_options.clear();
-          break;
+  if (auto *arg = args.getLastArg(OPT_repl)) {
+    auto optarg = arg->getValue();
+  }
 
-        case 'R':
-          m_option_data.m_repl_lang =
-              SBLanguageRuntime::GetLanguageTypeFromString(optarg);
-          if (m_option_data.m_repl_lang == eLanguageTypeUnknown) {
-            error.SetErrorStringWithFormat("Unrecognized language name: \"%s\"",
-                                           optarg);
-          }
-          break;
+  for (auto *arg : args.filtered(OPT_source_on_crash)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, true,
+                                    error);
+    if (error.Fail())
+      return error;
 
-        case 's':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile,
-                                          true, error);
-          break;
-        case 'o':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile,
-                                          false, error);
-          break;
-        case 'S':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile,
-                                          true, error);
-          break;
-        case 'O':
-          m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile,
-                                          false, error);
-          break;
-        default:
-          m_option_data.m_print_help = true;
-          error.SetErrorStringWithFormat("unrecognized option %c",
-                                         short_option);
-          break;
-        }
-      } else {
-        error.SetErrorStringWithFormat("invalid option with value %i", val);
-      }
-      if (error.Fail()) {
-        return error;
-      }
-    }
+  for (auto *arg : args.filtered(OPT_one_line_on_crash)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, false,
+                                    error);
+    if (error.Fail())
+      return error;
+
+  for (auto *arg : args.filtered(OPT_source)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, true,
+                                    error);
+    if (error.Fail())
+      return error;
+
+  for (auto *arg : args.filtered(OPT_source_before_file)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, true,
+                                    error);
+    if (error.Fail())
+
+  for (auto *arg : args.filtered(OPT_one_line)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, false,
+                                    error);
+    if (error.Fail())
+      return error;
+
+  for (auto *arg : args.filtered(OPT_one_line_before_file)) {
+    auto optarg = arg->getValue();
+    m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, false,
+                                    error);
+    if (error.Fail())
+      return error;
   }
 
-  if (error.Fail() || m_option_data.m_print_help) {
-    ShowUsage(out_fh, m_option_data);
-    exiting = true;
-  } else if (m_option_data.m_print_version) {
+  if (m_option_data.m_process_name.empty() &&
+      m_option_data.m_process_pid == LLDB_INVALID_PROCESS_ID) {
+
+    // If a file was specified with -f then the filename is already in the
+    // m_option_data.m_args array, and any remaining args are arguments for the
+    // inferior program. If no file was specified with -f, then what is left is
+    // the program name followed by any arguments.
+    if (auto remaining = args.getLastArg(OPT_remaining)) {
+      auto index = remaining->getIndex() + 1;
+      auto end = args.getNumInputArgStrings();
+      while (index < end) {
+        m_option_data.m_args.push_back(args.getArgString(index++));
+      }
+    }
+
+  } else {
+    if (args.getLastArgNoClaim()) {
+      ::fprintf(out_fh,
+                "Warning: program arguments are ignored when attaching.\n");
+    }
+  }
+
+  if (m_option_data.m_print_version) {
     ::fprintf(out_fh, "%s\n", m_debugger.GetVersionString());
     exiting = true;
-  } else if (m_option_data.m_print_python_path) {
+    return error;
+  }
+
+  if (m_option_data.m_print_python_path) {
     SBFileSpec python_file_spec = SBHostOS::GetLLDBPythonPath();
     if (python_file_spec.IsValid()) {
       char python_path[PATH_MAX];
       size_t num_chars = python_file_spec.GetPath(python_path, PATH_MAX);
       if (num_chars < PATH_MAX) {
         ::fprintf(out_fh, "%s\n", python_path);
       } else
         ::fprintf(out_fh, "<PATH TOO LONG>\n");
     } else
       ::fprintf(out_fh, "<COULD NOT FIND PATH>\n");
     exiting = true;
-  } else if (m_option_data.m_process_name.empty() &&
-             m_option_data.m_process_pid == LLDB_INVALID_PROCESS_ID) {
-    // Any arguments that are left over after option parsing are for
-    // the program. If a file was specified with -f then the filename
-    // is already in the m_option_data.m_args array, and any remaining args
-    // are arguments for the inferior program. If no file was specified with
-    // -f, then what is left is the program name followed by any arguments.
-
-    // Skip any options we consumed with getopt_long_only
-    argc -= optind;
-    argv += optind;
-
-    if (argc > 0) {
-      for (int arg_idx = 0; arg_idx < argc; ++arg_idx) {
-        const char *arg = argv[arg_idx];
-        if (arg)
-          m_option_data.m_args.push_back(arg);
-      }
-    }
-
-  } else {
-    // Skip any options we consumed with getopt_long_only
-    argc -= optind;
-
-    if (argc > 0)
-      ::fprintf(out_fh,
-                "Warning: program arguments are ignored when attaching.\n");
+    return error;
   }
 
   return error;
 }
 
 static ::FILE *PrepareCommandsForSourcing(const char *commands_data,
                                           size_t commands_size, int fds[2]) {
   enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE

 int
 #ifdef _MSC_VER
 wmain(int argc, wchar_t const *wargv[])
 #else
 main(int argc, char const *argv[])
 #endif
 {
 #ifdef _MSC_VER
   // Convert wide arguments to UTF-8
   std::vector<std::string> argvStrings(argc);
   std::vector<const char *> argvPointers(argc);
   for (int i = 0; i != argc; ++i) {
     llvm::convertWideToUTF8(wargv[i], argvStrings[i]);
     argvPointers[i] = argvStrings[i].c_str();
   }
   const char **argv = argvPointers.data();
 #endif
 
+  // Print stack trace on crash.
   llvm::StringRef ToolName = argv[0];
   llvm::sys::PrintStackTraceOnErrorSignal(ToolName);
   llvm::PrettyStackTraceProgram X(argc, argv);
 
-  SBDebugger::Initialize();
+  // Parse arguments.
+  LLDBOptTable T;
+  unsigned MAI, MAC;
+  ArrayRef<const char *> arg_arr = makeArrayRef(argv + 1, argc - 1);
+  opt::InputArgList input_args = T.ParseArgs(arg_arr, MAI, MAC);
+
+  if (input_args.hasArg(OPT_help)) {
+    std::string usage = std::string(argv[0]) + " [options]";
+    T.PrintHelp(llvm::outs(), usage.c_str(), "LLDB", false);
+    return 0;
+  }
 
+  SBDebugger::Initialize();
   SBHostOS::ThreadCreated("<lldb.driver.main-thread>");
 
   signal(SIGINT, sigint_handler);
 #if !defined(_MSC_VER)
   signal(SIGPIPE, SIG_IGN);
   signal(SIGWINCH, sigwinch_handler);
   signal(SIGTSTP, sigtstp_handler);
   signal(SIGCONT, sigcont_handler);
 #endif
 
   int exit_code = 0;
   // Create a scope for driver so that the driver object will destroy itself
   // before SBDebugger::Terminate() is called.
   {
     Driver driver;
 
     bool exiting = false;
-    SBError error(driver.ParseArgs(argc, argv, stdout, exiting));
+    SBError error(driver.ProcessArgs(input_args, stdout, exiting));
     if (error.Fail()) {
       exit_code = 1;
       const char *error_cstr = error.GetCString();
       if (error_cstr)
         ::fprintf(stderr, "error: %s\n", error_cstr);
     } else if (!exiting) {
       exit_code = driver.MainLoop();
     }
   }
 
   SBDebugger::Terminate();
   return exit_code;
 }

tools/driver/Options.td

+include "llvm/Option/OptParser.td"
+
+class F<string name>: Flag<["--", "-"], name>;
+class S<string name>: Separate<["--", "-"], name>;
+
+def version: F<"version">,
+  HelpText<"Prints out the current version number of the LLDB debugger.">;
+def: Flag<["-"], "v">, Alias<version>, HelpText<"Alias for --version">;
+
+def help: F<"help">,
+  HelpText<"Prints out the usage information for the LLDB debugger.">;
+def: Flag<["-"], "h">, Alias<help>, HelpText<"Alias for --help">;
+
+def python_path: F<"python-path">,
+  HelpText<"Prints out the path to the lldb.py file for this version of lldb.">;
+def: Flag<["-"], "P">, Alias<python_path>, HelpText<"Alias for --python-path">;
+
+def batch: F<"batch">,
+  HelpText<"Tells the debugger to run the commands from -s, -S, -o & -O, and then quit.">;
+def: Flag<["-"], "b">, Alias<batch>, HelpText<"Alias for --batch">;
+
+def core: F<"core">,
+  HelpText<"Tells the debugger to use the full path to <core> as the core file.">;
+def: Flag<["-"], "c">, Alias<core>, HelpText<"Alias for --core">;
+
+def editor: F<"editor">,
+  HelpText<"Tells the debugger to open source files using the host's \"external editor\" mechanism.">;
+def: Flag<["-"], "e">, Alias<editor>, HelpText<"Alias for --editor">;
+
+def no_lldbinit: F<"no-lldbinit">,
+  HelpText<"Do not automatically parse any '.lldbinit' files.">;
+def: Flag<["-"], "x">, Alias<no_lldbinit>, HelpText<"Alias for --no-lldbinit">;
+
+def no_use_colors: F<"no-use-colors">,
+  HelpText<"Do not use colors.">;
+def: Flag<["-"], "X">, Alias<no_use_colors>, HelpText<"Alias for --no-use-color">;
+
+def file: Separate<["--", "-"], "file">, MetaVarName<"<filename>">,
+  HelpText<"Tells the debugger to use the file <filename> as the program to be debugged.">;
+def: Separate<["-"], "f">, Alias<file>, HelpText<"Alias for --file">;
+
+def arch: Separate<["--", "-"], "arch">, MetaVarName<"<architecture>">,
+  HelpText<"Tells the debugger to use the specified architecture when starting and running the program.">;
+def: Separate<["-"], "a">, Alias<arch>, HelpText<"Alias for --arch">;
+
+def script_language: Separate<["--", "-"], "script-language">, MetaVarName<"<language>">,
+  HelpText<"Tells the debugger to use the specified scripting language for user-defined scripts.">;
+def: Separate<["-"], "l">, Alias<script_language>, HelpText<"Alias for --script-language">;
+
+def debug: F<"debug">,
+  HelpText<"Tells the debugger to print out extra information for debugging itself.">;
+def: Flag<["-"], "d">, Alias<debug>, HelpText<"Alias for --debug">;
+
+def reproducer: Separate<["--", "-"], "reproducer">, MetaVarName<"<filename>">,
+  HelpText<"Tells the debugger to use the fullpath to <filename> as a reproducer.">;
+def: Separate<["-"], "z">, Alias<file>, HelpText<"Alias for --reproducer">;
+
+def source_quietly: F<"source-quietly">,
+  HelpText<"Tells the debugger to execute this one-line lldb command before any file has been loaded.">;
+def: Flag<["-"], "Q">, Alias<source_quietly>, HelpText<"Alias for --source-quietly">;
+
+def attach_name: Separate<["--", "-"], "attach-name">, MetaVarName<"<name>">,
+  HelpText<"Tells the debugger to attach to a process with the given name.">;
+def: Separate<["-"], "n">, Alias<attach_name>, HelpText<"Alias for --attach-name">;
+
+def wait_for: F<"wait-for">,
+  HelpText<"Tells the debugger to wait for a process with the given pid or name to launch before attaching.">;
+def: Flag<["-"], "w">, Alias<source_quietly>, HelpText<"Alias for --wait-for">;
+
+def attach_pid: Separate<["--", "-"], "attach-pid">, MetaVarName<"<pid>">,
+  HelpText<"Tells the debugger to attach to a process with the given pid.">;
+def: Separate<["-"], "p">, Alias<attach_pid>, HelpText<"Alias for --attach-pid">;
+
+def repl: Separate<["--", "-"], "repl">,
+  HelpText<"Runs lldb in REPL mode with a stub process.">;
+def: Separate<["-"], "r">, Alias<repl>, HelpText<"Alias for --repl">;
+
+def repl_language: Separate<["--", "-"], "repl-language">, MetaVarName<"<language>">,
+  HelpText<"Chooses the language for the REPL.">;
+def: Separate<["-"], "R">, Alias<repl_language>, HelpText<"Alias for --repl-language">;
+
+def source_on_crash: Separate<["--", "-"], "source-on-crash">, MetaVarName<"<file>">,
+  HelpText<"When in batch mode, tells the debugger to source this file of lldb commands if the target crashes.">;
+def: Separate<["-"], "K">, Alias<source_on_crash>, HelpText<"Alias for --source-on-crash">;
+
+def one_line_on_crash: Separate<["--", "-"], "one-line-on-crash">, MetaVarName<"<command>">,
+  HelpText<"When in batch mode, tells the debugger to source this file of lldb commands if the target crashes.">;
+def: Separate<["-"], "k">, Alias<one_line_on_crash>, HelpText<"Alias for --one-line-on-crash">;
+
+def source: Separate<["--", "-"], "source">, MetaVarName<"<file>">,
+  HelpText<"Tells the debugger to read in and execute the lldb commands in the given file, after any file has been loaded.">;
+def: Separate<["-"], "s">, Alias<source>, HelpText<"Alias for --source">;
+
+def source_before_file: Separate<["--", "-"], "source-before-file">, MetaVarName<"<file>">,
+  HelpText<"Tells the debugger to read in and execute the lldb commands in the given file, before any file has been loaded.">;
+def: Separate<["-"], "S">, Alias<source_before_file>, HelpText<"Alias for --source-before-file">;
+
+def one_line: Separate<["--", "-"], "one-line">, MetaVarName<"<command>">,
+  HelpText<"Tells the debugger to execute this one-line lldb command after any file provided on the command line has been loaded.">;
+def: Separate<["-"], "o">, Alias<one_line>, HelpText<"Alias for --one-line">;
+
+def one_line_before_file: Separate<["--", "-"], "one-line-before-file">, MetaVarName<"<command>">,
+  HelpText<"Tells the debugger to execute this one-line lldb command before any file provided on the command line has been loaded.">;
+def: Separate<["-"], "O">, Alias<one_line_before_file>, HelpText<"Alias for --one-line-before-file">;
+
+def remaining : Flag<["--"], "">;