1 /* TUI display locator. 2 3 Copyright (C) 1998-2016 Free Software Foundation, Inc. 4 5 Contributed by Hewlett-Packard Company. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "symtab.h" 24 #include "breakpoint.h" 25 #include "frame.h" 26 #include "command.h" 27 #include "inferior.h" 28 #include "target.h" 29 #include "top.h" 30 #include "gdb-demangle.h" 31 #include "source.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 full_name portion of the locator. */ 48 static void tui_set_locator_fullname (const char *fullname); 49 50 /* Update the locator, with the provided arguments. */ 51 static int tui_set_locator_info (struct gdbarch *gdbarch, 52 const char *fullname, 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 xsnprintf (line_buf, sizeof (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) - 1); 231 name[sizeof (name) - 1] = 0; 232 p = strchr (name, '('); 233 if (!p) 234 p = strchr (name, '>'); 235 if (p) 236 *p = 0; 237 p = strchr (name, '+'); 238 if (p) 239 *p = 0; 240 ui_file_delete (stream); 241 return name; 242 } 243 244 void 245 tui_show_locator_content (void) 246 { 247 char *string; 248 struct tui_gen_win_info *locator; 249 250 locator = tui_locator_win_info_ptr (); 251 252 if (locator != NULL && locator->handle != (WINDOW *) NULL) 253 { 254 struct tui_win_element *element; 255 256 element = locator->content[0]; 257 258 string = tui_make_status_line (&element->which_element.locator); 259 wmove (locator->handle, 0, 0); 260 /* We ignore the return value from wstandout and wstandend, casting 261 them to void in order to avoid a compiler warning. The warning 262 itself was introduced by a patch to ncurses 5.7 dated 2009-08-29, 263 changing these macro to expand to code that causes the compiler 264 to generate an unused-value warning. */ 265 (void) wstandout (locator->handle); 266 waddstr (locator->handle, string); 267 wclrtoeol (locator->handle); 268 (void) wstandend (locator->handle); 269 tui_refresh_win (locator); 270 wmove (locator->handle, 0, 0); 271 xfree (string); 272 locator->content_in_use = TRUE; 273 } 274 } 275 276 277 /* Set the filename portion of the locator. */ 278 static void 279 tui_set_locator_fullname (const char *fullname) 280 { 281 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 282 struct tui_locator_element *element; 283 284 if (locator->content[0] == NULL) 285 { 286 tui_set_locator_info (NULL, fullname, NULL, 0, 0); 287 return; 288 } 289 290 element = &locator->content[0]->which_element.locator; 291 element->full_name[0] = 0; 292 strcat_to_buf (element->full_name, MAX_LOCATOR_ELEMENT_LEN, fullname); 293 } 294 295 /* Update the locator, with the provided arguments. 296 297 Returns 1 if any of the locator's fields were actually changed, 298 and 0 otherwise. */ 299 300 static int 301 tui_set_locator_info (struct gdbarch *gdbarch, 302 const char *fullname, 303 const char *procname, 304 int lineno, 305 CORE_ADDR addr) 306 { 307 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 308 struct tui_locator_element *element; 309 int locator_changed_p = 0; 310 311 /* Allocate the locator content if necessary. */ 312 if (locator->content_size <= 0) 313 { 314 locator->content = tui_alloc_content (1, LOCATOR_WIN); 315 locator->content_size = 1; 316 locator_changed_p = 1; 317 } 318 319 if (procname == NULL) 320 procname = ""; 321 322 if (fullname == NULL) 323 fullname = ""; 324 325 element = &locator->content[0]->which_element.locator; 326 327 locator_changed_p |= strncmp (element->proc_name, procname, 328 MAX_LOCATOR_ELEMENT_LEN) != 0; 329 locator_changed_p |= lineno != element->line_no; 330 locator_changed_p |= addr != element->addr; 331 locator_changed_p |= gdbarch != element->gdbarch; 332 locator_changed_p |= strncmp (element->full_name, fullname, 333 MAX_LOCATOR_ELEMENT_LEN) != 0; 334 335 element->proc_name[0] = (char) 0; 336 strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname); 337 element->line_no = lineno; 338 element->addr = addr; 339 element->gdbarch = gdbarch; 340 tui_set_locator_fullname (fullname); 341 342 return locator_changed_p; 343 } 344 345 /* Update only the full_name portion of the locator. */ 346 void 347 tui_update_locator_fullname (const char *fullname) 348 { 349 tui_set_locator_fullname (fullname); 350 tui_show_locator_content (); 351 } 352 353 /* Function to print the frame information for the TUI. The windows are 354 refreshed only if frame information has changed since the last refresh. 355 356 Return 1 if frame information has changed (and windows subsequently 357 refreshed), 0 otherwise. */ 358 359 int 360 tui_show_frame_info (struct frame_info *fi) 361 { 362 struct tui_win_info *win_info; 363 int locator_changed_p; 364 int i; 365 366 if (fi) 367 { 368 int start_line, i; 369 CORE_ADDR low; 370 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 371 int source_already_displayed; 372 struct symtab_and_line sal; 373 CORE_ADDR pc; 374 375 find_frame_sal (fi, &sal); 376 377 source_already_displayed = sal.symtab != 0 378 && tui_source_is_displayed (symtab_to_fullname (sal.symtab)); 379 380 if (get_frame_pc_if_available (fi, &pc)) 381 locator_changed_p 382 = tui_set_locator_info (get_frame_arch (fi), 383 (sal.symtab == 0 384 ? "??" : symtab_to_fullname (sal.symtab)), 385 tui_get_function_from_frame (fi), 386 sal.line, 387 pc); 388 else 389 locator_changed_p 390 = tui_set_locator_info (get_frame_arch (fi), 391 "??", _("<unavailable>"), sal.line, 0); 392 393 /* If the locator information has not changed, then frame information has 394 not changed. If frame information has not changed, then the windows' 395 contents will not change. So don't bother refreshing the windows. */ 396 if (!locator_changed_p) 397 return 0; 398 399 tui_show_locator_content (); 400 start_line = 0; 401 for (i = 0; i < (tui_source_windows ())->count; i++) 402 { 403 union tui_which_element *item; 404 405 win_info = (tui_source_windows ())->list[i]; 406 407 item = &locator->content[0]->which_element; 408 if (win_info == TUI_SRC_WIN) 409 { 410 start_line = (item->locator.line_no - 411 (win_info->generic.viewport_height / 2)) + 1; 412 if (start_line <= 0) 413 start_line = 1; 414 } 415 else 416 { 417 if (find_pc_partial_function (get_frame_pc (fi), 418 (const char **) NULL, 419 &low, NULL) == 0) 420 { 421 /* There is no symbol available for current PC. There is no 422 safe way how to "disassemble backwards". */ 423 low = get_frame_pc (fi); 424 } 425 else 426 low = tui_get_low_disassembly_address (get_frame_arch (fi), 427 low, get_frame_pc (fi)); 428 } 429 430 if (win_info == TUI_SRC_WIN) 431 { 432 struct tui_line_or_address l; 433 434 l.loa = LOA_LINE; 435 l.u.line_no = start_line; 436 if (!(source_already_displayed 437 && tui_line_is_displayed (item->locator.line_no, 438 win_info, TRUE))) 439 tui_update_source_window (win_info, get_frame_arch (fi), 440 sal.symtab, l, TRUE); 441 else 442 { 443 l.u.line_no = item->locator.line_no; 444 tui_set_is_exec_point_at (l, win_info); 445 } 446 } 447 else 448 { 449 if (win_info == TUI_DISASM_WIN) 450 { 451 struct tui_line_or_address a; 452 453 a.loa = LOA_ADDRESS; 454 a.u.addr = low; 455 if (!tui_addr_is_displayed (item->locator.addr, 456 win_info, TRUE)) 457 tui_update_source_window (win_info, get_frame_arch (fi), 458 sal.symtab, a, TRUE); 459 else 460 { 461 a.u.addr = item->locator.addr; 462 tui_set_is_exec_point_at (a, win_info); 463 } 464 } 465 } 466 tui_update_exec_info (win_info); 467 } 468 469 return 1; 470 } 471 else 472 { 473 locator_changed_p 474 = tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0); 475 476 if (!locator_changed_p) 477 return 0; 478 479 tui_show_locator_content (); 480 for (i = 0; i < (tui_source_windows ())->count; i++) 481 { 482 win_info = (tui_source_windows ())->list[i]; 483 tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT); 484 tui_update_exec_info (win_info); 485 } 486 487 return 1; 488 } 489 } 490 491 /* Function to initialize gdb commands, for tui window stack 492 manipulation. */ 493 494 /* Provide a prototype to silence -Wmissing-prototypes. */ 495 extern initialize_file_ftype _initialize_tui_stack; 496 497 void 498 _initialize_tui_stack (void) 499 { 500 add_com ("update", class_tui, tui_update_command, 501 _("Update the source window and locator to " 502 "display the current execution point.\n")); 503 } 504 505 /* Command to update the display with the current execution point. */ 506 static void 507 tui_update_command (char *arg, int from_tty) 508 { 509 char cmd[sizeof("frame 0")]; 510 511 strcpy (cmd, "frame 0"); 512 execute_command (cmd, from_tty); 513 } 514