/* Generic prepare_to_proceed(). This one should be suitable for most targets that support threads. */ int generic_prepare_to_proceed (int select_it) { ptid_t wait_ptid; struct target_waitstatus wait_status; /* Get the last target status returned by target_wait(). */ get_last_target_status (&wait_ptid, &wait_status); /* Make sure we were stopped either at a breakpoint, or because of a Ctrl-C. */ if (wait_status.kind != TARGET_WAITKIND_STOPPED || (wait_status.value.sig != TARGET_SIGNAL_TRAP && wait_status.value.sig != TARGET_SIGNAL_INT)) { return 0; } if (!ptid_equal (wait_ptid, minus_one_ptid) && !ptid_equal (inferior_ptid, wait_ptid)) { /* Switched over from WAIT_PID. */ CORE_ADDR wait_pc = read_pc_pid (wait_ptid); if (wait_pc != read_pc ()) { if (select_it) { /* Switch back to WAIT_PID thread. */ inferior_ptid = wait_ptid; /* FIXME: This stuff came from switch_to_thread() in thread.c (which should probably be a public function). */ flush_cached_frames (); registers_changed (); stop_pc = wait_pc; select_frame (get_current_frame ()); } /* We return 1 to indicate that there is a breakpoint here, so we need to step over it before continuing to avoid hitting it straight away. */ if (breakpoint_here_p (wait_pc)) { return 1; } } } return 0; }
static struct target_waitstatus record_btrace_step_thread (struct thread_info *tp) { struct btrace_insn_iterator *replay, end; struct btrace_thread_info *btinfo; struct address_space *aspace; struct inferior *inf; enum btrace_thread_flag flags; unsigned int steps; btinfo = &tp->btrace; replay = btinfo->replay; flags = btinfo->flags & BTHR_MOVE; btinfo->flags &= ~BTHR_MOVE; DEBUG ("stepping %d (%s): %u", tp->num, target_pid_to_str (tp->ptid), flags); switch (flags) { default: internal_error (__FILE__, __LINE__, _("invalid stepping type.")); case BTHR_STEP: /* We're done if we're not replaying. */ if (replay == NULL) return btrace_step_no_history (); /* We are always able to step at least once. */ steps = btrace_insn_next (replay, 1); gdb_assert (steps == 1); /* Determine the end of the instruction trace. */ btrace_insn_end (&end, btinfo); /* We stop replaying if we reached the end of the trace. */ if (btrace_insn_cmp (replay, &end) == 0) record_btrace_stop_replaying (tp); return btrace_step_stopped (); case BTHR_RSTEP: /* Start replaying if we're not already doing so. */ if (replay == NULL) replay = record_btrace_start_replaying (tp); /* If we can't step any further, we reached the end of the history. */ steps = btrace_insn_prev (replay, 1); if (steps == 0) return btrace_step_no_history (); return btrace_step_stopped (); case BTHR_CONT: /* We're done if we're not replaying. */ if (replay == NULL) return btrace_step_no_history (); inf = find_inferior_pid (ptid_get_pid (tp->ptid)); aspace = inf->aspace; /* Determine the end of the instruction trace. */ btrace_insn_end (&end, btinfo); for (;;) { const struct btrace_insn *insn; /* We are always able to step at least once. */ steps = btrace_insn_next (replay, 1); gdb_assert (steps == 1); /* We stop replaying if we reached the end of the trace. */ if (btrace_insn_cmp (replay, &end) == 0) { record_btrace_stop_replaying (tp); return btrace_step_no_history (); } insn = btrace_insn_get (replay); gdb_assert (insn); DEBUG ("stepping %d (%s) ... %s", tp->num, target_pid_to_str (tp->ptid), core_addr_to_string_nz (insn->pc)); if (breakpoint_here_p (aspace, insn->pc)) return btrace_step_stopped (); } case BTHR_RCONT: /* Start replaying if we're not already doing so. */ if (replay == NULL) replay = record_btrace_start_replaying (tp); inf = find_inferior_pid (ptid_get_pid (tp->ptid)); aspace = inf->aspace; for (;;) { const struct btrace_insn *insn; /* If we can't step any further, we're done. */ steps = btrace_insn_prev (replay, 1); if (steps == 0) return btrace_step_no_history (); insn = btrace_insn_get (replay); gdb_assert (insn); DEBUG ("reverse-stepping %d (%s) ... %s", tp->num, target_pid_to_str (tp->ptid), core_addr_to_string_nz (insn->pc)); if (breakpoint_here_p (aspace, insn->pc)) return btrace_step_stopped (); } } }
/* Function to set the disassembly window's content. */ enum tui_status tui_set_disassem_content (CORE_ADDR pc) { enum tui_status ret = TUI_FAILURE; int i; int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset; int line_width, max_lines; CORE_ADDR cur_pc; struct tui_gen_win_info * locator = tui_locator_win_info_ptr (); int tab_len = tui_default_tab_len (); struct tui_asm_line* asm_lines; int insn_pos; int addr_size, max_size; char* line; if (pc == 0) return TUI_FAILURE; ret = tui_alloc_source_buffer (TUI_DISASM_WIN); if (ret != TUI_SUCCESS) return ret; TUI_DISASM_WIN->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS; TUI_DISASM_WIN->detail.source_info.start_line_or_addr.u.addr = pc; cur_pc = (CORE_ADDR) (((struct tui_win_element *) locator->content[0])->which_element.locator.addr); max_lines = TUI_DISASM_WIN->generic.height - 2; /* account for hilite */ /* Get temporary table that will hold all strings (addr & insn). */ asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line) * max_lines); memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines); line_width = TUI_DISASM_WIN->generic.width - 1; tui_disassemble (asm_lines, pc, max_lines); /* See what is the maximum length of an address and of a line. */ addr_size = 0; max_size = 0; for (i = 0; i < max_lines; i++) { size_t len = strlen (asm_lines[i].addr_string); if (len > addr_size) addr_size = len; len = strlen (asm_lines[i].insn) + tab_len; if (len > max_size) max_size = len; } max_size += addr_size + tab_len; /* Allocate memory to create each line. */ line = (char*) alloca (max_size); insn_pos = (1 + (addr_size / tab_len)) * tab_len; /* Now construct each line */ for (i = 0; i < max_lines; i++) { struct tui_win_element * element; struct tui_source_element* src; int cur_len; element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i]; src = &element->which_element.source; strcpy (line, asm_lines[i].addr_string); cur_len = strlen (line); /* Add spaces to make the instructions start on the same column */ while (cur_len < insn_pos) { strcat (line, " "); cur_len++; } strcat (line, asm_lines[i].insn); /* Now copy the line taking the offset into account */ if (strlen (line) > offset) strcpy (src->line, &line[offset]); else src->line[0] = '\0'; src->line_or_addr.loa = LOA_ADDRESS; src->line_or_addr.u.addr = asm_lines[i].addr; src->is_exec_point = asm_lines[i].addr == cur_pc; /* See whether there is a breakpoint installed. */ src->has_break = (!src->is_exec_point && breakpoint_here_p (pc) != no_breakpoint_here); xfree (asm_lines[i].addr_string); xfree (asm_lines[i].insn); } TUI_DISASM_WIN->generic.content_size = i; return TUI_SUCCESS; }
/* Function to set the disassembly window's content. */ enum tui_status tui_set_disassem_content (struct gdbarch *gdbarch, CORE_ADDR pc) { enum tui_status ret = TUI_FAILURE; int i; int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset; int max_lines, line_width; CORE_ADDR cur_pc; struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); int tab_len = tui_tab_width; struct tui_asm_line *asm_lines; int insn_pos; int addr_size, insn_size; char *line; if (pc == 0) return TUI_FAILURE; ret = tui_alloc_source_buffer (TUI_DISASM_WIN); if (ret != TUI_SUCCESS) return ret; TUI_DISASM_WIN->detail.source_info.gdbarch = gdbarch; TUI_DISASM_WIN->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS; TUI_DISASM_WIN->detail.source_info.start_line_or_addr.u.addr = pc; cur_pc = locator->content[0]->which_element.locator.addr; /* Window size, excluding highlight box. */ max_lines = TUI_DISASM_WIN->generic.height - 2; line_width = TUI_DISASM_WIN->generic.width - 2; /* Get temporary table that will hold all strings (addr & insn). */ asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines); memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines); tui_disassemble (gdbarch, asm_lines, pc, max_lines); /* Determine maximum address- and instruction lengths. */ addr_size = 0; insn_size = 0; for (i = 0; i < max_lines; i++) { size_t len = strlen (asm_lines[i].addr_string); if (len > addr_size) addr_size = len; len = strlen (asm_lines[i].insn); if (len > insn_size) insn_size = len; } /* Align instructions to the same column. */ insn_pos = (1 + (addr_size / tab_len)) * tab_len; /* Allocate memory to create each line. */ line = (char*) alloca (insn_pos + insn_size + 1); /* Now construct each line. */ for (i = 0; i < max_lines; i++) { struct tui_win_element *element; struct tui_source_element *src; int cur_len; element = TUI_DISASM_WIN->generic.content[i]; src = &element->which_element.source; strcpy (line, asm_lines[i].addr_string); cur_len = strlen (line); memset (line + cur_len, ' ', insn_pos - cur_len); strcpy (line + insn_pos, asm_lines[i].insn); /* Now copy the line taking the offset into account. */ if (strlen (line) > offset) { strncpy (src->line, &line[offset], line_width); src->line[line_width] = '\0'; } else src->line[0] = '\0'; src->line_or_addr.loa = LOA_ADDRESS; src->line_or_addr.u.addr = asm_lines[i].addr; src->is_exec_point = asm_lines[i].addr == cur_pc; /* See whether there is a breakpoint installed. */ src->has_break = (!src->is_exec_point && breakpoint_here_p (current_program_space->aspace, pc) != no_breakpoint_here); xfree (asm_lines[i].addr_string); xfree (asm_lines[i].insn); } TUI_DISASM_WIN->generic.content_size = i; return TUI_SUCCESS; }