int main (int argc, char const *argv[], const char *envp[]) { SBDebugger::Initialize(); SBHostOS::ThreadCreated ("<lldb.driver.main-thread>"); signal (SIGPIPE, SIG_IGN); signal (SIGWINCH, sigwinch_handler); signal (SIGINT, sigint_handler); signal (SIGTSTP, sigtstp_handler); signal (SIGCONT, sigcont_handler); // Create a scope for driver so that the driver object will destroy itself // before SBDebugger::Terminate() is called. { Driver driver; bool exiting = false; SBError error (driver.ParseArgs (argc, argv, stdout, exiting)); if (error.Fail()) { const char *error_cstr = error.GetCString (); if (error_cstr) ::fprintf (stderr, "error: %s\n", error_cstr); } else if (!exiting) { driver.MainLoop (); } } SBDebugger::Terminate(); return 0; }
SBError SBDebugger::RunREPL (lldb::LanguageType language, const char *repl_options) { SBError error; if (m_opaque_sp) error.ref() = m_opaque_sp->RunREPL(language, repl_options); else error.SetErrorString ("invalid debugger"); return error; }
size_t SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error) { size_t bytes_written = 0; LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); ProcessSP process_sp(GetSP()); if (log) { log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p))...", process_sp.get(), addr, src, src_len, sb_error.get()); } if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref()); } else { if (log) log->Printf ("SBProcess(%p)::WriteMemory() => error: process is running", process_sp.get()); sb_error.SetErrorString("process is running"); } } if (log) { SBStream sstr; sb_error.GetDescription (sstr); log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p): %s) => %zu", process_sp.get(), addr, src, src_len, sb_error.get(), sstr.GetData(), bytes_written); } return bytes_written; }
void Driver::OptionData::AddInitialCommand (const char *command, bool before_file, bool is_file, SBError &error) { std::vector<std::pair<bool, std::string> > *command_set; if (before_file) command_set = &(m_initial_commands); else command_set = &(m_after_file_commands); if (is_file) { SBFileSpec file(command); if (file.Exists()) command_set->push_back (std::pair<bool, std::string> (true, optarg)); else if (file.ResolveExecutableLocation()) { char final_path[PATH_MAX]; file.GetPath (final_path, sizeof(final_path)); std::string path_str (final_path); command_set->push_back (std::pair<bool, std::string> (true, path_str)); } else error.SetErrorStringWithFormat("file specified in --source (-s) option doesn't exist: '%s'", optarg); } else command_set->push_back (std::pair<bool, std::string> (false, optarg)); }
void Driver::OptionData::AddInitialCommand (const char *command, CommandPlacement placement, bool is_file, SBError &error) { std::vector<InitialCmdEntry> *command_set; switch (placement) { case eCommandPlacementBeforeFile: command_set = &(m_initial_commands); break; case eCommandPlacementAfterFile: command_set = &(m_after_file_commands); break; case eCommandPlacementAfterCrash: command_set = &(m_after_crash_commands); break; } if (is_file) { SBFileSpec file(command); if (file.Exists()) command_set->push_back (InitialCmdEntry(command, is_file)); else if (file.ResolveExecutableLocation()) { char final_path[PATH_MAX]; file.GetPath (final_path, sizeof(final_path)); command_set->push_back (InitialCmdEntry(final_path, is_file)); } else error.SetErrorStringWithFormat("file specified in --source (-s) option doesn't exist: '%s'", optarg); } else command_set->push_back (InitialCmdEntry(command, is_file)); }
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address, lldb::addr_t size, SBError &error) { if (m_opaque_sp) { Address *start_address = sb_start_address.get(); if (!start_address) { return SBThreadPlan(); } AddressRange range(*start_address, size); SymbolContext sc; start_address->CalculateSymbolContext(&sc); Status plan_status; SBThreadPlan plan = SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepInRange( false, range, sc, NULL, eAllThreads, plan_status)); if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); return plan; } else { return SBThreadPlan(); } }
bool SBValue::SetData (lldb::SBData &data, SBError &error) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); bool ret = true; if (value_sp) { DataExtractor *data_extractor = data.get(); if (!data_extractor) { if (log) log->Printf ("SBValue(%p)::SetData() => error: no data to set", value_sp.get()); error.SetErrorString("No data to set"); ret = false; } else { Error set_error; value_sp->SetData(*data_extractor, set_error); if (!set_error.Success()) { error.SetErrorStringWithFormat("Couldn't set data: %s", set_error.AsCString()); ret = false; } } } else { error.SetErrorStringWithFormat ("Couldn't set data: could not get SBValue: %s", locker.GetError().AsCString()); ret = false; } if (log) log->Printf ("SBValue(%p)::SetData (%p) => %s", value_sp.get(), data.get(), ret ? "true" : "false"); return ret; }
size_t SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); size_t bytes_read = 0; if (log) { log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p))...", m_opaque_sp.get(), addr, dst, (uint32_t) dst_len, sb_error.get()); } if (m_opaque_sp) { Error error; Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex()); bytes_read = m_opaque_sp->ReadMemory (addr, dst, dst_len, error); sb_error.SetError (error); } else { sb_error.SetErrorString ("SBProcess is invalid"); } if (log) { SBStream sstr; sb_error.GetDescription (sstr); log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%zu, SBError (%p): %s) => %d", m_opaque_sp.get(), addr, dst, (uint32_t) dst_len, sb_error.get(), sstr.GetData(), (uint32_t) bytes_read); } return bytes_read; }
void listener_func() { while (!g_done) { SBEvent event; bool got_event = g_listener.WaitForEvent(1, event); if (got_event) { if (!event.IsValid()) throw Exception("event is not valid in listener thread"); SBProcess process = SBProcess::GetProcessFromEvent(event); if (process.GetState() == eStateStopped) { SBError error = process.Continue(); if (!error.Success()) throw Exception(string("Cannot continue process from listener thread: ") + error.GetCString()); g_process_started.push(true); } } } }
uint64_t SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) { error.Clear(); ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); if (value_sp) { Scalar scalar; if (value_sp->ResolveValue (scalar)) return scalar.ULongLong(fail_value); else error.SetErrorString("could not resolve value"); } else error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString()); return fail_value; }
uint64_t SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) { error.Clear(); if (m_opaque_sp) { if (m_opaque_sp->GetUpdatePoint().GetTargetSP()) { Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); Scalar scalar; if (m_opaque_sp->ResolveValue (scalar)) return scalar.GetRawBits64(fail_value); else error.SetErrorString("could not get value"); } else error.SetErrorString("could not get target"); } error.SetErrorString("invalid SBValue"); return fail_value; }
size_t SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error) { size_t bytes_written = 0; LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) { log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p))...", m_opaque_sp.get(), addr, src, (uint32_t) src_len, sb_error.get()); } if (m_opaque_sp) { Error error; Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex()); bytes_written = m_opaque_sp->WriteMemory (addr, src, src_len, error); sb_error.SetError (error); } if (log) { SBStream sstr; sb_error.GetDescription (sstr); log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%llx, src=%p, dst_len=%zu, SBError (%p): %s) => %d", m_opaque_sp.get(), addr, src, (uint32_t) src_len, sb_error.get(), sstr.GetData(), (uint32_t) bytes_written); } return bytes_written; }
int main (int argc, char const *argv[], const char *envp[]) { #if 1 // Enable for debug logging lldb::StreamSP logStream(new lldb_private::StreamCallback(LogOutput, 0)); const char* logCategories[] = { 0 }; lldb::LogSP log = lldb_private::EnableLog(logStream, 0, logCategories, 0); log->GetMask().Reset(LIBLLDB_LOG_ALL); #endif SBDebugger::Initialize(); SBHostOS::ThreadCreated ("<lldb.driver.main-thread>"); SetupPosixSignals(); // Create a scope for driver so that the driver object will destroy itself // before SBDebugger::Terminate() is called. { Driver driver; bool exit = false; SBError error = driver.ParseArgs (argc, argv, stdout, exit); if (error.Fail()) { const char *error_cstr = error.GetCString (); if (error_cstr) ::fprintf (stderr, "error: %s\n", error_cstr); } else if (!exit) { driver.Initialize(); } } SBDebugger::Terminate(); return 0; }
size_t SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error) { LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); size_t bytes_read = 0; ProcessSP process_sp(GetSP()); if (log) { log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%llu, SBError (%p))...", process_sp.get(), addr, dst, (uint64_t)dst_len, sb_error.get()); } if (process_sp) { Process::StopLocker stop_locker; if (stop_locker.TryLock(&process_sp->GetRunLock())) { Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref()); } else { if (log) log->Printf ("SBProcess(%p)::ReadMemory() => error: process is running", process_sp.get()); sb_error.SetErrorString("process is running"); } } else { sb_error.SetErrorString ("SBProcess is invalid"); } if (log) { SBStream sstr; sb_error.GetDescription (sstr); log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%llx, dst=%p, dst_len=%llu, SBError (%p): %s) => %llu", process_sp.get(), addr, dst, (uint64_t)dst_len, sb_error.get(), sstr.GetData(), (uint64_t)bytes_read); } return bytes_read; }
void SBThread::StepInto(const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); std::unique_lock<std::recursive_mutex> lock; ExecutionContext exe_ctx(m_opaque_sp.get(), lock); if (log) log->Printf( "SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')", static_cast<void *>(exe_ctx.GetThreadPtr()), target_name ? target_name : "<NULL>", Thread::RunModeAsCString(stop_other_threads)); if (exe_ctx.HasThreadScope()) { bool abort_other_plans = false; Thread *thread = exe_ctx.GetThreadPtr(); StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); ThreadPlanSP new_plan_sp; if (frame_sp && frame_sp->HasDebugInformation()) { SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything)); AddressRange range; if (end_line == LLDB_INVALID_LINE_NUMBER) range = sc.line_entry.range; else { if (!sc.GetAddressRangeFromHereToEndLine(end_line, range, error.ref())) return; } const LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate; const LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate; new_plan_sp = thread->QueueThreadPlanForStepInRange( abort_other_plans, range, sc, target_name, stop_other_threads, step_in_avoids_code_without_debug_info, step_out_avoids_code_without_debug_info); } else { new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction( false, abort_other_plans, stop_other_threads); } error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); } }
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name, SBError &error) { if (m_opaque_sp) { Status plan_status; SBThreadPlan plan = SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted( false, script_class_name, false, plan_status)); if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); return plan; } else { return SBThreadPlan(); } }
SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address, SBError &error) { if (m_opaque_sp) { Address *address = sb_address.get(); if (!address) return SBThreadPlan(); Status plan_status; SBThreadPlan plan = SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress( false, *address, false, plan_status)); if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); return plan; } else { return SBThreadPlan(); } }
SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to, bool first_insn, SBError &error) { if (m_opaque_sp) { SymbolContext sc; sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext( lldb::eSymbolContextEverything); Status plan_status; SBThreadPlan plan = SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut( false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion, frame_idx_to_step_to, plan_status)); if (plan_status.Fail()) error.SetErrorString(plan_status.AsCString()); return plan; } else { return SBThreadPlan(); } }
void Driver::MainLoop () { if (::tcgetattr(STDIN_FILENO, &g_old_stdin_termios) == 0) { g_old_stdin_termios_is_valid = true; atexit (reset_stdin_termios); } ::setbuf (stdin, NULL); ::setbuf (stdout, NULL); m_debugger.SetErrorFileHandle (stderr, false); m_debugger.SetOutputFileHandle (stdout, false); m_debugger.SetInputFileHandle (stdin, false); // Don't take ownership of STDIN yet... m_debugger.SetUseExternalEditor(m_option_data.m_use_external_editor); struct winsize window_size; if (isatty (STDIN_FILENO) && ::ioctl (STDIN_FILENO, TIOCGWINSZ, &window_size) == 0) { if (window_size.ws_col > 0) m_debugger.SetTerminalWidth (window_size.ws_col); } SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter(); // Before we handle any options from the command line, we parse the // .lldbinit file in the user's home directory. SBCommandReturnObject result; sb_interpreter.SourceInitFileInHomeDirectory(result); if (GetDebugMode()) { result.PutError (m_debugger.GetErrorFileHandle()); result.PutOutput (m_debugger.GetOutputFileHandle()); } // Now we handle options we got from the command line SBStream commands_stream; // First source in the commands specified to be run before the file arguments are processed. WriteCommandsForSourcing(eCommandPlacementBeforeFile, commands_stream); const size_t num_args = m_option_data.m_args.size(); if (num_args > 0) { char arch_name[64]; if (m_debugger.GetDefaultArchitecture (arch_name, sizeof (arch_name))) commands_stream.Printf("target create --arch=%s %s", arch_name, EscapeString(m_option_data.m_args[0]).c_str()); else commands_stream.Printf("target create %s", EscapeString(m_option_data.m_args[0]).c_str()); if (!m_option_data.m_core_file.empty()) { commands_stream.Printf(" --core %s", EscapeString(m_option_data.m_core_file).c_str()); } commands_stream.Printf("\n"); if (num_args > 1) { commands_stream.Printf ("settings set -- target.run-args "); for (size_t arg_idx = 1; arg_idx < num_args; ++arg_idx) commands_stream.Printf(" %s", EscapeString(m_option_data.m_args[arg_idx]).c_str()); commands_stream.Printf("\n"); } } else if (!m_option_data.m_core_file.empty()) { commands_stream.Printf("target create --core %s\n", EscapeString(m_option_data.m_core_file).c_str()); } else if (!m_option_data.m_process_name.empty()) { commands_stream.Printf ("process attach --name %s", EscapeString(m_option_data.m_process_name).c_str()); if (m_option_data.m_wait_for) commands_stream.Printf(" --waitfor"); commands_stream.Printf("\n"); } else if (LLDB_INVALID_PROCESS_ID != m_option_data.m_process_pid) { commands_stream.Printf ("process attach --pid %" PRIu64 "\n", m_option_data.m_process_pid); } WriteCommandsForSourcing(eCommandPlacementAfterFile, commands_stream); if (GetDebugMode()) { result.PutError(m_debugger.GetErrorFileHandle()); result.PutOutput(m_debugger.GetOutputFileHandle()); } bool handle_events = true; bool spawn_thread = false; if (m_option_data.m_repl) { const char *repl_options = NULL; if (!m_option_data.m_repl_options.empty()) repl_options = m_option_data.m_repl_options.c_str(); SBError error (m_debugger.RunREPL(m_option_data.m_repl_lang, repl_options)); if (error.Fail()) { const char *error_cstr = error.GetCString(); if (error_cstr && error_cstr[0]) fprintf (stderr, "error: %s\n", error_cstr); else fprintf (stderr, "error: %u\n", error.GetError()); } } else { // Check if we have any data in the commands stream, and if so, save it to a temp file // so we can then run the command interpreter using the file contents. const char *commands_data = commands_stream.GetData(); const size_t commands_size = commands_stream.GetSize(); // The command file might have requested that we quit, this variable will track that. bool quit_requested = false; bool stopped_for_crash = false; if (commands_data && commands_size) { int initial_commands_fds[2]; bool success = true; FILE *commands_file = PrepareCommandsForSourcing (commands_data, commands_size, initial_commands_fds); if (commands_file) { m_debugger.SetInputFileHandle (commands_file, true); // Set the debugger into Sync mode when running the command file. Otherwise command files // that run the target won't run in a sensible way. bool old_async = m_debugger.GetAsync(); m_debugger.SetAsync(false); int num_errors; SBCommandInterpreterRunOptions options; options.SetStopOnError (true); if (m_option_data.m_batch) options.SetStopOnCrash (true); m_debugger.RunCommandInterpreter(handle_events, spawn_thread, options, num_errors, quit_requested, stopped_for_crash); if (m_option_data.m_batch && stopped_for_crash && !m_option_data.m_after_crash_commands.empty()) { int crash_command_fds[2]; SBStream crash_commands_stream; WriteCommandsForSourcing (eCommandPlacementAfterCrash, crash_commands_stream); const char *crash_commands_data = crash_commands_stream.GetData(); const size_t crash_commands_size = crash_commands_stream.GetSize(); commands_file = PrepareCommandsForSourcing (crash_commands_data, crash_commands_size, crash_command_fds); if (commands_file) { bool local_quit_requested; bool local_stopped_for_crash; m_debugger.SetInputFileHandle (commands_file, true); m_debugger.RunCommandInterpreter(handle_events, spawn_thread, options, num_errors, local_quit_requested, local_stopped_for_crash); if (local_quit_requested) quit_requested = true; } } m_debugger.SetAsync(old_async); } else success = false; // Close any pipes that we still have ownership of CleanupAfterCommandSourcing(initial_commands_fds); // Something went wrong with command pipe if (!success) { exit(1); } } // Now set the input file handle to STDIN and run the command // interpreter again in interactive mode and let the debugger // take ownership of stdin bool go_interactive = true; if (quit_requested) go_interactive = false; else if (m_option_data.m_batch && !stopped_for_crash) go_interactive = false; if (go_interactive) { m_debugger.SetInputFileHandle (stdin, true); m_debugger.RunCommandInterpreter(handle_events, spawn_thread); } } reset_stdin_termios(); fclose (stdin); SBDebugger::Destroy (m_debugger); }
SBError Driver::ParseArgs (int argc, const char *argv[], FILE *out_fh, bool &exiting) { ResetOptionValues (); SBCommandReturnObject result; SBError error; std::string option_string; struct option *long_options = NULL; std::vector<struct option> long_options_vector; uint32_t num_options; for (num_options = 0; g_options[num_options].long_option != NULL; ++num_options) /* Do Nothing. */; if (num_options == 0) { if (argc > 1) error.SetErrorStringWithFormat ("invalid number of options"); return error; } BuildGetOptTable (g_options, long_options_vector, num_options); if (long_options_vector.empty()) long_options = NULL; else long_options = &long_options_vector.front(); if (long_options == NULL) { error.SetErrorStringWithFormat ("invalid long options"); return error; } // Build the option_string argument for call to getopt_long_only. for (int i = 0; long_options[i].name != NULL; ++i) { if (long_options[i].flag == NULL) { option_string.push_back ((char) long_options[i].val); switch (long_options[i].has_arg) { default: case no_argument: break; case required_argument: option_string.push_back (':'); break; case optional_argument: option_string.append ("::"); break; } } } // This is kind of a pain, but since we make the debugger in the Driver's constructor, we can't // know at that point whether we should read in init files yet. So we don't read them in in the // Driver constructor, then set the flags back to "read them in" here, and then if we see the // "-n" flag, we'll turn it off again. Finally we have to read them in by hand later in the // main loop. m_debugger.SkipLLDBInitFiles (false); m_debugger.SkipAppInitFiles (false); // Prepare for & make calls to getopt_long_only. #if __GLIBC__ optind = 0; #else optreset = 1; optind = 1; #endif int val; while (1) { int long_options_index = -1; val = ::getopt_long_only (argc, const_cast<char **>(argv), option_string.c_str(), long_options, &long_options_index); if (val == -1) break; else if (val == '?') { m_option_data.m_print_help = true; error.SetErrorStringWithFormat ("unknown or ambiguous option"); break; } else if (val == 0) continue; else { m_option_data.m_seen_options.insert ((char) val); if (long_options_index == -1) { for (int i = 0; long_options[i].name || long_options[i].has_arg || long_options[i].flag || long_options[i].val; ++i) { if (long_options[i].val == val) { long_options_index = i; break; } } } if (long_options_index >= 0) { const int short_option = g_options[long_options_index].short_option; switch (short_option) { case 'h': m_option_data.m_print_help = true; break; case 'v': m_option_data.m_print_version = true; break; case 'P': m_option_data.m_print_python_path = true; break; case 'b': m_option_data.m_batch = true; break; case 'c': { SBFileSpec file(optarg); if (file.Exists()) { m_option_data.m_core_file = optarg; } else error.SetErrorStringWithFormat("file specified in --core (-c) option doesn't exist: '%s'", optarg); } break; case 'e': m_option_data.m_use_external_editor = true; break; case 'x': m_debugger.SkipLLDBInitFiles (true); m_debugger.SkipAppInitFiles (true); break; case 'X': m_debugger.SetUseColor (false); break; case 'f': { SBFileSpec file(optarg); if (file.Exists()) { m_option_data.m_args.push_back (optarg); } else if (file.ResolveExecutableLocation()) { char path[PATH_MAX]; file.GetPath (path, sizeof(path)); m_option_data.m_args.push_back (path); } else error.SetErrorStringWithFormat("file specified in --file (-f) option doesn't exist: '%s'", optarg); } break; case 'a': if (!m_debugger.SetDefaultArchitecture (optarg)) error.SetErrorStringWithFormat("invalid architecture in the -a or --arch option: '%s'", optarg); break; case 'l': m_option_data.m_script_lang = m_debugger.GetScriptingLanguage (optarg); break; case 'd': m_option_data.m_debug_mode = true; break; case 'Q': m_option_data.m_source_quietly = true; break; case 'K': m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, true, error); break; case 'k': m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterCrash, false, error); break; case 'n': m_option_data.m_process_name = optarg; break; case 'w': m_option_data.m_wait_for = true; break; case 'p': { char *remainder; m_option_data.m_process_pid = strtol (optarg, &remainder, 0); if (remainder == optarg || *remainder != '\0') error.SetErrorStringWithFormat ("Could not convert process PID: \"%s\" into a pid.", optarg); } break; case 'r': m_option_data.m_repl = true; if (optarg && optarg[0]) m_option_data.m_repl_options = optarg; else m_option_data.m_repl_options.clear(); break; case 'R': m_option_data.m_repl_lang = SBLanguageRuntime::GetLanguageTypeFromString (optarg); if (m_option_data.m_repl_lang == eLanguageTypeUnknown) { error.SetErrorStringWithFormat ("Unrecognized language name: \"%s\"", optarg); } break; case 's': m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, true, error); break; case 'o': m_option_data.AddInitialCommand(optarg, eCommandPlacementAfterFile, false, error); break; case 'S': m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, true, error); break; case 'O': m_option_data.AddInitialCommand(optarg, eCommandPlacementBeforeFile, false, error); break; default: m_option_data.m_print_help = true; error.SetErrorStringWithFormat ("unrecognized option %c", short_option); break; } } else { error.SetErrorStringWithFormat ("invalid option with value %i", val); } if (error.Fail()) { return error; } } } if (error.Fail() || m_option_data.m_print_help) { ShowUsage (out_fh, g_options, m_option_data); exiting = true; } else if (m_option_data.m_print_version) { ::fprintf (out_fh, "%s\n", m_debugger.GetVersionString()); exiting = true; } else if (m_option_data.m_print_python_path) { SBFileSpec python_file_spec = SBHostOS::GetLLDBPythonPath(); if (python_file_spec.IsValid()) { char python_path[PATH_MAX]; size_t num_chars = python_file_spec.GetPath(python_path, PATH_MAX); if (num_chars < PATH_MAX) { ::fprintf (out_fh, "%s\n", python_path); } else ::fprintf (out_fh, "<PATH TOO LONG>\n"); } else ::fprintf (out_fh, "<COULD NOT FIND PATH>\n"); exiting = true; } else if (m_option_data.m_process_name.empty() && m_option_data.m_process_pid == LLDB_INVALID_PROCESS_ID) { // Any arguments that are left over after option parsing are for // the program. If a file was specified with -f then the filename // is already in the m_option_data.m_args array, and any remaining args // are arguments for the inferior program. If no file was specified with // -f, then what is left is the program name followed by any arguments. // Skip any options we consumed with getopt_long_only argc -= optind; argv += optind; if (argc > 0) { for (int arg_idx=0; arg_idx<argc; ++arg_idx) { const char *arg = argv[arg_idx]; if (arg) m_option_data.m_args.push_back (arg); } } } else { // Skip any options we consumed with getopt_long_only argc -= optind; //argv += optind; // Commented out to keep static analyzer happy if (argc > 0) ::fprintf (out_fh, "Warning: program arguments are ignored when attaching.\n"); } return error; }
int main (int argc, char const *argv[]) { // Use a sentry object to properly initialize/terminate LLDB. LLDBSentry sentry; SBDebugger debugger (SBDebugger::Create()); // Create a debugger instance so we can create a target if (!debugger.IsValid()) fprintf (stderr, "error: failed to create a debugger object\n"); bool show_usage = false; bool verbose = false; bool canonical = false; bool external_only = false; const char *arch = NULL; const char *platform = NULL; std::string short_options("h?"); for (const struct option *opt = g_long_options; opt->name; ++opt) { if (isprint(opt->val)) { short_options.append(1, (char)opt->val); switch (opt->has_arg) { case no_argument: break; case required_argument: short_options.append(1, ':'); break; case optional_argument: short_options.append(2, ':'); break; } } } #ifdef __GLIBC__ optind = 0; #else optreset = 1; optind = 1; #endif char ch; while ((ch = getopt_long_only(argc, (char * const *)argv, short_options.c_str(), g_long_options, 0)) != -1) { switch (ch) { case 0: break; case 'a': if (arch != NULL) { fprintf (stderr, "error: the --arch option can only be specified once\n"); exit(1); } arch = optarg; break; case 'c': canonical = true; break; case 'x': external_only = true; break; case 'p': platform = optarg; break; case 'v': verbose = true; break; case 'h': case '?': default: show_usage = true; break; } } argc -= optind; argv += optind; const bool add_dependent_libs = false; SBError error; for (int arg_idx = 0; arg_idx < argc; ++arg_idx) { // The first argument is the file path we want to look something up in const char *exe_file_path = argv[arg_idx]; // Create a target using the executable. SBTarget target = debugger.CreateTarget (exe_file_path, arch, platform, add_dependent_libs, error); if (error.Success()) { if (target.IsValid()) { SBFileSpec exe_file_spec (exe_file_path, true); SBModule module (target.FindModule (exe_file_spec)); SBFileSpecList comp_unit_list; if (module.IsValid()) { char command[1024]; lldb::SBCommandReturnObject command_result; snprintf (command, sizeof(command), "add-dsym --uuid %s", module.GetUUIDString()); debugger.GetCommandInterpreter().HandleCommand (command, command_result); if (!command_result.Succeeded()) { fprintf (stderr, "error: couldn't locate debug symbols for '%s'\n", exe_file_path); exit(1); } SBFileSpecList module_list; module_list.Append(exe_file_spec); SBBreakpoint bp = target.BreakpointCreateByRegex (".", module_list, comp_unit_list); const size_t num_locations = bp.GetNumLocations(); for (uint32_t bp_loc_idx=0; bp_loc_idx<num_locations; ++bp_loc_idx) { SBBreakpointLocation bp_loc = bp.GetLocationAtIndex(bp_loc_idx); SBSymbolContext sc (bp_loc.GetAddress().GetSymbolContext(eSymbolContextEverything)); if (sc.IsValid()) { if (sc.GetBlock().GetContainingInlinedBlock().IsValid()) { // Skip inlined functions continue; } SBFunction function (sc.GetFunction()); if (function.IsValid()) { addr_t lo_pc = function.GetStartAddress().GetFileAddress(); if (lo_pc == LLDB_INVALID_ADDRESS) { // Skip functions that don't have concrete instances in the binary continue; } addr_t hi_pc = function.GetEndAddress().GetFileAddress(); const char *func_demangled_name = function.GetName(); const char *func_mangled_name = function.GetMangledName(); bool dump = true; const bool is_objc_method = ((func_demangled_name[0] == '-') || (func_demangled_name[0] == '+')) && (func_demangled_name[1] == '['); if (external_only) { // Dump all objective C methods, or external symbols dump = is_objc_method; if (!dump) dump = sc.GetSymbol().IsExternal(); } if (dump) { if (verbose) { printf ("\n name: %s\n", func_demangled_name); if (func_mangled_name) printf ("mangled: %s\n", func_mangled_name); printf (" range: [0x%16.16llx - 0x%16.16llx)\n type: ", lo_pc, hi_pc); } else { printf ("[0x%16.16llx - 0x%16.16llx) ", lo_pc, hi_pc); } SBType function_type = function.GetType(); SBType return_type = function_type.GetFunctionReturnType(); if (canonical) return_type = return_type.GetCanonicalType(); if (func_mangled_name && func_mangled_name[0] == '_' && func_mangled_name[1] == 'Z') { printf ("%s %s\n", return_type.GetName(), func_demangled_name); } else { SBTypeList function_args = function_type.GetFunctionArgumentTypes(); const size_t num_function_args = function_args.GetSize(); if (is_objc_method) { const char *class_name_start = func_demangled_name + 2; if (num_function_args == 0) { printf("%c(%s)[%s\n", func_demangled_name[0], return_type.GetName(), class_name_start); } else { const char *class_name_end = strchr(class_name_start,' '); const int class_name_len = class_name_end - class_name_start; printf ("%c(%s)[%*.*s", func_demangled_name[0], return_type.GetName(), class_name_len, class_name_len, class_name_start); const char *selector_pos = class_name_end + 1; for (uint32_t function_arg_idx = 0; function_arg_idx < num_function_args; ++function_arg_idx) { const char *selector_end = strchr(selector_pos, ':') + 1; const int selector_len = selector_end - selector_pos; SBType function_arg_type = function_args.GetTypeAtIndex(function_arg_idx); if (canonical) function_arg_type = function_arg_type.GetCanonicalType(); printf (" %*.*s", selector_len, selector_len, selector_pos); if (function_arg_type.IsValid()) { printf ("(%s)", function_arg_type.GetName()); } else { printf ("(?)"); } selector_pos = selector_end; } printf ("]\n"); } } else { printf ("%s ", return_type.GetName()); if (strchr (func_demangled_name, '(')) printf ("(*)("); else printf ("%s(", func_demangled_name); for (uint32_t function_arg_idx = 0; function_arg_idx < num_function_args; ++function_arg_idx) { SBType function_arg_type = function_args.GetTypeAtIndex(function_arg_idx); if (canonical) function_arg_type = function_arg_type.GetCanonicalType(); if (function_arg_type.IsValid()) { printf ("%s%s", function_arg_idx > 0 ? ", " : "", function_arg_type.GetName()); } else { printf ("%s???", function_arg_idx > 0 ? ", " : ""); } } printf (")\n"); } } } } } } } } } else { fprintf (stderr, "error: %s\n", error.GetCString()); exit(1); } } return 0; }
lldb::SBWatchpoint SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error) { SBWatchpoint sb_watchpoint; // If the SBValue is not valid, there's no point in even trying to watch it. ValueLocker locker; lldb::ValueObjectSP value_sp(GetSP(locker)); TargetSP target_sp (GetTarget().GetSP()); if (value_sp && target_sp) { // Read and Write cannot both be false. if (!read && !write) return sb_watchpoint; // If the value is not in scope, don't try and watch and invalid value if (!IsInScope()) return sb_watchpoint; addr_t addr = GetLoadAddress(); if (addr == LLDB_INVALID_ADDRESS) return sb_watchpoint; size_t byte_size = GetByteSize(); if (byte_size == 0) return sb_watchpoint; uint32_t watch_type = 0; if (read) watch_type |= LLDB_WATCH_TYPE_READ; if (write) watch_type |= LLDB_WATCH_TYPE_WRITE; Error rc; ClangASTType type (value_sp->GetClangType()); WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); error.SetError(rc); if (watchpoint_sp) { sb_watchpoint.SetSP (watchpoint_sp); Declaration decl; if (value_sp->GetDeclaration (decl)) { if (decl.GetFile()) { StreamString ss; // True to show fullpath for declaration file. decl.DumpStopContext(&ss, true); watchpoint_sp->SetDeclInfo(ss.GetString()); } } } } else if (target_sp) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) log->Printf ("SBValue(%p)::Watch() => error getting SBValue: %s", value_sp.get(), locker.GetError().AsCString()); error.SetErrorStringWithFormat("could not get SBValue: %s", locker.GetError().AsCString()); } else { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) log->Printf ("SBValue(%p)::Watch() => error getting SBValue: no target", value_sp.get()); error.SetErrorString("could not set watchpoint, a target is required"); } return sb_watchpoint; }
SBError::SBError (const SBError &rhs) : m_opaque_ap () { if (rhs.IsValid()) m_opaque_ap.reset (new Error(*rhs)); }