/* 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; }
/* Find the disassembly address that corresponds to FROM lines above or below the PC. Variable sized instructions are taken into account by the algorithm. */ static CORE_ADDR tui_find_disassembly_address (CORE_ADDR pc, int from) { CORE_ADDR new_low; int max_lines; int i; struct tui_asm_line* asm_lines; max_lines = (from > 0) ? from : - from; if (max_lines <= 1) return pc; 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); new_low = pc; if (from > 0) { tui_disassemble (asm_lines, pc, max_lines); new_low = asm_lines[max_lines - 1].addr; } else { CORE_ADDR last_addr; int pos; struct minimal_symbol* msymbol; /* Find backward an address which is a symbol and for which disassembling from that address will fill completely the window. */ pos = max_lines - 1; do { new_low -= 1 * max_lines; msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0); if (msymbol) new_low = SYMBOL_VALUE_ADDRESS (msymbol); else new_low += 1 * max_lines; tui_disassemble (asm_lines, new_low, max_lines); last_addr = asm_lines[pos].addr; } while (last_addr > pc && msymbol); /* Scan forward disassembling one instruction at a time until the last visible instruction of the window matches the pc. We keep the disassembled instructions in the 'lines' window and shift it downward (increasing its addresses). */ if (last_addr < pc) do { CORE_ADDR next_addr; pos++; if (pos >= max_lines) pos = 0; next_addr = tui_disassemble (&asm_lines[pos], last_addr, 1); /* If there are some problems while disassembling exit. */ if (next_addr <= last_addr) break; last_addr = next_addr; } while (last_addr <= pc); pos++; if (pos >= max_lines) pos = 0; new_low = asm_lines[pos].addr; } for (i = 0; i < max_lines; i++) { xfree (asm_lines[i].addr_string); xfree (asm_lines[i].insn); } return new_low; }
/* 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; }