def do_include_path(cls, args): sdk = args.sdk or sdk_manager.get_current_sdk() path = sdk_manager.path_for_sdk(sdk) path = os.path.join(path, "pebble", args.platform, "include") if not os.path.exists(path): raise MissingSDK("No platform '{}' available for SDK {}".format(args.platform, sdk)) print(path)
def do_include_path(cls, args): sdk = args.sdk or sdk_manager.get_current_sdk() path = sdk_manager.path_for_sdk(sdk) path = os.path.join(path, "pebble", args.platform, "include") if not os.path.exists(path): raise MissingSDK("No platform '{}' available for SDK {}".format( args.platform, sdk)) print(path)
def __call__(self, args): super(GdbCommand, self).__call__(args) # We poke around in the ManagedEmulatorTransport, so it's important that we actually have one. # Just asserting is okay because this should already be enforced by valid_connections. assert isinstance(self.pebble.transport, ManagedEmulatorTransport) platform = self.pebble.transport.platform sdk_version = self.pebble.transport.version gdb_port = self.pebble.transport.qemu_gdb_port if gdb_port is None: raise ToolError( "The emulator does not have gdb support. Try killing and re-running it." ) sdk_root = sdk_manager.path_for_sdk(sdk_version) fw_elf = os.path.join(sdk_root, 'pebble', platform, 'qemu', '{}_sdk_debug.elf'.format(platform)) if not os.path.exists(fw_elf): raise ToolError( "SDK {} does not support app debugging. You need at least SDK 3.10." .format(sdk_version)) base_address = self._find_app_load_offset(fw_elf) app_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-app.elf') if not os.path.exists(app_elf_path): raise ToolError( "No app debugging information available. " "You must be in a project directory and have built the app.") offsets = self._find_real_app_section_offsets(base_address, app_elf_path) gdb_commands = [ "target remote :{}".format(gdb_port), "set confirm off", 'add-symbol-file "{elf}" {text} -s .data {data} -s .bss {bss}'. format(elf=app_elf_path, **offsets), "set confirm on", "break app_crashed", # app crashes (as of FW 3.10) go through this symbol for our convenience. 'echo \nPress ctrl-D or type \'quit\' to exit.\n', 'echo Try `pebble gdb --help` for a short cheat sheet.\n' ] gdb_args = ['arm-none-eabi-gdb', fw_elf, '-q' ] + ['--ex={}'.format(x) for x in gdb_commands] # Ignore SIGINT, or we'll die every time the user tries to pause execution. signal.signal(signal.SIGINT, signal.SIG_IGN) subprocess.call(gdb_args)
def __call__(self, args): super(GdbCommand, self).__call__(args) # We poke around in the ManagedEmulatorTransport, so it's important that we actually have one. # Just asserting is okay because this should already be enforced by valid_connections. assert isinstance(self.pebble.transport, ManagedEmulatorTransport) add_tools_to_path() platform = self.pebble.transport.platform sdk_version = self.pebble.transport.version gdb_port = self.pebble.transport.qemu_gdb_port if gdb_port is None: raise ToolError("The emulator does not have gdb support. Try killing and re-running it.") sdk_root = sdk_manager.path_for_sdk(sdk_version) self._fw_elf = os.path.join(sdk_root, 'pebble', platform, 'qemu', '{}_sdk_debug.elf'.format(platform)) if not os.path.exists(self._fw_elf): raise ToolError("SDK {} does not support app debugging. You need at least SDK 3.10.".format(sdk_version)) app_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-app.elf') if not os.path.exists(app_elf_path): raise ToolError("No app debugging information available. " "You must be in a project directory and have built the app.") gdb_commands = [ "set charset US-ASCII", # Avoid a bug in the ancient version of libiconv apple ships. "target remote :{}".format(gdb_port), "set confirm off", self._get_symbol_command(app_elf_path, 'app') ] # Optionally add the worker symbols, if any exist. worker_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-worker.elf') if os.path.exists(worker_elf_path): gdb_commands.append(self._get_symbol_command(worker_elf_path, 'worker')) gdb_commands.extend([ "set confirm on", "break app_crashed", # app crashes (as of FW 3.10) go through this symbol for our convenience. 'echo \nPress ctrl-D or type \'quit\' to exit.\n', 'echo Try `pebble gdb --help` for a short cheat sheet.\n', ]) gdb_args = ['arm-none-eabi-gdb', self._fw_elf, '-q'] + ['--ex={}'.format(x) for x in gdb_commands] # Ignore SIGINT, or we'll die every time the user tries to pause execution. signal.signal(signal.SIGINT, signal.SIG_IGN) subprocess.call(gdb_args)
def __call__(self, args): super(GdbCommand, self).__call__(args) # We poke around in the ManagedEmulatorTransport, so it's important that we actually have one. # Just asserting is okay because this should already be enforced by valid_connections. assert isinstance(self.pebble.transport, ManagedEmulatorTransport) platform = self.pebble.transport.platform sdk_version = self.pebble.transport.version gdb_port = self.pebble.transport.qemu_gdb_port if gdb_port is None: raise ToolError("The emulator does not have gdb support. Try killing and re-running it.") sdk_root = sdk_manager.path_for_sdk(sdk_version) fw_elf = os.path.join(sdk_root, 'pebble', platform, 'qemu', '{}_sdk_debug.elf'.format(platform)) if not os.path.exists(fw_elf): raise ToolError("SDK {} does not support app debugging. You need at least SDK 3.10.".format(sdk_version)) base_address = self._find_app_load_offset(fw_elf) app_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-app.elf') if not os.path.exists(app_elf_path): raise ToolError("No app debugging information available. " "You must be in a project directory and have built the app.") offsets = self._find_real_app_section_offsets(base_address, app_elf_path) gdb_commands = [ "target remote :{}".format(gdb_port), "set confirm off", 'add-symbol-file "{elf}" {text} -s .data {data} -s .bss {bss}'.format(elf=app_elf_path, **offsets), "set confirm on", "break app_crashed", # app crashes (as of FW 3.10) go through this symbol for our convenience. 'echo \nPress ctrl-D or type \'quit\' to exit.\n', 'echo Try `pebble gdb --help` for a short cheat sheet.\n' ] gdb_args = ['arm-none-eabi-gdb', fw_elf, '-q'] + ['--ex={}'.format(x) for x in gdb_commands] # Ignore SIGINT, or we'll die every time the user tries to pause execution. signal.signal(signal.SIGINT, signal.SIG_IGN) subprocess.call(gdb_args)
def __call__(self, args): super(GdbCommand, self).__call__(args) # We poke around in the ManagedEmulatorTransport, so it's important that we actually have one. # Just asserting is okay because this should already be enforced by valid_connections. assert isinstance(self.pebble.transport, ManagedEmulatorTransport) self._ensure_correct_app() add_tools_to_path() platform = self.pebble.transport.platform sdk_version = self.pebble.transport.version gdb_port = self.pebble.transport.qemu_gdb_port if gdb_port is None: raise ToolError( "The emulator does not have gdb support. Try killing and re-running it." ) sdk_root = sdk_manager.path_for_sdk(sdk_version) self._fw_elf = os.path.join(sdk_root, 'pebble', platform, 'qemu', '{}_sdk_debug.elf'.format(platform)) if not os.path.exists(self._fw_elf): raise ToolError( "SDK {} does not support app debugging. You need at least SDK 3.10." .format(sdk_version)) app_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-app.elf') if not os.path.exists(app_elf_path): raise ToolError( "No app debugging information available. " "You must be in a project directory and have built the app.") if self.pebble.firmware_version.major >= 4: # Type information for symbols is not currently written into the # debugging symbols generated by fw_elf_obfuscate.py. We must # explicitly tell GDB what type the symbols are so that their values # can be read. app_load_address = '*(void**)&g_app_load_address' worker_load_address = '*(void**)&g_worker_load_address' else: # The version of fw_elf_obfuscate.py which generated the debugging # symbol files for 3.x SDKs wrote out the symbol information for # variables in a way that caused them to be unavailable to GDB. # We have to use readelf to work around that and get the symbol # addresses. app_load_address = '(void*){:#x}'.format( self._find_legacy_app_load_offset(self._fw_elf, 'app')) worker_load_address = '(void*){:#x}'.format( self._find_legacy_app_load_offset(self._fw_elf, 'worker')) gdb_commands = [ "set charset US-ASCII", # Avoid a bug in the ancient version of libiconv apple ships. "target remote :{}".format(gdb_port), "set confirm off", self._get_symbol_command(app_elf_path, app_load_address) ] # Optionally add the worker symbols, if any exist. worker_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-worker.elf') if os.path.exists(worker_elf_path): gdb_commands.append( self._get_symbol_command(worker_elf_path, worker_load_address)) gdb_commands.extend([ "set confirm on", "break app_crashed", # app crashes (as of FW 3.10) go through this symbol for our convenience. 'echo \nPress ctrl-D or type \'quit\' to exit.\n', 'echo Try `pebble gdb --help` for a short cheat sheet.\n', ]) gdb_args = ['arm-none-eabi-gdb', self._fw_elf, '-q' ] + ['--ex={}'.format(x) for x in gdb_commands] # Ignore SIGINT, or we'll die every time the user tries to pause execution. signal.signal(signal.SIGINT, signal.SIG_IGN) subprocess.call(gdb_args)
def get_sdk_path(self): path = sdk_manager.path_for_sdk(self.sdk) if self.sdk is not None else sdk_path() logger.debug("SDK path: %s", path) if not os.path.exists(os.path.join(path, "pebble", "waf")): raise MissingSDK("SDK unavailable; can't run this command.") return path
def __call__(self, args): super(GdbCommand, self).__call__(args) # We poke around in the ManagedEmulatorTransport, so it's important that we actually have one. # Just asserting is okay because this should already be enforced by valid_connections. assert isinstance(self.pebble.transport, ManagedEmulatorTransport) self._ensure_correct_app() add_tools_to_path() platform = self.pebble.transport.platform sdk_version = self.pebble.transport.version gdb_port = self.pebble.transport.qemu_gdb_port if gdb_port is None: raise ToolError("The emulator does not have gdb support. Try killing and re-running it.") sdk_root = sdk_manager.path_for_sdk(sdk_version) self._fw_elf = os.path.join(sdk_root, 'pebble', platform, 'qemu', '{}_sdk_debug.elf'.format(platform)) if not os.path.exists(self._fw_elf): raise ToolError("SDK {} does not support app debugging. You need at least SDK 3.10.".format(sdk_version)) app_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-app.elf') if not os.path.exists(app_elf_path): raise ToolError("No app debugging information available. " "You must be in a project directory and have built the app.") if self.pebble.firmware_version.major >= 4: # Type information for symbols is not currently written into the # debugging symbols generated by fw_elf_obfuscate.py. We must # explicitly tell GDB what type the symbols are so that their values # can be read. app_load_address = '*(void**)&g_app_load_address' worker_load_address = '*(void**)&g_worker_load_address' else: # The version of fw_elf_obfuscate.py which generated the debugging # symbol files for 3.x SDKs wrote out the symbol information for # variables in a way that caused them to be unavailable to GDB. # We have to use readelf to work around that and get the symbol # addresses. app_load_address = '(void*){:#x}'.format( self._find_legacy_app_load_offset(self._fw_elf, 'app')) worker_load_address = '(void*){:#x}'.format( self._find_legacy_app_load_offset(self._fw_elf, 'worker')) gdb_commands = [ "set charset US-ASCII", # Avoid a bug in the ancient version of libiconv apple ships. "target remote :{}".format(gdb_port), "set confirm off", self._get_symbol_command(app_elf_path, app_load_address) ] # Optionally add the worker symbols, if any exist. worker_elf_path = os.path.join(os.getcwd(), 'build', platform, 'pebble-worker.elf') if os.path.exists(worker_elf_path): gdb_commands.append(self._get_symbol_command(worker_elf_path, worker_load_address)) gdb_commands.extend([ "set confirm on", "break app_crashed", # app crashes (as of FW 3.10) go through this symbol for our convenience. 'echo \nPress ctrl-D or type \'quit\' to exit.\n', 'echo Try `pebble gdb --help` for a short cheat sheet.\n', ]) gdb_args = ['arm-none-eabi-gdb', self._fw_elf, '-q'] + ['--ex={}'.format(x) for x in gdb_commands] # Ignore SIGINT, or we'll die every time the user tries to pause execution. signal.signal(signal.SIGINT, signal.SIG_IGN) subprocess.call(gdb_args)
def get_sdk_path(self): path = sdk_manager.path_for_sdk(self.sdk) if self.sdk is not None else sdk_path() logger.debug("SDK path: %s", path) if not os.path.exists(os.path.join(path, 'pebble', 'waf')): raise MissingSDK("SDK unavailable; can't run this command.") return path