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 <getopt.h> 13 #include <libgen.h> 14 #include <sys/ioctl.h> 15 #include <termios.h> 16 #include <unistd.h> 17 #include <string.h> 18 #include <stdlib.h> 19 #include <limits.h> 20 #include <fcntl.h> 21 #include <inttypes.h> 22 23 #include <string> 24 25 #include "IOChannel.h" 26 #include "lldb/API/SBBreakpoint.h" 27 #include "lldb/API/SBCommandInterpreter.h" 28 #include "lldb/API/SBCommandReturnObject.h" 29 #include "lldb/API/SBCommunication.h" 30 #include "lldb/API/SBDebugger.h" 31 #include "lldb/API/SBEvent.h" 32 #include "lldb/API/SBHostOS.h" 33 #include "lldb/API/SBListener.h" 34 #include "lldb/API/SBStream.h" 35 #include "lldb/API/SBTarget.h" 36 #include "lldb/API/SBThread.h" 37 #include "lldb/API/SBProcess.h" 38 39 using namespace lldb; 40 41 static void reset_stdin_termios (); 42 static bool g_old_stdin_termios_is_valid = false; 43 static struct termios g_old_stdin_termios; 44 45 static char *g_debugger_name = (char *) ""; 46 static Driver *g_driver = NULL; 47 48 // In the Driver::MainLoop, we change the terminal settings. This function is 49 // added as an atexit handler to make sure we clean them up. 50 static void 51 reset_stdin_termios () 52 { 53 if (g_old_stdin_termios_is_valid) 54 { 55 g_old_stdin_termios_is_valid = false; 56 ::tcsetattr (STDIN_FILENO, TCSANOW, &g_old_stdin_termios); 57 } 58 } 59 60 typedef struct 61 { 62 uint32_t usage_mask; // Used to mark options that can be used together. If (1 << n & usage_mask) != 0 63 // then this option belongs to option set n. 64 bool required; // This option is required (in the current usage level) 65 const char * long_option; // Full name for this option. 66 int short_option; // Single character for this option. 67 int option_has_arg; // no_argument, required_argument or optional_argument 68 uint32_t completion_type; // Cookie the option class can use to do define the argument completion. 69 lldb::CommandArgumentType argument_type; // Type of argument this option takes 70 const char * usage_text; // Full text explaining what this options does and what (if any) argument to 71 // pass it. 72 } OptionDefinition; 73 74 #define LLDB_3_TO_5 LLDB_OPT_SET_3|LLDB_OPT_SET_4|LLDB_OPT_SET_5 75 #define LLDB_4_TO_5 LLDB_OPT_SET_4|LLDB_OPT_SET_5 76 77 static OptionDefinition g_options[] = 78 { 79 { LLDB_OPT_SET_1, true , "help" , 'h', no_argument , 0, eArgTypeNone, 80 "Prints out the usage information for the LLDB debugger." }, 81 { LLDB_OPT_SET_2, true , "version" , 'v', no_argument , 0, eArgTypeNone, 82 "Prints out the current version number of the LLDB debugger." }, 83 { LLDB_OPT_SET_3, true , "arch" , 'a', required_argument, 0, eArgTypeArchitecture, 84 "Tells the debugger to use the specified architecture when starting and running the program. <architecture> must " 85 "be one of the architectures for which the program was compiled." }, 86 { LLDB_OPT_SET_3, true , "file" , 'f', required_argument, 0, eArgTypeFilename, 87 "Tells the debugger to use the file <filename> as the program to be debugged." }, 88 { LLDB_OPT_SET_3, false, "core" , 'c', required_argument, 0, eArgTypeFilename, 89 "Tells the debugger to use the fullpath to <path> as the core file." }, 90 { LLDB_OPT_SET_4, true , "attach-name" , 'n', required_argument, 0, eArgTypeProcessName, 91 "Tells the debugger to attach to a process with the given name." }, 92 { LLDB_OPT_SET_4, true , "wait-for" , 'w', no_argument , 0, eArgTypeNone, 93 "Tells the debugger to wait for a process with the given pid or name to launch before attaching." }, 94 { LLDB_OPT_SET_5, true , "attach-pid" , 'p', required_argument, 0, eArgTypePid, 95 "Tells the debugger to attach to a process with the given pid." }, 96 { LLDB_3_TO_5, false, "script-language", 'l', required_argument, 0, eArgTypeScriptLang, 97 "Tells the debugger to use the specified scripting language for user-defined scripts, rather than the default. " 98 "Valid scripting languages that can be specified include Python, Perl, Ruby and Tcl. Currently only the Python " 99 "extensions have been implemented." }, 100 { LLDB_3_TO_5, false, "debug" , 'd', no_argument , 0, eArgTypeNone, 101 "Tells the debugger to print out extra information for debugging itself." }, 102 { LLDB_3_TO_5, false, "source" , 's', required_argument, 0, eArgTypeFilename, 103 "Tells the debugger to read in and execute the file <file>, which should contain lldb commands." }, 104 { LLDB_3_TO_5, false, "editor" , 'e', no_argument , 0, eArgTypeNone, 105 "Tells the debugger to open source files using the host's \"external editor\" mechanism." }, 106 { LLDB_3_TO_5, false, "no-lldbinit" , 'x', no_argument , 0, eArgTypeNone, 107 "Do not automatically parse any '.lldbinit' files." }, 108 { LLDB_OPT_SET_6, true , "python-path" , 'P', no_argument , 0, eArgTypeNone, 109 "Prints out the path to the lldb.py file for this version of lldb." }, 110 { 0, false, NULL , 0 , 0 , 0, eArgTypeNone, NULL } 111 }; 112 113 static const uint32_t last_option_set_with_args = 2; 114 115 Driver::Driver () : 116 SBBroadcaster ("Driver"), 117 m_debugger (SBDebugger::Create(false)), 118 m_editline_pty (), 119 m_editline_slave_fh (NULL), 120 m_editline_reader (), 121 m_io_channel_ap (), 122 m_option_data (), 123 m_waiting_for_command (false), 124 m_done(false) 125 { 126 // We want to be able to handle CTRL+D in the terminal to have it terminate 127 // certain input 128 m_debugger.SetCloseInputOnEOF (false); 129 g_debugger_name = (char *) m_debugger.GetInstanceName(); 130 if (g_debugger_name == NULL) 131 g_debugger_name = (char *) ""; 132 g_driver = this; 133 } 134 135 Driver::~Driver () 136 { 137 g_driver = NULL; 138 g_debugger_name = NULL; 139 } 140 141 void 142 Driver::CloseIOChannelFile () 143 { 144 // Write an End of File sequence to the file descriptor to ensure any 145 // read functions can exit. 146 char eof_str[] = "\x04"; 147 ::write (m_editline_pty.GetMasterFileDescriptor(), eof_str, strlen(eof_str)); 148 149 m_editline_pty.CloseMasterFileDescriptor(); 150 151 if (m_editline_slave_fh) 152 { 153 ::fclose (m_editline_slave_fh); 154 m_editline_slave_fh = NULL; 155 } 156 } 157 158 // This function takes INDENT, which tells how many spaces to output at the front 159 // of each line; TEXT, which is the text that is to be output. It outputs the 160 // text, on multiple lines if necessary, to RESULT, with INDENT spaces at the 161 // front of each line. It breaks lines on spaces, tabs or newlines, shortening 162 // the line if necessary to not break in the middle of a word. It assumes that 163 // each output line should contain a maximum of OUTPUT_MAX_COLUMNS characters. 164 165 void 166 OutputFormattedUsageText (FILE *out, int indent, const char *text, int output_max_columns) 167 { 168 int len = strlen (text); 169 std::string text_string (text); 170 171 // Force indentation to be reasonable. 172 if (indent >= output_max_columns) 173 indent = 0; 174 175 // Will it all fit on one line? 176 177 if (len + indent < output_max_columns) 178 // Output as a single line 179 fprintf (out, "%*s%s\n", indent, "", text); 180 else 181 { 182 // We need to break it up into multiple lines. 183 int text_width = output_max_columns - indent - 1; 184 int start = 0; 185 int end = start; 186 int final_end = len; 187 int sub_len; 188 189 while (end < final_end) 190 { 191 // Dont start the 'text' on a space, since we're already outputting the indentation. 192 while ((start < final_end) && (text[start] == ' ')) 193 start++; 194 195 end = start + text_width; 196 if (end > final_end) 197 end = final_end; 198 else 199 { 200 // If we're not at the end of the text, make sure we break the line on white space. 201 while (end > start 202 && text[end] != ' ' && text[end] != '\t' && text[end] != '\n') 203 end--; 204 } 205 sub_len = end - start; 206 std::string substring = text_string.substr (start, sub_len); 207 fprintf (out, "%*s%s\n", indent, "", substring.c_str()); 208 start = end + 1; 209 } 210 } 211 } 212 213 void 214 ShowUsage (FILE *out, OptionDefinition *option_table, Driver::OptionData data) 215 { 216 uint32_t screen_width = 80; 217 uint32_t indent_level = 0; 218 const char *name = "lldb"; 219 220 fprintf (out, "\nUsage:\n\n"); 221 222 indent_level += 2; 223 224 225 // First, show each usage level set of options, e.g. <cmd> [options-for-level-0] 226 // <cmd> [options-for-level-1] 227 // etc. 228 229 uint32_t num_options; 230 uint32_t num_option_sets = 0; 231 232 for (num_options = 0; option_table[num_options].long_option != NULL; ++num_options) 233 { 234 uint32_t this_usage_mask = option_table[num_options].usage_mask; 235 if (this_usage_mask == LLDB_OPT_SET_ALL) 236 { 237 if (num_option_sets == 0) 238 num_option_sets = 1; 239 } 240 else 241 { 242 for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) 243 { 244 if (this_usage_mask & 1 << j) 245 { 246 if (num_option_sets <= j) 247 num_option_sets = j + 1; 248 } 249 } 250 } 251 } 252 253 for (uint32_t opt_set = 0; opt_set < num_option_sets; opt_set++) 254 { 255 uint32_t opt_set_mask; 256 257 opt_set_mask = 1 << opt_set; 258 259 if (opt_set > 0) 260 fprintf (out, "\n"); 261 fprintf (out, "%*s%s", indent_level, "", name); 262 bool is_help_line = false; 263 264 for (uint32_t i = 0; i < num_options; ++i) 265 { 266 if (option_table[i].usage_mask & opt_set_mask) 267 { 268 CommandArgumentType arg_type = option_table[i].argument_type; 269 const char *arg_name = SBCommandInterpreter::GetArgumentTypeAsCString (arg_type); 270 // This is a bit of a hack, but there's no way to say certain options don't have arguments yet... 271 // so we do it by hand here. 272 if (option_table[i].short_option == 'h') 273 is_help_line = true; 274 275 if (option_table[i].required) 276 { 277 if (option_table[i].option_has_arg == required_argument) 278 fprintf (out, " -%c <%s>", option_table[i].short_option, arg_name); 279 else if (option_table[i].option_has_arg == optional_argument) 280 fprintf (out, " -%c [<%s>]", option_table[i].short_option, arg_name); 281 else 282 fprintf (out, " -%c", option_table[i].short_option); 283 } 284 else 285 { 286 if (option_table[i].option_has_arg == required_argument) 287 fprintf (out, " [-%c <%s>]", option_table[i].short_option, arg_name); 288 else if (option_table[i].option_has_arg == optional_argument) 289 fprintf (out, " [-%c [<%s>]]", option_table[i].short_option, arg_name); 290 else 291 fprintf (out, " [-%c]", option_table[i].short_option); 292 } 293 } 294 } 295 if (!is_help_line && (opt_set <= last_option_set_with_args)) 296 fprintf (out, " [[--] <PROGRAM-ARG-1> [<PROGRAM_ARG-2> ...]]"); 297 } 298 299 fprintf (out, "\n\n"); 300 301 // Now print out all the detailed information about the various options: long form, short form and help text: 302 // -- long_name <argument> 303 // - short <argument> 304 // help text 305 306 // This variable is used to keep track of which options' info we've printed out, because some options can be in 307 // more than one usage level, but we only want to print the long form of its information once. 308 309 Driver::OptionData::OptionSet options_seen; 310 Driver::OptionData::OptionSet::iterator pos; 311 312 indent_level += 5; 313 314 for (uint32_t i = 0; i < num_options; ++i) 315 { 316 // Only print this option if we haven't already seen it. 317 pos = options_seen.find (option_table[i].short_option); 318 if (pos == options_seen.end()) 319 { 320 CommandArgumentType arg_type = option_table[i].argument_type; 321 const char *arg_name = SBCommandInterpreter::GetArgumentTypeAsCString (arg_type); 322 323 options_seen.insert (option_table[i].short_option); 324 fprintf (out, "%*s-%c ", indent_level, "", option_table[i].short_option); 325 if (arg_type != eArgTypeNone) 326 fprintf (out, "<%s>", arg_name); 327 fprintf (out, "\n"); 328 fprintf (out, "%*s--%s ", indent_level, "", option_table[i].long_option); 329 if (arg_type != eArgTypeNone) 330 fprintf (out, "<%s>", arg_name); 331 fprintf (out, "\n"); 332 indent_level += 5; 333 OutputFormattedUsageText (out, indent_level, option_table[i].usage_text, screen_width); 334 indent_level -= 5; 335 fprintf (out, "\n"); 336 } 337 } 338 339 indent_level -= 5; 340 341 fprintf (out, "\n%*s(If you don't provide -f then the first argument will be the file to be debugged" 342 "\n%*s so '%s -- <filename> [<ARG1> [<ARG2>]]' also works." 343 "\n%*s Remember to end the options with \"--\" if any of your arguments have a \"-\" in them.)\n\n", 344 indent_level, "", 345 indent_level, "", 346 name, 347 indent_level, ""); 348 } 349 350 void 351 BuildGetOptTable (OptionDefinition *expanded_option_table, std::vector<struct option> &getopt_table, 352 uint32_t num_options) 353 { 354 if (num_options == 0) 355 return; 356 357 uint32_t i; 358 uint32_t j; 359 std::bitset<256> option_seen; 360 361 getopt_table.resize (num_options + 1); 362 363 for (i = 0, j = 0; i < num_options; ++i) 364 { 365 char short_opt = expanded_option_table[i].short_option; 366 367 if (option_seen.test(short_opt) == false) 368 { 369 getopt_table[j].name = expanded_option_table[i].long_option; 370 getopt_table[j].has_arg = expanded_option_table[i].option_has_arg; 371 getopt_table[j].flag = NULL; 372 getopt_table[j].val = expanded_option_table[i].short_option; 373 option_seen.set(short_opt); 374 ++j; 375 } 376 } 377 378 getopt_table[j].name = NULL; 379 getopt_table[j].has_arg = 0; 380 getopt_table[j].flag = NULL; 381 getopt_table[j].val = 0; 382 383 } 384 385 Driver::OptionData::OptionData () : 386 m_args(), 387 m_script_lang (lldb::eScriptLanguageDefault), 388 m_core_file (), 389 m_crash_log (), 390 m_source_command_files (), 391 m_debug_mode (false), 392 m_print_version (false), 393 m_print_python_path (false), 394 m_print_help (false), 395 m_wait_for(false), 396 m_process_name(), 397 m_process_pid(LLDB_INVALID_PROCESS_ID), 398 m_use_external_editor(false), 399 m_seen_options() 400 { 401 } 402 403 Driver::OptionData::~OptionData () 404 { 405 } 406 407 void 408 Driver::OptionData::Clear () 409 { 410 m_args.clear (); 411 m_script_lang = lldb::eScriptLanguageDefault; 412 m_source_command_files.clear (); 413 m_debug_mode = false; 414 m_print_help = false; 415 m_print_version = false; 416 m_print_python_path = false; 417 m_use_external_editor = false; 418 m_wait_for = false; 419 m_process_name.erase(); 420 m_process_pid = LLDB_INVALID_PROCESS_ID; 421 } 422 423 void 424 Driver::ResetOptionValues () 425 { 426 m_option_data.Clear (); 427 } 428 429 const char * 430 Driver::GetFilename() const 431 { 432 if (m_option_data.m_args.empty()) 433 return NULL; 434 return m_option_data.m_args.front().c_str(); 435 } 436 437 const char * 438 Driver::GetCrashLogFilename() const 439 { 440 if (m_option_data.m_crash_log.empty()) 441 return NULL; 442 return m_option_data.m_crash_log.c_str(); 443 } 444 445 lldb::ScriptLanguage 446 Driver::GetScriptLanguage() const 447 { 448 return m_option_data.m_script_lang; 449 } 450 451 size_t 452 Driver::GetNumSourceCommandFiles () const 453 { 454 return m_option_data.m_source_command_files.size(); 455 } 456 457 const char * 458 Driver::GetSourceCommandFileAtIndex (uint32_t idx) const 459 { 460 if (idx < m_option_data.m_source_command_files.size()) 461 return m_option_data.m_source_command_files[idx].c_str(); 462 return NULL; 463 } 464 465 bool 466 Driver::GetDebugMode() const 467 { 468 return m_option_data.m_debug_mode; 469 } 470 471 472 // Check the arguments that were passed to this program to make sure they are valid and to get their 473 // argument values (if any). Return a boolean value indicating whether or not to start up the full 474 // debugger (i.e. the Command Interpreter) or not. Return FALSE if the arguments were invalid OR 475 // if the user only wanted help or version information. 476 477 SBError 478 Driver::ParseArgs (int argc, const char *argv[], FILE *out_fh, bool &exit) 479 { 480 ResetOptionValues (); 481 482 SBCommandReturnObject result; 483 484 SBError error; 485 std::string option_string; 486 struct option *long_options = NULL; 487 std::vector<struct option> long_options_vector; 488 uint32_t num_options; 489 490 for (num_options = 0; g_options[num_options].long_option != NULL; ++num_options) 491 /* Do Nothing. */; 492 493 if (num_options == 0) 494 { 495 if (argc > 1) 496 error.SetErrorStringWithFormat ("invalid number of options"); 497 return error; 498 } 499 500 BuildGetOptTable (g_options, long_options_vector, num_options); 501 502 if (long_options_vector.empty()) 503 long_options = NULL; 504 else 505 long_options = &long_options_vector.front(); 506 507 if (long_options == NULL) 508 { 509 error.SetErrorStringWithFormat ("invalid long options"); 510 return error; 511 } 512 513 // Build the option_string argument for call to getopt_long. 514 515 for (int i = 0; long_options[i].name != NULL; ++i) 516 { 517 if (long_options[i].flag == NULL) 518 { 519 option_string.push_back ((char) long_options[i].val); 520 switch (long_options[i].has_arg) 521 { 522 default: 523 case no_argument: 524 break; 525 case required_argument: 526 option_string.push_back (':'); 527 break; 528 case optional_argument: 529 option_string.append ("::"); 530 break; 531 } 532 } 533 } 534 535 // This is kind of a pain, but since we make the debugger in the Driver's constructor, we can't 536 // know at that point whether we should read in init files yet. So we don't read them in in the 537 // Driver constructor, then set the flags back to "read them in" here, and then if we see the 538 // "-n" flag, we'll turn it off again. Finally we have to read them in by hand later in the 539 // main loop. 540 541 m_debugger.SkipLLDBInitFiles (false); 542 m_debugger.SkipAppInitFiles (false); 543 544 // Prepare for & make calls to getopt_long. 545 #if __GLIBC__ 546 optind = 0; 547 #else 548 optreset = 1; 549 optind = 1; 550 #endif 551 int val; 552 while (1) 553 { 554 int long_options_index = -1; 555 val = ::getopt_long (argc, const_cast<char **>(argv), option_string.c_str(), long_options, &long_options_index); 556 557 if (val == -1) 558 break; 559 else if (val == '?') 560 { 561 m_option_data.m_print_help = true; 562 error.SetErrorStringWithFormat ("unknown or ambiguous option"); 563 break; 564 } 565 else if (val == 0) 566 continue; 567 else 568 { 569 m_option_data.m_seen_options.insert ((char) val); 570 if (long_options_index == -1) 571 { 572 for (int i = 0; 573 long_options[i].name || long_options[i].has_arg || long_options[i].flag || long_options[i].val; 574 ++i) 575 { 576 if (long_options[i].val == val) 577 { 578 long_options_index = i; 579 break; 580 } 581 } 582 } 583 584 if (long_options_index >= 0) 585 { 586 const int short_option = g_options[long_options_index].short_option; 587 588 switch (short_option) 589 { 590 case 'h': 591 m_option_data.m_print_help = true; 592 break; 593 594 case 'v': 595 m_option_data.m_print_version = true; 596 break; 597 598 case 'P': 599 m_option_data.m_print_python_path = true; 600 break; 601 602 case 'c': 603 { 604 SBFileSpec file(optarg); 605 if (file.Exists()) 606 { 607 m_option_data.m_core_file = optarg; 608 } 609 else 610 error.SetErrorStringWithFormat("file specified in --core (-c) option doesn't exist: '%s'", optarg); 611 } 612 break; 613 614 case 'e': 615 m_option_data.m_use_external_editor = true; 616 break; 617 618 case 'x': 619 m_debugger.SkipLLDBInitFiles (true); 620 m_debugger.SkipAppInitFiles (true); 621 break; 622 623 case 'f': 624 { 625 SBFileSpec file(optarg); 626 if (file.Exists()) 627 { 628 m_option_data.m_args.push_back (optarg); 629 } 630 else if (file.ResolveExecutableLocation()) 631 { 632 char path[PATH_MAX]; 633 file.GetPath (path, sizeof(path)); 634 m_option_data.m_args.push_back (path); 635 } 636 else 637 error.SetErrorStringWithFormat("file specified in --file (-f) option doesn't exist: '%s'", optarg); 638 } 639 break; 640 641 case 'a': 642 if (!m_debugger.SetDefaultArchitecture (optarg)) 643 error.SetErrorStringWithFormat("invalid architecture in the -a or --arch option: '%s'", optarg); 644 break; 645 646 case 'l': 647 m_option_data.m_script_lang = m_debugger.GetScriptingLanguage (optarg); 648 break; 649 650 case 'd': 651 m_option_data.m_debug_mode = true; 652 break; 653 654 case 'n': 655 m_option_data.m_process_name = optarg; 656 break; 657 658 case 'w': 659 m_option_data.m_wait_for = true; 660 break; 661 662 case 'p': 663 { 664 char *remainder; 665 m_option_data.m_process_pid = strtol (optarg, &remainder, 0); 666 if (remainder == optarg || *remainder != '\0') 667 error.SetErrorStringWithFormat ("Could not convert process PID: \"%s\" into a pid.", 668 optarg); 669 } 670 break; 671 case 's': 672 { 673 SBFileSpec file(optarg); 674 if (file.Exists()) 675 m_option_data.m_source_command_files.push_back (optarg); 676 else if (file.ResolveExecutableLocation()) 677 { 678 char final_path[PATH_MAX]; 679 file.GetPath (final_path, sizeof(final_path)); 680 std::string path_str (final_path); 681 m_option_data.m_source_command_files.push_back (path_str); 682 } 683 else 684 error.SetErrorStringWithFormat("file specified in --source (-s) option doesn't exist: '%s'", optarg); 685 } 686 break; 687 688 default: 689 m_option_data.m_print_help = true; 690 error.SetErrorStringWithFormat ("unrecognized option %c", short_option); 691 break; 692 } 693 } 694 else 695 { 696 error.SetErrorStringWithFormat ("invalid option with value %i", val); 697 } 698 if (error.Fail()) 699 { 700 return error; 701 } 702 } 703 } 704 705 if (error.Fail() || m_option_data.m_print_help) 706 { 707 ShowUsage (out_fh, g_options, m_option_data); 708 exit = true; 709 } 710 else if (m_option_data.m_print_version) 711 { 712 ::fprintf (out_fh, "%s\n", m_debugger.GetVersionString()); 713 exit = true; 714 } 715 else if (m_option_data.m_print_python_path) 716 { 717 SBFileSpec python_file_spec = SBHostOS::GetLLDBPythonPath(); 718 if (python_file_spec.IsValid()) 719 { 720 char python_path[PATH_MAX]; 721 size_t num_chars = python_file_spec.GetPath(python_path, PATH_MAX); 722 if (num_chars < PATH_MAX) 723 { 724 ::fprintf (out_fh, "%s\n", python_path); 725 } 726 else 727 ::fprintf (out_fh, "<PATH TOO LONG>\n"); 728 } 729 else 730 ::fprintf (out_fh, "<COULD NOT FIND PATH>\n"); 731 exit = true; 732 } 733 else if (m_option_data.m_process_name.empty() && m_option_data.m_process_pid == LLDB_INVALID_PROCESS_ID) 734 { 735 // Any arguments that are left over after option parsing are for 736 // the program. If a file was specified with -f then the filename 737 // is already in the m_option_data.m_args array, and any remaining args 738 // are arguments for the inferior program. If no file was specified with 739 // -f, then what is left is the program name followed by any arguments. 740 741 // Skip any options we consumed with getopt_long 742 argc -= optind; 743 argv += optind; 744 745 if (argc > 0) 746 { 747 for (int arg_idx=0; arg_idx<argc; ++arg_idx) 748 { 749 const char *arg = argv[arg_idx]; 750 if (arg) 751 m_option_data.m_args.push_back (arg); 752 } 753 } 754 755 } 756 else 757 { 758 // Skip any options we consumed with getopt_long 759 argc -= optind; 760 //argv += optind; // Commented out to keep static analyzer happy 761 762 if (argc > 0) 763 ::fprintf (out_fh, "Warning: program arguments are ignored when attaching.\n"); 764 } 765 766 return error; 767 } 768 769 size_t 770 Driver::GetProcessSTDOUT () 771 { 772 // The process has stuff waiting for stdout; get it and write it out to the appropriate place. 773 char stdio_buffer[1024]; 774 size_t len; 775 size_t total_bytes = 0; 776 while ((len = m_debugger.GetSelectedTarget().GetProcess().GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 777 { 778 m_io_channel_ap->OutWrite (stdio_buffer, len, ASYNC); 779 total_bytes += len; 780 } 781 return total_bytes; 782 } 783 784 size_t 785 Driver::GetProcessSTDERR () 786 { 787 // The process has stuff waiting for stderr; get it and write it out to the appropriate place. 788 char stdio_buffer[1024]; 789 size_t len; 790 size_t total_bytes = 0; 791 while ((len = m_debugger.GetSelectedTarget().GetProcess().GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 792 { 793 m_io_channel_ap->ErrWrite (stdio_buffer, len, ASYNC); 794 total_bytes += len; 795 } 796 return total_bytes; 797 } 798 799 void 800 Driver::UpdateSelectedThread () 801 { 802 using namespace lldb; 803 SBProcess process(m_debugger.GetSelectedTarget().GetProcess()); 804 if (process.IsValid()) 805 { 806 SBThread curr_thread (process.GetSelectedThread()); 807 SBThread thread; 808 StopReason curr_thread_stop_reason = eStopReasonInvalid; 809 curr_thread_stop_reason = curr_thread.GetStopReason(); 810 811 if (!curr_thread.IsValid() || 812 curr_thread_stop_reason == eStopReasonInvalid || 813 curr_thread_stop_reason == eStopReasonNone) 814 { 815 // Prefer a thread that has just completed its plan over another thread as current thread. 816 SBThread plan_thread; 817 SBThread other_thread; 818 const size_t num_threads = process.GetNumThreads(); 819 size_t i; 820 for (i = 0; i < num_threads; ++i) 821 { 822 thread = process.GetThreadAtIndex(i); 823 StopReason thread_stop_reason = thread.GetStopReason(); 824 switch (thread_stop_reason) 825 { 826 case eStopReasonInvalid: 827 case eStopReasonNone: 828 break; 829 830 case eStopReasonTrace: 831 case eStopReasonBreakpoint: 832 case eStopReasonWatchpoint: 833 case eStopReasonSignal: 834 case eStopReasonException: 835 case eStopReasonExec: 836 case eStopReasonThreadExiting: 837 if (!other_thread.IsValid()) 838 other_thread = thread; 839 break; 840 case eStopReasonPlanComplete: 841 if (!plan_thread.IsValid()) 842 plan_thread = thread; 843 break; 844 } 845 } 846 if (plan_thread.IsValid()) 847 process.SetSelectedThread (plan_thread); 848 else if (other_thread.IsValid()) 849 process.SetSelectedThread (other_thread); 850 else 851 { 852 if (curr_thread.IsValid()) 853 thread = curr_thread; 854 else 855 thread = process.GetThreadAtIndex(0); 856 857 if (thread.IsValid()) 858 process.SetSelectedThread (thread); 859 } 860 } 861 } 862 } 863 864 // This function handles events that were broadcast by the process. 865 void 866 Driver::HandleBreakpointEvent (const SBEvent &event) 867 { 868 using namespace lldb; 869 const uint32_t event_type = SBBreakpoint::GetBreakpointEventTypeFromEvent (event); 870 871 if (event_type & eBreakpointEventTypeAdded 872 || event_type & eBreakpointEventTypeRemoved 873 || event_type & eBreakpointEventTypeEnabled 874 || event_type & eBreakpointEventTypeDisabled 875 || event_type & eBreakpointEventTypeCommandChanged 876 || event_type & eBreakpointEventTypeConditionChanged 877 || event_type & eBreakpointEventTypeIgnoreChanged 878 || event_type & eBreakpointEventTypeLocationsResolved) 879 { 880 // Don't do anything about these events, since the breakpoint commands already echo these actions. 881 } 882 else if (event_type & eBreakpointEventTypeLocationsAdded) 883 { 884 char message[256]; 885 uint32_t num_new_locations = SBBreakpoint::GetNumBreakpointLocationsFromEvent(event); 886 if (num_new_locations > 0) 887 { 888 SBBreakpoint breakpoint = SBBreakpoint::GetBreakpointFromEvent(event); 889 int message_len = ::snprintf (message, sizeof(message), "%d location%s added to breakpoint %d\n", 890 num_new_locations, 891 num_new_locations == 1 ? "" : "s", 892 breakpoint.GetID()); 893 m_io_channel_ap->OutWrite(message, message_len, ASYNC); 894 } 895 } 896 else if (event_type & eBreakpointEventTypeLocationsRemoved) 897 { 898 // These locations just get disabled, not sure it is worth spamming folks about this on the command line. 899 } 900 else if (event_type & eBreakpointEventTypeLocationsResolved) 901 { 902 // This might be an interesting thing to note, but I'm going to leave it quiet for now, it just looked noisy. 903 } 904 } 905 906 // This function handles events that were broadcast by the process. 907 void 908 Driver::HandleProcessEvent (const SBEvent &event) 909 { 910 using namespace lldb; 911 const uint32_t event_type = event.GetType(); 912 913 if (event_type & SBProcess::eBroadcastBitSTDOUT) 914 { 915 // The process has stdout available, get it and write it out to the 916 // appropriate place. 917 GetProcessSTDOUT (); 918 } 919 else if (event_type & SBProcess::eBroadcastBitSTDERR) 920 { 921 // The process has stderr available, get it and write it out to the 922 // appropriate place. 923 GetProcessSTDERR (); 924 } 925 else if (event_type & SBProcess::eBroadcastBitStateChanged) 926 { 927 // Drain all stout and stderr so we don't see any output come after 928 // we print our prompts 929 GetProcessSTDOUT (); 930 GetProcessSTDERR (); 931 // Something changed in the process; get the event and report the process's current status and location to 932 // the user. 933 StateType event_state = SBProcess::GetStateFromEvent (event); 934 if (event_state == eStateInvalid) 935 return; 936 937 SBProcess process (SBProcess::GetProcessFromEvent (event)); 938 assert (process.IsValid()); 939 940 switch (event_state) 941 { 942 case eStateInvalid: 943 case eStateUnloaded: 944 case eStateConnected: 945 case eStateAttaching: 946 case eStateLaunching: 947 case eStateStepping: 948 case eStateDetached: 949 { 950 char message[1024]; 951 int message_len = ::snprintf (message, sizeof(message), "Process %" PRIu64 " %s\n", process.GetProcessID(), 952 m_debugger.StateAsCString (event_state)); 953 m_io_channel_ap->OutWrite(message, message_len, ASYNC); 954 } 955 break; 956 957 case eStateRunning: 958 // Don't be chatty when we run... 959 break; 960 961 case eStateExited: 962 { 963 SBCommandReturnObject result; 964 m_debugger.GetCommandInterpreter().HandleCommand("process status", result, false); 965 m_io_channel_ap->ErrWrite (result.GetError(), result.GetErrorSize(), ASYNC); 966 m_io_channel_ap->OutWrite (result.GetOutput(), result.GetOutputSize(), ASYNC); 967 } 968 break; 969 970 case eStateStopped: 971 case eStateCrashed: 972 case eStateSuspended: 973 // Make sure the program hasn't been auto-restarted: 974 if (SBProcess::GetRestartedFromEvent (event)) 975 { 976 // FIXME: Do we want to report this, or would that just be annoyingly chatty? 977 char message[1024]; 978 int message_len = ::snprintf (message, sizeof(message), "Process %" PRIu64 " stopped and was programmatically restarted.\n", 979 process.GetProcessID()); 980 m_io_channel_ap->OutWrite(message, message_len, ASYNC); 981 } 982 else 983 { 984 if (GetDebugger().GetSelectedTarget() == process.GetTarget()) 985 { 986 SBCommandReturnObject result; 987 UpdateSelectedThread (); 988 m_debugger.GetCommandInterpreter().HandleCommand("process status", result, false); 989 m_io_channel_ap->ErrWrite (result.GetError(), result.GetErrorSize(), ASYNC); 990 m_io_channel_ap->OutWrite (result.GetOutput(), result.GetOutputSize(), ASYNC); 991 } 992 else 993 { 994 SBStream out_stream; 995 uint32_t target_idx = GetDebugger().GetIndexOfTarget(process.GetTarget()); 996 if (target_idx != UINT32_MAX) 997 out_stream.Printf ("Target %d: (", target_idx); 998 else 999 out_stream.Printf ("Target <unknown index>: ("); 1000 process.GetTarget().GetDescription (out_stream, eDescriptionLevelBrief); 1001 out_stream.Printf (") stopped.\n"); 1002 m_io_channel_ap->OutWrite (out_stream.GetData(), out_stream.GetSize(), ASYNC); 1003 } 1004 } 1005 break; 1006 } 1007 } 1008 } 1009 1010 void 1011 Driver::HandleThreadEvent (const SBEvent &event) 1012 { 1013 // At present the only thread event we handle is the Frame Changed event, and all we do for that is just 1014 // reprint the thread status for that thread. 1015 using namespace lldb; 1016 const uint32_t event_type = event.GetType(); 1017 if (event_type == SBThread::eBroadcastBitStackChanged 1018 || event_type == SBThread::eBroadcastBitThreadSelected) 1019 { 1020 SBThread thread = SBThread::GetThreadFromEvent (event); 1021 if (thread.IsValid()) 1022 { 1023 SBStream out_stream; 1024 thread.GetStatus(out_stream); 1025 m_io_channel_ap->OutWrite (out_stream.GetData (), out_stream.GetSize (), ASYNC); 1026 } 1027 } 1028 } 1029 1030 // This function handles events broadcast by the IOChannel (HasInput, UserInterrupt, or ThreadShouldExit). 1031 1032 bool 1033 Driver::HandleIOEvent (const SBEvent &event) 1034 { 1035 bool quit = false; 1036 1037 const uint32_t event_type = event.GetType(); 1038 1039 if (event_type & IOChannel::eBroadcastBitHasUserInput) 1040 { 1041 // We got some input (i.e. a command string) from the user; pass it off to the command interpreter for 1042 // handling. 1043 1044 const char *command_string = SBEvent::GetCStringFromEvent(event); 1045 if (command_string == NULL) 1046 command_string = ""; 1047 SBCommandReturnObject result; 1048 1049 // We don't want the result to bypass the OutWrite function in IOChannel, as this can result in odd 1050 // output orderings and problems with the prompt. 1051 m_debugger.GetCommandInterpreter().HandleCommand (command_string, result, true); 1052 1053 const bool only_if_no_immediate = true; 1054 1055 const size_t output_size = result.GetOutputSize(); 1056 1057 if (output_size > 0) 1058 m_io_channel_ap->OutWrite (result.GetOutput(only_if_no_immediate), output_size, NO_ASYNC); 1059 1060 const size_t error_size = result.GetErrorSize(); 1061 1062 if (error_size > 0) 1063 m_io_channel_ap->OutWrite (result.GetError(only_if_no_immediate), error_size, NO_ASYNC); 1064 1065 // We are done getting and running our command, we can now clear the 1066 // m_waiting_for_command so we can get another one. 1067 m_waiting_for_command = false; 1068 1069 // If our editline input reader is active, it means another input reader 1070 // got pushed onto the input reader and caused us to become deactivated. 1071 // When the input reader above us gets popped, we will get re-activated 1072 // and our prompt will refresh in our callback 1073 if (m_editline_reader.IsActive()) 1074 { 1075 ReadyForCommand (); 1076 } 1077 } 1078 else if (event_type & IOChannel::eBroadcastBitUserInterrupt) 1079 { 1080 // This is here to handle control-c interrupts from the user. It has not yet really been implemented. 1081 // TO BE DONE: PROPERLY HANDLE CONTROL-C FROM USER 1082 //m_io_channel_ap->CancelInput(); 1083 // Anything else? Send Interrupt to process? 1084 } 1085 else if ((event_type & IOChannel::eBroadcastBitThreadShouldExit) || 1086 (event_type & IOChannel::eBroadcastBitThreadDidExit)) 1087 { 1088 // If the IOChannel thread is trying to go away, then it is definitely 1089 // time to end the debugging session. 1090 quit = true; 1091 } 1092 1093 return quit; 1094 } 1095 1096 void 1097 Driver::MasterThreadBytesReceived (void *baton, const void *src, size_t src_len) 1098 { 1099 Driver *driver = (Driver*)baton; 1100 driver->GetFromMaster ((const char *)src, src_len); 1101 } 1102 1103 void 1104 Driver::GetFromMaster (const char *src, size_t src_len) 1105 { 1106 // Echo the characters back to the Debugger's stdout, that way if you 1107 // type characters while a command is running, you'll see what you've typed. 1108 FILE *out_fh = m_debugger.GetOutputFileHandle(); 1109 if (out_fh) 1110 ::fwrite (src, 1, src_len, out_fh); 1111 } 1112 1113 size_t 1114 Driver::EditLineInputReaderCallback 1115 ( 1116 void *baton, 1117 SBInputReader *reader, 1118 InputReaderAction notification, 1119 const char *bytes, 1120 size_t bytes_len 1121 ) 1122 { 1123 Driver *driver = (Driver *)baton; 1124 1125 switch (notification) 1126 { 1127 case eInputReaderActivate: 1128 break; 1129 1130 case eInputReaderReactivate: 1131 driver->ReadyForCommand(); 1132 break; 1133 1134 case eInputReaderDeactivate: 1135 break; 1136 1137 case eInputReaderAsynchronousOutputWritten: 1138 if (driver->m_io_channel_ap.get() != NULL) 1139 driver->m_io_channel_ap->RefreshPrompt(); 1140 break; 1141 1142 case eInputReaderInterrupt: 1143 if (driver->m_io_channel_ap.get() != NULL) 1144 { 1145 SBProcess process(driver->GetDebugger().GetSelectedTarget().GetProcess()); 1146 if (!driver->m_io_channel_ap->EditLineHasCharacters() 1147 && process.IsValid() 1148 && (process.GetState() == lldb::eStateRunning || process.GetState() == lldb::eStateAttaching)) 1149 { 1150 process.SendAsyncInterrupt (); 1151 } 1152 else 1153 { 1154 driver->m_io_channel_ap->OutWrite ("^C\n", 3, NO_ASYNC); 1155 // I wish I could erase the entire input line, but there's no public API for that. 1156 driver->m_io_channel_ap->EraseCharsBeforeCursor(); 1157 driver->m_io_channel_ap->RefreshPrompt(); 1158 } 1159 } 1160 break; 1161 1162 case eInputReaderEndOfFile: 1163 if (driver->m_io_channel_ap.get() != NULL) 1164 { 1165 driver->m_io_channel_ap->OutWrite ("^D\n", 3, NO_ASYNC); 1166 driver->m_io_channel_ap->RefreshPrompt (); 1167 } 1168 write (driver->m_editline_pty.GetMasterFileDescriptor(), "quit\n", 5); 1169 break; 1170 1171 case eInputReaderGotToken: 1172 write (driver->m_editline_pty.GetMasterFileDescriptor(), bytes, bytes_len); 1173 break; 1174 1175 case eInputReaderDone: 1176 break; 1177 } 1178 return bytes_len; 1179 } 1180 1181 void 1182 Driver::MainLoop () 1183 { 1184 char error_str[1024]; 1185 if (m_editline_pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, error_str, sizeof(error_str)) == false) 1186 { 1187 ::fprintf (stderr, "error: failed to open driver pseudo terminal : %s", error_str); 1188 exit(1); 1189 } 1190 else 1191 { 1192 const char *driver_slave_name = m_editline_pty.GetSlaveName (error_str, sizeof(error_str)); 1193 if (driver_slave_name == NULL) 1194 { 1195 ::fprintf (stderr, "error: failed to get slave name for driver pseudo terminal : %s", error_str); 1196 exit(2); 1197 } 1198 else 1199 { 1200 m_editline_slave_fh = ::fopen (driver_slave_name, "r+"); 1201 if (m_editline_slave_fh == NULL) 1202 { 1203 SBError error; 1204 error.SetErrorToErrno(); 1205 ::fprintf (stderr, "error: failed to get open slave for driver pseudo terminal : %s", 1206 error.GetCString()); 1207 exit(3); 1208 } 1209 1210 ::setbuf (m_editline_slave_fh, NULL); 1211 } 1212 } 1213 1214 lldb_utility::PseudoTerminal editline_output_pty; 1215 FILE *editline_output_slave_fh = NULL; 1216 1217 if (editline_output_pty.OpenFirstAvailableMaster (O_RDWR|O_NOCTTY, error_str, sizeof (error_str)) == false) 1218 { 1219 ::fprintf (stderr, "error: failed to open output pseudo terminal : %s", error_str); 1220 exit(1); 1221 } 1222 else 1223 { 1224 const char *output_slave_name = editline_output_pty.GetSlaveName (error_str, sizeof(error_str)); 1225 if (output_slave_name == NULL) 1226 { 1227 ::fprintf (stderr, "error: failed to get slave name for output pseudo terminal : %s", error_str); 1228 exit(2); 1229 } 1230 else 1231 { 1232 editline_output_slave_fh = ::fopen (output_slave_name, "r+"); 1233 if (editline_output_slave_fh == NULL) 1234 { 1235 SBError error; 1236 error.SetErrorToErrno(); 1237 ::fprintf (stderr, "error: failed to get open slave for output pseudo terminal : %s", 1238 error.GetCString()); 1239 exit(3); 1240 } 1241 ::setbuf (editline_output_slave_fh, NULL); 1242 } 1243 } 1244 1245 // struct termios stdin_termios; 1246 1247 if (::tcgetattr(STDIN_FILENO, &g_old_stdin_termios) == 0) 1248 { 1249 g_old_stdin_termios_is_valid = true; 1250 atexit (reset_stdin_termios); 1251 } 1252 1253 ::setbuf (stdin, NULL); 1254 ::setbuf (stdout, NULL); 1255 1256 m_debugger.SetErrorFileHandle (stderr, false); 1257 m_debugger.SetOutputFileHandle (stdout, false); 1258 m_debugger.SetInputFileHandle (stdin, true); 1259 1260 m_debugger.SetUseExternalEditor(m_option_data.m_use_external_editor); 1261 1262 // You have to drain anything that comes to the master side of the PTY. master_out_comm is 1263 // for that purpose. The reason you need to do this is a curious reason... editline will echo 1264 // characters to the PTY when it gets characters while el_gets is not running, and then when 1265 // you call el_gets (or el_getc) it will try to reset the terminal back to raw mode which blocks 1266 // if there are unconsumed characters in the out buffer. 1267 // However, you don't need to do anything with the characters, since editline will dump these 1268 // unconsumed characters after printing the prompt again in el_gets. 1269 1270 SBCommunication master_out_comm("driver.editline"); 1271 master_out_comm.SetCloseOnEOF (false); 1272 master_out_comm.AdoptFileDesriptor(m_editline_pty.GetMasterFileDescriptor(), false); 1273 master_out_comm.SetReadThreadBytesReceivedCallback(Driver::MasterThreadBytesReceived, this); 1274 1275 if (master_out_comm.ReadThreadStart () == false) 1276 { 1277 ::fprintf (stderr, "error: failed to start master out read thread"); 1278 exit(5); 1279 } 1280 1281 SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter(); 1282 1283 m_io_channel_ap.reset (new IOChannel(m_editline_slave_fh, editline_output_slave_fh, stdout, stderr, this)); 1284 1285 SBCommunication out_comm_2("driver.editline_output"); 1286 out_comm_2.SetCloseOnEOF (false); 1287 out_comm_2.AdoptFileDesriptor (editline_output_pty.GetMasterFileDescriptor(), false); 1288 out_comm_2.SetReadThreadBytesReceivedCallback (IOChannel::LibeditOutputBytesReceived, m_io_channel_ap.get()); 1289 1290 if (out_comm_2.ReadThreadStart () == false) 1291 { 1292 ::fprintf (stderr, "error: failed to start libedit output read thread"); 1293 exit (5); 1294 } 1295 1296 1297 struct winsize window_size; 1298 if (isatty (STDIN_FILENO) 1299 && ::ioctl (STDIN_FILENO, TIOCGWINSZ, &window_size) == 0) 1300 { 1301 if (window_size.ws_col > 0) 1302 m_debugger.SetTerminalWidth (window_size.ws_col); 1303 } 1304 1305 // Since input can be redirected by the debugger, we must insert our editline 1306 // input reader in the queue so we know when our reader should be active 1307 // and so we can receive bytes only when we are supposed to. 1308 SBError err (m_editline_reader.Initialize (m_debugger, 1309 Driver::EditLineInputReaderCallback, // callback 1310 this, // baton 1311 eInputReaderGranularityByte, // token_size 1312 NULL, // end token - NULL means never done 1313 NULL, // prompt - taken care of elsewhere 1314 false)); // echo input - don't need Debugger 1315 // to do this, we handle it elsewhere 1316 1317 if (err.Fail()) 1318 { 1319 ::fprintf (stderr, "error: %s", err.GetCString()); 1320 exit (6); 1321 } 1322 1323 m_debugger.PushInputReader (m_editline_reader); 1324 1325 SBListener listener(m_debugger.GetListener()); 1326 if (listener.IsValid()) 1327 { 1328 1329 listener.StartListeningForEventClass(m_debugger, 1330 SBTarget::GetBroadcasterClassName(), 1331 SBTarget::eBroadcastBitBreakpointChanged); 1332 listener.StartListeningForEventClass(m_debugger, 1333 SBThread::GetBroadcasterClassName(), 1334 SBThread::eBroadcastBitStackChanged | 1335 SBThread::eBroadcastBitThreadSelected); 1336 listener.StartListeningForEvents (*m_io_channel_ap, 1337 IOChannel::eBroadcastBitHasUserInput | 1338 IOChannel::eBroadcastBitUserInterrupt | 1339 IOChannel::eBroadcastBitThreadShouldExit | 1340 IOChannel::eBroadcastBitThreadDidStart | 1341 IOChannel::eBroadcastBitThreadDidExit); 1342 1343 if (m_io_channel_ap->Start ()) 1344 { 1345 bool iochannel_thread_exited = false; 1346 1347 listener.StartListeningForEvents (sb_interpreter.GetBroadcaster(), 1348 SBCommandInterpreter::eBroadcastBitQuitCommandReceived | 1349 SBCommandInterpreter::eBroadcastBitAsynchronousOutputData | 1350 SBCommandInterpreter::eBroadcastBitAsynchronousErrorData); 1351 1352 // Before we handle any options from the command line, we parse the 1353 // .lldbinit file in the user's home directory. 1354 SBCommandReturnObject result; 1355 sb_interpreter.SourceInitFileInHomeDirectory(result); 1356 if (GetDebugMode()) 1357 { 1358 result.PutError (m_debugger.GetErrorFileHandle()); 1359 result.PutOutput (m_debugger.GetOutputFileHandle()); 1360 } 1361 1362 // Now we handle options we got from the command line 1363 char command_string[PATH_MAX * 2]; 1364 const size_t num_source_command_files = GetNumSourceCommandFiles(); 1365 const bool dump_stream_only_if_no_immediate = true; 1366 if (num_source_command_files > 0) 1367 { 1368 for (size_t i=0; i < num_source_command_files; ++i) 1369 { 1370 const char *command_file = GetSourceCommandFileAtIndex(i); 1371 ::snprintf (command_string, sizeof(command_string), "command source '%s'", command_file); 1372 m_debugger.GetCommandInterpreter().HandleCommand (command_string, result, false); 1373 if (GetDebugMode()) 1374 { 1375 result.PutError (m_debugger.GetErrorFileHandle()); 1376 result.PutOutput (m_debugger.GetOutputFileHandle()); 1377 } 1378 1379 // if the command sourcing generated an error - dump the result object 1380 if (result.Succeeded() == false) 1381 { 1382 const size_t output_size = result.GetOutputSize(); 1383 if (output_size > 0) 1384 m_io_channel_ap->OutWrite (result.GetOutput(dump_stream_only_if_no_immediate), output_size, NO_ASYNC); 1385 const size_t error_size = result.GetErrorSize(); 1386 if (error_size > 0) 1387 m_io_channel_ap->OutWrite (result.GetError(dump_stream_only_if_no_immediate), error_size, NO_ASYNC); 1388 } 1389 1390 result.Clear(); 1391 } 1392 } 1393 1394 // Was there a core file specified? 1395 std::string core_file_spec(""); 1396 if (!m_option_data.m_core_file.empty()) 1397 core_file_spec.append("--core ").append(m_option_data.m_core_file); 1398 1399 const size_t num_args = m_option_data.m_args.size(); 1400 if (num_args > 0) 1401 { 1402 char arch_name[64]; 1403 if (m_debugger.GetDefaultArchitecture (arch_name, sizeof (arch_name))) 1404 ::snprintf (command_string, 1405 sizeof (command_string), 1406 "target create --arch=%s %s \"%s\"", 1407 arch_name, 1408 core_file_spec.c_str(), 1409 m_option_data.m_args[0].c_str()); 1410 else 1411 ::snprintf (command_string, 1412 sizeof(command_string), 1413 "target create %s \"%s\"", 1414 core_file_spec.c_str(), 1415 m_option_data.m_args[0].c_str()); 1416 1417 m_debugger.HandleCommand (command_string); 1418 1419 if (num_args > 1) 1420 { 1421 m_debugger.HandleCommand ("settings clear target.run-args"); 1422 char arg_cstr[1024]; 1423 for (size_t arg_idx = 1; arg_idx < num_args; ++arg_idx) 1424 { 1425 ::snprintf (arg_cstr, 1426 sizeof(arg_cstr), 1427 "settings append target.run-args \"%s\"", 1428 m_option_data.m_args[arg_idx].c_str()); 1429 m_debugger.HandleCommand (arg_cstr); 1430 } 1431 } 1432 } 1433 else if (!core_file_spec.empty()) 1434 { 1435 ::snprintf (command_string, 1436 sizeof(command_string), 1437 "target create %s", 1438 core_file_spec.c_str()); 1439 m_debugger.HandleCommand (command_string);; 1440 } 1441 1442 // Now that all option parsing is done, we try and parse the .lldbinit 1443 // file in the current working directory 1444 sb_interpreter.SourceInitFileInCurrentWorkingDirectory (result); 1445 if (GetDebugMode()) 1446 { 1447 result.PutError(m_debugger.GetErrorFileHandle()); 1448 result.PutOutput(m_debugger.GetOutputFileHandle()); 1449 } 1450 1451 SBEvent event; 1452 1453 // Make sure the IO channel is started up before we try to tell it we 1454 // are ready for input 1455 listener.WaitForEventForBroadcasterWithType (UINT32_MAX, 1456 *m_io_channel_ap, 1457 IOChannel::eBroadcastBitThreadDidStart, 1458 event); 1459 // If we were asked to attach, then do that here: 1460 // I'm going to use the command string rather than directly 1461 // calling the API's because then I don't have to recode the 1462 // event handling here. 1463 if (!m_option_data.m_process_name.empty() 1464 || m_option_data.m_process_pid != LLDB_INVALID_PROCESS_ID) 1465 { 1466 std::string command_str("process attach "); 1467 if (m_option_data.m_process_pid != LLDB_INVALID_PROCESS_ID) 1468 { 1469 command_str.append("-p "); 1470 char pid_buffer[32]; 1471 ::snprintf (pid_buffer, sizeof(pid_buffer), "%" PRIu64, m_option_data.m_process_pid); 1472 command_str.append(pid_buffer); 1473 } 1474 else 1475 { 1476 command_str.append("-n \""); 1477 command_str.append(m_option_data.m_process_name); 1478 command_str.push_back('\"'); 1479 if (m_option_data.m_wait_for) 1480 command_str.append(" -w"); 1481 } 1482 1483 if (m_debugger.GetOutputFileHandle()) 1484 ::fprintf (m_debugger.GetOutputFileHandle(), 1485 "Attaching to process with:\n %s\n", 1486 command_str.c_str()); 1487 1488 // Force the attach to be synchronous: 1489 bool orig_async = m_debugger.GetAsync(); 1490 m_debugger.SetAsync(true); 1491 m_debugger.HandleCommand(command_str.c_str()); 1492 m_debugger.SetAsync(orig_async); 1493 } 1494 1495 ReadyForCommand (); 1496 1497 while (!GetIsDone()) 1498 { 1499 listener.WaitForEvent (UINT32_MAX, event); 1500 if (event.IsValid()) 1501 { 1502 if (event.GetBroadcaster().IsValid()) 1503 { 1504 uint32_t event_type = event.GetType(); 1505 if (event.BroadcasterMatchesRef (*m_io_channel_ap)) 1506 { 1507 if ((event_type & IOChannel::eBroadcastBitThreadShouldExit) || 1508 (event_type & IOChannel::eBroadcastBitThreadDidExit)) 1509 { 1510 SetIsDone(); 1511 if (event_type & IOChannel::eBroadcastBitThreadDidExit) 1512 iochannel_thread_exited = true; 1513 } 1514 else 1515 { 1516 if (HandleIOEvent (event)) 1517 SetIsDone(); 1518 } 1519 } 1520 else if (SBProcess::EventIsProcessEvent (event)) 1521 { 1522 HandleProcessEvent (event); 1523 } 1524 else if (SBBreakpoint::EventIsBreakpointEvent (event)) 1525 { 1526 HandleBreakpointEvent (event); 1527 } 1528 else if (SBThread::EventIsThreadEvent (event)) 1529 { 1530 HandleThreadEvent (event); 1531 } 1532 else if (event.BroadcasterMatchesRef (sb_interpreter.GetBroadcaster())) 1533 { 1534 // TODO: deprecate the eBroadcastBitQuitCommandReceived event 1535 // now that we have SBCommandInterpreter::SetCommandOverrideCallback() 1536 // that can take over a command 1537 if (event_type & SBCommandInterpreter::eBroadcastBitQuitCommandReceived) 1538 { 1539 SetIsDone(); 1540 } 1541 else if (event_type & SBCommandInterpreter::eBroadcastBitAsynchronousErrorData) 1542 { 1543 const char *data = SBEvent::GetCStringFromEvent (event); 1544 m_io_channel_ap->ErrWrite (data, strlen(data), ASYNC); 1545 } 1546 else if (event_type & SBCommandInterpreter::eBroadcastBitAsynchronousOutputData) 1547 { 1548 const char *data = SBEvent::GetCStringFromEvent (event); 1549 m_io_channel_ap->OutWrite (data, strlen(data), ASYNC); 1550 } 1551 } 1552 } 1553 } 1554 } 1555 1556 editline_output_pty.CloseMasterFileDescriptor(); 1557 master_out_comm.Disconnect(); 1558 out_comm_2.Disconnect(); 1559 reset_stdin_termios(); 1560 fclose (stdin); 1561 1562 CloseIOChannelFile (); 1563 1564 if (!iochannel_thread_exited) 1565 { 1566 event.Clear(); 1567 listener.GetNextEventForBroadcasterWithType (*m_io_channel_ap, 1568 IOChannel::eBroadcastBitThreadDidExit, 1569 event); 1570 if (!event.IsValid()) 1571 { 1572 // Send end EOF to the driver file descriptor 1573 m_io_channel_ap->Stop(); 1574 } 1575 } 1576 1577 SBDebugger::Destroy (m_debugger); 1578 } 1579 } 1580 } 1581 1582 1583 void 1584 Driver::ReadyForCommand () 1585 { 1586 if (m_waiting_for_command == false) 1587 { 1588 m_waiting_for_command = true; 1589 BroadcastEventByType (Driver::eBroadcastBitReadyForInput, true); 1590 } 1591 } 1592 1593 1594 void 1595 sigwinch_handler (int signo) 1596 { 1597 struct winsize window_size; 1598 if (isatty (STDIN_FILENO) 1599 && ::ioctl (STDIN_FILENO, TIOCGWINSZ, &window_size) == 0) 1600 { 1601 if ((window_size.ws_col > 0) && g_driver != NULL) 1602 { 1603 g_driver->GetDebugger().SetTerminalWidth (window_size.ws_col); 1604 } 1605 } 1606 } 1607 1608 void 1609 sigint_handler (int signo) 1610 { 1611 static bool g_interrupt_sent = false; 1612 if (g_driver) 1613 { 1614 if (!g_interrupt_sent) 1615 { 1616 g_interrupt_sent = true; 1617 g_driver->GetDebugger().DispatchInputInterrupt(); 1618 g_interrupt_sent = false; 1619 return; 1620 } 1621 } 1622 1623 exit (signo); 1624 } 1625 1626 void 1627 sigtstp_handler (int signo) 1628 { 1629 g_driver->GetDebugger().SaveInputTerminalState(); 1630 signal (signo, SIG_DFL); 1631 kill (getpid(), signo); 1632 signal (signo, sigtstp_handler); 1633 } 1634 1635 void 1636 sigcont_handler (int signo) 1637 { 1638 g_driver->GetDebugger().RestoreInputTerminalState(); 1639 signal (signo, SIG_DFL); 1640 kill (getpid(), signo); 1641 signal (signo, sigcont_handler); 1642 } 1643 1644 int 1645 main (int argc, char const *argv[], const char *envp[]) 1646 { 1647 SBDebugger::Initialize(); 1648 1649 SBHostOS::ThreadCreated ("<lldb.driver.main-thread>"); 1650 1651 signal (SIGPIPE, SIG_IGN); 1652 signal (SIGWINCH, sigwinch_handler); 1653 signal (SIGINT, sigint_handler); 1654 signal (SIGTSTP, sigtstp_handler); 1655 signal (SIGCONT, sigcont_handler); 1656 1657 // Create a scope for driver so that the driver object will destroy itself 1658 // before SBDebugger::Terminate() is called. 1659 { 1660 Driver driver; 1661 1662 bool exit = false; 1663 SBError error (driver.ParseArgs (argc, argv, stdout, exit)); 1664 if (error.Fail()) 1665 { 1666 const char *error_cstr = error.GetCString (); 1667 if (error_cstr) 1668 ::fprintf (stderr, "error: %s\n", error_cstr); 1669 } 1670 else if (!exit) 1671 { 1672 driver.MainLoop (); 1673 } 1674 } 1675 1676 SBDebugger::Terminate(); 1677 return 0; 1678 } 1679