"""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.")