path: root/lldb/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 <thread>
#include <utility>

#if !defined(__APPLE__)
#include "llvm/Support/DataTypes.h"
#endif

using namespace lldb;

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_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;
}

Driver::~Driver() { g_driver = NULL; }

// This function takes INDENT, which tells how many spaces to output at the
// front
// of each line; TEXT, which is the text that is to be output. It outputs the
// text, on multiple lines if necessary, to RESULT, with INDENT spaces at the
// front of each line.  It breaks lines on spaces, tabs or newlines, shortening
// the line if necessary to not break in the middle of a word. It assumes that
// each output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.

void OutputFormattedUsageText(FILE *out, int indent, const char *text,
                              int output_max_columns) {
  int len = strlen(text);
  std::string text_string(text);

  // Force indentation to be reasonable.
  if (indent >= output_max_columns)
    indent = 0;

  // Will it all fit on one line?

  if (len + indent < output_max_columns)
    // Output as a single line
    fprintf(out, "%*s%s\n", indent, "", text);
  else {
    // We need to break it up into multiple lines.
    int text_width = output_max_columns - indent - 1;
    int start = 0;
    int end = start;
    int final_end = len;
    int sub_len;

    while (end < final_end) {
      // Dont start the 'text' on a space, since we're already outputting the
      // indentation.
      while ((start < final_end) && (text[start] == ' '))
        start++;

      end = start + text_width;
      if (end > final_end)
        end = final_end;
      else {
        // If we're not at the end of the text, make sure we break the line on
        // white space.
        while (end > start && text[end] != ' ' && text[end] != '\t' &&
               text[end] != '\n')
          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() {}

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 there is a local .lldbinit, add that to the
  // list of things to be sourced, if the settings
  // permit it.
  SBFileSpec local_lldbinit(".lldbinit", true);

  SBFileSpec homedir_dot_lldb = SBHostOS::GetUserHomeDirectory();
  homedir_dot_lldb.AppendPathComponent(".lldbinit");

  // Only read .lldbinit in the current working directory
  // if it's not the same as the .lldbinit in the home
  // directory (which is already being read in).
  if (local_lldbinit.Exists() &&
      strcmp(local_lldbinit.GetDirectory(), homedir_dot_lldb.GetDirectory()) !=
          0) {
    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,
                                           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);
    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);
  } 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())
    return NULL;
  return m_option_data.m_args.front().c_str();
}

const char *Driver::GetCrashLogFilename() const {
  if (m_option_data.m_crash_log.empty())
    return NULL;
  return m_option_data.m_crash_log.c_str();
}

lldb::ScriptLanguage Driver::GetScriptLanguage() const {
  return m_option_data.m_script_lang;
}

void Driver::WriteCommandsForSourcing(CommandPlacement placement,
                                      SBStream &strm) {
  std::vector<OptionData::InitialCmdEntry> *command_set;
  switch (placement) {
  case eCommandPlacementBeforeFile:
    command_set = &m_option_data.m_initial_commands;
    break;
  case eCommandPlacementAfterFile:
    command_set = &m_option_data.m_after_file_commands;
    break;
  case eCommandPlacementAfterCrash:
    command_set = &m_option_data.m_after_crash_commands;
    break;
  }

  for (const auto &command_entry : *command_set) {
    const char *command = command_entry.contents.c_str();
    if (command_entry.is_file) {
      // If this command_entry is a file to be sourced, and it's the ./.lldbinit
      // file (the .lldbinit
      // file in the current working directory), only read it if
      // target.load-cwd-lldbinit is 'true'.
      if (command_entry.is_cwd_lldbinit_file_read) {
        SBStringList strlist = m_debugger.GetInternalVariableValue(
            "target.load-cwd-lldbinit", m_debugger.GetInstanceName());
        if (strlist.GetSize() == 1 &&
            strcmp(strlist.GetStringAtIndex(0), "warn") == 0) {
          FILE *output = m_debugger.GetOutputFileHandle();
          ::fprintf(
              output,
              "There is a .lldbinit file in the current directory which is not "
              "being read.\n"
              "To silence this warning without sourcing in the local "
              ".lldbinit,\n"
              "add the following to the lldbinit file in your home directory:\n"
              "    settings set target.load-cwd-lldbinit false\n"
              "To allow lldb to source .lldbinit files in the current working "
              "directory,\n"
              "set the value of this variable to true.  Only do so if you "
              "understand and\n"
              "accept the security risk.\n");
          return;
        }
        if (strlist.GetSize() == 1 &&
            strcmp(strlist.GetStringAtIndex(0), "false") == 0) {
          return;
        }
      }
      bool source_quietly =
          m_option_data.m_source_quietly || command_entry.source_quietly;
      strm.Printf("command source -s %i '%s'\n", source_quietly, command);
    } 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,
                          bool &exiting) {
  static_assert(g_num_options > 0, "cannot handle arguments");

  ResetOptionValues();

  // No arguments or just program name, nothing to parse.
  if (argc <= 1)
    return SBError();

  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;
      }
    }
  }

  // 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.

  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;

        case 'P':
          m_option_data.m_print_python_path = true;
          break;

        case 'b':
          m_option_data.m_batch = true;
          break;

        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;

        case 'e':
          m_option_data.m_use_external_editor = true;
          break;

        case 'x':
          m_debugger.SkipLLDBInitFiles(true);
          m_debugger.SkipAppInitFiles(true);
          break;

        case 'X':
          m_debugger.SetUseColor(false);
          break;

        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;

        case 'a':
          if (!m_debugger.SetDefaultArchitecture(optarg))
            error.SetErrorStringWithFormat(
                "invalid architecture in the -a or --arch option: '%s'",
                optarg);
          break;

        case 'l':
          m_option_data.m_script_lang = m_debugger.GetScriptingLanguage(optarg);
          break;

        case 'd':
          m_option_data.m_debug_mode = true;
          break;

        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;

        case 'n':
          m_option_data.m_process_name = optarg;
          break;

        case 'w':
          m_option_data.m_wait_for = true;
          break;

        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;

        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;

        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;

        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;
      }
    }
  }

  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) {
    ::fprintf(out_fh, "%s\n", m_debugger.GetVersionString());
    exiting = true;
  } else 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;
}

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

  ::FILE *commands_file = NULL;
  fds[0] = -1;
  fds[1] = -1;
  int err = 0;
#ifdef _WIN32
  err = _pipe(fds, commands_size, O_BINARY);
#else
  err = pipe(fds);
#endif
  if (err == 0) {
    ssize_t nrwr = write(fds[WRITE], commands_data, commands_size);
    if (nrwr < 0) {
      fprintf(stderr, "error: write(%i, %p, %" PRIu64 ") failed (errno = %i) "
                      "when trying to open LLDB commands pipe\n",
              fds[WRITE], static_cast<const void *>(commands_data),
              static_cast<uint64_t>(commands_size), errno);
    } else if (static_cast<size_t>(nrwr) == commands_size) {
// Close the write end of the pipe so when we give the read end to
// the debugger/command interpreter it will exit when it consumes all
// of the data
#ifdef _WIN32
      _close(fds[WRITE]);
      fds[WRITE] = -1;
#else
      close(fds[WRITE]);
      fds[WRITE] = -1;
#endif
      // Now open the read file descriptor in a FILE * that we can give to
      // the debugger as an input handle
      commands_file = fdopen(fds[READ], "r");
      if (commands_file) {
        fds[READ] =
            -1; // The FILE * 'commands_file' now owns the read descriptor
                // Hand ownership if the FILE * over to the debugger for
                // "commands_file".
      } else {
        fprintf(stderr, "error: fdopen(%i, \"r\") failed (errno = %i) when "
                        "trying to open LLDB commands pipe\n",
                fds[READ], errno);
      }
    }
  } else {
    fprintf(stderr,
            "error: can't create pipe file descriptors for LLDB commands\n");
  }

  return commands_file;
}

void CleanupAfterCommandSourcing(int fds[2]) {
  enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE

  // Close any pipes that we still have ownership of
  if (fds[WRITE] != -1) {
#ifdef _WIN32
    _close(fds[WRITE]);
    fds[WRITE] = -1;
#else
    close(fds[WRITE]);
    fds[WRITE] = -1;
#endif
  }

  if (fds[READ] != -1) {
#ifdef _WIN32
    _close(fds[READ]);
    fds[READ] = -1;
#else
    close(fds[READ]);
    fds[READ] = -1;
#endif
  }
}

std::string EscapeString(std::string arg) {
  std::string::size_type pos = 0;
  while ((pos = arg.find_first_of("\"\\", pos)) != std::string::npos) {
    arg.insert(pos, 1, '\\');
    pos += 2;
  }
  return '"' + arg + '"';
}

int Driver::MainLoop() {
  if (::tcgetattr(STDIN_FILENO, &g_old_stdin_termios) == 0) {
    g_old_stdin_termios_is_valid = true;
    atexit(reset_stdin_termios);
  }

#ifndef _MSC_VER
  // Disabling stdin buffering with MSVC's 2015 CRT exposes a bug in fgets
  // which causes it to miss newlines depending on whether there have been an
  // odd or even number of characters.  Bug has been reported to MS via Connect.
  ::setbuf(stdin, NULL);
#endif
  ::setbuf(stdout, NULL);

  m_debugger.SetErrorFileHandle(stderr, false);
  m_debugger.SetOutputFileHandle(stdout, false);
  m_debugger.SetInputFileHandle(stdin,
                                false); // Don't take ownership of STDIN yet...

  m_debugger.SetUseExternalEditor(m_option_data.m_use_external_editor);

  struct winsize window_size;
  if (isatty(STDIN_FILENO) &&
      ::ioctl(STDIN_FILENO, TIOCGWINSZ, &window_size) == 0) {
    if (window_size.ws_col > 0)
      m_debugger.SetTerminalWidth(window_size.ws_col);
  }

  SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter();

  // Before we handle any options from the command line, we parse the
  // .lldbinit file in the user's home directory.
  SBCommandReturnObject result;
  sb_interpreter.SourceInitFileInHomeDirectory(result);
  if (GetDebugMode()) {
    result.PutError(m_debugger.GetErrorFileHandle());
    result.PutOutput(m_debugger.GetOutputFileHandle());
  }

  // We allow the user to specify an exit code when calling quit which we will
  // return when exiting.
  m_debugger.GetCommandInterpreter().AllowExitCodeOnQuit(true);

  // Now we handle options we got from the command line
  SBStream commands_stream;

  // First source in the commands specified to be run before the file arguments
  // are processed.
  WriteCommandsForSourcing(eCommandPlacementBeforeFile, commands_stream);

  const size_t num_args = m_option_data.m_args.size();
  if (num_args > 0) {
    char arch_name[64];
    if (m_debugger.GetDefaultArchitecture(arch_name, sizeof(arch_name)))
      commands_stream.Printf("target create --arch=%s %s", arch_name,
                             EscapeString(m_option_data.m_args[0]).c_str());
    else
      commands_stream.Printf("target create %s",
                             EscapeString(m_option_data.m_args[0]).c_str());

    if (!m_option_data.m_core_file.empty()) {
      commands_stream.Printf(" --core %s",
                             EscapeString(m_option_data.m_core_file).c_str());
    }
    commands_stream.Printf("\n");

    if (num_args > 1) {
      commands_stream.Printf("settings set -- target.run-args ");
      for (size_t arg_idx = 1; arg_idx < num_args; ++arg_idx)
        commands_stream.Printf(
            " %s", EscapeString(m_option_data.m_args[arg_idx]).c_str());
      commands_stream.Printf("\n");
    }
  } else if (!m_option_data.m_core_file.empty()) {
    commands_stream.Printf("target create --core %s\n",
                           EscapeString(m_option_data.m_core_file).c_str());
  } else if (!m_option_data.m_process_name.empty()) {
    commands_stream.Printf("process attach --name %s",
                           EscapeString(m_option_data.m_process_name).c_str());

    if (m_option_data.m_wait_for)
      commands_stream.Printf(" --waitfor");

    commands_stream.Printf("\n");

  } else if (LLDB_INVALID_PROCESS_ID != m_option_data.m_process_pid) {
    commands_stream.Printf("process attach --pid %" PRIu64 "\n",
                           m_option_data.m_process_pid);
  }

  WriteCommandsForSourcing(eCommandPlacementAfterFile, commands_stream);

  if (GetDebugMode()) {
    result.PutError(m_debugger.GetErrorFileHandle());
    result.PutOutput(m_debugger.GetOutputFileHandle());
  }

  bool handle_events = true;
  bool spawn_thread = false;

  if (m_option_data.m_repl) {
    const char *repl_options = NULL;
    if (!m_option_data.m_repl_options.empty())
      repl_options = m_option_data.m_repl_options.c_str();
    SBError error(m_debugger.RunREPL(m_option_data.m_repl_lang, repl_options));
    if (error.Fail()) {
      const char *error_cstr = error.GetCString();
      if (error_cstr && error_cstr[0])
        fprintf(stderr, "error: %s\n", error_cstr);
      else
        fprintf(stderr, "error: %u\n", error.GetError());
    }
  } else {
    // Check if we have any data in the commands stream, and if so, save it to a
    // temp file
    // so we can then run the command interpreter using the file contents.
    const char *commands_data = commands_stream.GetData();
    const size_t commands_size = commands_stream.GetSize();

    // The command file might have requested that we quit, this variable will
    // track that.
    bool quit_requested = false;
    bool stopped_for_crash = false;
    if (commands_data && commands_size) {
      int initial_commands_fds[2];
      bool success = true;
      FILE *commands_file = PrepareCommandsForSourcing(
          commands_data, commands_size, initial_commands_fds);
      if (commands_file) {
        m_debugger.SetInputFileHandle(commands_file, true);

        // Set the debugger into Sync mode when running the command file.
        // Otherwise command files
        // that run the target won't run in a sensible way.
        bool old_async = m_debugger.GetAsync();
        m_debugger.SetAsync(false);
        int num_errors;

        SBCommandInterpreterRunOptions options;
        options.SetStopOnError(true);
        if (m_option_data.m_batch)
          options.SetStopOnCrash(true);

        m_debugger.RunCommandInterpreter(handle_events, spawn_thread, options,
                                         num_errors, quit_requested,
                                         stopped_for_crash);

        if (m_option_data.m_batch && stopped_for_crash &&
            !m_option_data.m_after_crash_commands.empty()) {
          int crash_command_fds[2];
          SBStream crash_commands_stream;
          WriteCommandsForSourcing(eCommandPlacementAfterCrash,
                                   crash_commands_stream);
          const char *crash_commands_data = crash_commands_stream.GetData();
          const size_t crash_commands_size = crash_commands_stream.GetSize();
          commands_file = PrepareCommandsForSourcing(
              crash_commands_data, crash_commands_size, crash_command_fds);
          if (commands_file) {
            bool local_quit_requested;
            bool local_stopped_for_crash;
            m_debugger.SetInputFileHandle(commands_file, true);

            m_debugger.RunCommandInterpreter(
                handle_events, spawn_thread, options, num_errors,
                local_quit_requested, local_stopped_for_crash);
            if (local_quit_requested)
              quit_requested = true;
          }
        }
        m_debugger.SetAsync(old_async);
      } else
        success = false;

      // Close any pipes that we still have ownership of
      CleanupAfterCommandSourcing(initial_commands_fds);

      // Something went wrong with command pipe
      if (!success) {
        exit(1);
      }
    }

    // Now set the input file handle to STDIN and run the command
    // interpreter again in interactive mode and let the debugger
    // take ownership of stdin

    bool go_interactive = true;
    if (quit_requested)
      go_interactive = false;
    else if (m_option_data.m_batch && !stopped_for_crash)
      go_interactive = false;

    if (go_interactive) {
      m_debugger.SetInputFileHandle(stdin, true);
      m_debugger.RunCommandInterpreter(handle_events, spawn_thread);
    }
  }

  reset_stdin_termios();
  fclose(stdin);

  int exit_code = sb_interpreter.GetQuitStatus();
  SBDebugger::Destroy(m_debugger);
  return exit_code;
}

void Driver::ResizeWindow(unsigned short col) {
  GetDebugger().SetTerminalWidth(col);
}

void sigwinch_handler(int signo) {
  struct winsize window_size;
  if (isatty(STDIN_FILENO) &&
      ::ioctl(STDIN_FILENO, TIOCGWINSZ, &window_size) == 0) {
    if ((window_size.ws_col > 0) && g_driver != NULL) {
      g_driver->ResizeWindow(window_size.ws_col);
    }
  }
}

void sigint_handler(int signo) {
  static std::atomic_flag g_interrupt_sent = ATOMIC_FLAG_INIT;
  if (g_driver) {
    if (!g_interrupt_sent.test_and_set()) {
      g_driver->GetDebugger().DispatchInputInterrupt();
      g_interrupt_sent.clear();
      return;
    }
  }

  _exit(signo);
}

void sigtstp_handler(int signo) {
  if (g_driver)
    g_driver->GetDebugger().SaveInputTerminalState();

  signal(signo, SIG_DFL);
  kill(getpid(), signo);
  signal(signo, sigtstp_handler);
}

void sigcont_handler(int signo) {
  if (g_driver)
    g_driver->GetDebugger().RestoreInputTerminalState();

  signal(signo, SIG_DFL);
  kill(getpid(), signo);
  signal(signo, sigcont_handler);
}

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

  llvm::StringRef ToolName = argv[0];
  llvm::sys::PrintStackTraceOnErrorSignal(ToolName);
  llvm::PrettyStackTraceProgram X(argc, argv);

  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));
    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;
}