contrib/llvm/tools/lldb/tools/driver/Driver.cpp

   1 //===-- Driver.cpp ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Driver.h"
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <limits.h>
  16 #include <fcntl.h>
  17
  18 // Includes for pipe()
  19 #if defined(_WIN32)
  20 #include <io.h>
  21 #include <fcntl.h>
  22 #elif defined(__ANDROID_NDK__)
  23 #include <errno.h>
  24 #else
  25 #include <unistd.h>
  26 #endif
  27
  28 #include <string>
  29
  30 #include <thread>
  31 #include "lldb/API/SBBreakpoint.h"
  32 #include "lldb/API/SBCommandInterpreter.h"
  33 #include "lldb/API/SBCommandReturnObject.h"
  34 #include "lldb/API/SBCommunication.h"
  35 #include "lldb/API/SBDebugger.h"
  36 #include "lldb/API/SBEvent.h"
  37 #include "lldb/API/SBHostOS.h"
  38 #include "lldb/API/SBListener.h"
  39 #include "lldb/API/SBStream.h"
  40 #include "lldb/API/SBTarget.h"
  41 #include "lldb/API/SBThread.h"
  42 #include "lldb/API/SBProcess.h"
  43
  44 #if !defined(__APPLE__)
  45 #include "llvm/Support/DataTypes.h"
  46 #endif
  47
  48 using namespace lldb;
  49
  50 static void reset_stdin_termios ();
  51 static bool g_old_stdin_termios_is_valid = false;
  52 static struct termios g_old_stdin_termios;
  53
  54 static char *g_debugger_name =  (char *) "";
  55 static Driver *g_driver = NULL;
  56
  57 // In the Driver::MainLoop, we change the terminal settings.  This function is
  58 // added as an atexit handler to make sure we clean them up.
  59 static void
  60 reset_stdin_termios ()
  61 {
  62     if (g_old_stdin_termios_is_valid)
  63     {
  64         g_old_stdin_termios_is_valid = false;
  65         ::tcsetattr (STDIN_FILENO, TCSANOW, &g_old_stdin_termios);
  66     }
  67 }
  68
  69 typedef struct
  70 {
  71     uint32_t usage_mask;                     // Used to mark options that can be used together.  If (1 << n & usage_mask) != 0
  72                                              // then this option belongs to option set n.
  73     bool required;                           // This option is required (in the current usage level)
  74     const char * long_option;                // Full name for this option.
  75     int short_option;                        // Single character for this option.
  76     int option_has_arg;                      // no_argument, required_argument or optional_argument
  77     uint32_t completion_type;                // Cookie the option class can use to do define the argument completion.
  78     lldb::CommandArgumentType argument_type; // Type of argument this option takes
  79     const char *  usage_text;                // Full text explaining what this options does and what (if any) argument to
  80                                              // pass it.
  81 } OptionDefinition;
  82
  83 #define LLDB_3_TO_5 LLDB_OPT_SET_3|LLDB_OPT_SET_4|LLDB_OPT_SET_5
  84 #define LLDB_4_TO_5 LLDB_OPT_SET_4|LLDB_OPT_SET_5
  85
  86 static OptionDefinition g_options[] =
  87 {
  88     { LLDB_OPT_SET_1,    true , "help"           , 'h', no_argument      , 0,  eArgTypeNone,
  89         "Prints out the usage information for the LLDB debugger." },
  90     { LLDB_OPT_SET_2,    true , "version"        , 'v', no_argument      , 0,  eArgTypeNone,
  91         "Prints out the current version number of the LLDB debugger." },
  92     { LLDB_OPT_SET_3,    true , "arch"           , 'a', required_argument, 0,  eArgTypeArchitecture,
  93         "Tells the debugger to use the specified architecture when starting and running the program.  <architecture> must "
  94         "be one of the architectures for which the program was compiled." },
  95     { LLDB_OPT_SET_3,    true , "file"           , 'f', required_argument, 0,  eArgTypeFilename,
  96         "Tells the debugger to use the file <filename> as the program to be debugged." },
  97     { LLDB_OPT_SET_3,    false, "core"           , 'c', required_argument, 0,  eArgTypeFilename,
  98         "Tells the debugger to use the fullpath to <path> as the core file." },
  99     { LLDB_OPT_SET_5,    true , "attach-pid"     , 'p', required_argument, 0,  eArgTypePid,
 100         "Tells the debugger to attach to a process with the given pid." },
 101     { LLDB_OPT_SET_4,    true , "attach-name"    , 'n', required_argument, 0,  eArgTypeProcessName,
 102         "Tells the debugger to attach to a process with the given name." },
 103     { LLDB_OPT_SET_4,    true , "wait-for"       , 'w', no_argument      , 0,  eArgTypeNone,
 104         "Tells the debugger to wait for a process with the given pid or name to launch before attaching." },
 105     { LLDB_3_TO_5,       false, "source"         , 's', required_argument, 0,  eArgTypeFilename,
 106         "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." },
 107     { LLDB_3_TO_5,       false, "one-line"         , 'o', required_argument, 0,  eArgTypeNone,
 108         "Tells the debugger to execute this one-line lldb command after any file provided on the command line has been loaded." },
 109     { LLDB_3_TO_5,       false, "source-before-file"         , 'S', required_argument, 0,  eArgTypeFilename,
 110         "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." },
 111     { LLDB_3_TO_5,       false, "one-line-before-file"         , 'O', required_argument, 0,  eArgTypeNone,
 112         "Tells the debugger to execute this one-line lldb command before any file provided on the command line has been loaded." },
 113     { LLDB_3_TO_5,       false, "one-line-on-crash"         , 'k', required_argument, 0,  eArgTypeNone,
 114         "When in batch mode, tells the debugger to execute this one-line lldb command if the target crashes." },
 115     { LLDB_3_TO_5,       false, "source-on-crash"         , 'K', required_argument, 0,  eArgTypeFilename,
 116         "When in batch mode, tells the debugger to source this file of lldb commands if the target crashes." },
 117     { LLDB_3_TO_5,       false, "source-quietly"          , 'Q', no_argument      , 0,  eArgTypeNone,
 118         "Tells the debugger to execute this one-line lldb command before any file provided on the command line has been loaded." },
 119     { LLDB_3_TO_5,       false, "batch"          , 'b', no_argument      , 0,  eArgTypeNone,
 120         "Tells the debugger to running the commands from -s, -S, -o & -O, and then quit.  However if any run command stopped due to a signal or crash, "
 121         "the debugger will return to the interactive prompt at the place of the crash." },
 122     { LLDB_3_TO_5,       false, "editor"         , 'e', no_argument      , 0,  eArgTypeNone,
 123         "Tells the debugger to open source files using the host's \"external editor\" mechanism." },
 124     { LLDB_3_TO_5,       false, "no-lldbinit"    , 'x', no_argument      , 0,  eArgTypeNone,
 125         "Do not automatically parse any '.lldbinit' files." },
 126     { LLDB_3_TO_5,       false, "no-use-colors"  , 'X', no_argument      , 0,  eArgTypeNone,
 127         "Do not use colors." },
 128     { LLDB_OPT_SET_6,    true , "python-path"    , 'P', no_argument      , 0,  eArgTypeNone,
 129         "Prints out the path to the lldb.py file for this version of lldb." },
 130     { LLDB_3_TO_5,       false, "script-language", 'l', required_argument, 0,  eArgTypeScriptLang,
 131         "Tells the debugger to use the specified scripting language for user-defined scripts, rather than the default.  "
 132         "Valid scripting languages that can be specified include Python, Perl, Ruby and Tcl.  Currently only the Python "
 133         "extensions have been implemented." },
 134     { LLDB_3_TO_5,       false, "debug"          , 'd', no_argument      , 0,  eArgTypeNone,
 135         "Tells the debugger to print out extra information for debugging itself." },
 136     { 0,                 false, NULL             , 0  , 0                , 0,  eArgTypeNone,         NULL }
 137 };
 138
 139 static const uint32_t last_option_set_with_args = 2;
 140
 141 Driver::Driver () :
 142     SBBroadcaster ("Driver"),
 143     m_debugger (SBDebugger::Create(false)),
 144     m_option_data ()
 145 {
 146     // We want to be able to handle CTRL+D in the terminal to have it terminate
 147     // certain input
 148     m_debugger.SetCloseInputOnEOF (false);
 149     g_debugger_name = (char *) m_debugger.GetInstanceName();
 150     if (g_debugger_name == NULL)
 151         g_debugger_name = (char *) "";
 152     g_driver = this;
 153 }
 154
 155 Driver::~Driver ()
 156 {
 157     g_driver = NULL;
 158     g_debugger_name = NULL;
 159 }
 160
 161
 162 // This function takes INDENT, which tells how many spaces to output at the front
 163 // of each line; TEXT, which is the text that is to be output. It outputs the
 164 // text, on multiple lines if necessary, to RESULT, with INDENT spaces at the
 165 // front of each line.  It breaks lines on spaces, tabs or newlines, shortening
 166 // the line if necessary to not break in the middle of a word. It assumes that
 167 // each output line should contain a maximum of OUTPUT_MAX_COLUMNS characters.
 168
 169 void
 170 OutputFormattedUsageText (FILE *out, int indent, const char *text, int output_max_columns)
 171 {
 172     int len = strlen (text);
 173     std::string text_string (text);
 174
 175     // Force indentation to be reasonable.
 176     if (indent >= output_max_columns)
 177         indent = 0;
 178
 179     // Will it all fit on one line?
 180
 181     if (len + indent < output_max_columns)
 182         // Output as a single line
 183         fprintf (out, "%*s%s\n", indent, "", text);
 184     else
 185     {
 186         // We need to break it up into multiple lines.
 187         int text_width = output_max_columns - indent - 1;
 188         int start = 0;
 189         int end = start;
 190         int final_end = len;
 191         int sub_len;
 192
 193         while (end < final_end)
 194         {
 195               // Dont start the 'text' on a space, since we're already outputting the indentation.
 196               while ((start < final_end) && (text[start] == ' '))
 197                   start++;
 198
 199               end = start + text_width;
 200               if (end > final_end)
 201                   end = final_end;
 202               else
 203               {
 204                   // If we're not at the end of the text, make sure we break the line on white space.
 205                   while (end > start
 206                          && text[end] != ' ' && text[end] != '\t' && text[end] != '\n')
 207                       end--;
 208               }
 209               sub_len = end - start;
 210               std::string substring = text_string.substr (start, sub_len);
 211               fprintf (out, "%*s%s\n", indent, "", substring.c_str());
 212               start = end + 1;
 213         }
 214     }
 215 }
 216
 217 void
 218 ShowUsage (FILE *out, OptionDefinition *option_table, Driver::OptionData data)
 219 {
 220     uint32_t screen_width = 80;
 221     uint32_t indent_level = 0;
 222     const char *name = "lldb";
 223
 224     fprintf (out, "\nUsage:\n\n");
 225
 226     indent_level += 2;
 227
 228
 229     // First, show each usage level set of options, e.g. <cmd> [options-for-level-0]
 230     //                                                   <cmd> [options-for-level-1]
 231     //                                                   etc.
 232
 233     uint32_t num_options;
 234     uint32_t num_option_sets = 0;
 235
 236     for (num_options = 0; option_table[num_options].long_option != NULL; ++num_options)
 237     {
 238         uint32_t this_usage_mask = option_table[num_options].usage_mask;
 239         if (this_usage_mask == LLDB_OPT_SET_ALL)
 240         {
 241             if (num_option_sets == 0)
 242                 num_option_sets = 1;
 243         }
 244         else
 245         {
 246             for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++)
 247             {
 248                 if (this_usage_mask & 1 << j)
 249                 {
 250                     if (num_option_sets <= j)
 251                         num_option_sets = j + 1;
 252                 }
 253             }
 254         }
 255     }
 256
 257     for (uint32_t opt_set = 0; opt_set < num_option_sets; opt_set++)
 258     {
 259         uint32_t opt_set_mask;
 260
 261         opt_set_mask = 1 << opt_set;
 262
 263         if (opt_set > 0)
 264             fprintf (out, "\n");
 265         fprintf (out, "%*s%s", indent_level, "", name);
 266         bool is_help_line = false;
 267
 268         for (uint32_t i = 0; i < num_options; ++i)
 269         {
 270             if (option_table[i].usage_mask & opt_set_mask)
 271             {
 272                 CommandArgumentType arg_type = option_table[i].argument_type;
 273                 const char *arg_name = SBCommandInterpreter::GetArgumentTypeAsCString (arg_type);
 274                 // This is a bit of a hack, but there's no way to say certain options don't have arguments yet...
 275                 // so we do it by hand here.
 276                 if (option_table[i].short_option == 'h')
 277                     is_help_line = true;
 278
 279                 if (option_table[i].required)
 280                 {
 281                     if (option_table[i].option_has_arg == required_argument)
 282                         fprintf (out, " -%c <%s>", option_table[i].short_option, arg_name);
 283                     else if (option_table[i].option_has_arg == optional_argument)
 284                         fprintf (out, " -%c [<%s>]", option_table[i].short_option, arg_name);
 285                     else
 286                         fprintf (out, " -%c", option_table[i].short_option);
 287                 }
 288                 else
 289                 {
 290                     if (option_table[i].option_has_arg == required_argument)
 291                         fprintf (out, " [-%c <%s>]", option_table[i].short_option, arg_name);
 292                     else if (option_table[i].option_has_arg == optional_argument)
 293                         fprintf (out, " [-%c [<%s>]]", option_table[i].short_option, arg_name);
 294                     else
 295                         fprintf (out, " [-%c]", option_table[i].short_option);
 296                 }
 297             }
 298         }
 299         if (!is_help_line && (opt_set <= last_option_set_with_args))
 300             fprintf (out, " [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]]");
 301     }
 302
 303     fprintf (out, "\n\n");
 304
 305     // Now print out all the detailed information about the various options:  long form, short form and help text:
 306     //   -- long_name <argument>
 307     //   - short <argument>
 308     //   help text
 309
 310     // This variable is used to keep track of which options' info we've printed out, because some options can be in
 311     // more than one usage level, but we only want to print the long form of its information once.
 312
 313     Driver::OptionData::OptionSet options_seen;
 314     Driver::OptionData::OptionSet::iterator pos;
 315
 316     indent_level += 5;
 317
 318     for (uint32_t i = 0; i < num_options; ++i)
 319     {
 320         // Only print this option if we haven't already seen it.
 321         pos = options_seen.find (option_table[i].short_option);
 322         if (pos == options_seen.end())
 323         {
 324             CommandArgumentType arg_type = option_table[i].argument_type;
 325             const char *arg_name = SBCommandInterpreter::GetArgumentTypeAsCString (arg_type);
 326
 327             options_seen.insert (option_table[i].short_option);
 328             fprintf (out, "%*s-%c ", indent_level, "", option_table[i].short_option);
 329             if (arg_type != eArgTypeNone)
 330                 fprintf (out, "<%s>", arg_name);
 331             fprintf (out, "\n");
 332             fprintf (out, "%*s--%s ", indent_level, "", option_table[i].long_option);
 333             if (arg_type != eArgTypeNone)
 334                 fprintf (out, "<%s>", arg_name);
 335             fprintf (out, "\n");
 336             indent_level += 5;
 337             OutputFormattedUsageText (out, indent_level, option_table[i].usage_text, screen_width);
 338             indent_level -= 5;
 339             fprintf (out, "\n");
 340         }
 341     }
 342
 343     indent_level -= 5;
 344
 345     fprintf (out, "\n%*sNotes:\n",
 346              indent_level, "");
 347     indent_level += 5;
 348
 349     fprintf (out, "\n%*sMultiple \"-s\" and \"-o\" options can be provided.  They will be processed from left to right in order, "
 350                   "\n%*swith the source files and commands interleaved.  The same is true of the \"-S\" and \"-O\" options."
 351                   "\n%*sThe before file and after file sets can intermixed freely, the command parser will sort them out."
 352                   "\n%*sThe order of the file specifiers (\"-c\", \"-f\", etc.) is not significant in this regard.\n\n",
 353              indent_level, "",
 354              indent_level, "",
 355              indent_level, "",
 356              indent_level, "");
 357
 358     fprintf (out, "\n%*sIf you don't provide -f then the first argument will be the file to be debugged"
 359                   "\n%*swhich means that '%s -- <filename> [<ARG1> [<ARG2>]]' also works."
 360                   "\n%*sBut remember to end the options with \"--\" if any of your arguments have a \"-\" in them.\n\n",
 361              indent_level, "",
 362              indent_level, "",
 363              name,
 364              indent_level, "");
 365 }
 366
 367 void
 368 BuildGetOptTable (OptionDefinition *expanded_option_table, std::vector<struct option> &getopt_table,
 369                   uint32_t num_options)
 370 {
 371     if (num_options == 0)
 372         return;
 373
 374     uint32_t i;
 375     uint32_t j;
 376     std::bitset<256> option_seen;
 377
 378     getopt_table.resize (num_options + 1);
 379
 380     for (i = 0, j = 0; i < num_options; ++i)
 381     {
 382         char short_opt = expanded_option_table[i].short_option;
 383
 384         if (option_seen.test(short_opt) == false)
 385         {
 386             getopt_table[j].name    = expanded_option_table[i].long_option;
 387             getopt_table[j].has_arg = expanded_option_table[i].option_has_arg;
 388             getopt_table[j].flag    = NULL;
 389             getopt_table[j].val     = expanded_option_table[i].short_option;
 390             option_seen.set(short_opt);
 391             ++j;
 392         }
 393     }
 394
 395     getopt_table[j].name    = NULL;
 396     getopt_table[j].has_arg = 0;
 397     getopt_table[j].flag    = NULL;
 398     getopt_table[j].val     = 0;
 399
 400 }
 401
 402 Driver::OptionData::OptionData () :
 403     m_args(),
 404     m_script_lang (lldb::eScriptLanguageDefault),
 405     m_core_file (),
 406     m_crash_log (),
 407     m_initial_commands (),
 408     m_after_file_commands (),
 409     m_after_crash_commands(),
 410     m_debug_mode (false),
 411     m_source_quietly(false),
 412     m_print_version (false),
 413     m_print_python_path (false),
 414     m_print_help (false),
 415     m_wait_for(false),
 416     m_process_name(),
 417     m_process_pid(LLDB_INVALID_PROCESS_ID),
 418     m_use_external_editor(false),
 419     m_batch(false),
 420     m_seen_options()
 421 {
 422 }
 423
 424 Driver::OptionData::~OptionData ()
 425 {
 426 }
 427
 428 void
 429 Driver::OptionData::Clear ()
 430 {
 431     m_args.clear ();
 432     m_script_lang = lldb::eScriptLanguageDefault;
 433     m_initial_commands.clear ();
 434     m_after_file_commands.clear ();
 435     // If there is a local .lldbinit, source that:
 436     SBFileSpec local_lldbinit("./.lldbinit", true);
 437     if (local_lldbinit.Exists())
 438     {
 439         char path[2048];
 440         local_lldbinit.GetPath(path, 2047);
 441         InitialCmdEntry entry(path, true, true);
 442         m_after_file_commands.push_back (entry);
 443     }
 444
 445     m_debug_mode = false;
 446     m_source_quietly = false;
 447     m_print_help = false;
 448     m_print_version = false;
 449     m_print_python_path = false;
 450     m_use_external_editor = false;
 451     m_wait_for = false;
 452     m_process_name.erase();
 453     m_batch = false;
 454     m_after_crash_commands.clear();
 455
 456     m_process_pid = LLDB_INVALID_PROCESS_ID;
 457 }
 458
 459 void
 460 Driver::OptionData::AddInitialCommand (const char *command, CommandPlacement placement, bool is_file,  bool silent, SBError &error)
 461 {
 462     std::vector<InitialCmdEntry> *command_set;
 463     switch (placement)
 464     {
 465     case eCommandPlacementBeforeFile:
 466         command_set = &(m_initial_commands);
 467         break;
 468     case eCommandPlacementAfterFile:
 469         command_set = &(m_after_file_commands);
 470         break;
 471     case eCommandPlacementAfterCrash:
 472         command_set = &(m_after_crash_commands);
 473         break;
 474     }
 475
 476     if (is_file)
 477     {
 478         SBFileSpec file(command);
 479         if (file.Exists())
 480             command_set->push_back (InitialCmdEntry(command, is_file, silent));
 481         else if (file.ResolveExecutableLocation())
 482         {
 483             char final_path[PATH_MAX];
 484             file.GetPath (final_path, sizeof(final_path));
 485             command_set->push_back (InitialCmdEntry(final_path, is_file, silent));
 486         }
 487         else
 488             error.SetErrorStringWithFormat("file specified in --source (-s) option doesn't exist: '%s'", optarg);
 489     }
 490     else
 491         command_set->push_back (InitialCmdEntry(command, is_file, silent));
 492 }
 493
 494 void
 495 Driver::ResetOptionValues ()
 496 {
 497     m_option_data.Clear ();
 498 }
 499
 500 const char *
 501 Driver::GetFilename() const
 502 {
 503     if (m_option_data.m_args.empty())
 504         return NULL;
 505     return m_option_data.m_args.front().c_str();
 506 }
 507
 508 const char *
 509 Driver::GetCrashLogFilename() const
 510 {
 511     if (m_option_data.m_crash_log.empty())
 512         return NULL;
 513     return m_option_data.m_crash_log.c_str();
 514 }
 515
 516 lldb::ScriptLanguage
 517 Driver::GetScriptLanguage() const
 518 {
 519     return m_option_data.m_script_lang;
 520 }
 521
 522 void
 523 Driver::WriteCommandsForSourcing (CommandPlacement placement, SBStream &strm)
 524 {
 525     std::vector<OptionData::InitialCmdEntry> *command_set;
 526     switch (placement)
 527     {
 528     case eCommandPlacementBeforeFile:
 529         command_set = &m_option_data.m_initial_commands;
 530         break;
 531     case eCommandPlacementAfterFile:
 532         command_set = &m_option_data.m_after_file_commands;
 533         break;
 534     case eCommandPlacementAfterCrash:
 535         command_set = &m_option_data.m_after_crash_commands;
 536         break;
 537     }
 538
 539     for (const auto &command_entry : *command_set)
 540     {
 541         const char *command = command_entry.contents.c_str();
 542         if (command_entry.is_file)
 543         {
 544             bool source_quietly = m_option_data.m_source_quietly || command_entry.source_quietly;
 545             strm.Printf("command source -s %i '%s'\n", source_quietly, command);
 546         }
 547         else
 548             strm.Printf("%s\n", command);
 549     }
 550 }
 551
 552 bool
 553 Driver::GetDebugMode() const
 554 {
 555     return m_option_data.m_debug_mode;
 556 }
 557
 558
 559 // Check the arguments that were passed to this program to make sure they are valid and to get their
 560 // argument values (if any).  Return a boolean value indicating whether or not to start up the full
 561 // debugger (i.e. the Command Interpreter) or not.  Return FALSE if the arguments were invalid OR
 562 // if the user only wanted help or version information.
 563
 564 SBError
 565 Driver::ParseArgs (int argc, const char *argv[], FILE *out_fh, bool &exiting)
 566 {
 567     ResetOptionValues ();
 568
 569     SBCommandReturnObject result;
 570
 571     SBError error;
 572     std::string option_string;
 573     struct option *long_options = NULL;
 574     std::vector<struct option> long_options_vector;
 575     uint32_t num_options;
 576
 577     for (num_options = 0; g_options[num_options].long_option != NULL; ++num_options)
 578         /* Do Nothing. */;
 579
 580     if (num_options == 0)
 581     {
 582         if (argc > 1)
 583             error.SetErrorStringWithFormat ("invalid number of options");
 584         return error;
 585     }
 586
 587     BuildGetOptTable (g_options, long_options_vector, num_options);
 588
 589     if (long_options_vector.empty())
 590         long_options = NULL;
 591     else
 592         long_options = &long_options_vector.front();
 593
 594     if (long_options == NULL)
 595     {
 596         error.SetErrorStringWithFormat ("invalid long options");
 597         return error;
 598     }
 599
 600     // Build the option_string argument for call to getopt_long_only.
 601
 602     for (int i = 0; long_options[i].name != NULL; ++i)
 603     {
 604         if (long_options[i].flag == NULL)
 605         {
 606             option_string.push_back ((char) long_options[i].val);
 607             switch (long_options[i].has_arg)
 608             {
 609                 default:
 610                 case no_argument:
 611                     break;
 612                 case required_argument:
 613                     option_string.push_back (':');
 614                     break;
 615                 case optional_argument:
 616                     option_string.append ("::");
 617                     break;
 618             }
 619         }
 620     }
 621
 622     // This is kind of a pain, but since we make the debugger in the Driver's constructor, we can't
 623     // know at that point whether we should read in init files yet.  So we don't read them in in the
 624     // Driver constructor, then set the flags back to "read them in" here, and then if we see the
 625     // "-n" flag, we'll turn it off again.  Finally we have to read them in by hand later in the
 626     // main loop.
 627
 628     m_debugger.SkipLLDBInitFiles (false);
 629     m_debugger.SkipAppInitFiles (false);
 630
 631     // Prepare for & make calls to getopt_long_only.
 632 #if __GLIBC__
 633     optind = 0;
 634 #else
 635     optreset = 1;
 636     optind = 1;
 637 #endif
 638     int val;
 639     while (1)
 640     {
 641         int long_options_index = -1;
 642         val = ::getopt_long_only (argc, const_cast<char **>(argv), option_string.c_str(), long_options, &long_options_index);
 643
 644         if (val == -1)
 645             break;
 646         else if (val == '?')
 647         {
 648             m_option_data.m_print_help = true;
 649             error.SetErrorStringWithFormat ("unknown or ambiguous option");
 650             break;
 651         }
 652         else if (val == 0)
 653             continue;
 654         else
 655         {
 656             m_option_data.m_seen_options.insert ((char) val);
 657             if (long_options_index == -1)
 658             {
 659                 for (int i = 0;
 660                      long_options[i].name || long_options[i].has_arg || long_options[i].flag || long_options[i].val;
 661                      ++i)
 662                 {
 663                     if (long_options[i].val == val)
 664                     {
 665                         long_options_index = i;
 666                         break;
 667                     }
 668                 }
 669             }
 670
 671             if (long_options_index >= 0)
 672             {
 673                 const int short_option = g_options[long_options_index].short_option;
 674
 675                 switch (short_option)
 676                 {
 677                     case 'h':
 678                         m_option_data.m_print_help = true;
 679                         break;
 680
 681                     case 'v':
 682                         m_option_data.m_print_version = true;
 683                         break;
 684
 685                     case 'P':
 686                         m_option_data.m_print_python_path = true;
 687                         break;
 688
 689                     case 'b':
 690                         m_option_data.m_batch = true;
 691                         break;
 692
 693                     case 'c':
 694                         {
 695                             SBFileSpec file(optarg);
 696                             if (file.Exists())
 697                             {
 698                                 m_option_data.m_core_file = optarg;
 699                             }
 700                             else
 701                                 error.SetErrorStringWithFormat("file specified in --core (-c) option doesn't exist: '%s'", optarg);
 702                         }
 703                         break;
 704
 705                     case 'e':
 706                         m_option_data.m_use_external_editor = true;
 707                         break;
 708
 709                     case 'x':
 710                         m_debugger.SkipLLDBInitFiles (true);
 711                         m_debugger.SkipAppInitFiles (true);
 712                         break;
 713
 714                     case 'X':
 715                         m_debugger.SetUseColor (false);
 716                         break;
 717
 718                     case 'f':
 719                         {
 720                             SBFileSpec file(optarg);
 721                             if (file.Exists())
 722                             {
 723                                 m_option_data.m_args.push_back (optarg);
 724                             }
 725                             else if (file.ResolveExecutableLocation())
 726                             {
 727                                 char path[PATH_MAX];
 728                                 file.GetPath (path, sizeof(path));
 729                                 m_option_data.m_args.push_back (path);
 730                             }
 731                             else
 732                                 error.SetErrorStringWithFormat("file specified in --file (-f) option doesn't exist: '%s'", optarg);
 733                         }
 734                         break;
 735
 736                     case 'a':
 737                         if (!m_debugger.SetDefaultArchitecture (optarg))
 738                             error.SetErrorStringWithFormat("invalid architecture in the -a or --arch option: '%s'", optarg);
 739                         break;
 740
 741                     case 'l':
 742                         m_option_data.m_script_lang = m_debugger.GetScriptingLanguage (optarg);
 743                         break;
 744
 745                     case 'd':
 746                         m_option_data.m_debug_mode = true;
 747                         break;
 748
 749                     case 'Q':
 750                         m_option_data.m_source_quietly = true;
 751                         break;
 752
 753                     case 'K':
 754                         m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, true, true, error);
 755                         break;
 756                     case 'k':
 757                         m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, false, true, error);
 758                         break;
 759
 760                     case 'n':
 761                         m_option_data.m_process_name = optarg;
 762                         break;
 763
 764                     case 'w':
 765                         m_option_data.m_wait_for = true;
 766                         break;
 767
 768                     case 'p':
 769                         {
 770                             char *remainder;
 771                             m_option_data.m_process_pid = strtol (optarg, &remainder, 0);
 772                             if (remainder == optarg || *remainder != '\0')
 773                                 error.SetErrorStringWithFormat ("Could not convert process PID: \"%s\" into a pid.",
 774                                                                 optarg);
 775                         }
 776                         break;
 777                     case 's':
 778                         m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, true, true, error);
 779                         break;
 780                     case 'o':
 781                         m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, false, true, error);
 782                         break;
 783                     case 'S':
 784                         m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, true, true, error);
 785                         break;
 786                     case 'O':
 787                         m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, false, true, error);
 788                         break;
 789                     default:
 790                         m_option_data.m_print_help = true;
 791                         error.SetErrorStringWithFormat ("unrecognized option %c", short_option);
 792                         break;
 793                 }
 794             }
 795             else
 796             {
 797                 error.SetErrorStringWithFormat ("invalid option with value %i", val);
 798             }
 799             if (error.Fail())
 800             {
 801                 return error;
 802             }
 803         }
 804     }
 805
 806     if (error.Fail() || m_option_data.m_print_help)
 807     {
 808         ShowUsage (out_fh, g_options, m_option_data);
 809         exiting = true;
 810     }
 811     else if (m_option_data.m_print_version)
 812     {
 813         ::fprintf (out_fh, "%s\n", m_debugger.GetVersionString());
 814         exiting = true;
 815     }
 816     else if (m_option_data.m_print_python_path)
 817     {
 818         SBFileSpec python_file_spec = SBHostOS::GetLLDBPythonPath();
 819         if (python_file_spec.IsValid())
 820         {
 821             char python_path[PATH_MAX];
 822             size_t num_chars = python_file_spec.GetPath(python_path, PATH_MAX);
 823             if (num_chars < PATH_MAX)
 824             {
 825                 ::fprintf (out_fh, "%s\n", python_path);
 826             }
 827             else
 828                 ::fprintf (out_fh, "<PATH TOO LONG>\n");
 829         }
 830         else
 831             ::fprintf (out_fh, "<COULD NOT FIND PATH>\n");
 832         exiting = true;
 833     }
 834     else if (m_option_data.m_process_name.empty() && m_option_data.m_process_pid == LLDB_INVALID_PROCESS_ID)
 835     {
 836         // Any arguments that are left over after option parsing are for
 837         // the program. If a file was specified with -f then the filename
 838         // is already in the m_option_data.m_args array, and any remaining args
 839         // are arguments for the inferior program. If no file was specified with
 840         // -f, then what is left is the program name followed by any arguments.
 841
 842         // Skip any options we consumed with getopt_long_only
 843         argc -= optind;
 844         argv += optind;
 845
 846         if (argc > 0)
 847         {
 848             for (int arg_idx=0; arg_idx<argc; ++arg_idx)
 849             {
 850                 const char *arg = argv[arg_idx];
 851                 if (arg)
 852                     m_option_data.m_args.push_back (arg);
 853             }
 854         }
 855
 856     }
 857     else
 858     {
 859         // Skip any options we consumed with getopt_long_only
 860         argc -= optind;
 861         //argv += optind; // Commented out to keep static analyzer happy
 862
 863         if (argc > 0)
 864             ::fprintf (out_fh, "Warning: program arguments are ignored when attaching.\n");
 865     }
 866
 867     return error;
 868 }
 869
 870 static ::FILE *
 871 PrepareCommandsForSourcing (const char *commands_data, size_t commands_size, int fds[2])
 872 {
 873     enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 874
 875     bool success = true;
 876     ::FILE *commands_file = NULL;
 877     fds[0] = -1;
 878     fds[1] = -1;
 879     int err = 0;
 880 #ifdef _WIN32
 881     err = _pipe(fds, commands_size, O_BINARY);
 882 #else
 883     err = pipe(fds);
 884 #endif
 885     if (err == 0)
 886     {
 887         ssize_t nrwr = write(fds[WRITE], commands_data, commands_size);
 888         if (nrwr < 0)
 889         {
 890             fprintf(stderr, "error: write(%i, %p, %zd) failed (errno = %i) "
 891                             "when trying to open LLDB commands pipe\n",
 892                     fds[WRITE], commands_data, commands_size, errno);
 893             success = false;
 894         }
 895         else if (static_cast<size_t>(nrwr) == commands_size)
 896         {
 897             // Close the write end of the pipe so when we give the read end to
 898             // the debugger/command interpreter it will exit when it consumes all
 899             // of the data
 900 #ifdef _WIN32
 901             _close(fds[WRITE]); fds[WRITE] = -1;
 902 #else
 903             close(fds[WRITE]); fds[WRITE] = -1;
 904 #endif
 905             // Now open the read file descriptor in a FILE * that we can give to
 906             // the debugger as an input handle
 907             commands_file = fdopen(fds[READ], "r");
 908             if (commands_file)
 909             {
 910                 fds[READ] = -1; // The FILE * 'commands_file' now owns the read descriptor
 911                 // Hand ownership if the FILE * over to the debugger for "commands_file".
 912             }
 913             else
 914             {
 915                 fprintf(stderr,
 916                         "error: fdopen(%i, \"r\") failed (errno = %i) when "
 917                         "trying to open LLDB commands pipe\n",
 918                         fds[READ], errno);
 919                 success = false;
 920             }
 921         }
 922     }
 923     else
 924     {
 925         fprintf(stderr, "error: can't create pipe file descriptors for LLDB commands\n");
 926         success = false;
 927     }
 928
 929     return commands_file;
 930 }
 931
 932 void
 933 CleanupAfterCommandSourcing (int fds[2])
 934 {
 935      enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 936
 937    // Close any pipes that we still have ownership of
 938     if ( fds[WRITE] != -1)
 939     {
 940 #ifdef _WIN32
 941         _close(fds[WRITE]); fds[WRITE] = -1;
 942 #else
 943         close(fds[WRITE]); fds[WRITE] = -1;
 944 #endif
 945
 946     }
 947
 948     if ( fds[READ] != -1)
 949     {
 950 #ifdef _WIN32
 951         _close(fds[READ]); fds[READ] = -1;
 952 #else
 953         close(fds[READ]); fds[READ] = -1;
 954 #endif
 955     }
 956
 957 }
 958
 959 void
 960 Driver::MainLoop ()
 961 {
 962     if (::tcgetattr(STDIN_FILENO, &g_old_stdin_termios) == 0)
 963     {
 964         g_old_stdin_termios_is_valid = true;
 965         atexit (reset_stdin_termios);
 966     }
 967
 968     ::setbuf (stdin, NULL);
 969     ::setbuf (stdout, NULL);
 970
 971     m_debugger.SetErrorFileHandle (stderr, false);
 972     m_debugger.SetOutputFileHandle (stdout, false);
 973     m_debugger.SetInputFileHandle (stdin, false); // Don't take ownership of STDIN yet...
 974
 975     m_debugger.SetUseExternalEditor(m_option_data.m_use_external_editor);
 976
 977     struct winsize window_size;
 978     if (isatty (STDIN_FILENO)
 979         && ::ioctl (STDIN_FILENO, TIOCGWINSZ, &window_size) == 0)
 980     {
 981         if (window_size.ws_col > 0)
 982             m_debugger.SetTerminalWidth (window_size.ws_col);
 983     }
 984
 985     SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter();
 986
 987     // Before we handle any options from the command line, we parse the
 988     // .lldbinit file in the user's home directory.
 989     SBCommandReturnObject result;
 990     sb_interpreter.SourceInitFileInHomeDirectory(result);
 991     if (GetDebugMode())
 992     {
 993         result.PutError (m_debugger.GetErrorFileHandle());
 994         result.PutOutput (m_debugger.GetOutputFileHandle());
 995     }
 996
 997     // Now we handle options we got from the command line
 998     SBStream commands_stream;
 999
1000     // First source in the commands specified to be run before the file arguments are processed.
1001     WriteCommandsForSourcing(eCommandPlacementBeforeFile, commands_stream);
1002
1003     const size_t num_args = m_option_data.m_args.size();
1004     if (num_args > 0)
1005     {
1006         char arch_name[64];
1007         if (m_debugger.GetDefaultArchitecture (arch_name, sizeof (arch_name)))
1008             commands_stream.Printf("target create --arch=%s \"%s\"", arch_name, m_option_data.m_args[0].c_str());
1009         else
1010             commands_stream.Printf("target create \"%s\"", m_option_data.m_args[0].c_str());
1011
1012         if (!m_option_data.m_core_file.empty())
1013         {
1014             commands_stream.Printf(" --core \"%s\"", m_option_data.m_core_file.c_str());
1015         }
1016         commands_stream.Printf("\n");
1017
1018         if (num_args > 1)
1019         {
1020             commands_stream.Printf ("settings set -- target.run-args ");
1021             for (size_t arg_idx = 1; arg_idx < num_args; ++arg_idx)
1022             {
1023                 const char *arg_cstr = m_option_data.m_args[arg_idx].c_str();
1024                 if (strchr(arg_cstr, '"') == NULL)
1025                     commands_stream.Printf(" \"%s\"", arg_cstr);
1026                 else
1027                     commands_stream.Printf(" '%s'", arg_cstr);
1028             }
1029             commands_stream.Printf("\n");
1030         }
1031     }
1032     else if (!m_option_data.m_core_file.empty())
1033     {
1034         commands_stream.Printf("target create --core \"%s\"\n", m_option_data.m_core_file.c_str());
1035     }
1036     else if (!m_option_data.m_process_name.empty())
1037     {
1038         commands_stream.Printf ("process attach --name \"%s\"", m_option_data.m_process_name.c_str());
1039
1040         if (m_option_data.m_wait_for)
1041             commands_stream.Printf(" --waitfor");
1042
1043         commands_stream.Printf("\n");
1044
1045     }
1046     else if (LLDB_INVALID_PROCESS_ID != m_option_data.m_process_pid)
1047     {
1048         commands_stream.Printf ("process attach --pid %" PRIu64 "\n", m_option_data.m_process_pid);
1049     }
1050
1051     WriteCommandsForSourcing(eCommandPlacementAfterFile, commands_stream);
1052
1053     if (GetDebugMode())
1054     {
1055         result.PutError(m_debugger.GetErrorFileHandle());
1056         result.PutOutput(m_debugger.GetOutputFileHandle());
1057     }
1058
1059     bool handle_events = true;
1060     bool spawn_thread = false;
1061
1062     // Check if we have any data in the commands stream, and if so, save it to a temp file
1063     // so we can then run the command interpreter using the file contents.
1064     const char *commands_data = commands_stream.GetData();
1065     const size_t commands_size = commands_stream.GetSize();
1066
1067     // The command file might have requested that we quit, this variable will track that.
1068     bool quit_requested = false;
1069     bool stopped_for_crash = false;
1070     if (commands_data && commands_size)
1071     {
1072         int initial_commands_fds[2];
1073         bool success = true;
1074         FILE *commands_file = PrepareCommandsForSourcing (commands_data, commands_size, initial_commands_fds);
1075         if (commands_file)
1076         {
1077             m_debugger.SetInputFileHandle (commands_file, true);
1078
1079             // Set the debugger into Sync mode when running the command file.  Otherwise command files
1080             // that run the target won't run in a sensible way.
1081             bool old_async = m_debugger.GetAsync();
1082             m_debugger.SetAsync(false);
1083             int num_errors;
1084
1085             SBCommandInterpreterRunOptions options;
1086             options.SetStopOnError (true);
1087             if (m_option_data.m_batch)
1088                 options.SetStopOnCrash (true);
1089
1090             m_debugger.RunCommandInterpreter(handle_events,
1091                                              spawn_thread,
1092                                              options,
1093                                              num_errors,
1094                                              quit_requested,
1095                                              stopped_for_crash);
1096
1097             if (m_option_data.m_batch && stopped_for_crash && !m_option_data.m_after_crash_commands.empty())
1098             {
1099                 int crash_command_fds[2];
1100                 SBStream crash_commands_stream;
1101                 WriteCommandsForSourcing (eCommandPlacementAfterCrash, crash_commands_stream);
1102                 const char *crash_commands_data = crash_commands_stream.GetData();
1103                 const size_t crash_commands_size = crash_commands_stream.GetSize();
1104                 commands_file  = PrepareCommandsForSourcing (crash_commands_data, crash_commands_size, crash_command_fds);
1105                 if (commands_file)
1106                 {
1107                     bool local_quit_requested;
1108                     bool local_stopped_for_crash;
1109                     m_debugger.SetInputFileHandle (commands_file, true);
1110
1111                     m_debugger.RunCommandInterpreter(handle_events,
1112                                                      spawn_thread,
1113                                                      options,
1114                                                      num_errors,
1115                                                      local_quit_requested,
1116                                                      local_stopped_for_crash);
1117                     if (local_quit_requested)
1118                         quit_requested = true;
1119
1120                 }
1121             }
1122             m_debugger.SetAsync(old_async);
1123         }
1124         else
1125             success = false;
1126
1127         // Close any pipes that we still have ownership of
1128         CleanupAfterCommandSourcing(initial_commands_fds);
1129
1130         // Something went wrong with command pipe
1131         if (!success)
1132         {
1133             exit(1);
1134         }
1135
1136     }
1137
1138     // Now set the input file handle to STDIN and run the command
1139     // interpreter again in interactive mode and let the debugger
1140     // take ownership of stdin
1141
1142     bool go_interactive = true;
1143     if (quit_requested)
1144         go_interactive = false;
1145     else if (m_option_data.m_batch && !stopped_for_crash)
1146         go_interactive = false;
1147
1148     if (go_interactive)
1149     {
1150         m_debugger.SetInputFileHandle (stdin, true);
1151         m_debugger.RunCommandInterpreter(handle_events, spawn_thread);
1152     }
1153
1154     reset_stdin_termios();
1155     fclose (stdin);
1156
1157     SBDebugger::Destroy (m_debugger);
1158 }
1159
1160
1161 void
1162 Driver::ResizeWindow (unsigned short col)
1163 {
1164     GetDebugger().SetTerminalWidth (col);
1165 }
1166
1167 void
1168 sigwinch_handler (int signo)
1169 {
1170     struct winsize window_size;
1171     if (isatty (STDIN_FILENO)
1172         && ::ioctl (STDIN_FILENO, TIOCGWINSZ, &window_size) == 0)
1173     {
1174         if ((window_size.ws_col > 0) && g_driver != NULL)
1175         {
1176             g_driver->ResizeWindow (window_size.ws_col);
1177         }
1178     }
1179 }
1180
1181 void
1182 sigint_handler (int signo)
1183 {
1184         static bool g_interrupt_sent = false;
1185     if (g_driver)
1186         {
1187                 if (!g_interrupt_sent)
1188                 {
1189                         g_interrupt_sent = true;
1190                 g_driver->GetDebugger().DispatchInputInterrupt();
1191                         g_interrupt_sent = false;
1192                         return;
1193                 }
1194         }
1195
1196         exit (signo);
1197 }
1198
1199 void
1200 sigtstp_handler (int signo)
1201 {
1202     g_driver->GetDebugger().SaveInputTerminalState();
1203     signal (signo, SIG_DFL);
1204     kill (getpid(), signo);
1205     signal (signo, sigtstp_handler);
1206 }
1207
1208 void
1209 sigcont_handler (int signo)
1210 {
1211     g_driver->GetDebugger().RestoreInputTerminalState();
1212     signal (signo, SIG_DFL);
1213     kill (getpid(), signo);
1214     signal (signo, sigcont_handler);
1215 }
1216
1217 int
1218 main (int argc, char const *argv[], const char *envp[])
1219 {
1220 #ifdef _MSC_VER
1221         // disable buffering on windows
1222         setvbuf(stdout, NULL, _IONBF, 0);
1223         setvbuf(stdin , NULL, _IONBF, 0);
1224 #endif
1225
1226     SBDebugger::Initialize();
1227
1228     SBHostOS::ThreadCreated ("<lldb.driver.main-thread>");
1229
1230     signal (SIGPIPE, SIG_IGN);
1231     signal (SIGWINCH, sigwinch_handler);
1232     signal (SIGINT, sigint_handler);
1233     signal (SIGTSTP, sigtstp_handler);
1234     signal (SIGCONT, sigcont_handler);
1235
1236     // Create a scope for driver so that the driver object will destroy itself
1237     // before SBDebugger::Terminate() is called.
1238     {
1239         Driver driver;
1240
1241         bool exiting = false;
1242         SBError error (driver.ParseArgs (argc, argv, stdout, exiting));
1243         if (error.Fail())
1244         {
1245             const char *error_cstr = error.GetCString ();
1246             if (error_cstr)
1247                 ::fprintf (stderr, "error: %s\n", error_cstr);
1248         }
1249         else if (!exiting)
1250         {
1251             driver.MainLoop ();
1252         }
1253     }
1254
1255     SBDebugger::Terminate();
1256     return 0;
1257 }