From 061da546b983eb767bad15e67af1174fb0bcf31c Mon Sep 17 00:00:00 2001 From: patrick Date: Mon, 3 Aug 2020 14:33:06 +0000 Subject: Import LLVM 10.0.0 release including clang, lld and lldb. ok hackroom tested by plenty --- .../lldbsuite/test/python_api/frame/Makefile | 3 + .../lldbsuite/test/python_api/frame/TestFrames.py | 221 ++++++++++++++++ .../test/python_api/frame/get-variables/Makefile | 3 + .../frame/get-variables/TestGetVariables.py | 294 +++++++++++++++++++++ .../test/python_api/frame/get-variables/main.c | 28 ++ .../test/python_api/frame/inlines/Makefile | 7 + .../python_api/frame/inlines/TestInlinedFrame.py | 94 +++++++ .../test/python_api/frame/inlines/inlines.c | 53 ++++ .../test/python_api/frame/inlines/inlines.h | 4 + .../Python/lldbsuite/test/python_api/frame/main.c | 57 ++++ 10 files changed, 764 insertions(+) create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/Makefile create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/Makefile create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/main.c create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/Makefile create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.c create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.h create mode 100644 gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/main.c (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame') diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/Makefile new file mode 100644 index 00000000000..10495940055 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py new file mode 100644 index 00000000000..91ac30e36e3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py @@ -0,0 +1,221 @@ +""" +Use lldb Python SBFrame API to get the argument values of the call stacks. +And other SBFrame API tests. +""" + +from __future__ import print_function + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class FrameAPITestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @add_test_categories(['pyapi']) + def test_get_arg_vals_for_call_stack(self): + """Exercise SBFrame.GetVariables() API to get argument vals.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Now create a breakpoint on main.c by name 'c'. + breakpoint = target.BreakpointCreateByName('c', 'a.out') + #print("breakpoint:", breakpoint) + self.assertTrue(breakpoint and + breakpoint.GetNumLocations() == 1, + VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + process = target.GetProcess() + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + # Keeps track of the number of times 'a' is called where it is within a + # depth of 3 of the 'c' leaf function. + callsOfA = 0 + + from six import StringIO as SixStringIO + session = SixStringIO() + while process.GetState() == lldb.eStateStopped: + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + # Inspect at most 3 frames. + numFrames = min(3, thread.GetNumFrames()) + for i in range(numFrames): + frame = thread.GetFrameAtIndex(i) + if self.TraceOn(): + print("frame:", frame) + + name = frame.GetFunction().GetName() + if name == 'a': + callsOfA = callsOfA + 1 + + # We'll inspect only the arguments for the current frame: + # + # arguments => True + # locals => False + # statics => False + # in_scope_only => True + valList = frame.GetVariables(True, False, False, True) + argList = [] + for val in valList: + argList.append("(%s)%s=%s" % (val.GetTypeName(), + val.GetName(), + val.GetValue())) + print("%s(%s)" % (name, ", ".join(argList)), file=session) + + # Also check the generic pc & stack pointer. We can't test their absolute values, + # but they should be valid. Uses get_GPRs() from the lldbutil + # module. + gpr_reg_set = lldbutil.get_GPRs(frame) + pc_value = gpr_reg_set.GetChildMemberWithName("pc") + self.assertTrue(pc_value, "We should have a valid PC.") + pc_value_int = int(pc_value.GetValue(), 0) + # Make sure on arm targets we dont mismatch PC value on the basis of thumb bit. + # Frame PC will not have thumb bit set in case of a thumb + # instruction as PC. + if self.getArchitecture() in ['arm', 'armv7', 'armv7k']: + pc_value_int &= ~1 + self.assertTrue( + pc_value_int == frame.GetPC(), + "PC gotten as a value should equal frame's GetPC") + sp_value = gpr_reg_set.GetChildMemberWithName("sp") + self.assertTrue( + sp_value, "We should have a valid Stack Pointer.") + self.assertTrue(int(sp_value.GetValue(), 0) == frame.GetSP( + ), "SP gotten as a value should equal frame's GetSP") + + print("---", file=session) + process.Continue() + + # At this point, the inferior process should have exited. + self.assertTrue( + process.GetState() == lldb.eStateExited, + PROCESS_EXITED) + + # Expect to find 'a' on the call stacks two times. + self.assertTrue(callsOfA == 2, + "Expect to find 'a' on the call stacks two times") + # By design, the 'a' call frame has the following arg vals: + # o a((int)val=1, (char)ch='A') + # o a((int)val=3, (char)ch='A') + if self.TraceOn(): + print("Full stack traces when stopped on the breakpoint 'c':") + print(session.getvalue()) + self.expect(session.getvalue(), "Argugment values displayed correctly", + exe=False, + substrs=["a((int)val=1, (char)ch='A')", + "a((int)val=3, (char)ch='A')"]) + + @add_test_categories(['pyapi']) + def test_frame_api_boundary_condition(self): + """Exercise SBFrame APIs with boundary condition inputs.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Now create a breakpoint on main.c by name 'c'. + breakpoint = target.BreakpointCreateByName('c', 'a.out') + #print("breakpoint:", breakpoint) + self.assertTrue(breakpoint and + breakpoint.GetNumLocations() == 1, + VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + process = target.GetProcess() + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + frame = thread.GetFrameAtIndex(0) + if self.TraceOn(): + print("frame:", frame) + + # Boundary condition testings. + val1 = frame.FindVariable(None, True) + val2 = frame.FindVariable(None, False) + val3 = frame.FindValue(None, lldb.eValueTypeVariableGlobal) + if self.TraceOn(): + print("val1:", val1) + print("val2:", val2) + + frame.EvaluateExpression(None) + + @add_test_categories(['pyapi']) + def test_frame_api_IsEqual(self): + """Exercise SBFrame API IsEqual.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Now create a breakpoint on main.c by name 'c'. + breakpoint = target.BreakpointCreateByName('c', 'a.out') + #print("breakpoint:", breakpoint) + self.assertTrue(breakpoint and + breakpoint.GetNumLocations() == 1, + VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + process = target.GetProcess() + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + + frameEntered = thread.GetFrameAtIndex(0) + if self.TraceOn(): + print(frameEntered) + lldbutil.print_stacktrace(thread) + self.assertTrue(frameEntered) + + # Doing two step overs while still inside c(). + thread.StepOver() + thread.StepOver() + self.assertTrue(thread) + frameNow = thread.GetFrameAtIndex(0) + if self.TraceOn(): + print(frameNow) + lldbutil.print_stacktrace(thread) + self.assertTrue(frameNow) + + # The latest two frames are considered equal. + self.assertTrue(frameEntered.IsEqual(frameNow)) + + # Now let's step out of frame c(). + thread.StepOutOfFrame(frameNow) + frameOutOfC = thread.GetFrameAtIndex(0) + if self.TraceOn(): + print(frameOutOfC) + lldbutil.print_stacktrace(thread) + self.assertTrue(frameOutOfC) + + # The latest two frames should not be equal. + self.assertFalse(frameOutOfC.IsEqual(frameNow)) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/Makefile new file mode 100644 index 00000000000..10495940055 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py new file mode 100644 index 00000000000..7ced4ddb98f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py @@ -0,0 +1,294 @@ +""" +Test that SBFrame::GetVariables() calls work correctly. +""" + +from __future__ import print_function + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbplatform +from lldbsuite.test import lldbutil + + +def get_names_from_value_list(value_list): + names = list() + for value in value_list: + names.append(value.GetName()) + return names + + +class TestGetVariables(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + self.source = 'main.c' + + def verify_variable_names(self, description, value_list, names): + copy_names = list(names) + actual_names = get_names_from_value_list(value_list) + for name in actual_names: + if name in copy_names: + copy_names.remove(name) + else: + self.assertTrue( + False, "didn't find '%s' in %s" % + (name, copy_names)) + self.assertEqual( + len(copy_names), 0, "%s: we didn't find variables: %s in value list (%s)" % + (description, copy_names, actual_names)) + + def test(self): + self.build() + + # Set debugger into synchronous mode + self.dbg.SetAsync(False) + + # Create a target by the debugger. + exe = self.getBuildArtifact("a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + line1 = line_number(self.source, '// breakpoint 1') + line2 = line_number(self.source, '// breakpoint 2') + line3 = line_number(self.source, '// breakpoint 3') + + breakpoint1 = target.BreakpointCreateByLocation(self.source, line1) + breakpoint2 = target.BreakpointCreateByLocation(self.source, line2) + breakpoint3 = target.BreakpointCreateByLocation(self.source, line3) + + self.assertTrue(breakpoint1.GetNumLocations() >= 1, PROCESS_IS_VALID) + self.assertTrue(breakpoint2.GetNumLocations() >= 1, PROCESS_IS_VALID) + self.assertTrue(breakpoint3.GetNumLocations() >= 1, PROCESS_IS_VALID) + + # Register our shared libraries for remote targets so they get + # automatically uploaded + arguments = None + environment = None + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + arguments, environment, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint1) + self.assertEqual( + len(threads), + 1, + "There should be a thread stopped at breakpoint 1") + + thread = threads[0] + self.assertTrue(thread.IsValid(), "Thread must be valid") + frame = thread.GetFrameAtIndex(0) + self.assertTrue(frame.IsValid(), "Frame must be valid") + + arg_names = ['argc', 'argv'] + local_names = ['i', 'j', 'k'] + static_names = ['static_var', 'g_global_var', 'g_static_var'] + breakpoint1_locals = ['i'] + breakpoint1_statics = ['static_var'] + num_args = len(arg_names) + num_locals = len(local_names) + num_statics = len(static_names) + args_yes = True + args_no = False + locals_yes = True + locals_no = False + statics_yes = True + statics_no = False + in_scopy_only = True + ignore_scope = False + + # Verify if we ask for only arguments that we got what we expect + vars = frame.GetVariables( + args_yes, locals_no, statics_no, ignore_scope) + self.assertEqual( + vars.GetSize(), + num_args, + "There should be %i arguments, but we are reporting %i" % + (num_args, + vars.GetSize())) + self.verify_variable_names("check names of arguments", vars, arg_names) + self.assertEqual( + len(arg_names), + num_args, + "make sure verify_variable_names() didn't mutate list") + + # Verify if we ask for only locals that we got what we expect + vars = frame.GetVariables( + args_no, locals_yes, statics_no, ignore_scope) + self.assertEqual( + vars.GetSize(), + num_locals, + "There should be %i local variables, but we are reporting %i" % + (num_locals, + vars.GetSize())) + self.verify_variable_names("check names of locals", vars, local_names) + + # Verify if we ask for only statics that we got what we expect + vars = frame.GetVariables( + args_no, locals_no, statics_yes, ignore_scope) + print('statics: ', str(vars)) + self.assertEqual( + vars.GetSize(), + num_statics, + "There should be %i static variables, but we are reporting %i" % + (num_statics, + vars.GetSize())) + self.verify_variable_names( + "check names of statics", vars, static_names) + + # Verify if we ask for arguments and locals that we got what we expect + vars = frame.GetVariables( + args_yes, locals_yes, statics_no, ignore_scope) + desc = 'arguments + locals' + names = arg_names + local_names + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Verify if we ask for arguments and statics that we got what we expect + vars = frame.GetVariables( + args_yes, locals_no, statics_yes, ignore_scope) + desc = 'arguments + statics' + names = arg_names + static_names + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Verify if we ask for locals and statics that we got what we expect + vars = frame.GetVariables( + args_no, locals_yes, statics_yes, ignore_scope) + desc = 'locals + statics' + names = local_names + static_names + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Verify if we ask for arguments, locals and statics that we got what + # we expect + vars = frame.GetVariables( + args_yes, locals_yes, statics_yes, ignore_scope) + desc = 'arguments + locals + statics' + names = arg_names + local_names + static_names + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Verify if we ask for in scope locals that we got what we expect + vars = frame.GetVariables( + args_no, locals_yes, statics_no, in_scopy_only) + desc = 'in scope locals at breakpoint 1' + names = ['i'] + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Continue to breakpoint 2 + process.Continue() + + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint2) + self.assertEqual( + len(threads), + 1, + "There should be a thread stopped at breakpoint 2") + + thread = threads[0] + self.assertTrue(thread.IsValid(), "Thread must be valid") + frame = thread.GetFrameAtIndex(0) + self.assertTrue(frame.IsValid(), "Frame must be valid") + + # Verify if we ask for in scope locals that we got what we expect + vars = frame.GetVariables( + args_no, locals_yes, statics_no, in_scopy_only) + desc = 'in scope locals at breakpoint 2' + names = ['i', 'j'] + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) + + # Continue to breakpoint 3 + process.Continue() + + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint3) + self.assertEqual( + len(threads), + 1, + "There should be a thread stopped at breakpoint 3") + + thread = threads[0] + self.assertTrue(thread.IsValid(), "Thread must be valid") + frame = thread.GetFrameAtIndex(0) + self.assertTrue(frame.IsValid(), "Frame must be valid") + + # Verify if we ask for in scope locals that we got what we expect + vars = frame.GetVariables( + args_no, locals_yes, statics_no, in_scopy_only) + desc = 'in scope locals at breakpoint 3' + names = ['i', 'j', 'k'] + count = len(names) + self.assertEqual( + vars.GetSize(), + count, + "There should be %i %s (%s) but we are reporting %i (%s)" % + (count, + desc, + names, + vars.GetSize(), + get_names_from_value_list(vars))) + self.verify_variable_names("check names of %s" % (desc), vars, names) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/main.c b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/main.c new file mode 100644 index 00000000000..7606e2ac909 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/get-variables/main.c @@ -0,0 +1,28 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// 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 + +int g_global_var = 123; +static int g_static_var = 123; + +int main (int argc, char const *argv[]) +{ + static int static_var = 123; + g_static_var = 123; // clang bug. Need to touch this variable, otherwise it disappears. + int i = 0; // breakpoint 1 + for (i=0; i<1; ++i) + { + int j = i*2; + printf("i = %i, j = %i\n", i, j); // breakpoint 2 + { + int k = i*j*3; + printf("i = %i, j = %i\n", i, j); // breakpoint 3 + } + } + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/Makefile new file mode 100644 index 00000000000..e6d9d8310a0 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/Makefile @@ -0,0 +1,7 @@ +C_SOURCES := inlines.c + +ifneq (,$(findstring icc,$(CC))) + CFLAGS_EXTRAS := -debug inline-debug-info +endif + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py new file mode 100644 index 00000000000..da4e9cb06e7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py @@ -0,0 +1,94 @@ +""" +Testlldb Python SBFrame APIs IsInlined() and GetFunctionName(). +""" + +from __future__ import print_function + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class InlinedFrameAPITestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to of function 'c'. + self.source = 'inlines.c' + self.first_stop = line_number( + self.source, '// This should correspond to the first break stop.') + self.second_stop = line_number( + self.source, '// This should correspond to the second break stop.') + + @add_test_categories(['pyapi']) + def test_stop_at_outer_inline(self): + """Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName().""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Now create a breakpoint on main.c by the name of 'inner_inline'. + breakpoint = target.BreakpointCreateByName('inner_inline', 'a.out') + #print("breakpoint:", breakpoint) + self.assertTrue(breakpoint and + breakpoint.GetNumLocations() > 1, + VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + process = target.GetProcess() + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + import lldbsuite.test.lldbutil as lldbutil + stack_traces1 = lldbutil.print_stacktraces(process, string_buffer=True) + if self.TraceOn(): + print( + "Full stack traces when first stopped on the breakpoint 'inner_inline':") + print(stack_traces1) + + # The first breakpoint should correspond to an inlined call frame. + # If it's an inlined call frame, expect to find, in the stack trace, + # that there is a frame which corresponds to the following call site: + # + # outer_inline (argc); + # + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + + frame0 = thread.GetFrameAtIndex(0) + if frame0.IsInlined(): + filename = frame0.GetLineEntry().GetFileSpec().GetFilename() + self.assertTrue(filename == self.source) + self.expect( + stack_traces1, "First stop at %s:%d" % + (self.source, self.first_stop), exe=False, substrs=[ + '%s:%d' % + (self.source, self.first_stop)]) + + # Expect to break again for the second time. + process.Continue() + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + stack_traces2 = lldbutil.print_stacktraces( + process, string_buffer=True) + if self.TraceOn(): + print( + "Full stack traces when stopped on the breakpoint 'inner_inline' for the second time:") + print(stack_traces2) + self.expect( + stack_traces2, "Second stop at %s:%d" % + (self.source, self.second_stop), exe=False, substrs=[ + '%s:%d' % + (self.source, self.second_stop)]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.c b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.c new file mode 100644 index 00000000000..a2a8212278d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.c @@ -0,0 +1,53 @@ +#include +#include "inlines.h" + +#define INLINE_ME __inline__ __attribute__((always_inline)) + +int +not_inlined_2 (int input) +{ + printf ("Called in not_inlined_2 with : %d.\n", input); + return input; +} + +int +not_inlined_1 (int input) +{ + printf ("Called in not_inlined_1 with %d.\n", input); + return not_inlined_2(input); +} + +INLINE_ME int +inner_inline (int inner_input, int mod_value) +{ + int inner_result; + inner_result = inner_input % mod_value; + printf ("Returning: %d.\n", inner_result); + return not_inlined_1 (inner_result); +} + +INLINE_ME int +outer_inline (int outer_input) +{ + int outer_result; + + outer_result = inner_inline (outer_input, outer_input % 3); + return outer_result; +} + +int +main (int argc, char **argv) +{ + printf ("Starting...\n"); + + int (*func_ptr) (int); + func_ptr = outer_inline; + + outer_inline (argc); // This should correspond to the first break stop. + + func_ptr (argc); // This should correspond to the second break stop. + + return 0; +} + + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.h new file mode 100644 index 00000000000..265d7b4966e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/inlines/inlines.h @@ -0,0 +1,4 @@ +int inner_inline (int inner_input, int mod_value); +int outer_inline (int outer_input); +int not_inlined_2 (int input); +int not_inlined_1 (int input); diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/main.c b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/main.c new file mode 100644 index 00000000000..75f4448758b --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/python_api/frame/main.c @@ -0,0 +1,57 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// 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 + +// This simple program is to test the lldb Python API related to frames. + +int a(int, char); +int b(int, char); +int c(int, char); + +int a(int val, char ch) +{ + int my_val = val; + char my_ch = ch; + printf("a(val=%d, ch='%c')\n", val, ch); + if (val <= 1) + return b(val+1, ch+1); + else if (val >= 3) + return c(val+1, ch+1); + + return val; +} + +int b(int val, char ch) +{ + int my_val = val; + char my_ch = ch; + printf("b(val=%d, ch='%c')\n", val, ch); + return c(val+1, ch+1); +} + +int c(int val, char ch) +{ + int my_val = val; + char my_ch = ch; + printf("c(val=%d, ch='%c')\n", val, ch); + return val + 3 + ch; +} + +int main (int argc, char const *argv[]) +{ + int A1 = a(1, 'A'); // a(1, 'A') -> b(2, 'B') -> c(3, 'C') + printf("a(1, 'A') returns %d\n", A1); + + int B2 = b(2, 'B'); // b(2, 'B') -> c(3, 'C') + printf("b(2, 'B') returns %d\n", B2); + + int A3 = a(3, 'A'); // a(3, 'A') -> c(4, 'B') + printf("a(3, 'A') returns %d\n", A3); + + return 0; +} -- cgit v1.2.3-59-g8ed1b