#include "lldb/Utility/StringList.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h"
-
#include <mutex>
-#include <stack>
namespace lldb_private {
class CommandInterpreter;
CommandInterpreter(Debugger &debugger, bool synchronous_execution);
- ~CommandInterpreter() override = default;
+ ~CommandInterpreter() override;
// These two functions fill out the Broadcaster interface:
CommandReturnObject &result);
bool HandleCommand(const char *command_line, LazyBool add_to_history,
- const ExecutionContext &override_context,
- CommandReturnObject &result);
-
- bool HandleCommand(const char *command_line, LazyBool add_to_history,
- CommandReturnObject &result);
+ CommandReturnObject &result,
+ ExecutionContext *override_context = nullptr,
+ bool repeat_on_empty_command = true,
+ bool no_context_switching = false);
bool WasInterrupted() const;
/// \param[in] commands
/// The list of commands to execute.
/// \param[in,out] context
- /// The execution context in which to run the commands.
+ /// The execution context in which to run the commands. Can be nullptr in
+ /// which case the default
+ /// context will be used.
/// \param[in] options
/// This object holds the options used to control when to stop, whether to
/// execute commands,
/// safely,
/// and failed with some explanation if we aborted executing the commands
/// at some point.
- void HandleCommands(const StringList &commands,
- const ExecutionContext &context,
- const CommandInterpreterRunOptions &options,
- CommandReturnObject &result);
-
- void HandleCommands(const StringList &commands,
- const CommandInterpreterRunOptions &options,
+ void HandleCommands(const StringList &commands, ExecutionContext *context,
+ CommandInterpreterRunOptions &options,
CommandReturnObject &result);
/// Execute a list of commands from a file.
/// \param[in] file
/// The file from which to read in commands.
/// \param[in,out] context
- /// The execution context in which to run the commands.
+ /// The execution context in which to run the commands. Can be nullptr in
+ /// which case the default
+ /// context will be used.
/// \param[in] options
/// This object holds the options used to control when to stop, whether to
/// execute commands,
/// safely,
/// and failed with some explanation if we aborted executing the commands
/// at some point.
- void HandleCommandsFromFile(FileSpec &file, const ExecutionContext &context,
- const CommandInterpreterRunOptions &options,
- CommandReturnObject &result);
-
- void HandleCommandsFromFile(FileSpec &file,
- const CommandInterpreterRunOptions &options,
+ void HandleCommandsFromFile(FileSpec &file, ExecutionContext *context,
+ CommandInterpreterRunOptions &options,
CommandReturnObject &result);
CommandObject *GetCommandObjectForCommand(llvm::StringRef &command_line);
Debugger &GetDebugger() { return m_debugger; }
- ExecutionContext GetExecutionContext() const;
+ ExecutionContext GetExecutionContext() {
+ const bool thread_and_frame_only_if_stopped = true;
+ return m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped);
+ }
+
+ void UpdateExecutionContext(ExecutionContext *override_context);
lldb::PlatformSP GetPlatform(bool prefer_target_platform);
StringList *descriptions = nullptr) const;
private:
- void OverrideExecutionContext(const ExecutionContext &override_context);
-
- void RestoreExecutionContext();
-
Status PreprocessCommand(std::string &command);
void SourceInitFile(FileSpec file, CommandReturnObject &result);
Debugger &m_debugger; // The debugger session that this interpreter is
// associated with
- // Execution contexts that were temporarily set by some of HandleCommand*
- // overloads.
- std::stack<ExecutionContext> m_overriden_exe_contexts;
+ ExecutionContextRef m_exe_ctx_ref; // The current execution context to use
+ // when handling commands
bool m_synchronous_execution;
bool m_skip_lldbinit_files;
bool m_skip_app_init_files;
lldb::SBCommandReturnObject &, bool),
command_line, override_context, result, add_to_history);
+
+ ExecutionContext ctx, *ctx_ptr;
+ if (override_context.get()) {
+ ctx = override_context.get()->Lock(true);
+ ctx_ptr = &ctx;
+ } else
+ ctx_ptr = nullptr;
+
result.Clear();
if (command_line && IsValid()) {
result.ref().SetInteractive(false);
- auto do_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo;
- if (override_context.get())
- m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
- override_context.get()->Lock(true),
- result.ref());
- else
- m_opaque_ptr->HandleCommand(command_line, do_add_to_history,
- result.ref());
+ m_opaque_ptr->HandleCommand(command_line,
+ add_to_history ? eLazyBoolYes : eLazyBoolNo,
+ result.ref(), ctx_ptr);
} else {
result->AppendError(
"SBCommandInterpreter or the command line is not valid");
result->SetStatus(eReturnStatusFailed);
}
+
return result.GetStatus();
}
}
FileSpec tmp_spec = file.ref();
- if (override_context.get())
- m_opaque_ptr->HandleCommandsFromFile(tmp_spec,
- override_context.get()->Lock(true),
- options.ref(),
- result.ref());
-
- else
- m_opaque_ptr->HandleCommandsFromFile(tmp_spec, options.ref(), result.ref());
+ ExecutionContext ctx, *ctx_ptr;
+ if (override_context.get()) {
+ ctx = override_context.get()->Lock(true);
+ ctx_ptr = &ctx;
+ } else
+ ctx_ptr = nullptr;
+
+ m_opaque_ptr->HandleCommandsFromFile(tmp_spec, ctx_ptr, options.ref(),
+ result.ref());
}
int SBCommandInterpreter::HandleCompletion(
options.SetPrintErrors(true);
options.SetAddToHistory(false);
- debugger.GetCommandInterpreter().HandleCommands(commands, exe_ctx,
+ debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
options, result);
result.GetImmediateOutputStream()->Flush();
result.GetImmediateErrorStream()->Flush();
FileSpec cmd_file(command[0].ref());
FileSystem::Instance().Resolve(cmd_file);
+ ExecutionContext *exe_ctx = nullptr; // Just use the default context.
- CommandInterpreterRunOptions options;
// If any options were set, then use them
if (m_options.m_stop_on_error.OptionWasSet() ||
m_options.m_silent_run.OptionWasSet() ||
m_options.m_stop_on_continue.OptionWasSet()) {
+ // Use user set settings
+ CommandInterpreterRunOptions options;
+
if (m_options.m_stop_on_continue.OptionWasSet())
options.SetStopOnContinue(
m_options.m_stop_on_continue.GetCurrentValue());
options.SetEchoCommands(m_interpreter.GetEchoCommands());
options.SetEchoCommentCommands(m_interpreter.GetEchoCommentCommands());
}
- }
- m_interpreter.HandleCommandsFromFile(cmd_file, options, result);
+ m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
+ } else {
+ // No options were set, inherit any settings from nested "command source"
+ // commands, or set to sane default settings...
+ CommandInterpreterRunOptions options;
+ m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
+ }
return result.Succeeded();
}
options.SetAutoApplyFixIts(false);
options.SetGenerateDebugInfo(false);
- ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
-
- // Get out before we start doing things that expect a valid frame pointer.
- if (exe_ctx.GetFramePtr() == nullptr)
+ // We need a valid execution context with a frame pointer for this
+ // completion, so if we don't have one we should try to make a valid
+ // execution context.
+ if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
+ m_interpreter.UpdateExecutionContext(nullptr);
+
+ // This didn't work, so let's get out before we start doing things that
+ // expect a valid frame pointer.
+ if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
return;
+ ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
Target *exe_target = exe_ctx.GetTargetPtr();
Target &target = exe_target ? *exe_target : GetDummyTarget();
return false;
}
+ m_interpreter.UpdateExecutionContext(nullptr);
StreamString stream;
const auto error = target->Attach(m_options.attach_info, &stream);
if (error.Success()) {
// Pass in true for "no context switching". The command that called us
// should have set up the context appropriately, we shouldn't have to
// redo that.
- return m_interpreter.HandleCommand(new_command.c_str(),
- eLazyBoolCalculate, result);
+ return m_interpreter.HandleCommand(
+ new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
}
}
result.SetStatus(eReturnStatusFailed);
bool DoExecute(Args &command, CommandReturnObject &result) override {
FileSpec file(m_options.m_filename);
FileSystem::Instance().Resolve(file);
+ ExecutionContext clean_ctx;
CommandInterpreterRunOptions options;
options.SetAddToHistory(false);
options.SetEchoCommands(false);
options.SetPrintResults(true);
options.SetPrintErrors(true);
options.SetStopOnError(false);
- m_interpreter.HandleCommandsFromFile(file, options, result);
+ m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
return result.Succeeded();
}
options.SetPrintErrors(true);
options.SetAddToHistory(false);
- debugger.GetCommandInterpreter().HandleCommands(commands, exe_ctx,
+ debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
options, result);
result.GetImmediateOutputStream()->Flush();
result.GetImmediateErrorStream()->Flush();
ConstString broadcaster_class(
broadcaster->GetBroadcasterClass());
if (broadcaster_class == broadcaster_class_process) {
+ debugger.GetCommandInterpreter().UpdateExecutionContext(
+ nullptr);
m_update_screen = true;
continue; // Don't get any key, just update our view
}
HandleCharResult key_result = m_window_sp->HandleChar(ch);
switch (key_result) {
case eKeyHandled:
+ debugger.GetCommandInterpreter().UpdateExecutionContext(nullptr);
m_update_screen = true;
break;
case eKeyNotHandled:
bool CommandInterpreter::HandleCommand(const char *command_line,
LazyBool lazy_add_to_history,
- const ExecutionContext &override_context,
- CommandReturnObject &result) {
-
- OverrideExecutionContext(override_context);
- bool status = HandleCommand(command_line, lazy_add_to_history, result);
- RestoreExecutionContext();
- return status;
-}
+ CommandReturnObject &result,
+ ExecutionContext *override_context,
+ bool repeat_on_empty_command,
+ bool no_context_switching)
-bool CommandInterpreter::HandleCommand(const char *command_line,
- LazyBool lazy_add_to_history,
- CommandReturnObject &result) {
+{
std::string command_string(command_line);
std::string original_command_string(command_line);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "Handling command: %s.", command_line);
+ if (!no_context_switching)
+ UpdateExecutionContext(override_context);
+
if (WasInterrupted()) {
result.AppendError("interrupted");
result.SetStatus(eReturnStatusFailed);
}
if (empty_command) {
- if (m_command_history.IsEmpty()) {
- result.AppendError("empty command");
- result.SetStatus(eReturnStatusFailed);
- return false;
- }
-
- command_line = m_repeat_command.c_str();
- command_string = command_line;
- original_command_string = command_line;
- if (m_repeat_command.empty()) {
- result.AppendError("No auto repeat.");
- result.SetStatus(eReturnStatusFailed);
- return false;
+ if (repeat_on_empty_command) {
+ if (m_command_history.IsEmpty()) {
+ result.AppendError("empty command");
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ } else {
+ command_line = m_repeat_command.c_str();
+ command_string = command_line;
+ original_command_string = command_line;
+ if (m_repeat_command.empty()) {
+ result.AppendError("No auto repeat.");
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+ }
+ add_to_history = false;
+ } else {
+ result.SetStatus(eReturnStatusSuccessFinishNoResult);
+ return true;
}
-
- add_to_history = false;
} else if (comment_command) {
result.SetStatus(eReturnStatusSuccessFinishNoResult);
return true;
void CommandInterpreter::HandleCompletion(CompletionRequest &request) {
+ UpdateExecutionContext(nullptr);
+
// Don't complete comments, and if the line we are completing is just the
// history repeat character, substitute the appropriate history line.
llvm::StringRef first_arg = request.GetParsedLine().GetArgumentAtIndex(0);
return llvm::None;
}
+CommandInterpreter::~CommandInterpreter() {}
+
void CommandInterpreter::UpdatePrompt(llvm::StringRef new_prompt) {
EventSP prompt_change_event_sp(
new Event(eBroadcastBitResetPrompt, new EventDataBytes(new_prompt)));
// broadcasting of the commands back to any appropriate listener (see
// CommandObjectSource::Execute for more details).
const bool saved_batch = SetBatchCommandMode(true);
+ ExecutionContext *ctx = nullptr;
CommandInterpreterRunOptions options;
options.SetSilent(true);
options.SetPrintErrors(true);
options.SetStopOnError(false);
options.SetStopOnContinue(true);
- HandleCommandsFromFile(file, options, result);
+ HandleCommandsFromFile(file, ctx, options, result);
SetBatchCommandMode(saved_batch);
}
}
bool CommandInterpreter::DidProcessStopAbnormally() const {
- auto exe_ctx = GetExecutionContext();
- TargetSP target_sp = exe_ctx.GetTargetSP();
+ TargetSP target_sp = m_debugger.GetTargetList().GetSelectedTarget();
if (!target_sp)
return false;
return false;
}
-void
-CommandInterpreter::HandleCommands(const StringList &commands,
- const ExecutionContext &override_context,
- const CommandInterpreterRunOptions &options,
- CommandReturnObject &result) {
-
- OverrideExecutionContext(override_context);
- HandleCommands(commands, options, result);
- RestoreExecutionContext();
-}
-
void CommandInterpreter::HandleCommands(const StringList &commands,
- const CommandInterpreterRunOptions &options,
+ ExecutionContext *override_context,
+ CommandInterpreterRunOptions &options,
CommandReturnObject &result) {
size_t num_lines = commands.GetSize();
bool old_async_execution = m_debugger.GetAsyncExecution();
+ // If we've been given an execution context, set it at the start, but don't
+ // keep resetting it or we will cause series of commands that change the
+ // context, then do an operation that relies on that context to fail.
+
+ if (override_context != nullptr)
+ UpdateExecutionContext(override_context);
+
if (!options.GetStopOnContinue()) {
m_debugger.SetAsyncExecution(false);
}
CommandReturnObject tmp_result(m_debugger.GetUseColor());
tmp_result.SetInteractive(result.GetInteractive());
+ // If override_context is not NULL, pass no_context_switching = true for
+ // HandleCommand() since we updated our context already.
+
// We might call into a regex or alias command, in which case the
// add_to_history will get lost. This m_command_source_depth dingus is the
// way we turn off adding to the history in that case, so set it up here.
if (!options.GetAddToHistory())
m_command_source_depth++;
- bool success = HandleCommand(cmd, options.m_add_to_history, tmp_result);
+ bool success =
+ HandleCommand(cmd, options.m_add_to_history, tmp_result,
+ nullptr, /* override_context */
+ true, /* repeat_on_empty_command */
+ override_context != nullptr /* no_context_switching */);
if (!options.GetAddToHistory())
m_command_source_depth--;
};
void CommandInterpreter::HandleCommandsFromFile(
- FileSpec &cmd_file, const ExecutionContext &context,
- const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
- OverrideExecutionContext(context);
- HandleCommandsFromFile(cmd_file, options, result);
- RestoreExecutionContext();
-}
-
-void CommandInterpreter::HandleCommandsFromFile(FileSpec &cmd_file,
- const CommandInterpreterRunOptions &options, CommandReturnObject &result) {
+ FileSpec &cmd_file, ExecutionContext *context,
+ CommandInterpreterRunOptions &options, CommandReturnObject &result) {
if (!FileSystem::Instance().Exists(cmd_file)) {
result.AppendErrorWithFormat(
"Error reading commands from file %s - file not found.\n",
m_alias_dict);
}
-ExecutionContext CommandInterpreter::GetExecutionContext() const {
- return !m_overriden_exe_contexts.empty()
- ? m_overriden_exe_contexts.top()
- : m_debugger.GetSelectedExecutionContext();
-}
-
-void CommandInterpreter::OverrideExecutionContext(
- const ExecutionContext &override_context) {
- m_overriden_exe_contexts.push(override_context);
-}
-
-void CommandInterpreter::RestoreExecutionContext() {
- if (!m_overriden_exe_contexts.empty())
- m_overriden_exe_contexts.pop();
+void CommandInterpreter::UpdateExecutionContext(
+ ExecutionContext *override_context) {
+ if (override_context != nullptr) {
+ m_exe_ctx_ref = *override_context;
+ } else {
+ const bool adopt_selected = true;
+ m_exe_ctx_ref.SetTargetPtr(m_debugger.GetSelectedTarget().get(),
+ adopt_selected);
+ }
}
void CommandInterpreter::GetProcessOutput() {
- auto *process_ptr = GetExecutionContext().GetProcessPtr();
- if (process_ptr != nullptr)
- m_debugger.FlushProcessOutput(*process_ptr, /*flush_stdout*/ true,
+ TargetSP target_sp(m_debugger.GetTargetList().GetSelectedTarget());
+ if (!target_sp)
+ return;
+
+ if (ProcessSP process_sp = target_sp->GetProcessSP())
+ m_debugger.FlushProcessOutput(*process_sp, /*flush_stdout*/ true,
/*flush_stderr*/ true);
}
// Force Async:
bool old_async = debugger.GetAsyncExecution();
debugger.SetAsyncExecution(true);
- debugger.GetCommandInterpreter().HandleCommands(GetCommands(), exc_ctx,
+ debugger.GetCommandInterpreter().HandleCommands(GetCommands(), &exc_ctx,
options, result);
debugger.SetAsyncExecution(old_async);
lldb::ReturnStatus status = result.GetStatus();
+++ /dev/null
-CXX_SOURCES := main.cpp
-
-include Makefile.rules
target = lldb.SBTarget()
self.assertFalse(target.IsValid())
self.dbg.DeleteTarget(target)
-
- def test_debugger_internal_variable(self):
- """Ensure that SBDebugger reachs the same instance of properties
- regardless CommandInterpreter's context initialization"""
- self.build()
- exe = self.getBuildArtifact("a.out")
-
- # Create a target by the debugger.
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target, VALID_TARGET)
-
- property_name = "target.process.memory-cache-line-size"
-
- def get_cache_line_size():
- value_list = lldb.SBStringList()
- value_list = self.dbg.GetInternalVariableValue(property_name,
- self.dbg.GetInstanceName())
-
- self.assertEqual(value_list.GetSize(), 1)
- try:
- return int(value_list.GetStringAtIndex(0))
- except ValueError as error:
- self.fail("Value is not a number: " + error)
-
- # Get global property value while there are no processes.
- global_cache_line_size = get_cache_line_size()
-
- # Run a process via SB interface. CommandInterpreter's execution context
- # remains empty.
- error = lldb.SBError()
- launch_info = lldb.SBLaunchInfo(None)
- launch_info.SetLaunchFlags(lldb.eLaunchFlagStopAtEntry)
- process = target.Launch(launch_info, error)
- self.assertTrue(process, PROCESS_IS_VALID)
-
- # This should change the value of a process's local property.
- new_cache_line_size = global_cache_line_size + 512
- error = self.dbg.SetInternalVariable(property_name,
- str(new_cache_line_size),
- self.dbg.GetInstanceName())
- self.assertTrue(error.Success(),
- property_name + " value was changed successfully")
-
- # Check that it was set actually.
- self.assertEqual(get_cache_line_size(), new_cache_line_size)
-
- # Run any command to initialize CommandInterpreter's execution context.
- self.runCmd("target list")
-
- # Test the local property again, is it set to new_cache_line_size?
- self.assertEqual(get_cache_line_size(), new_cache_line_size)
+++ /dev/null
-// This simple program is to test the lldb Python API SBDebugger.
-
-int func(int val) {
- return val - 1;
-}
-
-int main (int argc, char const *argv[]) {
- return func(argc);
-}
projects / platform / upstream / llvm.git / commitdiff