1 /* TUI display locator. 2 3 Copyright (C) 1998-2004, 2006-2012 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 "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) - 1); 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 *) 290 locator->content[0])->which_element.locator; 291 element->file_name[0] = 0; 292 strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename); 293 } 294 295 /* Update the locator, with the provided arguments. */ 296 static void 297 tui_set_locator_info (struct gdbarch *gdbarch, 298 const char *filename, 299 const char *procname, 300 int lineno, 301 CORE_ADDR addr) 302 { 303 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 304 struct tui_locator_element *element; 305 306 /* Allocate the locator content if necessary. */ 307 if (locator->content_size <= 0) 308 { 309 locator->content = (void **) tui_alloc_content (1, locator->type); 310 locator->content_size = 1; 311 } 312 313 element = &((struct tui_win_element *) 314 locator->content[0])->which_element.locator; 315 element->proc_name[0] = (char) 0; 316 strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname); 317 element->line_no = lineno; 318 element->addr = addr; 319 element->gdbarch = gdbarch; 320 tui_set_locator_filename (filename); 321 } 322 323 /* Update only the filename portion of the locator. */ 324 void 325 tui_update_locator_filename (const char *filename) 326 { 327 tui_set_locator_filename (filename); 328 tui_show_locator_content (); 329 } 330 331 /* Function to print the frame information for the TUI. */ 332 void 333 tui_show_frame_info (struct frame_info *fi) 334 { 335 struct tui_win_info *win_info; 336 int i; 337 338 if (fi) 339 { 340 int start_line, i; 341 CORE_ADDR low; 342 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 343 int source_already_displayed; 344 struct symtab_and_line sal; 345 CORE_ADDR pc; 346 347 find_frame_sal (fi, &sal); 348 349 source_already_displayed = sal.symtab != 0 350 && tui_source_is_displayed (sal.symtab->filename); 351 352 if (get_frame_pc_if_available (fi, &pc)) 353 tui_set_locator_info (get_frame_arch (fi), 354 sal.symtab == 0 ? "??" : sal.symtab->filename, 355 tui_get_function_from_frame (fi), 356 sal.line, 357 pc); 358 else 359 tui_set_locator_info (get_frame_arch (fi), 360 "??", _("<unavailable>"), sal.line, 0); 361 362 tui_show_locator_content (); 363 start_line = 0; 364 for (i = 0; i < (tui_source_windows ())->count; i++) 365 { 366 union tui_which_element *item; 367 368 win_info = (tui_source_windows ())->list[i]; 369 370 item = &((struct tui_win_element *) 371 locator->content[0])->which_element; 372 if (win_info == TUI_SRC_WIN) 373 { 374 start_line = (item->locator.line_no - 375 (win_info->generic.viewport_height / 2)) + 1; 376 if (start_line <= 0) 377 start_line = 1; 378 } 379 else 380 { 381 if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL, 382 &low, (CORE_ADDR) 0) == 0) 383 { 384 /* There is no symbol available for current PC. There is no 385 safe way how to "disassemble backwards". */ 386 low = get_frame_pc (fi); 387 } 388 else 389 low = tui_get_low_disassembly_address (get_frame_arch (fi), 390 low, get_frame_pc (fi)); 391 } 392 393 if (win_info == TUI_SRC_WIN) 394 { 395 struct tui_line_or_address l; 396 397 l.loa = LOA_LINE; 398 l.u.line_no = start_line; 399 if (!(source_already_displayed 400 && tui_line_is_displayed (item->locator.line_no, 401 win_info, TRUE))) 402 tui_update_source_window (win_info, get_frame_arch (fi), 403 sal.symtab, l, TRUE); 404 else 405 { 406 l.u.line_no = item->locator.line_no; 407 tui_set_is_exec_point_at (l, win_info); 408 } 409 } 410 else 411 { 412 if (win_info == TUI_DISASM_WIN) 413 { 414 struct tui_line_or_address a; 415 416 a.loa = LOA_ADDRESS; 417 a.u.addr = low; 418 if (!tui_addr_is_displayed (item->locator.addr, 419 win_info, TRUE)) 420 tui_update_source_window (win_info, get_frame_arch (fi), 421 sal.symtab, a, TRUE); 422 else 423 { 424 a.u.addr = item->locator.addr; 425 tui_set_is_exec_point_at (a, win_info); 426 } 427 } 428 } 429 tui_update_exec_info (win_info); 430 } 431 } 432 else 433 { 434 tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0); 435 tui_show_locator_content (); 436 for (i = 0; i < (tui_source_windows ())->count; i++) 437 { 438 win_info = (tui_source_windows ())->list[i]; 439 tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT); 440 tui_update_exec_info (win_info); 441 } 442 } 443 } 444 445 /* Function to initialize gdb commands, for tui window stack 446 manipulation. */ 447 448 /* Provide a prototype to silence -Wmissing-prototypes. */ 449 extern initialize_file_ftype _initialize_tui_stack; 450 451 void 452 _initialize_tui_stack (void) 453 { 454 add_com ("update", class_tui, tui_update_command, 455 _("Update the source window and locator to " 456 "display the current execution point.\n")); 457 } 458 459 /* Command to update the display with the current execution point. */ 460 static void 461 tui_update_command (char *arg, int from_tty) 462 { 463 char cmd[sizeof("frame 0")]; 464 465 strcpy (cmd, "frame 0"); 466 execute_command (cmd, from_tty); 467 } 468