| """Test aspects of lldb commands on universal binaries.""" |
| |
| from __future__ import print_function |
| |
| |
| import unittest2 |
| import os |
| import time |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| class UniversalTestCase(TestBase): |
| |
| mydir = TestBase.compute_mydir(__file__) |
| |
| def setUp(self): |
| # Call super's setUp(). |
| TestBase.setUp(self) |
| # Find the line number to break inside main(). |
| self.line = line_number('main.c', '// Set break point at this line.') |
| |
| @add_test_categories(['pyapi']) |
| @skipUnlessDarwin |
| @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [ |
| 'i386', 'x86_64'], "requires i386 or x86_64") |
| @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system |
| def test_sbdebugger_create_target_with_file_and_target_triple(self): |
| """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API.""" |
| # Invoke the default build rule. |
| self.build() |
| |
| # Note that "testit" is a universal binary. |
| exe = self.getBuildArtifact("testit") |
| |
| # Create a target by the debugger. |
| target = self.dbg.CreateTargetWithFileAndTargetTriple( |
| exe, "i386-apple-macosx") |
| self.assertTrue(target, VALID_TARGET) |
| |
| # 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) |
| |
| @skipUnlessDarwin |
| @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [ |
| 'i386', 'x86_64'], "requires i386 or x86_64") |
| @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system |
| def test_process_launch_for_universal(self): |
| """Test process launch of a universal binary.""" |
| from lldbsuite.test.lldbutil import print_registers |
| |
| # Invoke the default build rule. |
| self.build() |
| |
| # Note that "testit" is a universal binary. |
| exe = self.getBuildArtifact("testit") |
| |
| # By default, x86_64 is assumed if no architecture is specified. |
| self.expect("file " + exe, CURRENT_EXECUTABLE_SET, |
| startstr="Current executable set to ", |
| substrs=["testit' (x86_64)."]) |
| |
| # Break inside the main. |
| lldbutil.run_break_set_by_file_and_line( |
| self, "main.c", self.line, num_expected_locations=1, loc_exact=True) |
| |
| # We should be able to launch the x86_64 executable. |
| self.runCmd("run", RUN_SUCCEEDED) |
| |
| # Check whether we have a 64-bit process launched. |
| target = self.dbg.GetSelectedTarget() |
| process = target.GetProcess() |
| self.assertTrue(target and process and |
| self.invoke(process, 'GetAddressByteSize') == 8, |
| "64-bit process launched") |
| |
| frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0) |
| registers = print_registers(frame, string_buffer=True) |
| self.expect(registers, exe=False, |
| substrs=['Name: rax']) |
| |
| self.runCmd("continue") |
| |
| # Now specify i386 as the architecture for "testit". |
| self.expect("file -a i386 " + exe, CURRENT_EXECUTABLE_SET, |
| startstr="Current executable set to ", |
| substrs=["testit' (i386)."]) |
| |
| # Break inside the main. |
| lldbutil.run_break_set_by_file_and_line( |
| self, "main.c", self.line, num_expected_locations=1, loc_exact=True) |
| |
| # We should be able to launch the i386 executable as well. |
| self.runCmd("run", RUN_SUCCEEDED) |
| |
| # Check whether we have a 32-bit process launched. |
| target = self.dbg.GetSelectedTarget() |
| process = target.GetProcess() |
| self.assertTrue(target and process, |
| "32-bit process launched") |
| |
| pointerSize = self.invoke(process, 'GetAddressByteSize') |
| self.assertTrue( |
| pointerSize == 4, |
| "AddressByteSize of 32-bit process should be 4, got %d instead." % |
| pointerSize) |
| |
| frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0) |
| registers = print_registers(frame, string_buffer=True) |
| self.expect(registers, exe=False, |
| substrs=['Name: eax']) |
| |
| self.runCmd("continue") |
| |
| @skipUnlessDarwin |
| @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in [ |
| 'i386', 'x86_64'], "requires i386 or x86_64") |
| @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system |
| def test_process_attach_with_wrong_arch(self): |
| """Test that when we attach to a binary from the wrong fork of a universal binary, we fix up the ABI correctly.""" |
| # Now keep the architecture at 32 bit, but switch the binary we launch to |
| # 64 bit, and make sure on attach we switch to the correct |
| # architecture. |
| |
| # Invoke the default build rule. |
| self.build() |
| |
| # Note that "testit" is a universal binary. |
| exe = self.getBuildArtifact("testit") |
| |
| # Create a target by the debugger. |
| target = self.dbg.CreateTargetWithFileAndTargetTriple( |
| exe, "i386-apple-macosx") |
| self.assertTrue(target, VALID_TARGET) |
| pointer_size = target.GetAddressByteSize() |
| self.assertTrue(pointer_size == 4, "Initially we were 32 bit.") |
| |
| bkpt = target.BreakpointCreateBySourceRegex( |
| "sleep", lldb.SBFileSpec("main.c")) |
| self.assertTrue(bkpt.IsValid(), "Valid breakpoint") |
| self.assertTrue( |
| bkpt.GetNumLocations() >= 1, |
| "Our main breakpoint has locations.") |
| |
| popen = self.spawnSubprocess(exe, ["keep_waiting"]) |
| self.addTearDownHook(self.cleanupSubprocesses) |
| |
| error = lldb.SBError() |
| empty_listener = lldb.SBListener() |
| process = target.AttachToProcessWithID( |
| empty_listener, popen.pid, error) |
| self.assertTrue(error.Success(), "Attached to process.") |
| |
| pointer_size = target.GetAddressByteSize() |
| self.assertTrue(pointer_size == 8, "We switched to 64 bit.") |
| |
| # It may seem odd that I am checking the number of frames, but the bug that |
| # motivated this test was that we eventually fixed the architecture, but we |
| # left the ABI set to the original value. In that case, if you asked the |
| # process for its architecture, it would look right, but since the ABI was |
| # wrong, backtracing failed. |
| |
| threads = lldbutil.continue_to_breakpoint(process, bkpt) |
| self.assertTrue(len(threads) == 1) |
| thread = threads[0] |
| self.assertTrue( |
| thread.GetNumFrames() > 1, |
| "We were able to backtrace.") |