X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=3e9cce5b06e104f2d34dad5b7204ca32c651902a;hp=8f785dd302b0ce7f995131ce417ddab9b4ef4381;hb=e18e23e1b6c7cdfd4294e1f05aeee2b841d3cca2;hpb=86d3e744641ef670f4376e47589afac37d9a87ab diff --git a/src/target/target.c b/src/target/target.c index 8f785dd302..3e9cce5b06 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -51,7 +51,6 @@ int cli_target_callback_event_handler(struct target_s *target, enum target_event int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -132,8 +131,6 @@ char *target_endianess_strings[] = "little endian", }; -enum daemon_startup_mode startup_mode = DAEMON_ATTACH; - static int target_continous_poll = 1; /* read a u32 from a buffer in target memory endianness */ @@ -251,11 +248,45 @@ int target_run_and_halt_handler(void *priv) { target_t *target = priv; - target->type->halt(target); + target_halt(target); return ERROR_OK; } +int target_poll(struct target_s *target) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + /* Fail silently lest we pollute the log */ + return ERROR_FAIL; + } + return target->type->poll(target); +} + +int target_halt(struct target_s *target) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->halt(target); +} + +int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->resume(target, current, address, handle_breakpoints, debug_execution); +} + + int target_process_reset(struct command_context_s *cmd_ctx) { int retval = ERROR_OK; @@ -264,6 +295,12 @@ int target_process_reset(struct command_context_s *cmd_ctx) jtag->speed(jtag_speed); + if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK) + return retval; + + if ((retval = target_examine(cmd_ctx)) != ERROR_OK) + return retval; + /* prepare reset_halt where necessary */ target = targets; while (target) @@ -284,25 +321,24 @@ int target_process_reset(struct command_context_s *cmd_ctx) break; } } - switch (target->reset_mode) - { - case RESET_HALT: - case RESET_INIT: - target->type->prepare_reset_halt(target); - break; - default: - break; - } target = target->next; } target = targets; while (target) { + /* we have no idea what state the target is in, so we + * have to drop working areas + */ + target_free_all_working_areas_restore(target, 0); target->type->assert_reset(target); target = target->next; } - jtag_execute_queue(); + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed asserting reset."); + retval = ERROR_OK; + } /* request target halt if necessary, and schedule further action */ target = targets; @@ -323,10 +359,10 @@ int target_process_reset(struct command_context_s *cmd_ctx) target_register_event_callback(target_init_handler, cmd_ctx); break; case RESET_HALT: - target->type->halt(target); + target_halt(target); break; case RESET_INIT: - target->type->halt(target); + target_halt(target); target_register_event_callback(target_init_handler, cmd_ctx); break; default: @@ -335,13 +371,26 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = target->next; } + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config."); + retval = ERROR_OK; + } + target = targets; while (target) { target->type->deassert_reset(target); target = target->next; } - jtag_execute_queue(); + + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed while deasserting reset."); + retval = ERROR_OK; + } + + LOG_DEBUG("Waiting for halted stated as approperiate"); /* Wait for reset to complete, maximum 5 seconds. */ gettimeofday(&timeout, NULL); @@ -355,14 +404,18 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = targets; while (target) { - target->type->poll(target); - if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT)) + LOG_DEBUG("Polling target"); + target_poll(target); + if ((target->reset_mode == RESET_RUN_AND_INIT) || + (target->reset_mode == RESET_RUN_AND_HALT) || + (target->reset_mode == RESET_HALT) || + (target->reset_mode == RESET_INIT)) { if (target->state != TARGET_HALTED) { if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) { - LOG_USER("Timed out waiting for reset"); + LOG_USER("Timed out waiting for halt after reset"); goto done; } /* this will send alive messages on e.g. GDB remote protocol. */ @@ -384,6 +437,16 @@ int target_process_reset(struct command_context_s *cmd_ctx) /* We want any events to be processed before the prompt */ target_call_timer_callbacks_now(); + /* if we timed out we need to unregister these handlers */ + target = targets; + while (target) + { + target_unregister_timer_callback(target_run_and_halt_handler, target); + target = target->next; + } + target_unregister_event_callback(target_init_handler, cmd_ctx); + + jtag->speed(jtag_speed_post_reset); return retval; @@ -401,12 +464,83 @@ static int default_mmu(struct target_s *target, int *enabled) return ERROR_OK; } +static int default_examine(struct command_context_s *cmd_ctx, struct target_s *target) +{ + target->type->examined = 1; + return ERROR_OK; +} + + +/* Targets that correctly implement init+examine, i.e. + * no communication with target during init: + * + * XScale + */ +int target_examine(struct command_context_s *cmd_ctx) +{ + int retval = ERROR_OK; + target_t *target = targets; + while (target) + { + if ((retval = target->type->examine(cmd_ctx, target))!=ERROR_OK) + return retval; + target = target->next; + } + return retval; +} + +static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->write_memory_imp(target, address, size, count, buffer); +} + +static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->read_memory_imp(target, address, size, count, buffer); +} + +static int target_soft_reset_halt_imp(struct target_s *target) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->soft_reset_halt_imp(target); +} + +static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info); +} + int target_init(struct command_context_s *cmd_ctx) { target_t *target = targets; while (target) { + target->type->examined = 0; + if (target->type->examine == NULL) + { + target->type->examine = default_examine; + } + if (target->type->init_target(cmd_ctx, target) != ERROR_OK) { LOG_ERROR("target '%s' init failed", target->type->name); @@ -418,6 +552,20 @@ int target_init(struct command_context_s *cmd_ctx) { target->type->virt2phys = default_virt2phys; } + target->type->virt2phys = default_virt2phys; + /* a non-invasive way(in terms of patches) to add some code that + * runs before the type->write/read_memory implementation + */ + target->type->write_memory_imp = target->type->write_memory; + target->type->write_memory = target_write_memory_imp; + target->type->read_memory_imp = target->type->read_memory; + target->type->read_memory = target_read_memory_imp; + target->type->soft_reset_halt_imp = target->type->soft_reset_halt; + target->type->soft_reset_halt = target_soft_reset_halt_imp; + target->type->run_algorithm_imp = target->type->run_algorithm; + target->type->run_algorithm = target_run_algorithm_imp; + + if (target->type->mmu == NULL) { target->type->mmu = default_mmu; @@ -434,14 +582,6 @@ int target_init(struct command_context_s *cmd_ctx) return ERROR_OK; } -int target_init_reset(struct command_context_s *cmd_ctx) -{ - if (startup_mode == DAEMON_RESET) - target_process_reset(cmd_ctx); - - return ERROR_OK; -} - int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv) { target_event_callback_t **callbacks_p = &target_event_callbacks; @@ -722,12 +862,12 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t return ERROR_OK; } -int target_free_working_area(struct target_s *target, working_area_t *area) +int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore) { if (area->free) return ERROR_OK; - if (target->backup_working_area) + if (restore&&target->backup_working_area) target->type->write_memory(target, area->address, 4, area->size / 4, area->backup); area->free = 1; @@ -739,14 +879,19 @@ int target_free_working_area(struct target_s *target, working_area_t *area) return ERROR_OK; } -int target_free_all_working_areas(struct target_s *target) +int target_free_working_area(struct target_s *target, working_area_t *area) +{ + return target_free_working_area_restore(target, area, 1); +} + +int target_free_all_working_areas_restore(struct target_s *target, int restore) { working_area_t *c = target->working_areas; while (c) { working_area_t *next = c->next; - target_free_working_area(target, c); + target_free_working_area_restore(target, c, restore); if (c->backup) free(c->backup); @@ -761,11 +906,15 @@ int target_free_all_working_areas(struct target_s *target) return ERROR_OK; } +int target_free_all_working_areas(struct target_s *target) +{ + return target_free_all_working_areas_restore(target, 1); +} + int target_register_commands(struct command_context_s *cmd_ctx) { - register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL); + register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target [reset_init default - DEPRECATED] [cpu type specifc args]"); register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL); - register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, " "); register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area
<'backup'|'nobackup'> [virtual address]"); @@ -800,6 +949,11 @@ int target_arch_state(struct target_s *target) int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer) { int retval; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address); @@ -864,7 +1018,12 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer) { int retval; - + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address); if (((address % 2) == 0) && (size == 2)) @@ -917,6 +1076,11 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* int retval; int i; u32 checksum = 0; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } if ((retval = target->type->checksum_memory(target, address, size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) @@ -954,6 +1118,11 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* int target_read_u32(struct target_s *target, u32 address, u32 *value) { u8 value_buf[4]; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } int retval = target->type->read_memory(target, address, 4, 1, value_buf); @@ -974,7 +1143,12 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value) int target_read_u16(struct target_s *target, u32 address, u16 *value) { u8 value_buf[2]; - + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + int retval = target->type->read_memory(target, address, 2, 1, value_buf); if (retval == ERROR_OK) @@ -994,6 +1168,11 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value) int target_read_u8(struct target_s *target, u32 address, u8 *value) { int retval = target->type->read_memory(target, address, 1, 1, value); + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } if (retval == ERROR_OK) { @@ -1012,6 +1191,11 @@ int target_write_u32(struct target_s *target, u32 address, u32 value) { int retval; u8 value_buf[4]; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); @@ -1028,7 +1212,12 @@ int target_write_u16(struct target_s *target, u32 address, u16 value) { int retval; u8 value_buf[2]; - + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); target_buffer_set_u16(target, value_buf, value); @@ -1043,7 +1232,12 @@ int target_write_u16(struct target_s *target, u32 address, u16 value) int target_write_u8(struct target_s *target, u32 address, u8 value) { int retval; - + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value); if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK) @@ -1069,9 +1263,9 @@ int target_register_user_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [count]"); register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [count]"); - register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word "); - register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word "); - register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte "); + register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [count]"); + register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [count]"); + register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [count]"); register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint
[hw]"); register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint "); @@ -1170,6 +1364,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a } /* what to do on a target reset */ + (*last_target_p)->reset_mode = RESET_INIT; /* default */ if (strcmp(args[2], "reset_halt") == 0) (*last_target_p)->reset_mode = RESET_HALT; else if (strcmp(args[2], "reset_run") == 0) @@ -1182,8 +1377,9 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->reset_mode = RESET_RUN_AND_INIT; else { - LOG_ERROR("unknown target startup mode %s", args[2]); - return ERROR_COMMAND_SYNTAX_ERROR; + /* Kludge! we want to make this reset arg optional while remaining compatible! */ + args--; + argc++; } (*last_target_p)->run_and_halt_time = 1000; /* default 1s */ @@ -1351,19 +1547,14 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch /* process target state changes */ int handle_target(void *priv) { - int retval; target_t *target = targets; while (target) { - /* only poll if target isn't already halted */ - if (target->state != TARGET_HALTED) + if (target_continous_poll) { - if (target_continous_poll) - if ((retval = target->type->poll(target)) != ERROR_OK) - { - LOG_ERROR("couldn't poll target(%d). It's due for a reset.", retval); - } + /* polling may fail silently until the target has been examined */ + target_poll(target); } target = target->next; @@ -1502,7 +1693,7 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg if (argc == 0) { - target->type->poll(target); + target_poll(target); target_arch_state(target); } else @@ -1547,7 +1738,7 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char static void target_process_events(struct command_context_s *cmd_ctx) { target_t *target = get_current_target(cmd_ctx); - target->type->poll(target); + target_poll(target); target_call_timer_callbacks_now(); } @@ -1562,7 +1753,7 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_ target_t *target = get_current_target(cmd_ctx); for (;;) { - if ((retval=target->type->poll(target))!=ERROR_OK) + if ((retval=target_poll(target))!=ERROR_OK) return retval; target_call_timer_callbacks_now(); if (target->state == state) @@ -1593,7 +1784,7 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg LOG_DEBUG("-"); - if ((retval = target->type->halt(target)) != ERROR_OK) + if ((retval = target_halt(target)) != ERROR_OK) { return retval; } @@ -1601,27 +1792,6 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg return handle_wait_halt_command(cmd_ctx, cmd, args, argc); } -/* what to do on daemon startup */ -int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - if (argc == 1) - { - if (strcmp(args[0], "attach") == 0) - { - startup_mode = DAEMON_ATTACH; - return ERROR_OK; - } - else if (strcmp(args[0], "reset") == 0) - { - startup_mode = DAEMON_RESET; - return ERROR_OK; - } - } - - LOG_WARNING("invalid daemon_startup configuration directive: %s", args[0]); - return ERROR_OK; - -} int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { @@ -1691,9 +1861,9 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a target_t *target = get_current_target(cmd_ctx); if (argc == 0) - retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ + retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ else if (argc == 1) - retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */ + retval = target_resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */ else { return ERROR_COMMAND_SYNTAX_ERROR; @@ -1804,36 +1974,59 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, { u32 address = 0; u32 value = 0; - int retval; + int count = 1; + int i; + int wordsize; target_t *target = get_current_target(cmd_ctx); u8 value_buf[4]; - if (argc < 2) - return ERROR_OK; + if ((argc < 2) || (argc > 3)) + return ERROR_COMMAND_SYNTAX_ERROR; address = strtoul(args[0], NULL, 0); value = strtoul(args[1], NULL, 0); + if (argc == 3) + count = strtoul(args[2], NULL, 0); + switch (cmd[2]) { case 'w': + wordsize = 4; target_buffer_set_u32(target, value_buf, value); - retval = target->type->write_memory(target, address, 4, 1, value_buf); break; case 'h': + wordsize = 2; target_buffer_set_u16(target, value_buf, value); - retval = target->type->write_memory(target, address, 2, 1, value_buf); break; case 'b': + wordsize = 1; value_buf[0] = value; - retval = target->type->write_memory(target, address, 1, 1, value_buf); break; default: - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } - if (retval!=ERROR_OK) + for (i=0; itype->write_memory(target, address + i*wordsize, 4, 1, value_buf); + break; + case 2: + retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf); + break; + case 1: + retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf); + break; + default: + return ERROR_OK; + } + if (retval!=ERROR_OK) + { + return retval; + } } return ERROR_OK; @@ -2009,14 +2202,13 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch if (argc < 1) { - command_print(cmd_ctx, "usage: verify_image [offset] [type]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } if (!target) { LOG_ERROR("no target selected"); - return ERROR_OK; + return ERROR_FAIL; } duration_start_measure(&duration); @@ -2034,9 +2226,9 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch image.start_address_set = 0; - if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK) + if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK) { - return ERROR_OK; + return retval; } image_size = 0x0; @@ -2421,18 +2613,18 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char ** for (;;) { - target->type->poll(target); + target_poll(target); if (target->state == TARGET_HALTED) { u32 t=*((u32 *)reg->value); samples[numSamples++]=t; - retval = target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ - target->type->poll(target); + retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + target_poll(target); usleep(10*1000); // sleep 10ms, i.e. <100 samples/second. } else if (target->state == TARGET_RUNNING) { // We want to quickly sample the PC. - target->type->halt(target); + target_halt(target); } else { command_print(cmd_ctx, "Target not halted or running"); @@ -2448,12 +2640,12 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char ** if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) { command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples); - target->type->poll(target); + target_poll(target); if (target->state == TARGET_HALTED) { - target->type->resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ } - target->type->poll(target); + target_poll(target); writeGmon(samples, numSamples, args[1]); command_print(cmd_ctx, "Wrote %s", args[1]); break;