def test_SBModule(self): obj = lldb.SBModule() if self.TraceOn(): print obj self.assertFalse(obj) # Do fuzz testing on the invalid obj, it should not crash lldb. import sb_module sb_module.fuzz_obj(obj)
def test_union_members(self): self.build() spec = lldb.SBModuleSpec() spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact("a.out"))) module = lldb.SBModule(spec) self.assertTrue(module.IsValid()) mytype = module.FindFirstType("foobár") self.assertTrue(mytype.IsValid()) self.assertTrue(mytype.IsPointerType())
def modules_loaded(sbmodule_addrs, assign_sbmodule_addr): assign_sbmodule = ASSIGN_SBMODULE(assign_sbmodule_addr) # SWIG does not provide a method for wrapping raw pointers from Python, # so we create a dummy module object, then call back into Rust code to # overwrite it with the module we need wrapped. for addr in sbmodule_addrs: sbmodule = lldb.SBModule( ) # Recreate, because sbmodule.compile_units will cache the list assign_sbmodule(long(sbmodule.this), addr) analyze_module(sbmodule)
def test(self): self.build() # Extracts path of the interpreter. spec = lldb.SBModuleSpec() spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact("a.out"))) interp_section = lldb.SBModule(spec).FindSection(".interp") if not interp_section: return section_data = interp_section.GetSectionData() error = lldb.SBError() exe = section_data.GetString(error, 0) if error.Fail(): return target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Set breakpoints both on shared library function as well as on # main. Both of them will be pending breakpoints. breakpoint_main = target.BreakpointCreateBySourceRegex( "// Break here", lldb.SBFileSpec("main.cpp")) breakpoint_shared_library = target.BreakpointCreateBySourceRegex( "get_signal_crash", lldb.SBFileSpec("signal_file.cpp")) launch_info = lldb.SBLaunchInfo([ "--library-path", self.get_process_working_directory(), self.getBuildArtifact("a.out") ]) launch_info.SetWorkingDirectory(self.get_process_working_directory()) error = lldb.SBError() process = target.Launch(launch_info, error) self.assertTrue(error.Success()) # Stopped on main here. self.assertEqual(process.GetState(), lldb.eStateStopped) thread = process.GetSelectedThread() self.assertIn("main", thread.GetFrameAtIndex(0).GetDisplayFunctionName()) process.Continue() # Stopped on get_signal_crash function here. self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertIn("get_signal_crash", thread.GetFrameAtIndex(0).GetDisplayFunctionName()) process.Continue() # Stopped because of generated signal. self.assertEqual(process.GetState(), lldb.eStateStopped) self.assertIn("raise", thread.GetFrameAtIndex(0).GetDisplayFunctionName()) self.assertIn("get_signal_crash", thread.GetFrameAtIndex(1).GetDisplayFunctionName())
def find_module(self, target, name): num_modules = target.GetNumModules() index = 0 result = lldb.SBModule() while index < num_modules: module = target.GetModuleAtIndex(index) if module.GetFileSpec().GetFilename() == name: result = module break index += 1 self.assertTrue(result.IsValid()) return result
def _test(self): self.build() # Extracts path of the interpreter. exe = self.getBuildArtifact("a.out") spec = lldb.SBModuleSpec() spec.SetFileSpec(lldb.SBFileSpec(exe)) interp_section = lldb.SBModule(spec).FindSection(".interp") if not interp_section: return section_data = interp_section.GetSectionData() error = lldb.SBError() dyld_path = section_data.GetString(error, 0) if error.Fail(): return target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Set a breakpoint in the main function that will get hit after the # program exec's via the dynamic loader. The breakpoint will only get # hit if we can successfully read the shared library lists in the # DynamicLoaderPOSIXDYLD.cpp when we exec into the dynamic loader. breakpoint_main = target.BreakpointCreateBySourceRegex( "// Break here", lldb.SBFileSpec("main.cpp")) # Setup our launch info to supply the dynamic loader path to the # program so it gets two args: # - path to a.out # - path to dynamic loader launch_info = lldb.SBLaunchInfo([dyld_path]) error = lldb.SBError() process = target.Launch(launch_info, error) self.assertSuccess(error) threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonExec) self.assertEqual(len(threads), 1, "We got a thread stopped for exec.") process.Continue() # Stopped on main here. self.assertState(process.GetState(), lldb.eStateStopped) thread = process.GetSelectedThread() self.assertIn("main", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
def test_is_loaded(self): """Exercise SBTarget.IsLoaded(SBModule&) API.""" d = {'EXE': 'b.out'} self.build(dictionary=d) self.setTearDownCleanup(dictionary=d) target = self.create_simple_target('b.out') self.assertFalse(target.IsLoaded(lldb.SBModule())) num_modules = target.GetNumModules() for i in range(num_modules): module = target.GetModuleAtIndex(i) self.assertFalse(target.IsLoaded(module), "Target that isn't " "running shouldn't have any module loaded.") process = target.LaunchSimple(None, None, self.get_process_working_directory()) for i in range(num_modules): module = target.GetModuleAtIndex(i) self.assertTrue(target.IsLoaded(module), "Running the target should " "have loaded its modules.")