1 /* TUI display locator. 2 3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008, 4 2009, 2010 Free Software Foundation, Inc. 5 6 Contributed by Hewlett-Packard Company. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "breakpoint.h" 26 #include "frame.h" 27 #include "command.h" 28 #include "inferior.h" 29 #include "target.h" 30 #include "top.h" 31 #include "gdb_string.h" 32 #include "tui/tui.h" 33 #include "tui/tui-data.h" 34 #include "tui/tui-stack.h" 35 #include "tui/tui-wingeneral.h" 36 #include "tui/tui-source.h" 37 #include "tui/tui-winsource.h" 38 #include "tui/tui-file.h" 39 40 #include "gdb_curses.h" 41 42 /* Get a printable name for the function at the address. 43 The symbol name is demangled if demangling is turned on. 44 Returns a pointer to a static area holding the result. */ 45 static char *tui_get_function_from_frame (struct frame_info *fi); 46 47 /* Set the filename portion of the locator. */ 48 static void tui_set_locator_filename (const char *filename); 49 50 /* Update the locator, with the provided arguments. */ 51 static void tui_set_locator_info (struct gdbarch *gdbarch, 52 const char *filename, 53 const char *procname, 54 int lineno, CORE_ADDR addr); 55 56 static void tui_update_command (char *, int); 57 58 59 /* Create the status line to display as much information as we can on 60 this single line: target name, process number, current function, 61 current line, current PC, SingleKey mode. */ 62 static char* 63 tui_make_status_line (struct tui_locator_element *loc) 64 { 65 char *string; 66 char line_buf[50], *pname; 67 char *buf; 68 int status_size; 69 int i, proc_width; 70 const char *pid_name; 71 const char *pc_buf; 72 int target_width; 73 int pid_width; 74 int line_width; 75 int pc_width; 76 struct ui_file *pc_out; 77 78 if (ptid_equal (inferior_ptid, null_ptid)) 79 pid_name = "No process"; 80 else 81 pid_name = target_pid_to_str (inferior_ptid); 82 83 target_width = strlen (target_shortname); 84 if (target_width > MAX_TARGET_WIDTH) 85 target_width = MAX_TARGET_WIDTH; 86 87 pid_width = strlen (pid_name); 88 if (pid_width > MAX_PID_WIDTH) 89 pid_width = MAX_PID_WIDTH; 90 91 status_size = tui_term_width (); 92 string = (char *) xmalloc (status_size + 1); 93 buf = (char*) alloca (status_size + 1); 94 95 /* Translate line number and obtain its size. */ 96 if (loc->line_no > 0) 97 sprintf (line_buf, "%d", loc->line_no); 98 else 99 strcpy (line_buf, "??"); 100 line_width = strlen (line_buf); 101 if (line_width < MIN_LINE_WIDTH) 102 line_width = MIN_LINE_WIDTH; 103 104 /* Translate PC address. */ 105 pc_out = tui_sfileopen (128); 106 fputs_filtered (loc->gdbarch? paddress (loc->gdbarch, loc->addr) : "??", 107 pc_out); 108 pc_buf = tui_file_get_strbuf (pc_out); 109 pc_width = strlen (pc_buf); 110 111 /* First determine the amount of proc name width we have available. 112 The +1 are for a space separator between fields. 113 The -1 are to take into account the \0 counted by sizeof. */ 114 proc_width = (status_size 115 - (target_width + 1) 116 - (pid_width + 1) 117 - (sizeof (PROC_PREFIX) - 1 + 1) 118 - (sizeof (LINE_PREFIX) - 1 + line_width + 1) 119 - (sizeof (PC_PREFIX) - 1 + pc_width + 1) 120 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE 121 ? (sizeof (SINGLE_KEY) - 1 + 1) 122 : 0)); 123 124 /* If there is no room to print the function name, try by removing 125 some fields. */ 126 if (proc_width < MIN_PROC_WIDTH) 127 { 128 proc_width += target_width + 1; 129 target_width = 0; 130 if (proc_width < MIN_PROC_WIDTH) 131 { 132 proc_width += pid_width + 1; 133 pid_width = 0; 134 if (proc_width <= MIN_PROC_WIDTH) 135 { 136 proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1; 137 pc_width = 0; 138 if (proc_width < 0) 139 { 140 proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1; 141 line_width = 0; 142 if (proc_width < 0) 143 proc_width = 0; 144 } 145 } 146 } 147 } 148 149 /* Now convert elements to string form. */ 150 pname = loc->proc_name; 151 152 /* Now create the locator line from the string version of the 153 elements. We could use sprintf() here but that wouldn't ensure 154 that we don't overrun the size of the allocated buffer. 155 strcat_to_buf() will. */ 156 *string = (char) 0; 157 158 if (target_width > 0) 159 { 160 sprintf (buf, "%*.*s ", 161 -target_width, target_width, target_shortname); 162 strcat_to_buf (string, status_size, buf); 163 } 164 if (pid_width > 0) 165 { 166 sprintf (buf, "%*.*s ", 167 -pid_width, pid_width, pid_name); 168 strcat_to_buf (string, status_size, buf); 169 } 170 171 /* Show whether we are in SingleKey mode. */ 172 if (tui_current_key_mode == TUI_SINGLE_KEY_MODE) 173 { 174 strcat_to_buf (string, status_size, SINGLE_KEY); 175 strcat_to_buf (string, status_size, " "); 176 } 177 178 /* Procedure/class name. */ 179 if (proc_width > 0) 180 { 181 if (strlen (pname) > proc_width) 182 sprintf (buf, "%s%*.*s* ", PROC_PREFIX, 183 1 - proc_width, proc_width - 1, pname); 184 else 185 sprintf (buf, "%s%*.*s ", PROC_PREFIX, 186 -proc_width, proc_width, pname); 187 strcat_to_buf (string, status_size, buf); 188 } 189 190 if (line_width > 0) 191 { 192 sprintf (buf, "%s%*.*s ", LINE_PREFIX, 193 -line_width, line_width, line_buf); 194 strcat_to_buf (string, status_size, buf); 195 } 196 if (pc_width > 0) 197 { 198 strcat_to_buf (string, status_size, PC_PREFIX); 199 strcat_to_buf (string, status_size, pc_buf); 200 } 201 202 203 for (i = strlen (string); i < status_size; i++) 204 string[i] = ' '; 205 string[status_size] = (char) 0; 206 207 ui_file_delete (pc_out); 208 return string; 209 } 210 211 /* Get a printable name for the function at the address. The symbol 212 name is demangled if demangling is turned on. Returns a pointer to 213 a static area holding the result. */ 214 static char* 215 tui_get_function_from_frame (struct frame_info *fi) 216 { 217 static char name[256]; 218 struct ui_file *stream = tui_sfileopen (256); 219 char *p; 220 221 print_address_symbolic (get_frame_arch (fi), get_frame_pc (fi), 222 stream, demangle, ""); 223 p = tui_file_get_strbuf (stream); 224 225 /* Use simple heuristics to isolate the function name. The symbol 226 can be demangled and we can have function parameters. Remove 227 them because the status line is too short to display them. */ 228 if (*p == '<') 229 p++; 230 strncpy (name, p, sizeof (name)); 231 p = strchr (name, '('); 232 if (!p) 233 p = strchr (name, '>'); 234 if (p) 235 *p = 0; 236 p = strchr (name, '+'); 237 if (p) 238 *p = 0; 239 ui_file_delete (stream); 240 return name; 241 } 242 243 void 244 tui_show_locator_content (void) 245 { 246 char *string; 247 struct tui_gen_win_info *locator; 248 249 locator = tui_locator_win_info_ptr (); 250 251 if (locator != NULL && locator->handle != (WINDOW *) NULL) 252 { 253 struct tui_win_element *element; 254 255 element = (struct tui_win_element *) locator->content[0]; 256 257 string = tui_make_status_line (&element->which_element.locator); 258 wmove (locator->handle, 0, 0); 259 /* We ignore the return value from wstandout and wstandend, casting 260 them to void in order to avoid a compiler warning. The warning 261 itself was introduced by a patch to ncurses 5.7 dated 2009-08-29, 262 changing these macro to expand to code that causes the compiler 263 to generate an unused-value warning. */ 264 (void) wstandout (locator->handle); 265 waddstr (locator->handle, string); 266 wclrtoeol (locator->handle); 267 (void) wstandend (locator->handle); 268 tui_refresh_win (locator); 269 wmove (locator->handle, 0, 0); 270 xfree (string); 271 locator->content_in_use = TRUE; 272 } 273 } 274 275 276 /* Set the filename portion of the locator. */ 277 static void 278 tui_set_locator_filename (const char *filename) 279 { 280 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 281 struct tui_locator_element *element; 282 283 if (locator->content[0] == NULL) 284 { 285 tui_set_locator_info (NULL, filename, NULL, 0, 0); 286 return; 287 } 288 289 element = &((struct tui_win_element *) locator->content[0])->which_element.locator; 290 element->file_name[0] = 0; 291 strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename); 292 } 293 294 /* Update the locator, with the provided arguments. */ 295 static void 296 tui_set_locator_info (struct gdbarch *gdbarch, 297 const char *filename, 298 const char *procname, 299 int lineno, 300 CORE_ADDR addr) 301 { 302 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 303 struct tui_locator_element *element; 304 305 /* Allocate the locator content if necessary. */ 306 if (locator->content_size <= 0) 307 { 308 locator->content = (void **) tui_alloc_content (1, locator->type); 309 locator->content_size = 1; 310 } 311 312 element = &((struct tui_win_element *) locator->content[0])->which_element.locator; 313 element->proc_name[0] = (char) 0; 314 strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname); 315 element->line_no = lineno; 316 element->addr = addr; 317 element->gdbarch = gdbarch; 318 tui_set_locator_filename (filename); 319 } 320 321 /* Update only the filename portion of the locator. */ 322 void 323 tui_update_locator_filename (const char *filename) 324 { 325 tui_set_locator_filename (filename); 326 tui_show_locator_content (); 327 } 328 329 /* Function to print the frame information for the TUI. */ 330 void 331 tui_show_frame_info (struct frame_info *fi) 332 { 333 struct tui_win_info *win_info; 334 int i; 335 336 if (fi) 337 { 338 int start_line, i; 339 CORE_ADDR low; 340 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 341 int source_already_displayed; 342 struct symtab_and_line sal; 343 344 find_frame_sal (fi, &sal); 345 346 source_already_displayed = sal.symtab != 0 347 && tui_source_is_displayed (sal.symtab->filename); 348 tui_set_locator_info (get_frame_arch (fi), 349 sal.symtab == 0 ? "??" : sal.symtab->filename, 350 tui_get_function_from_frame (fi), 351 sal.line, 352 get_frame_pc (fi)); 353 tui_show_locator_content (); 354 start_line = 0; 355 for (i = 0; i < (tui_source_windows ())->count; i++) 356 { 357 union tui_which_element *item; 358 359 win_info = (tui_source_windows ())->list[i]; 360 361 item = &((struct tui_win_element *) locator->content[0])->which_element; 362 if (win_info == TUI_SRC_WIN) 363 { 364 start_line = (item->locator.line_no - 365 (win_info->generic.viewport_height / 2)) + 1; 366 if (start_line <= 0) 367 start_line = 1; 368 } 369 else 370 { 371 if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL, 372 &low, (CORE_ADDR) 0) == 0) 373 error (_("No function contains program counter for selected frame.")); 374 else 375 low = tui_get_low_disassembly_address (get_frame_arch (fi), 376 low, get_frame_pc (fi)); 377 } 378 379 if (win_info == TUI_SRC_WIN) 380 { 381 struct tui_line_or_address l; 382 383 l.loa = LOA_LINE; 384 l.u.line_no = start_line; 385 if (!(source_already_displayed 386 && tui_line_is_displayed (item->locator.line_no, win_info, TRUE))) 387 tui_update_source_window (win_info, get_frame_arch (fi), 388 sal.symtab, l, TRUE); 389 else 390 { 391 l.u.line_no = item->locator.line_no; 392 tui_set_is_exec_point_at (l, win_info); 393 } 394 } 395 else 396 { 397 if (win_info == TUI_DISASM_WIN) 398 { 399 struct tui_line_or_address a; 400 401 a.loa = LOA_ADDRESS; 402 a.u.addr = low; 403 if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE)) 404 tui_update_source_window (win_info, get_frame_arch (fi), 405 sal.symtab, a, TRUE); 406 else 407 { 408 a.u.addr = item->locator.addr; 409 tui_set_is_exec_point_at (a, win_info); 410 } 411 } 412 } 413 tui_update_exec_info (win_info); 414 } 415 } 416 else 417 { 418 tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0); 419 tui_show_locator_content (); 420 for (i = 0; i < (tui_source_windows ())->count; i++) 421 { 422 win_info = (tui_source_windows ())->list[i]; 423 tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT); 424 tui_update_exec_info (win_info); 425 } 426 } 427 } 428 429 /* Function to initialize gdb commands, for tui window stack 430 manipulation. */ 431 432 /* Provide a prototype to silence -Wmissing-prototypes. */ 433 extern initialize_file_ftype _initialize_tui_stack; 434 435 void 436 _initialize_tui_stack (void) 437 { 438 add_com ("update", class_tui, tui_update_command, _("\ 439 Update the source window and locator to display the current execution point.\n")); 440 } 441 442 /* Command to update the display with the current execution point. */ 443 static void 444 tui_update_command (char *arg, int from_tty) 445 { 446 char cmd[sizeof("frame 0")]; 447 448 strcpy (cmd, "frame 0"); 449 execute_command (cmd, from_tty); 450 } 451