[lldb] Use current execution context in SBDebugger

[werat]

Summary

Use GetSelectedExecutionContext() instead of GetCommandInterpreter().GetExecutionContext() in SBDebugger::GetInternalVariableValue/SBDebugger::SetInternalVariable. The execution context in the command interpreter might be empty, if no commands has been executed yet (it is updated only when handling commands or completions -- e.g. https://github.com/llvm/llvm-project/blob/main/lldb/source/Interpreter/CommandInterpreter.cpp#L1855).

[teemperor]

LGTM, thanks!

[werat]

Thanks for the review! Can you submit it for me, since I don't have commit access?

[jingham]

I think it's fine to fall back to the "currently selected target" if the command interpreter doesn't have a current execution context, that should not be your first choice.

For instance, if you are running this command in a Python breakpoint callback, then the current Interpreter context will be set to the target/process/thread that the interpreter is running that command for, whereas the selected context will be whatever the user last selected, and may be for a totally different target/process/thread.

lldb/source/API/SBDebugger.cpp

LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
                             (const char *, const char *, const char *),
                             var_name, value, debugger_instance_name);
 
   SBError sb_error;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));
   Status error;
   if (debugger_sp) {
-    ExecutionContext exe_ctx(
-        debugger_sp->GetCommandInterpreter().GetExecutionContext());
+    ExecutionContext exe_ctx(debugger_sp->GetSelectedExecutionContext());
     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
                                           var_name, value);
   } else {
     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
                                    debugger_instance_name);
   }
   if (error.Fail())
     sb_error.SetError(error);
   return LLDB_RECORD_RESULT(sb_error);
 }
 
 SBStringList
 SBDebugger::GetInternalVariableValue(const char *var_name,
                                      const char *debugger_instance_name) {
   LLDB_RECORD_STATIC_METHOD(
       lldb::SBStringList, SBDebugger, GetInternalVariableValue,
       (const char *, const char *), var_name, debugger_instance_name);
 
   SBStringList ret_value;
   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
       ConstString(debugger_instance_name)));
   Status error;
   if (debugger_sp) {
-    ExecutionContext exe_ctx(
-        debugger_sp->GetCommandInterpreter().GetExecutionContext());
+    ExecutionContext exe_ctx(debugger_sp->GetSelectedExecutionContext());
     lldb::OptionValueSP value_sp(
         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
     if (value_sp) {
       StreamString value_strm;
       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
       const std::string &value_str = std::string(value_strm.GetString());
       if (!value_str.empty()) {
         StringList string_list;

lldb/test/API/python_api/debugger/TestDebuggerAPI.py

def test_debugger_api_boundary_condition(self):
         self.assertEquals(len(fresh_dbg), 0)
 
     @add_test_categories(['pyapi'])
     def test_debugger_delete_invalid_target(self):
         """SBDebugger.DeleteTarget() should not crash LLDB given and invalid target."""
         target = lldb.SBTarget()
         self.assertFalse(target.IsValid())
         self.dbg.DeleteTarget(target)
+
+    @add_test_categories(['pyapi'])
+    def test_debugger_internal_variables(self):
+        debugger_name = self.dbg.GetInstanceName()
+
+        # Set a variable and check it was written successfully.
+        error = lldb.SBDebugger.SetInternalVariable(
+            'target.prefer-dynamic-value', 'no-dynamic-values', debugger_name)
+        self.assertTrue(error.Success())
+        ret = lldb.SBDebugger.GetInternalVariableValue(
+            'target.prefer-dynamic-value', debugger_name)
+        self.assertEqual(ret.GetSize(), 1)
+        self.assertEqual(ret.GetStringAtIndex(0), 'no-dynamic-values')
+
+        # Set a variable with a different value.
+        error = lldb.SBDebugger.SetInternalVariable(
+            'target.prefer-dynamic-value', 'no-run-target', debugger_name)
+        self.assertTrue(error.Success())
+        ret = lldb.SBDebugger.GetInternalVariableValue(
+            'target.prefer-dynamic-value', debugger_name)
+        self.assertEqual(ret.GetSize(), 1)
+        self.assertEqual(ret.GetStringAtIndex(0), 'no-run-target')
+
+        # Try setting invalid value, check for error.
+        error = lldb.SBDebugger.SetInternalVariable(
+            'target.prefer-dynamic-value', 'dummy-value', debugger_name)
+        self.assertTrue(error.Fail())
+        # Check that the value didn't change.
+        ret = lldb.SBDebugger.GetInternalVariableValue(
+            'target.prefer-dynamic-value', debugger_name)
+        self.assertEqual(ret.GetSize(), 1)
+        self.assertEqual(ret.GetStringAtIndex(0), 'no-run-target')