def test_with_run_command(self): self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target and target.IsValid(), "Target is valid") file_spec = lldb.SBFileSpec ("main.cpp", False) breakpoint1 = target.BreakpointCreateBySourceRegex('// Set break point at this line.', file_spec) self.assertTrue(breakpoint1 and breakpoint1.IsValid()) breakpoint2 = target.BreakpointCreateBySourceRegex('// Set second break point at this line.', file_spec) self.assertTrue(breakpoint2 and breakpoint2.IsValid()) # Run the program, it should stop at breakpoint 1. process = target.LaunchSimple(None, None, self.get_process_working_directory()) lldbutil.skip_if_library_missing(self, target, lldbutil.PrintableRegex("libc\+\+")) self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID) self.assertEquals(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint1)), 1) # verify our list is displayed correctly self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3', '[3] = 4', '[5] = 6']) # Continue to breakpoint 2. process.Continue() self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID) self.assertEquals(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint2)), 1) # The list is now inconsistent. However, we should be able to get the first three # elements at least (and most importantly, not crash). self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3']) # Run to completion. process.Continue() self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
def test_formatters_api(self): """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list""" self.build() self.setTearDownCleanup() exe_name = "a.out" exe = os.path.join(os.getcwd(), exe_name) # Create the target target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Set the breakpoints breakpoint = target.BreakpointCreateBySourceRegex('Set breakpoint here', lldb.SBFileSpec("main.cpp")) self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be at our breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue(len(threads) == 1) self.thread = threads[0] self.frame = self.thread.frames[0] self.assertTrue(self.frame, "Frame 0 is valid.") self.assertTrue(self.frame.GetVariables(True,True,False,True).GetSize() == 2, "variable count is off") self.assertFalse(self.frame.FindValue("NoSuchThing",lldb.eValueTypeVariableArgument,lldb.eDynamicCanRunTarget).IsValid(), "found something that should not be here") self.assertTrue(self.frame.GetVariables(True,True,False,True).GetSize() == 2, "variable count is off after failed FindValue()") self.assertTrue(self.frame.FindValue("a",lldb.eValueTypeVariableArgument,lldb.eDynamicCanRunTarget).IsValid(), "FindValue() didn't find an argument") self.assertTrue(self.frame.GetVariables(True,True,False,True).GetSize() == 2, "variable count is off after successful FindValue()")
def check_goroutines(self): self.assertLess(len(self.process().threads), 20) self.process().Continue() # Make sure we stopped at the 2nd breakpoint thread_list = lldbutil.get_threads_stopped_at_breakpoint( self.process(), self.bpt2) self.assertTrue( len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue( len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # There's (at least) 21 goroutines. self.assertGreater(len(self.process().threads), 20) # self.dbg.HandleCommand("log enable lldb os") # Now test that stepping works if the memory thread moves to a different backing thread. for i in xrange(11): self.thread().StepOver() self.assertEqual(lldb.eStopReasonPlanComplete, self.thread().GetStopReason(), self.thread().GetStopDescription(100)) # Disable the plugin and make sure the goroutines disappear self.dbg.HandleCommand( "settings set plugin.os.goroutines.enable false") self.thread().StepInstruction(False) self.assertLess(len(self.process().threads), 20)
def test_with_python_api(self): """Test function call thread safety.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.main_source_spec = lldb.SBFileSpec (self.main_source) break1 = target.BreakpointCreateByName ("stopper", 'a.out') self.assertTrue(break1, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1) if len(threads) != 1: self.fail ("Failed to stop at breakpoint 1.") self.check_number_of_threads(process) main_thread = lldb.SBThread() select_thread = lldb.SBThread() for idx in range (0, process.GetNumThreads()): t = process.GetThreadAtIndex (idx) if t.GetName() == "main thread": main_thread = t if t.GetName() == "select thread": select_thread = t self.assertTrue(main_thread.IsValid() and select_thread.IsValid(), "Got both expected threads") self.safe_to_call_func_on_main_thread (main_thread) self.safe_to_call_func_on_select_thread (select_thread)
def run_to_main(self): """Test that expr uses the correct property getters and setters""" exe = os.path.join(os.getcwd(), "a.out") # Create a target from the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Set up our breakpoints: main_bkpt = target.BreakpointCreateBySourceRegex( "Set a breakpoint here.", lldb.SBFileSpec(self.source_name)) self.assertTrue(main_bkpt and main_bkpt.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()) self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint( process, main_bkpt) self.assertTrue(len(threads) == 1) thread = threads[0] return thread
def objc_builtin_types(self): """Test expression parser respect for ObjC built-in types.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue( len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue( len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the class method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue(frame, "Got a valid frame 0 frame.") self.expect("expr (foo)", patterns=["\(ns::id\) \$.* = 0"]) self.expect("expr id my_id = 0; my_id", patterns=["\(id\) \$.* = 0x0"])
def objc_static_method(self): """Test calling functions in static methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the static method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.") cmd_value = frame.EvaluateExpression ("(char *) sel_getName (_cmd)") self.assertTrue (cmd_value.IsValid()) sel_name = cmd_value.GetSummary() self.assertTrue (sel_name == "\"doSomethingWithString:\"", "Got the right value for the selector as string.") cmd_value = frame.EvaluateExpression ("[self doSomethingElseWithString:string]") self.assertTrue (cmd_value.IsValid()) string_length = cmd_value.GetValueAsUnsigned() self.assertTrue (string_length == 27, "Got the right value from another class method on the same class.")
def objc_ivar_offsets(self): """Test that we can find stripped Objective-C ivars in the runtime""" exe = os.path.join(os.getcwd(), "a.out.stripped") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.dbg.HandleCommand("add-dsym a.out.dSYM") breakpoint = target.BreakpointCreateByLocation(self.main_source, self.stop_line) self.assertTrue(breakpoint.IsValid() and breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue (process, "Created a process.") self.assertTrue (process.GetState() == lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) self.assertTrue (frame, "frame 0 is valid") # Test the expression for mc->_foo error = lldb.SBError() ivar = frame.EvaluateExpression ("(mc->_foo)") self.assertTrue(ivar, "Got result for mc->_foo") ivar_value = ivar.GetValueAsSigned (error) self.assertTrue (error.Success()) self.assertTrue (ivar_value == 3)
def child_by_name(self): exe = os.path.join (os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) break_in_main = target.BreakpointCreateBySourceRegex ('// Set breakpoint 2 here.', lldb.SBFileSpec("main.c")) self.assertTrue(break_in_main, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue (process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint (process, break_in_main) if len(threads) != 1: self.fail ("Failed to stop at breakpoint in main.") thread = threads[0] frame = thread.frames[0] if not frame.IsValid(): self.fail ("Failed to get frame 0.") var_n = frame.FindVariable("n") if not var_n.IsValid(): self.fail ("Failed to get the variable 'n'") elem_a = var_n.GetChildMemberWithName("a") if not elem_a.IsValid(): self.fail ("Failed to get the element a in n") error = lldb.SBError() value = elem_a.GetValueAsSigned(error, 1000) if not error.Success() or value != 0: self.fail ("failed to get the correct value for element a in n")
def objc_class_method(self): """Test calling class methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue( len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue( len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the class method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue(frame, "Got a valid frame 0 frame.") cmd_value = frame.EvaluateExpression( "(int)[Foo doSomethingWithString:@\"Hello\"]") self.assertTrue(cmd_value.IsValid()) self.assertTrue(cmd_value.GetValueAsUnsigned() == 5)
def do_test(self, dictionary=None): """These basic expression commands should work as expected.""" self.buildDefault(dictionary = dictionary) target = self.dbg.CreateTarget(self.exe) self.assertTrue(target) breakpoint = target.BreakpointCreateBySourceRegex('// Break here', self.main_source_spec) self.assertTrue(breakpoint) # Launch the process, and do not stop at the entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process) threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) self.assertEqual(len(threads), 1) frame = threads[0].GetFrameAtIndex(0) value = frame.EvaluateExpression("foo(c)") self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success()) self.assertEqual(value.GetValueAsSigned(0), 1) value = frame.EvaluateExpression("foo(sc)") self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success()) self.assertEqual(value.GetValueAsSigned(0), 2) value = frame.EvaluateExpression("foo(uc)") self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success()) self.assertEqual(value.GetValueAsSigned(0), 3)
def run_to_main (self): """Test that expr uses the correct property getters and setters""" exe = os.path.join(os.getcwd(), "a.out") # Create a target from the debugger. target = self.dbg.CreateTarget (exe) self.assertTrue(target, VALID_TARGET) # Set up our breakpoints: main_bkpt = target.BreakpointCreateBySourceRegex ("Set a breakpoint here.", lldb.SBFileSpec (self.source_name)) self.assertTrue(main_bkpt and main_bkpt.GetNumLocations() == 1, VALID_BREAKPOINT) # Now launch the process, and do not stop at the entry point. process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint (process, main_bkpt) self.assertTrue (len(threads) == 1) thread = threads[0] return thread
def step_in_template(self): """Use Python APIs to test stepping in to templated functions.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) break_1_in_main = target.BreakpointCreateBySourceRegex ('// Call max_value template', self.main_source_spec) self.assertTrue(break_1_in_main, VALID_BREAKPOINT) break_2_in_main = target.BreakpointCreateBySourceRegex ('// Call max_value specialized', self.main_source_spec) self.assertTrue(break_2_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. self.process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(self.process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, break_1_in_main) if len(threads) != 1: self.fail ("Failed to stop at first breakpoint in main.") self.thread = threads[0] step_sequence = [["// In max_value template", "into"]] self.run_step_sequence(step_sequence) threads = lldbutil.continue_to_breakpoint (self.process, break_2_in_main) self.assertEqual(len(threads), 1, "Successfully ran to call site of second caller_trivial_1 call.") self.thread = threads[0] step_sequence = [["// In max_value specialized", "into"]] self.run_step_sequence(step_sequence)
def inline_stepping_step_over(self): """Use Python APIs to test stepping over and hitting breakpoints.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) break_1_in_main = target.BreakpointCreateBySourceRegex ('// At second call of caller_ref_1 in main.', self.main_source_spec) self.assertTrue(break_1_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. self.process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(self.process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, break_1_in_main) if len(threads) != 1: self.fail ("Failed to stop at first breakpoint in main.") self.thread = threads[0] step_sequence = [["// In caller_ref_1.", "into"], ["// In caller_ref_2.", "into"], ["// At increment in caller_ref_2.", "over"]] self.run_step_sequence (step_sequence)
def step_in_template(self): """Use Python APIs to test stepping in to templated functions.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) break_1_in_main = target.BreakpointCreateBySourceRegex("// Call max_value template", self.main_source_spec) self.assertTrue(break_1_in_main, VALID_BREAKPOINT) break_2_in_main = target.BreakpointCreateBySourceRegex("// Call max_value specialized", self.main_source_spec) self.assertTrue(break_2_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. self.process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(self.process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint(self.process, break_1_in_main) if len(threads) != 1: self.fail("Failed to stop at first breakpoint in main.") self.thread = threads[0] step_sequence = [["// In max_value template", "into"]] self.run_step_sequence(step_sequence) threads = lldbutil.continue_to_breakpoint(self.process, break_2_in_main) self.assertEqual(len(threads), 1, "Successfully ran to call site of second caller_trivial_1 call.") self.thread = threads[0] step_sequence = [["// In max_value specialized", "into"]] self.run_step_sequence(step_sequence)
def launchProcess(self): exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1) self.assertTrue(bpt1, VALID_BREAKPOINT) bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2) self.assertTrue(bpt2, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt1) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.")
def test_with_python_api(self): """Test calling methods on super.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the class method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.") cmd_value = frame.EvaluateExpression ("[self get]") self.assertTrue (cmd_value.IsValid()) self.assertTrue (cmd_value.GetValueAsUnsigned() == 2) cmd_value = frame.EvaluateExpression ("[super get]") self.assertTrue (cmd_value.IsValid()) self.assertTrue (cmd_value.GetValueAsUnsigned() == 1)
def launchProcess(self): exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1) self.assertTrue(bpt1, VALID_BREAKPOINT) bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2) self.assertTrue(bpt2, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt1) # Make sure we stopped at the first breakpoint. self.assertTrue( len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue( len(thread_list) == 1, "More than one thread stopped at our breakpoint.") frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue(frame, "Got a valid frame 0 frame.")
def objc_class_method(self): """Test calling class methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue( len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue( len(thread_list) == 1, "More than one thread stopped at our breakpoint.") frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue(frame, "Got a valid frame 0 frame.") # Now make sure we can call a method that returns a struct without crashing. cmd_value = frame.EvaluateExpression("[provider getRange]") self.assertTrue(cmd_value.IsValid())
def test_with_python_api(self): """Test expression parser respect for ObjC built-in types.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the class method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.") self.expect("expr (foo)", patterns = ["\(ns::id\) \$.* = 0"]) self.expect("expr id my_id = 0; my_id", patterns = ["\(id\) \$.* = nil"])
def inline_stepping_step_over(self): """Use Python APIs to test stepping over and hitting breakpoints.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) break_1_in_main = target.BreakpointCreateBySourceRegex ('// At second call of caller_ref_1 in main.', self.main_source_spec) self.assertTrue(break_1_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. self.process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue(self.process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, break_1_in_main) if len(threads) != 1: self.fail ("Failed to stop at first breakpoint in main.") self.thread = threads[0] step_sequence = [["// In caller_ref_1.", "into"], ["// In caller_ref_2.", "into"], ["// At increment in caller_ref_2.", "over"]] self.run_step_sequence (step_sequence)
def objc_static_method_stripped(self): """Test calling functions in static methods with a stripped binary.""" exe = os.path.join(os.getcwd(), "a.out.stripped") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") # Now make sure we can call a function in the static method we've stopped in. frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.") cmd_value = frame.EvaluateExpression ("(char *) sel_getName (_cmd)") self.assertTrue (cmd_value.IsValid()) sel_name = cmd_value.GetSummary() self.assertTrue (sel_name == "\"doSomethingWithString:\"", "Got the right value for the selector as string.") cmd_value = frame.EvaluateExpression ("[Foo doSomethingElseWithString:string]") self.assertTrue (cmd_value.IsValid()) string_length = cmd_value.GetValueAsUnsigned() self.assertTrue (string_length == 27, "Got the right value from another class method on the same class.")
def test_with_python_api(self): """Test passing structs to Objective-C methods.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue(len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue(len(thread_list) == 1, "More than one thread stopped at our breakpoint.") frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue(frame, "Got a valid frame 0 frame.") self.expect("p [summer sumThings:tts]", substrs=["9"]) self.expect("po [NSValue valueWithRect:rect]", substrs=["NSRect: {{0, 0}, {10, 20}}"]) # Now make sure we can call a method that returns a struct without crashing. cmd_value = frame.EvaluateExpression("[provider getRange]") self.assertTrue(cmd_value.IsValid())
def objc_class_method(self): """Test calling class methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) self.assertTrue(bpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) # Make sure we stopped at the first breakpoint. self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") frame = thread_list[0].GetFrameAtIndex(0) self.assertTrue (frame, "Got a valid frame 0 frame.") # Now make sure we can call a method that returns a struct without crashing. cmd_value = frame.EvaluateExpression ("[provider getRange]") self.assertTrue (cmd_value.IsValid())
def call_function(self): """Test calling function with timeout.""" exe_name = "a.out" exe = os.path.join(os.getcwd(), exe_name) target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateBySourceRegex( 'stop here in main.', self.main_source_spec) self.assertTrue(breakpoint, VALID_BREAKPOINT) self.runCmd("breakpoint list") # Launch the process, and do not stop at the entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be on self.step_out_of_malloc. threads = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertTrue(len(threads) == 1) thread = threads[0] # First set the timeout too short, and make sure we fail. options = lldb.SBExpressionOptions() options.SetTimeoutInMicroSeconds(100) options.SetUnwindOnError(True) frame = thread.GetFrameAtIndex(0) value = frame.EvaluateExpression("wait_a_while (10000)", options) self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success() == False) # Now do the same thing with the command line command, and make sure it works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() return_value = interp.HandleCommand( "expr -t 100 -u true -- wait_a_while(10000)", result) self.assertTrue(return_value == lldb.eReturnStatusFailed) # Okay, now do it again with long enough time outs: options.SetTimeoutInMicroSeconds(1000000) value = frame.EvaluateExpression("wait_a_while (1000)", options) self.assertTrue(value.IsValid()) self.assertTrue(value.GetError().Success() == True) # Now do the same thingwith the command line command, and make sure it works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() return_value = interp.HandleCommand( "expr -t 1000000 -u true -- wait_a_while(1000)", result) self.assertTrue(return_value == lldb.eReturnStatusSuccessFinishResult)
def objc_ivar_offsets(self): """Use Python APIs to test stepping into ObjC methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateByLocation(self.main_source, self.stop_line) self.assertTrue(breakpoint, VALID_BREAKPOINT) process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, "Created a process.") self.assertTrue(process.GetState() == lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertTrue(len(thread_list) == 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) self.assertTrue(frame, "frame 0 is valid") mine = thread.GetFrameAtIndex(0).FindVariable("mine") self.assertTrue(mine, "Found local variable mine.") # Test the value object value for BaseClass->_backed_int error = lldb.SBError() mine_backed_int = mine.GetChildMemberWithName("_backed_int") self.assertTrue(mine_backed_int, "Found mine->backed_int local variable.") backed_value = mine_backed_int.GetValueAsSigned(error) self.assertTrue(error.Success()) self.assertTrue(backed_value == 1111) # Test the value object value for DerivedClass->_derived_backed_int mine_derived_backed_int = mine.GetChildMemberWithName( "_derived_backed_int") self.assertTrue(mine_derived_backed_int, "Found mine->derived_backed_int local variable.") derived_backed_value = mine_derived_backed_int.GetValueAsSigned(error) self.assertTrue(error.Success()) self.assertTrue(derived_backed_value == 3333) # Make sure we also get bit-field offsets correct: mine_flag2 = mine.GetChildMemberWithName("flag2") self.assertTrue(mine_flag2, "Found mine->flag2 local variable.") flag2_value = int(mine_flag2.GetValue(), 0) self.assertTrue(flag2_value == 7) # GetValueAsUnsigned fails for bit-fields: flag2_value = mine_flag2.GetValueAsUnsigned(error) self.assertTrue(error.Success()) self.assertTrue(flag2_value == 7)
def test_11581_commands(self): # This is the function to remove the custom commands in order to have a # clean slate for the next test case. def cleanup(): self.runCmd('type synthetic clear', check=False) # Execute the cleanup function during test case tear down. self.addTearDownHook(cleanup) """valobj.AddressOf() should return correct values.""" self.buildDefault() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateBySourceRegex('Set breakpoint here.',lldb.SBFileSpec ("main.cpp", False)) process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue (process, "Created a process.") self.assertTrue (process.GetState() == lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] self.runCmd("command script import --allow-reload s11588.py") self.runCmd("type synthetic add --python-class s11588.Issue11581SyntheticProvider StgClosure") self.expect("expr --show-types -- *((StgClosure*)(r14-1))", substrs = ["(StgClosure) $", "(StgClosure *) &$","0x", "addr = ", "load_address = "]) target = lldb.debugger.GetSelectedTarget() process = target.GetProcess() # register r14 does not exist on 32-bit architectures, it is an x86_64 extension # let's skip this part of the test if we are in 32-bit mode if process.GetAddressByteSize() == 8: frame = process.GetSelectedThread().GetSelectedFrame() pointer = frame.FindVariable("r14") addr = pointer.GetValueAsUnsigned(0) self.assertTrue(addr != 0, "could not read pointer to StgClosure") addr = addr - 1 self.runCmd("register write r14 %d" % addr) self.expect("register read r14", substrs = ["0x",hex(addr)[2:].rstrip("L")]) # Remove trailing 'L' if it exists self.expect("expr --show-types -- *(StgClosure*)$r14", substrs = ["(StgClosure) $", "(StgClosure *) &$","0x", "addr = ", "load_address = ", hex(addr)[2:].rstrip("L"), str(addr)])
def queues(self): """Test queues inspection SB APIs without libBacktraceRecording.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.main_source_spec = lldb.SBFileSpec(self.main_source) break1 = target.BreakpointCreateByName("stopper", 'a.out') self.assertTrue(break1, VALID_BREAKPOINT) process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint(process, break1) if len(threads) != 1: self.fail("Failed to stop at breakpoint 1.") queue_submittor_1 = lldb.SBQueue() queue_performer_1 = lldb.SBQueue() queue_performer_2 = lldb.SBQueue() queue_performer_3 = lldb.SBQueue() for idx in range(0, process.GetNumQueues()): q = process.GetQueueAtIndex(idx) if q.GetName() == "com.apple.work_submittor_1": queue_submittor_1 = q if q.GetName() == "com.apple.work_performer_1": queue_performer_1 = q if q.GetName() == "com.apple.work_performer_2": queue_performer_2 = q if q.GetName() == "com.apple.work_performer_3": queue_performer_3 = q self.assertTrue( queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), "Got all four expected queues: %s %s %s %s" % (queue_submittor_1.IsValid(), queue_performer_1.IsValid(), queue_performer_2.IsValid(), queue_performer_3.IsValid())) self.check_queue_for_valid_queue_id(queue_submittor_1) self.check_queue_for_valid_queue_id(queue_performer_1) self.check_queue_for_valid_queue_id(queue_performer_2) self.check_queue_for_valid_queue_id(queue_performer_3) self.check_number_of_threads_owned_by_queue(queue_submittor_1, 1) self.check_number_of_threads_owned_by_queue(queue_performer_1, 1) self.check_number_of_threads_owned_by_queue(queue_performer_2, 1) self.check_number_of_threads_owned_by_queue(queue_performer_3, 4) self.check_queue_kind(queue_submittor_1, lldb.eQueueKindSerial) self.check_queue_kind(queue_performer_1, lldb.eQueueKindSerial) self.check_queue_kind(queue_performer_2, lldb.eQueueKindSerial) self.check_queue_kind(queue_performer_3, lldb.eQueueKindConcurrent) self.check_queues_threads_match_queue(queue_submittor_1) self.check_queues_threads_match_queue(queue_performer_1) self.check_queues_threads_match_queue(queue_performer_2) self.check_queues_threads_match_queue(queue_performer_3)
def ivars_in_blocks (self): """Test printing the ivars of the self when captured in blocks""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateBySourceRegex ('// Break here inside the block.', self.class_source_file_spec) self.assertTrue(breakpoint, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue (process, "Created a process.") self.assertTrue (process.GetState() == lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) self.assertTrue (frame, "frame 0 is valid") # First use the FindVariable API to see if we can find the ivar by undecorated name: direct_blocky = frame.GetValueForVariablePath ("blocky_ivar") self.assertTrue(direct_blocky, "Found direct access to blocky_ivar.") # Now get it as a member of "self" and make sure the two values are equal: self_var = frame.GetValueForVariablePath ("self") self.assertTrue (self_var, "Found self in block.") indirect_blocky = self_var.GetChildMemberWithName ("blocky_ivar") self.assertTrue (indirect_blocky, "Found blocky_ivar through self") error = lldb.SBError() direct_value = direct_blocky.GetValueAsSigned(error) self.assertTrue (error.Success(), "Got direct value for blocky_ivar") indirect_value = indirect_blocky.GetValueAsSigned (error) self.assertTrue (error.Success(), "Got indirect value for blocky_ivar") self.assertTrue (direct_value == indirect_value, "Direct and indirect values are equal.") # Now make sure that we can get at the captured ivar through the expression parser. # Doing a little trivial math will force this into the real expression parser: direct_expr = frame.EvaluateExpression ("blocky_ivar + 10") self.assertTrue (direct_expr, "Got blocky_ivar through the expression parser") # Again, get the value through self directly and make sure they are the same: indirect_expr = frame.EvaluateExpression ("self->blocky_ivar + 10") self.assertTrue (indirect_expr, "Got blocky ivar through expression parser using self.") direct_value = direct_expr.GetValueAsSigned (error) self.assertTrue (error.Success(), "Got value from direct use of expression parser") indirect_value = indirect_expr.GetValueAsSigned (error) self.assertTrue (error.Success(), "Got value from indirect access using the expression parser") self.assertTrue (direct_value == indirect_value, "Direct ivar access and indirect through expression parser produce same value.")
def test_with_python_api(self): """Test that adding, deleting and modifying watchpoints sends the appropriate events.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.main_source_spec = lldb.SBFileSpec(self.main_source) break_in_main = target.BreakpointCreateBySourceRegex( '// Put a breakpoint here.', self.main_source_spec) self.assertTrue(break_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint( process, break_in_main) if len(threads) != 1: self.fail("Failed to stop at first breakpoint in main.") thread = threads[0] frame = thread.GetFrameAtIndex(0) local_var = frame.FindVariable("local_var") self.assertTrue(local_var.IsValid()) self.listener = lldb.SBListener("com.lldb.testsuite_listener") self.target_bcast = target.GetBroadcaster() self.target_bcast.AddListener( self.listener, lldb.SBTarget.eBroadcastBitWatchpointChanged) self.listener.StartListeningForEvents( self.target_bcast, lldb.SBTarget.eBroadcastBitWatchpointChanged) error = lldb.SBError() local_watch = local_var.Watch(True, True, True, error) if not error.Success(): self.fail("Failed to make watchpoint for local_var: %s" % (error.GetCString())) self.GetWatchpointEvent(lldb.eWatchpointEventTypeAdded) # Now change some of the features of this watchpoint and make sure we get events: local_watch.SetEnabled(False) self.GetWatchpointEvent(lldb.eWatchpointEventTypeDisabled) local_watch.SetIgnoreCount(10) self.GetWatchpointEvent(lldb.eWatchpointEventTypeIgnoreChanged) local_watch.SetCondition("1 == 2") self.GetWatchpointEvent(lldb.eWatchpointEventTypeConditionChanged)
def call_function(self): """Test calling function with timeout.""" exe_name = "a.out" exe = os.path.join(os.getcwd(), exe_name) target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateBySourceRegex('stop here in main.',self.main_source_spec) self.assertTrue(breakpoint, VALID_BREAKPOINT) self.runCmd("breakpoint list") # Launch the process, and do not stop at the entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Frame #0 should be on self.step_out_of_malloc. threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue(len(threads) == 1) thread = threads[0] # First set the timeout too short, and make sure we fail. options = lldb.SBExpressionOptions() options.SetTimeoutInMicroSeconds(100) options.SetUnwindOnError(True) frame = thread.GetFrameAtIndex(0) value = frame.EvaluateExpression ("wait_a_while (10000)", options) self.assertTrue (value.IsValid()) self.assertTrue (value.GetError().Success() == False) # Now do the same thing with the command line command, and make sure it works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() return_value = interp.HandleCommand ("expr -t 100 -u true -- wait_a_while(10000)", result) self.assertTrue (return_value == lldb.eReturnStatusFailed) # Okay, now do it again with long enough time outs: options.SetTimeoutInMicroSeconds(1000000) value = frame.EvaluateExpression ("wait_a_while (1000)", options) self.assertTrue(value.IsValid()) self.assertTrue (value.GetError().Success() == True) # Now do the same thingwith the command line command, and make sure it works too. interp = self.dbg.GetCommandInterpreter() result = lldb.SBCommandReturnObject() return_value = interp.HandleCommand ("expr -t 1000000 -u true -- wait_a_while(1000)", result) self.assertTrue(return_value == lldb.eReturnStatusSuccessFinishResult)
def return_and_test_struct_value(self, func_name): """Pass in the name of the function to return from - takes in value, returns value.""" # Set the breakpoint, run to it, finish out. bkpt = self.target.BreakpointCreateByName(func_name) self.assertTrue(bkpt.GetNumResolvedLocations() > 0) self.process.Continue() thread_list = lldbutil.get_threads_stopped_at_breakpoint( self.process, bkpt) self.assertTrue(len(thread_list) == 1) thread = thread_list[0] self.target.BreakpointDelete(bkpt.GetID()) in_value = thread.GetFrameAtIndex(0).FindVariable("value") self.assertTrue(in_value.IsValid()) num_in_children = in_value.GetNumChildren() # This is a little hokey, but if we don't get all the children now, then # once we've stepped we won't be able to get them? for idx in range(0, num_in_children): in_child = in_value.GetChildAtIndex(idx) in_child_str = in_child.GetValue() thread.StepOut() self.assertTrue(self.process.GetState() == lldb.eStateStopped) self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete) # Assuming all these functions step out to main. Could figure out the caller dynamically # if that would add something to the test. frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() self.assertTrue(fun_name == "main") frame = thread.GetFrameAtIndex(0) ret_value = thread.GetStopReturnValue() self.assertTrue(ret_value.IsValid()) num_ret_children = ret_value.GetNumChildren() self.assertTrue(num_in_children == num_ret_children) for idx in range(0, num_ret_children): in_child = in_value.GetChildAtIndex(idx) ret_child = ret_value.GetChildAtIndex(idx) in_child_str = in_child.GetValue() ret_child_str = ret_child.GetValue() self.assertTrue(in_child_str == ret_child_str)
def objc_ivar_offsets(self): """Use Python APIs to test stepping into ObjC methods.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateByLocation(self.main_source, self.stop_line) self.assertTrue(breakpoint, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, os.getcwd()) self.assertTrue (process, "Created a process.") self.assertTrue (process.GetState() == lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) self.assertTrue (frame, "frame 0 is valid") mine = thread.GetFrameAtIndex(0).FindVariable("mine") self.assertTrue(mine, "Found local variable mine.") # Test the value object value for BaseClass->_backed_int error = lldb.SBError() mine_backed_int = mine.GetChildMemberWithName ("_backed_int") self.assertTrue(mine_backed_int, "Found mine->backed_int local variable.") backed_value = mine_backed_int.GetValueAsSigned (error) self.assertTrue (error.Success()) self.assertTrue (backed_value == 1111) # Test the value object value for DerivedClass->_derived_backed_int mine_derived_backed_int = mine.GetChildMemberWithName ("_derived_backed_int") self.assertTrue(mine_derived_backed_int, "Found mine->derived_backed_int local variable.") derived_backed_value = mine_derived_backed_int.GetValueAsSigned (error) self.assertTrue (error.Success()) self.assertTrue (derived_backed_value == 3333) # Make sure we also get bit-field offsets correct: mine_flag2 = mine.GetChildMemberWithName ("flag2") self.assertTrue(mine_flag2, "Found mine->flag2 local variable.") flag2_value = int (mine_flag2.GetValue (), 0) self.assertTrue (flag2_value == 7) # GetValueAsUnsigned fails for bit-fields: flag2_value = mine_flag2.GetValueAsUnsigned (error) self.assertTrue (error.Success()) self.assertTrue (flag2_value == 7)
def cpp_exceptions(self): """Test lldb exception breakpoint command for CPP.""" exe = os.path.join(os.getcwd(), "a.out") # Create a target from the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) exception_bkpt = target.BreakpointCreateForException( lldb.eLanguageTypeC_plus_plus, True, True) self.assertTrue(exception_bkpt, "Made an exception breakpoint") # Now run, and make sure we hit our breakpoint: process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, "Got a valid process") stopped_threads = [] stopped_threads = lldbutil.get_threads_stopped_at_breakpoint( process, exception_bkpt) self.assertTrue( len(stopped_threads) == 1, "Stopped at our exception breakpoint.") thread = stopped_threads[0] # Make sure our throw function is still above us on the stack: frame_functions = lldbutil.get_function_names(thread) self.assertTrue( frame_functions.count("throws_exception_on_even(int)") == 1, "Our throw function is still on the stack.") # Okay we hit our exception throw breakpoint, now make sure we get our catch breakpoint. # One potential complication is that we might hit a couple of the exception breakpoints in getting out of the throw. # so loop till we don't see the throws function on the stack. We should stop one more time for our exception breakpoint # and that should be the catch... while frame_functions.count("throws_exception_on_even(int)") == 1: stopped_threads = lldbutil.continue_to_breakpoint( process, exception_bkpt) self.assertTrue(len(stopped_threads) == 1) thread = stopped_threads[0] frame_functions = lldbutil.get_function_names(thread) self.assertTrue( frame_functions.count("throws_exception_on_even(int)") == 0, "At catch our throw function is off the stack") self.assertTrue( frame_functions.count("intervening_function(int)") == 0, "At catch our intervening function is off the stack") self.assertTrue( frame_functions.count("catches_exception(int)") == 1, "At catch our catch function is on the stack")
def return_and_test_struct_value (self, func_name): """Pass in the name of the function to return from - takes in value, returns value.""" # Set the breakpoint, run to it, finish out. bkpt = self.target.BreakpointCreateByName (func_name) self.assertTrue (bkpt.GetNumResolvedLocations() > 0) self.process.Continue () thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process, bkpt) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] self.target.BreakpointDelete (bkpt.GetID()) in_value = thread.GetFrameAtIndex(0).FindVariable ("value") self.assertTrue (in_value.IsValid()) num_in_children = in_value.GetNumChildren() # This is a little hokey, but if we don't get all the children now, then # once we've stepped we won't be able to get them? for idx in range(0, num_in_children): in_child = in_value.GetChildAtIndex (idx) in_child_str = in_child.GetValue() thread.StepOut() self.assertTrue (self.process.GetState() == lldb.eStateStopped) self.assertTrue (thread.GetStopReason() == lldb.eStopReasonPlanComplete) # Assuming all these functions step out to main. Could figure out the caller dynamically # if that would add something to the test. frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() self.assertTrue (fun_name == "main") frame = thread.GetFrameAtIndex(0) ret_value = thread.GetStopReturnValue() self.assertTrue (ret_value.IsValid()) num_ret_children = ret_value.GetNumChildren() self.assertTrue (num_in_children == num_ret_children) for idx in range(0, num_ret_children): in_child = in_value.GetChildAtIndex(idx) ret_child = ret_value.GetChildAtIndex(idx) in_child_str = in_child.GetValue() ret_child_str = ret_child.GetValue() self.assertEqual(in_child_str, ret_child_str)
def test_python(self): """Test that we obey thread conditioned breakpoints.""" self.build() exe = os.path.join(os.getcwd(), "a.out") self.dbg.HandleCommand( "log enable -f /tmp/lldb-testsuite-log.txt lldb step breakpoint process" ) target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) main_source_spec = lldb.SBFileSpec("main.cpp") # Set a breakpoint in the thread body, and make it active for only the first thread. break_thread_body = target.BreakpointCreateBySourceRegex( "Break here in thread body.", main_source_spec) self.assertTrue( break_thread_body.IsValid() and break_thread_body.GetNumLocations() > 0, "Failed to set thread body breakpoint.") process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint( process, break_thread_body) victim_thread = threads[0] # Pick one of the threads, and change the breakpoint so it ONLY stops for this thread, # but add a condition that it won't stop for this thread's my_value. The other threads # pass the condition, so they should stop, but if the thread-specification is working # they should not stop. So nobody should hit the breakpoint anymore, and we should # just exit cleanly. frame = victim_thread.GetFrameAtIndex(0) value = frame.FindVariable("my_value").GetValueAsSigned(0) self.assertTrue(value > 0 and value < 11, "Got a reasonable value for my_value.") cond_string = "my_value != %d" % (value) break_thread_body.SetThreadID(victim_thread.GetThreadID()) break_thread_body.SetCondition(cond_string) process.Continue() next_stop_state = process.GetState() self.assertTrue(next_stop_state == lldb.eStateExited, "We should have not hit the breakpoint again.")
def test_step_inst(self): self.build(dictionary=self.getBuildFlags()) exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target and target.IsValid(), "Target is valid") # This should create a breakpoint in the stepping thread. breakpoint = target.BreakpointCreateByName("main") self.assertTrue(breakpoint and breakpoint.IsValid(), "Breakpoint is valid") # Run the program. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertEquals(len(threads), 1, STOPPED_DUE_TO_BREAKPOINT) thread = threads[0] self.assertTrue(thread and thread.IsValid(), "Thread is valid") # Make sure we see only one threads self.assertEqual( process.GetNumThreads(), 1, 'Number of expected threads and actual threads do not match.') # Keep stepping until we see the thread creation while process.GetNumThreads() < 2: thread.StepInstruction(False) self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete, "Step operation succeeded") if self.TraceOn(): self.runCmd("disassemble --pc") if self.TraceOn(): self.runCmd("thread list") # We have successfully caught thread creation. Now just run to completion process.Continue() # At this point, the inferior process should have exited. self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
def queues(self): """Test queues inspection SB APIs without libBacktraceRecording.""" exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.main_source_spec = lldb.SBFileSpec (self.main_source) break1 = target.BreakpointCreateByName ("stopper", 'a.out') self.assertTrue(break1, VALID_BREAKPOINT) process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1) if len(threads) != 1: self.fail ("Failed to stop at breakpoint 1.") queue_submittor_1 = lldb.SBQueue() queue_performer_1 = lldb.SBQueue() queue_performer_2 = lldb.SBQueue() queue_performer_3 = lldb.SBQueue() for idx in range (0, process.GetNumQueues()): q = process.GetQueueAtIndex(idx) if q.GetName() == "com.apple.work_submittor_1": queue_submittor_1 = q if q.GetName() == "com.apple.work_performer_1": queue_performer_1 = q if q.GetName() == "com.apple.work_performer_2": queue_performer_2 = q if q.GetName() == "com.apple.work_performer_3": queue_performer_3 = q self.assertTrue(queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), "Got all four expected queues: %s %s %s %s" % (queue_submittor_1.IsValid(), queue_performer_1.IsValid(), queue_performer_2.IsValid(), queue_performer_3.IsValid())) self.check_queue_for_valid_queue_id (queue_submittor_1) self.check_queue_for_valid_queue_id (queue_performer_1) self.check_queue_for_valid_queue_id (queue_performer_2) self.check_queue_for_valid_queue_id (queue_performer_3) self.check_number_of_threads_owned_by_queue (queue_submittor_1, 1) self.check_number_of_threads_owned_by_queue (queue_performer_1, 1) self.check_number_of_threads_owned_by_queue (queue_performer_2, 1) self.check_number_of_threads_owned_by_queue (queue_performer_3, 4) self.check_queue_kind (queue_submittor_1, lldb.eQueueKindSerial) self.check_queue_kind (queue_performer_1, lldb.eQueueKindSerial) self.check_queue_kind (queue_performer_2, lldb.eQueueKindSerial) self.check_queue_kind (queue_performer_3, lldb.eQueueKindConcurrent) self.check_queues_threads_match_queue (queue_submittor_1) self.check_queues_threads_match_queue (queue_performer_1) self.check_queues_threads_match_queue (queue_performer_2) self.check_queues_threads_match_queue (queue_performer_3)
def test_with_python_api(self): """Test that adding, deleting and modifying watchpoints sends the appropriate events.""" self.build() exe = os.path.join(os.getcwd(), "a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) self.main_source_spec = lldb.SBFileSpec (self.main_source) break_in_main = target.BreakpointCreateBySourceRegex ('// Put a breakpoint here.', self.main_source_spec) self.assertTrue(break_in_main, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint (process, break_in_main) if len(threads) != 1: self.fail ("Failed to stop at first breakpoint in main.") thread = threads[0] frame = thread.GetFrameAtIndex(0) local_var = frame.FindVariable ("local_var") self.assertTrue (local_var.IsValid()) self.listener = lldb.SBListener("com.lldb.testsuite_listener") self.target_bcast = target.GetBroadcaster() self.target_bcast.AddListener (self.listener, lldb.SBTarget.eBroadcastBitWatchpointChanged) self.listener.StartListeningForEvents (self.target_bcast, lldb.SBTarget.eBroadcastBitWatchpointChanged) error = lldb.SBError() local_watch = local_var.Watch(True, True, True, error) if not error.Success(): self.fail ("Failed to make watchpoint for local_var: %s"%(error.GetCString())) self.GetWatchpointEvent (lldb.eWatchpointEventTypeAdded) # Now change some of the features of this watchpoint and make sure we get events: local_watch.SetEnabled(False) self.GetWatchpointEvent (lldb.eWatchpointEventTypeDisabled) local_watch.SetIgnoreCount(10) self.GetWatchpointEvent (lldb.eWatchpointEventTypeIgnoreChanged) local_watch.SetCondition ("1 == 2") self.GetWatchpointEvent (lldb.eWatchpointEventTypeConditionChanged)
def test_objc_checker(self): """Test that checkers catch unrecognized selectors""" if self.getArchitecture() == 'i386': self.skipTest("requires Objective-C 2.0 runtime") self.build() exe = os.path.join(os.getcwd(), "a.out") # Create a target from the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Set up our breakpoints: main_bkpt = target.BreakpointCreateBySourceRegex( "Set a breakpoint here.", lldb.SBFileSpec(self.source_name)) self.assertTrue(main_bkpt and main_bkpt.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()) self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint( process, main_bkpt) self.assertTrue(len(threads) == 1) thread = threads[0] # # The class Simple doesn't have a count method. Make sure that we don't # actually try to send count but catch it as an unrecognized selector. frame = thread.GetFrameAtIndex(0) expr_value = frame.EvaluateExpression("(int) [my_simple count]", False) expr_error = expr_value.GetError() self.assertTrue(expr_error.Fail()) # Make sure the call produced no NSLog stdout. stdout = process.GetSTDOUT(100) self.assertTrue(len(stdout) == 0) # Make sure the error is helpful: err_string = expr_error.GetCString() self.assertTrue("selector" in err_string)
def find_global_variables(self, exe_name): """Exercise SBTaget.FindGlobalVariables() API.""" exe = os.path.join(os.getcwd(), exe_name) # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) #rdar://problem/9700873 # Find global variable value fails for dwarf if inferior not started # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94) # # Remove the lines to create a breakpoint and to start the inferior # which are workarounds for the dwarf case. breakpoint = target.BreakpointCreateByLocation('main.c', self.line1) self.assertTrue(breakpoint, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Make sure we hit our breakpoint: thread_list = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertTrue(len(thread_list) == 1) value_list = target.FindGlobalVariables('my_global_var_of_char_type', 3) self.assertTrue(value_list.GetSize() == 1) my_global_var = value_list.GetValueAtIndex(0) self.DebugSBValue(my_global_var) self.assertTrue(my_global_var) self.expect(my_global_var.GetName(), exe=False, startstr="my_global_var_of_char_type") self.expect(my_global_var.GetTypeName(), exe=False, startstr="char") self.expect(my_global_var.GetValue(), exe=False, startstr="'X'") # While we are at it, let's also exercise the similar SBModule.FindGlobalVariables() API. for m in target.module_iter(): if os.path.normpath(m.GetFileSpec().GetDirectory()) == os.getcwd( ) and m.GetFileSpec().GetFilename() == exe_name: value_list = m.FindGlobalVariables( target, 'my_global_var_of_char_type', 3) self.assertTrue(value_list.GetSize() == 1) self.assertTrue( value_list.GetValueAtIndex(0).GetValue() == "'X'") break
def do_cpp_exception_bkpt(self): exe = os.path.join(os.getcwd(), "a.out") error = lldb.SBError() self.target = self.dbg.CreateTarget(exe) self.assertTrue(self.target, VALID_TARGET) exception_bkpt = self.target.BreakpointCreateForException(lldb.eLanguageTypeC_plus_plus, False, True) self.assertTrue(exception_bkpt.IsValid(), "Created exception breakpoint.") process = self.target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, exception_bkpt) self.assertTrue(len(thread_list) == 1, "One thread stopped at the exception breakpoint.")
def do_cpp_exception_bkpt (self): exe = os.path.join(os.getcwd(), "a.out") error = lldb.SBError() self.target = self.dbg.CreateTarget(exe) self.assertTrue(self.target, VALID_TARGET) exception_bkpt = self.target.BreakpointCreateForException(lldb.eLanguageTypeC_plus_plus, False, True) self.assertTrue (exception_bkpt.IsValid(), "Created exception breakpoint.") process = self.target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, exception_bkpt) self.assertTrue (len(thread_list) == 1, "One thread stopped at the exception breakpoint.")
def test_objc_checker(self): """Test that checkers catch unrecognized selectors""" if self.getArchitecture() == 'i386': self.skipTest("requires Objective-C 2.0 runtime") self.build() exe = os.path.join(os.getcwd(), "a.out") # Create a target from the debugger. target = self.dbg.CreateTarget (exe) self.assertTrue(target, VALID_TARGET) # Set up our breakpoints: main_bkpt = target.BreakpointCreateBySourceRegex ("Set a breakpoint here.", lldb.SBFileSpec (self.source_name)) self.assertTrue(main_bkpt and main_bkpt.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()) self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint (process, main_bkpt) self.assertTrue (len(threads) == 1) thread = threads[0] # # The class Simple doesn't have a count method. Make sure that we don't # actually try to send count but catch it as an unrecognized selector. frame = thread.GetFrameAtIndex(0) expr_value = frame.EvaluateExpression("(int) [my_simple count]", False) expr_error = expr_value.GetError() self.assertTrue (expr_error.Fail()) # Make sure the call produced no NSLog stdout. stdout = process.GetSTDOUT(100) self.assertTrue (len(stdout) == 0) # Make sure the error is helpful: err_string = expr_error.GetCString() self.assertTrue ("selector" in err_string)
def test_expr_options(self): """These expression command options should work as expected.""" self.build() # Set debugger into synchronous mode self.dbg.SetAsync(False) # Create a target by the debugger. target = self.dbg.CreateTarget(self.exe) self.assertTrue(target, VALID_TARGET) # Set breakpoints inside main. breakpoint = target.BreakpointCreateBySourceRegex( '// breakpoint_in_main', self.main_source_spec) self.assertTrue(breakpoint) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertEqual(len(threads), 1) frame = threads[0].GetFrameAtIndex(0) options = lldb.SBExpressionOptions() # test --language on C++ expression using the SB API's # Make sure we can evaluate 'ns::func'. val = frame.EvaluateExpression('foo != nullptr') self.assertTrue(val.IsValid()) self.assertTrue(val.GetError().Success()) self.DebugSBValue(val) # Make sure it still works if language is set to C++11: options.SetLanguage(lldb.eLanguageTypeC_plus_plus_11) val = frame.EvaluateExpression('foo != nullptr', options) self.assertTrue(val.IsValid()) self.assertTrue(val.GetError().Success()) self.DebugSBValue(val) # Make sure it fails if language is set to C: options.SetLanguage(lldb.eLanguageTypeC) val = frame.EvaluateExpression('foo != nullptr', options) self.assertTrue(val.IsValid()) self.assertFalse(val.GetError().Success())
def test_find_global_variables_then_object_description(self): """Exercise SBTarget.FindGlobalVariables() API.""" d = {'EXE': 'b.out'} self.build(dictionary=d) self.setTearDownCleanup(dictionary=d) exe = os.path.join(os.getcwd(), 'b.out') # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateByLocation(self.source, self.line) self.assertTrue(breakpoint, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Make sure we hit our breakpoint: thread_list = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertTrue(len(thread_list) == 1) thread = thread_list[0] frame0 = thread.GetFrameAtIndex(0) # Note my_global_str's object description prints fine here. value_list1 = frame0.GetVariables(True, True, True, True) for v in value_list1: self.DebugSBValue(v) if self.TraceOn(): print "val:", v print "object description:", v.GetObjectDescription() if v.GetName() == 'my_global_str': self.assertTrue( v.GetObjectDescription() == 'This is a global string') # But not here! value_list2 = target.FindGlobalVariables('my_global_str', 3) for v in value_list2: self.DebugSBValue(v) if self.TraceOn(): print "val:", v print "object description:", v.GetObjectDescription() if v.GetName() == 'my_global_str': self.assertTrue( v.GetObjectDescription() == 'This is a global string')
def test_expr_options(self): """These expression command options should work as expected.""" self.build() # Set debugger into synchronous mode self.dbg.SetAsync(False) # Create a target by the debugger. target = self.dbg.CreateTarget(self.exe) self.assertTrue(target, VALID_TARGET) # Set breakpoints inside main. breakpoint = target.BreakpointCreateBySourceRegex('// breakpoint_in_main', self.main_source_spec) self.assertTrue(breakpoint) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) self.assertEqual(len(threads), 1) frame = threads[0].GetFrameAtIndex(0) options = lldb.SBExpressionOptions() # test --language on C++ expression using the SB API's # Make sure we can evaluate 'ns::func'. val = frame.EvaluateExpression('foo != nullptr') self.assertTrue(val.IsValid()) self.assertTrue(val.GetError().Success()) self.DebugSBValue(val) # Make sure it still works if language is set to C++11: options.SetLanguage(lldb.eLanguageTypeC_plus_plus_11) val = frame.EvaluateExpression('foo != nullptr', options) self.assertTrue(val.IsValid()) self.assertTrue(val.GetError().Success()) self.DebugSBValue(val) # Make sure it fails if language is set to C: options.SetLanguage(lldb.eLanguageTypeC) val = frame.EvaluateExpression('foo != nullptr', options) self.assertTrue(val.IsValid()) self.assertFalse(val.GetError().Success())
def find_global_variables(self, exe_name): """Exercise SBTaget.FindGlobalVariables() API.""" exe = os.path.join(os.getcwd(), exe_name) # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) #rdar://problem/9700873 # Find global variable value fails for dwarf if inferior not started # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94) # # Remove the lines to create a breakpoint and to start the inferior # which are workarounds for the dwarf case. breakpoint = target.BreakpointCreateByLocation('main.c', self.line1) self.assertTrue(breakpoint, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, PROCESS_IS_VALID) # Make sure we hit our breakpoint: thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) value_list = target.FindGlobalVariables('my_global_var_of_char_type', 3) self.assertTrue(value_list.GetSize() == 1) my_global_var = value_list.GetValueAtIndex(0) self.DebugSBValue(my_global_var) self.assertTrue(my_global_var) self.expect(my_global_var.GetName(), exe=False, startstr = "my_global_var_of_char_type") self.expect(my_global_var.GetTypeName(), exe=False, startstr = "char") self.expect(my_global_var.GetValue(), exe=False, startstr = "'X'") # While we are at it, let's also exercise the similar SBModule.FindGlobalVariables() API. for m in target.module_iter(): if m.GetFileSpec().GetDirectory() == os.getcwd() and m.GetFileSpec().GetFilename() == exe_name: value_list = m.FindGlobalVariables(target, 'my_global_var_of_char_type', 3) self.assertTrue(value_list.GetSize() == 1) self.assertTrue(value_list.GetValueAtIndex(0).GetValue() == "'X'") break
def do_set_python_command_from_python (self): exe = os.path.join(os.getcwd(), "a.out") error = lldb.SBError() self.target = self.dbg.CreateTarget(exe) self.assertTrue(self.target, VALID_TARGET) body_bkpt = self.target.BreakpointCreateBySourceRegex("Set break point at this line.", self.main_source_spec) self.assertTrue(body_bkpt, VALID_BREAKPOINT) func_bkpt = self.target.BreakpointCreateBySourceRegex("Set break point at this line.", self.main_source_spec) self.assertTrue(func_bkpt, VALID_BREAKPOINT) PythonBreakpointCommandSettingTestCase.my_var = 10 error = lldb.SBError() error = body_bkpt.SetScriptCallbackBody("\ import TestBreakpointCommandsFromPython\n\ TestBreakpointCommandsFromPython.PythonBreakpointCommandSettingTestCase.my_var = 20\n\ print 'Hit breakpoint'") self.assertTrue (error.Success(), "Failed to set the script callback body: %s."%(error.GetCString())) self.dbg.HandleCommand("command script import --allow-reload ./bktptcmd.py") func_bkpt.SetScriptCallbackFunction("bktptcmd.function") # We will use the function that touches a text file, so remove it first: self.RemoveTempFile("output2.txt") # Now launch the process, and do not stop at entry point. self.process = self.target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(self.process, PROCESS_IS_VALID) # Now finish, and make sure the return value is correct. threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, body_bkpt) self.assertTrue(len(threads) == 1, "Stopped at inner breakpoint.") self.thread = threads[0] self.assertTrue(PythonBreakpointCommandSettingTestCase.my_var == 20) # Check for the function version as well, which produced this file: # Remember to clean up after ourselves... self.assertTrue(os.path.isfile("output2.txt"), "'output2.txt' exists due to breakpoint command for breakpoint function.") self.RemoveTempFile("output2.txt")
def do_thread_specific_break(self): """Test that we obey thread conditioned breakpoints.""" exe = os.path.join(os.getcwd(), "a.out") self.dbg.HandleCommand("log enable -f /tmp/lldb-testsuite-log.txt lldb step breakpoint process") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) main_source_spec = lldb.SBFileSpec("main.c") # Set a breakpoint in the thread body, and make it active for only the first thread. break_thread_body = target.BreakpointCreateBySourceRegex("Break here in thread body.", main_source_spec) self.assertTrue( break_thread_body.IsValid() and break_thread_body.GetNumLocations() > 0, "Failed to set thread body breakpoint.", ) process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) threads = lldbutil.get_threads_stopped_at_breakpoint(process, break_thread_body) victim_thread = threads[0] # Pick one of the threads, and change the breakpoint so it ONLY stops for this thread, # but add a condition that it won't stop for this thread's my_value. The other threads # pass the condition, so they should stop, but if the thread-specification is working # they should not stop. So nobody should hit the breakpoint anymore, and we should # just exit cleanly. frame = victim_thread.GetFrameAtIndex(0) value = frame.FindVariable("my_value").GetValueAsSigned(0) self.assertTrue(value > 0 and value < 11, "Got a reasonable value for my_value.") cond_string = "my_value != %d" % (value) break_thread_body.SetThreadID(victim_thread.GetThreadID()) break_thread_body.SetCondition(cond_string) process.Continue() next_stop_state = process.GetState() self.assertTrue(next_stop_state == lldb.eStateExited, "We should have not hit the breakpoint again.")
def get_to_starting_point (self): exe = os.path.join(os.getcwd(), "a.out") error = lldb.SBError() self.target = self.dbg.CreateTarget(exe) self.assertTrue(self.target, VALID_TARGET) inner_bkpt = self.target.BreakpointCreateBySourceRegex("Stop here and step out of me", self.main_source_spec) self.assertTrue(inner_bkpt, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. self.process = self.target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(self.process, PROCESS_IS_VALID) # Now finish, and make sure the return value is correct. threads = lldbutil.get_threads_stopped_at_breakpoint (self.process, inner_bkpt) self.assertTrue(len(threads) == 1, "Stopped at inner breakpoint.") self.thread = threads[0]
def test_find_global_variables_then_object_description(self): """Exercise SBTarget.FindGlobalVariables() API.""" d = {'EXE': 'b.out'} self.build(dictionary=d) self.setTearDownCleanup(dictionary=d) exe = os.path.join(os.getcwd(), 'b.out') # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) breakpoint = target.BreakpointCreateByLocation(self.source, self.line) self.assertTrue(breakpoint, VALID_BREAKPOINT) # Now launch the process, and do not stop at entry point. process = target.LaunchSimple (None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # Make sure we hit our breakpoint: thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint) self.assertTrue (len(thread_list) == 1) thread = thread_list[0] frame0 = thread.GetFrameAtIndex(0) # Note my_global_str's object description prints fine here. value_list1 = frame0.GetVariables(True, True, True, True) for v in value_list1: self.DebugSBValue(v) if self.TraceOn(): print "val:", v print "object description:", v.GetObjectDescription() if v.GetName() == 'my_global_str': self.assertTrue(v.GetObjectDescription() == 'This is a global string') # But not here! value_list2 = target.FindGlobalVariables('my_global_str', 3) for v in value_list2: self.DebugSBValue(v) if self.TraceOn(): print "val:", v print "object description:", v.GetObjectDescription() if v.GetName() == 'my_global_str': self.assertTrue(v.GetObjectDescription() == 'This is a global string')