[lldb] Add test for scripted frame provider producing python frames

Signed-off-by: Med Ismail Bennani <[email protected]>

Author: medismailben

lldb/test/API/functionalities/scripted_frame_provider/TestScriptedFrameProvider.py

@@ -426,3 +426,128 @@ def test_circular_dependency_fix(self):
             # These calls should not trigger circular dependency
             pc = frame.GetPC()
             self.assertNotEqual(pc, 0, f"Frame {i} should have valid PC")
+
+    def test_python_source_frames(self):
+        """Test that frames can point to Python source files and display properly."""
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, "Break here", lldb.SBFileSpec(self.source), only_one_thread=False
+        )
+
+        # Get original frame count
+        original_frame_count = thread.GetNumFrames()
+        self.assertGreaterEqual(
+            original_frame_count, 2, "Should have at least 2 real frames"
+        )
+
+        # Import the provider
+        script_path = os.path.join(self.getSourceDir(), "test_frame_providers.py")
+        self.runCmd("command script import " + script_path)
+
+        # Register the PythonSourceFrameProvider
+        error = lldb.SBError()
+        provider_id = target.RegisterScriptedFrameProvider(
+            "test_frame_providers.PythonSourceFrameProvider",
+            lldb.SBStructuredData(),
+            error,
+        )
+        self.assertTrue(error.Success(), f"Failed to register provider: {error}")
+        self.assertNotEqual(provider_id, 0, "Provider ID should be non-zero")
+
+        # Verify we have 3 more frames (Python frames)
+        new_frame_count = thread.GetNumFrames()
+        self.assertEqual(
+            new_frame_count,
+            original_frame_count + 3,
+            "Should have original frames + 3 Python frames",
+        )
+
+        # Verify first three frames are Python source frames
+        frame0 = thread.GetFrameAtIndex(0)
+        self.assertIsNotNone(frame0)
+        self.assertEqual(
+            frame0.GetFunctionName(),
+            "compute_fibonacci",
+            "First frame should be compute_fibonacci",
+        )
+        self.assertTrue(frame0.IsSynthetic(), "Frame should be marked as synthetic")
+        # PC-less frames should show invalid address
+        self.assertEqual(
+            frame0.GetPC(),
+            lldb.LLDB_INVALID_ADDRESS,
+            "PC-less frame should have LLDB_INVALID_ADDRESS",
+        )
+
+        frame1 = thread.GetFrameAtIndex(1)
+        self.assertIsNotNone(frame1)
+        self.assertEqual(
+            frame1.GetFunctionName(),
+            "process_data",
+            "Second frame should be process_data",
+        )
+        self.assertTrue(frame1.IsSynthetic(), "Frame should be marked as synthetic")
+
+        frame2 = thread.GetFrameAtIndex(2)
+        self.assertIsNotNone(frame2)
+        self.assertEqual(
+            frame2.GetFunctionName(), "main", "Third frame should be main"
+        )
+        self.assertTrue(frame2.IsSynthetic(), "Frame should be marked as synthetic")
+
+        # Verify line entry information is present
+        line_entry0 = frame0.GetLineEntry()
+        self.assertTrue(
+            line_entry0.IsValid(), "Frame 0 should have a valid line entry"
+        )
+        self.assertEqual(
+            line_entry0.GetLine(), 7, "Frame 0 should point to line 7"
+        )
+        file_spec0 = line_entry0.GetFileSpec()
+        self.assertTrue(file_spec0.IsValid(), "Frame 0 should have valid file spec")
+        self.assertEqual(
+            file_spec0.GetFilename(),
+            "python_helper.py",
+            "Frame 0 should point to python_helper.py",
+        )
+
+        line_entry1 = frame1.GetLineEntry()
+        self.assertTrue(
+            line_entry1.IsValid(), "Frame 1 should have a valid line entry"
+        )
+        self.assertEqual(
+            line_entry1.GetLine(), 16, "Frame 1 should point to line 16"
+        )
+
+        line_entry2 = frame2.GetLineEntry()
+        self.assertTrue(
+            line_entry2.IsValid(), "Frame 2 should have a valid line entry"
+        )
+        self.assertEqual(
+            line_entry2.GetLine(), 27, "Frame 2 should point to line 27"
+        )
+
+        # Verify the frames display properly in backtrace
+        # This tests that PC-less frames don't show 0xffffffffffffffff
+        self.runCmd("bt")
+        output = self.res.GetOutput()
+
+        # Should show function names
+        self.assertIn("compute_fibonacci", output)
+        self.assertIn("process_data", output)
+        self.assertIn("main", output)
+
+        # Should show Python file
+        self.assertIn("python_helper.py", output)
+
+        # Should show line numbers
+        self.assertIn(":7", output)  # compute_fibonacci line
+        self.assertIn(":16", output)  # process_data line
+        self.assertIn(":27", output)  # main line
+
+        # Should NOT show invalid address (0xffffffffffffffff)
+        self.assertNotIn("0xffffffffffffffff", output.lower())
+
+        # Verify frame 3 is the original real frame 0
+        frame3 = thread.GetFrameAtIndex(3)
+        self.assertIsNotNone(frame3)
+        self.assertIn("thread_func", frame3.GetFunctionName())

lldb/test/API/functionalities/scripted_frame_provider/python_helper.py

@@ -0,0 +1,36 @@
+"""
+Sample Python module to demonstrate Python source display in scripted frames.
+"""
+
+
+def compute_fibonacci(n):
+    """Compute the nth Fibonacci number."""
+    if n <= 1:
+        return n
+    a, b = 0, 1
+    for _ in range(n - 1):
+        a, b = b, a + b
+    return b
+
+
+def process_data(data):
+    """Process some data and return result."""
+    result = []
+    for item in data:
+        if isinstance(item, int):
+            result.append(item * 2)
+        elif isinstance(item, str):
+            result.append(item.upper())
+    return result
+
+
+def main():
+    """Main entry point for testing."""
+    fib_10 = compute_fibonacci(10)
+    data = [1, 2, "hello", 3, "world"]
+    processed = process_data(data)
+    return fib_10, processed
+
+
+if __name__ == "__main__":
+    main()

lldb/test/API/functionalities/scripted_frame_provider/test_frame_providers.py

@@ -10,6 +10,7 @@
 index to create stackframes
 """
 
+import os
 import lldb
 from lldb.plugins.scripted_process import ScriptedFrame
 from lldb.plugins.scripted_frame_provider import ScriptedFrameProvider
@@ -220,3 +221,98 @@ def get_frame_at_index(self, index):
             # Pass through original frames at indices 1, 2, 3, ...
             return index - 1
         return None
+
+
+class PythonSourceFrame(ScriptedFrame):
+    """Scripted frame that points to Python source code."""
+
+    def __init__(self, thread, idx, function_name, python_file, line_number):
+        args = lldb.SBStructuredData()
+        super().__init__(thread, args)
+
+        self.idx = idx
+        self.function_name = function_name
+        self.python_file = python_file
+        self.line_number = line_number
+
+    def get_id(self):
+        """Return the frame index."""
+        return self.idx
+
+    def get_pc(self):
+        """PC-less frame - return invalid address."""
+        return lldb.LLDB_INVALID_ADDRESS
+
+    def get_function_name(self):
+        """Return the function name."""
+        return self.function_name
+
+    def get_symbol_context(self):
+        """Return a symbol context with LineEntry pointing to Python source."""
+        # Create a LineEntry pointing to the Python source file
+        line_entry = lldb.SBLineEntry()
+        line_entry.SetFileSpec(lldb.SBFileSpec(self.python_file, True))
+        line_entry.SetLine(self.line_number)
+        line_entry.SetColumn(0)
+
+        # Create a symbol context with the line entry
+        sym_ctx = lldb.SBSymbolContext()
+        sym_ctx.SetLineEntry(line_entry)
+
+        return sym_ctx
+
+    def is_artificial(self):
+        """Not artificial."""
+        return False
+
+    def is_hidden(self):
+        """Not hidden."""
+        return False
+
+    def get_register_context(self):
+        """No register context for PC-less frames."""
+        return None
+
+
+class PythonSourceFrameProvider(ScriptedFrameProvider):
+    """
+    Provider that demonstrates Python source display in scripted frames.
+
+    This provider prepends frames pointing to Python source code, showing
+    that PC-less frames can display Python source files with proper line
+    numbers and module/compile unit information.
+    """
+
+    def __init__(self, input_frames, args):
+        super().__init__(input_frames, args)
+
+        # Find the python_helper.py file
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        self.python_file = os.path.join(current_dir, "python_helper.py")
+
+    @staticmethod
+    def get_description():
+        """Return a description of this provider."""
+        return "Provider that prepends frames pointing to Python source"
+
+    def get_frame_at_index(self, index):
+        """Return Python source frames followed by original frames."""
+        if index == 0:
+            # Frame pointing to compute_fibonacci function (line 7)
+            return PythonSourceFrame(
+                self.thread, 0, "compute_fibonacci", self.python_file, 7
+            )
+        elif index == 1:
+            # Frame pointing to process_data function (line 16)
+            return PythonSourceFrame(
+                self.thread, 1, "process_data", self.python_file, 16
+            )
+        elif index == 2:
+            # Frame pointing to main function (line 27)
+            return PythonSourceFrame(
+                self.thread, 2, "main", self.python_file, 27
+            )
+        elif index - 3 < len(self.input_frames):
+            # Pass through original frames
+            return index - 3
+        return None