[lldb] Make IR interpretation interruptible

[JDevlieghere]

Summary

Check the interrupt flag while interpreting IR expressions and allow the user to interrupt them.

[Michael137]

LGTM

[jingham]

LGTM. Thanks for adding this.

lldb/source/Expression/IRInterpreter.cpp

 //===-- IRInterpreter.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/IRInterpreter.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"

 };
 
 static const char *unsupported_opcode_error =
     "Interpreter doesn't handle one of the expression's opcodes";
 static const char *unsupported_operand_error =
     "Interpreter doesn't handle one of the expression's operands";
 static const char *interpreter_internal_error =
     "Interpreter encountered an internal error";
+static const char *interrupt_error =
+    "Interrupted while interpreting expression";
 static const char *bad_value_error =
     "Interpreter couldn't resolve a value during execution";
 static const char *memory_allocation_error =
     "Interpreter couldn't allocate memory";
 static const char *memory_write_error = "Interpreter couldn't write to memory";
 static const char *memory_read_error = "Interpreter couldn't read from memory";
 static const char *timeout_error =
     "Reached timeout while interpreting expression";
for (llvm::Function::arg_iterator ai = function.arg_begin(),
 
     lldb::addr_t ptr = args[arg_index];
 
     frame.MakeArgument(&*ai, ptr);
   }
 
   frame.Jump(&function.front());
 
+  lldb_private::Process *process = exe_ctx.GetProcessPtr();
+  lldb_private::Target *target = exe_ctx.GetTargetPtr();
+
   using clock = std::chrono::steady_clock;
 
   // Compute the time at which the timeout has been exceeded.
   std::optional<clock::time_point> end_time;
   if (timeout && timeout->count() > 0)
     end_time = clock::now() + *timeout;
 
   while (frame.m_ii != frame.m_ie) {
     // Timeout reached: stop interpreting.
     if (end_time && clock::now() >= *end_time) {
       error.SetErrorToGenericError();
       error.SetErrorString(timeout_error);
       return false;
     }
 
+    // If we have access to the debugger we can honor an interrupt request.
+    if (target) {
+      if (INTERRUPT_REQUESTED(target->GetDebugger(),
+                              "Interrupted in IR interpreting.")) {
+        error.SetErrorToGenericError();
+        error.SetErrorString(interrupt_error);
+        return false;
+      }
+    }
+
     const Instruction *inst = &*frame.m_ii;
 
     LLDB_LOGF(log, "Interpreting %s", PrintValue(inst).c_str());
 
     switch (inst->getOpcode()) {
     default:
       break;
 
case Instruction::Call: {
       // Check we can actually get a thread
       if (exe_ctx.GetThreadPtr() == nullptr) {
         error.SetErrorToGenericError();
         error.SetErrorString("unable to acquire thread");
         return false;
       }
 
       // Make sure we have a valid process
-      if (!exe_ctx.GetProcessPtr()) {
+      if (!process) {
         error.SetErrorToGenericError();
         error.SetErrorString("unable to get the process");
         return false;
       }
 
       // Find the address of the callee function
       lldb_private::Scalar I;
       const llvm::Value *val = call_inst->getCalledOperand();
case Instruction::Call: {
       if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
         error.SetErrorToGenericError();
         error.SetErrorStringWithFormat(
             "unable to make ThreadPlanCallFunctionUsingABI for 0x%llx",
             I.ULongLong());
         return false;
       }
 
-      exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
+      process->SetRunningUserExpression(true);
 
       // Execute the actual function call thread plan
-      lldb::ExpressionResults res = exe_ctx.GetProcessRef().RunThreadPlan(
-          exe_ctx, call_plan_sp, options, diagnostics);
+      lldb::ExpressionResults res =
+          process->RunThreadPlan(exe_ctx, call_plan_sp, options, diagnostics);
 
       // Check that the thread plan completed successfully
       if (res != lldb::ExpressionResults::eExpressionCompleted) {
         error.SetErrorToGenericError();
         error.SetErrorString("ThreadPlanCallFunctionUsingABI failed");
         return false;
       }
 
-      exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
+      process->SetRunningUserExpression(false);
 
       // Void return type
       if (returnType->isVoidTy()) {
         // Cant assign to void types, so we leave the frame untouched
       } else
           // Integer or pointer return type
           if (returnType->isIntegerTy() || returnType->isPointerTy()) {
         // Get the encapsulated return value

lldb/test/API/commands/expression/ir-interpreter/TestIRInterpreter.py

def test_interpreter_timeout(self):
 
         # Try a simple one second timeout.
         options.SetTimeoutInMicroSeconds(1000000)
         res, duration_sec = self.time_expression(inf_loop, options)
         self.assertIn(timeout_error, str(res.GetError()))
         self.assertGreaterEqual(duration_sec, 1)
         self.assertLess(duration_sec, 30)
 
+    def test_interpreter_interrupt(self):
+        """Test interrupting the IRInterpreter."""
+        self.build()
+        self.target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(self.target, VALID_TARGET)
+
+        # A non-trivial infinite loop.
+        inf_loop = "for (unsigned i = 0; i < 100; ++i) --i; 1"
+
+        options = lldb.SBExpressionOptions()
+
+        # This is an IRInterpreter specific test, so disable the JIT.
+        options.SetAllowJIT(False)
+
+        # Make sure we have a pretty long (10s) timeout so we have a chance to
+        # interrupt the interpreted expression.
+        options.SetTimeoutInMicroSeconds(10000000)
+
+        self.dbg.RequestInterrupt()
+
+        self.dbg.SetAsync(True)
+        res = self.target.EvaluateExpression(inf_loop, options)
+        self.dbg.SetAsync(False)
+
+        # Be sure to turn this off again:
+        def cleanup():
+            if self.dbg.InterruptRequested():
+                self.dbg.CancelInterruptRequest()
+
+        self.addTearDownHook(cleanup)
+
+        interrupt_error = "Interrupted while interpreting expression"
+        self.assertIn(interrupt_error, str(res.GetError()))
+
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number("main.c", "// Set breakpoint here")
 
         # Disable confirmation prompt to avoid infinite wait
         self.runCmd("settings set auto-confirm true")