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