def run_with(self, arch, os, vers, env, expected_load_command):
env_list = [env] if env else []
triple = '-'.join([arch, 'apple', os + vers] + env_list)
sdk = lldbutil.get_xcode_sdk(os, env)
version_min = ''
if not vers:
vers = lldbutil.get_xcode_sdk_version(sdk)
if env == 'simulator':
version_min = '-m{}-simulator-version-min={}'.format(os, vers)
elif os == 'macosx':
version_min = '-m{}-version-min={}'.format(os, vers)
sdk_root = lldbutil.get_xcode_sdk_root(sdk)
self.build(
dictionary={
'ARCH': arch,
'ARCH_CFLAGS': '-target {} {}'.format(triple, version_min),
'SDKROOT': sdk_root
})
self.check_load_commands(expected_load_command)
log = self.getBuildArtifact('packets.log')
self.expect("log enable gdb-remote packets -f " + log)
lldbutil.run_to_source_breakpoint(self, "break here",
lldb.SBFileSpec("hello.c"))
triple_re = '-'.join([arch, 'apple', os + vers + '.*'] + env_list)
self.expect('image list -b -t', patterns=['a\.out ' + triple_re])
self.check_debugserver(log, os + env, vers)
def get_triple():
# Construct the vendor component.
vendor = "apple"
# Construct the os component.
os, env = get_os_and_env()
if os is None or env is None:
return None, None, None, None
# Get the SDK from the os and env.
sdk = lldbutil.get_xcode_sdk(os, env)
if not sdk:
return None, None, None, None
# Get the version from the SDK.
version = lldbutil.get_xcode_sdk_version(sdk)
if not version:
return None, None, None, None
return vendor, os, version, env
def getArchCFlags(self, architecture):
"""Returns the ARCH_CFLAGS for the make system."""
# Construct the arch component.
arch = architecture if architecture else configuration.arch
if not arch:
arch = subprocess.check_output(['machine'
]).rstrip().decode('utf-8')
if not arch:
return ""
# Construct the vendor component.
vendor = "apple"
# Construct the os component.
os, env = self.getOsAndEnv()
if os is None or env is None:
return ""
# Get the SDK from the os and env.
sdk = lldbutil.get_xcode_sdk(os, env)
if not sdk:
return ""
version = lldbutil.get_xcode_sdk_version(sdk)
if not version:
return ""
# Construct the triple from its components.
triple = "{}-{}-{}-{}".format(vendor, os, version, env)
# Construct min version argument
version_min = ""
if env == "simulator":
version_min = "-m{}-simulator-version-min={}".format(os, version)
elif os == "macosx":
version_min = "-m{}-version-min={}".format(os, version)
return "ARCH_CFLAGS=\"-target {} {}\"".format(triple, version_min)
def check_simulator_ostype(self,
sdk,
platform_name,
arch=platform.machine()):
cmd = ['xcrun', 'simctl', 'list', '-j', 'devices']
self.trace(' '.join(cmd))
sim_devices_str = subprocess.check_output(cmd).decode("utf-8")
sim_devices = json.loads(sim_devices_str)['devices']
# Find an available simulator for the requested platform
deviceUDID = None
deviceRuntime = None
for simulator in sim_devices:
if isinstance(simulator, dict):
runtime = simulator['name']
devices = simulator['devices']
else:
runtime = simulator
devices = sim_devices[simulator]
if not platform_name in runtime.lower():
continue
for device in devices:
if 'availability' in device and device[
'availability'] != '(available)':
continue
if 'isAvailable' in device and device['isAvailable'] != True:
continue
if deviceRuntime and runtime < deviceRuntime:
continue
deviceUDID = device['udid']
deviceRuntime = runtime
# Stop searching in this runtime
break
# Launch the process using simctl
self.assertIsNotNone(deviceUDID)
exe_name = 'test_simulator_platform_{}'.format(platform_name)
sdkroot = lldbutil.get_xcode_sdk_root(sdk)
vers = lldbutil.get_xcode_sdk_version(sdk)
clang = lldbutil.get_xcode_clang(sdk)
# Older versions of watchOS (<7.0) only support i386
if platform_name == 'watchos':
from distutils.version import LooseVersion
if LooseVersion(vers) < LooseVersion("7.0"):
arch = 'i386'
triple = '-'.join([arch, 'apple', platform_name + vers, 'simulator'])
version_min = '-m{}-simulator-version-min={}'.format(
platform_name, vers)
self.build(
dictionary={
'EXE': exe_name,
'CC': clang,
'SDKROOT': sdkroot.strip(),
'ARCH': arch,
'ARCH_CFLAGS': '-target {} {}'.format(triple, version_min),
})
exe_path = self.getBuildArtifact(exe_name)
cmd = [
'xcrun', 'simctl', 'spawn', '-s', deviceUDID, exe_path,
'print-pid', 'sleep:10'
]
self.trace(' '.join(cmd))
sim_launcher = subprocess.Popen(cmd, stderr=subprocess.PIPE)
# Get the PID from the process output
pid = None
# Read the first READ_LINES to try to find the PID.
for _ in range(0, self.READ_LINES):
stderr = sim_launcher.stderr.readline().decode("utf-8")
if not stderr:
continue
match = re.match(r"PID: (.*)", stderr)
if match:
pid = int(match.group(1))
break
# Make sure we found the PID.
self.assertIsNotNone(pid)
# Launch debug monitor attaching to the simulated process
server = self.connect_to_debug_monitor(attach_pid=pid)
# Setup packet sequences
self.do_handshake()
self.add_process_info_collection_packets()
self.test_sequence.add_log_lines([
"read packet: " +
"$jGetLoadedDynamicLibrariesInfos:{\"fetch_all_solibs\" : true}]#ce",
{
"direction": "send",
"regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
"capture": {
1: "dylib_info_raw"
}
}
], True)
# Run the stream
context = self.expect_gdbremote_sequence()
self.assertIsNotNone(context)
# Gather process info response
process_info = self.parse_process_info_response(context)
self.assertIsNotNone(process_info)
# Check that ostype is correct
self.assertEquals(process_info['ostype'], platform_name + 'simulator')
# Now for dylibs
dylib_info_raw = context.get("dylib_info_raw")
dylib_info = json.loads(self.decode_gdbremote_binary(dylib_info_raw))
images = dylib_info['images']
image_info = None
for image in images:
if image['pathname'] != exe_path:
continue
image_info = image
break
self.assertIsNotNone(image_info)
self.assertEquals(image['min_version_os_name'],
platform_name + 'simulator')