1"""Test that lldb functions correctly after the inferior has asserted.""" 2 3import os, time 4import unittest2 5import lldb, lldbutil 6from lldbtest import * 7 8class AssertingInferiorTestCase(TestBase): 9 10 mydir = os.path.join("functionalities", "inferior-assert") 11 12 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") 13 def test_inferior_asserting_dsym(self): 14 """Test that lldb reliably catches the inferior asserting (command).""" 15 self.buildDsym() 16 self.inferior_asserting() 17 18 def test_inferior_asserting_dwarf(self): 19 """Test that lldb reliably catches the inferior asserting (command).""" 20 self.buildDwarf() 21 self.inferior_asserting() 22 23 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") 24 def test_inferior_asserting_registers_dsym(self): 25 """Test that lldb reliably reads registers from the inferior after asserting (command).""" 26 self.buildDsym() 27 self.inferior_asserting_registers() 28 29 def test_inferior_asserting_register_dwarf(self): 30 """Test that lldb reliably reads registers from the inferior after asserting (command).""" 31 self.buildDwarf() 32 self.inferior_asserting_registers() 33 34 @skipIfGcc # Avoid xpasses as the verion of libc used on the gcc buildbot has the required function symbols. 35 @expectedFailureLinux # ResolveSymbolContextForAddress can fail using ELF with stripped function symbols. 36 def test_inferior_asserting_disassemble(self): 37 """Test that lldb reliably disassemblers frames after asserting (command).""" 38 self.buildDefault() 39 self.inferior_asserting_disassemble() 40 41 @python_api_test 42 def test_inferior_asserting_python(self): 43 """Test that lldb reliably catches the inferior asserting (Python API).""" 44 self.buildDefault() 45 self.inferior_asserting_python() 46 47 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") 48 def test_inferior_asserting_expr(self): 49 """Test that the lldb expression interpreter can read from the inferior after asserting (command).""" 50 self.buildDsym() 51 self.inferior_asserting_expr() 52 53 def test_inferior_asserting_expr(self): 54 """Test that the lldb expression interpreter can read from the inferior after asserting (command).""" 55 self.buildDwarf() 56 self.inferior_asserting_expr() 57 58 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") 59 def test_inferior_asserting_step(self): 60 """Test that lldb functions correctly after stepping through a call to assert().""" 61 self.buildDsym() 62 self.inferior_asserting_step() 63 64 def test_inferior_asserting_step(self): 65 """Test that lldb functions correctly after stepping through a call to assert().""" 66 self.buildDwarf() 67 self.inferior_asserting_step() 68 69 def set_breakpoint(self, line): 70 lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True) 71 72 def check_stop_reason(self): 73 stop_reason = 'stop reason = signal SIGABRT' 74 75 # The stop reason of the thread should be an abort signal or exception. 76 self.expect("thread list", STOPPED_DUE_TO_ASSERT, 77 substrs = ['stopped', 78 stop_reason]) 79 80 return stop_reason 81 82 def setUp(self): 83 # Call super's setUp(). 84 TestBase.setUp(self) 85 # Find the line number of the call to assert. 86 self.line = line_number('main.c', '// Assert here.') 87 88 def inferior_asserting(self): 89 """Inferior asserts upon launching; lldb should catch the event and stop.""" 90 exe = os.path.join(os.getcwd(), "a.out") 91 self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) 92 93 self.runCmd("run", RUN_SUCCEEDED) 94 stop_reason = self.check_stop_reason() 95 96 # And it should report a backtrace that includes the assert site. 97 self.expect("thread backtrace all", 98 substrs = [stop_reason, 'main', 'argc', 'argv']) 99 100 # And it should report the correct line number. 101 self.expect("thread backtrace all", 102 substrs = [stop_reason, 103 'main.c:%d' % self.line]) 104 105 def inferior_asserting_python(self): 106 """Inferior asserts upon launching; lldb should catch the event and stop.""" 107 exe = os.path.join(os.getcwd(), "a.out") 108 109 target = self.dbg.CreateTarget(exe) 110 self.assertTrue(target, VALID_TARGET) 111 112 # Now launch the process, and do not stop at entry point. 113 # Both argv and envp are null. 114 process = target.LaunchSimple(None, None, os.getcwd()) 115 116 if process.GetState() != lldb.eStateStopped: 117 self.fail("Process should be in the 'stopped' state, " 118 "instead the actual state is: '%s'" % 119 lldbutil.state_type_to_str(process.GetState())) 120 121 thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal) 122 if not thread: 123 self.fail("Fail to stop the thread upon assert") 124 125 if self.TraceOn(): 126 lldbutil.print_stacktrace(thread) 127 128 def inferior_asserting_registers(self): 129 """Test that lldb can read registers after asserting.""" 130 exe = os.path.join(os.getcwd(), "a.out") 131 self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) 132 133 self.runCmd("run", RUN_SUCCEEDED) 134 self.check_stop_reason() 135 136 # lldb should be able to read from registers from the inferior after asserting. 137 self.expect("register read eax", 138 substrs = ['eax = 0x']) 139 140 def inferior_asserting_disassemble(self): 141 """Test that lldb can disassemble frames after asserting.""" 142 exe = os.path.join(os.getcwd(), "a.out") 143 144 # Create a target by the debugger. 145 target = self.dbg.CreateTarget(exe) 146 self.assertTrue(target, VALID_TARGET) 147 148 # Launch the process, and do not stop at the entry point. 149 target.LaunchSimple(None, None, os.getcwd()) 150 self.check_stop_reason() 151 152 process = target.GetProcess() 153 self.assertTrue(process.IsValid(), "current process is valid") 154 155 thread = process.GetThreadAtIndex(0) 156 self.assertTrue(thread.IsValid(), "current thread is valid") 157 158 # lldb should be able to disassemble frames from the inferior after asserting. 159 for frame in thread: 160 self.assertTrue(frame.IsValid(), "current frame is valid") 161 162 self.runCmd("frame select " + str(frame.GetFrameID()), RUN_SUCCEEDED) 163 164 self.expect("disassemble -a %s" % frame.GetPC(), 165 substrs = ['->', frame.GetFunctionName()]) 166 167 def check_expr_in_main(self, thread): 168 depth = thread.GetNumFrames() 169 for i in range(depth): 170 frame = thread.GetFrameAtIndex(i) 171 self.assertTrue(frame.IsValid(), "current frame is valid") 172 if self.TraceOn(): 173 print "Checking if function %s is main" % frame.GetFunctionName() 174 175 if 'main' == frame.GetFunctionName(): 176 frame_id = frame.GetFrameID() 177 self.runCmd("frame select " + str(frame_id), RUN_SUCCEEDED) 178 self.expect("p argc", substrs = ['(int)', ' = 1']) 179 self.expect("p hello_world", substrs = ['Hello']) 180 self.expect("p argv[0]", substrs = ['a.out']) 181 self.expect("p null_ptr", substrs = ['= 0x0']) 182 return True 183 return False 184 185 def inferior_asserting_expr(self): 186 """Test that the lldb expression interpreter can read symbols after asserting.""" 187 exe = os.path.join(os.getcwd(), "a.out") 188 189 # Create a target by the debugger. 190 target = self.dbg.CreateTarget(exe) 191 self.assertTrue(target, VALID_TARGET) 192 193 # Launch the process, and do not stop at the entry point. 194 target.LaunchSimple(None, None, os.getcwd()) 195 self.check_stop_reason() 196 197 process = target.GetProcess() 198 self.assertTrue(process.IsValid(), "current process is valid") 199 200 thread = process.GetThreadAtIndex(0) 201 self.assertTrue(thread.IsValid(), "current thread is valid") 202 203 # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert(). 204 self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace") 205 206 def inferior_asserting_step(self): 207 """Test that lldb functions correctly after stepping through a call to assert().""" 208 exe = os.path.join(os.getcwd(), "a.out") 209 210 # Create a target by the debugger. 211 target = self.dbg.CreateTarget(exe) 212 self.assertTrue(target, VALID_TARGET) 213 214 # Launch the process, and do not stop at the entry point. 215 self.set_breakpoint(self.line) 216 target.LaunchSimple(None, None, os.getcwd()) 217 218 self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, 219 substrs = ['main.c:%d' % self.line, 220 'stop reason = breakpoint']) 221 222 self.runCmd("next") 223 stop_reason = self.check_stop_reason() 224 225 # lldb should be able to read from registers from the inferior after asserting. 226 if "x86_64" in self.getArchitecture(): 227 self.expect("register read rbp", substrs = ['rbp = 0x']) 228 if "i386" in self.getArchitecture(): 229 self.expect("register read ebp", substrs = ['ebp = 0x']) 230 231 process = target.GetProcess() 232 self.assertTrue(process.IsValid(), "current process is valid") 233 234 thread = process.GetThreadAtIndex(0) 235 self.assertTrue(thread.IsValid(), "current thread is valid") 236 237 # The lldb expression interpreter should be able to read from addresses of the inferior after a call to assert(). 238 self.assertTrue(self.check_expr_in_main(thread), "cannot find 'main' in the backtrace") 239 240 # And it should report the correct line number. 241 self.expect("thread backtrace all", 242 substrs = [stop_reason, 243 'main.c:%d' % self.line]) 244 245if __name__ == '__main__': 246 import atexit 247 lldb.SBDebugger.Initialize() 248 atexit.register(lambda: lldb.SBDebugger.Terminate()) 249 unittest2.main() 250