1 /* Print and select stack frames for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "value.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "expression.h" 25 #include "language.h" 26 #include "frame.h" 27 #include "gdbcmd.h" 28 #include "gdbcore.h" 29 #include "target.h" 30 #include "source.h" 31 #include "breakpoint.h" 32 #include "demangle.h" 33 #include "inferior.h" 34 #include "annotate.h" 35 #include "ui-out.h" 36 #include "block.h" 37 #include "stack.h" 38 #include "dictionary.h" 39 #include "exceptions.h" 40 #include "reggroups.h" 41 #include "regcache.h" 42 #include "solib.h" 43 #include "valprint.h" 44 #include "gdbthread.h" 45 #include "cp-support.h" 46 #include "disasm.h" 47 #include "inline-frame.h" 48 #include "linespec.h" 49 50 #include "gdb_assert.h" 51 #include <ctype.h> 52 #include "gdb_string.h" 53 54 #include "psymtab.h" 55 #include "symfile.h" 56 57 void (*deprecated_selected_frame_level_changed_hook) (int); 58 59 /* The possible choices of "set print frame-arguments", and the value 60 of this setting. */ 61 62 static const char *print_frame_arguments_choices[] = 63 {"all", "scalars", "none", NULL}; 64 static const char *print_frame_arguments = "scalars"; 65 66 /* The possible choices of "set print entry-values", and the value 67 of this setting. */ 68 69 const char print_entry_values_no[] = "no"; 70 const char print_entry_values_only[] = "only"; 71 const char print_entry_values_preferred[] = "preferred"; 72 const char print_entry_values_if_needed[] = "if-needed"; 73 const char print_entry_values_both[] = "both"; 74 const char print_entry_values_compact[] = "compact"; 75 const char print_entry_values_default[] = "default"; 76 static const char *print_entry_values_choices[] = 77 { 78 print_entry_values_no, 79 print_entry_values_only, 80 print_entry_values_preferred, 81 print_entry_values_if_needed, 82 print_entry_values_both, 83 print_entry_values_compact, 84 print_entry_values_default, 85 NULL 86 }; 87 const char *print_entry_values = print_entry_values_default; 88 89 /* Prototypes for local functions. */ 90 91 static void print_frame_local_vars (struct frame_info *, int, 92 struct ui_file *); 93 94 static void print_frame (struct frame_info *frame, int print_level, 95 enum print_what print_what, int print_args, 96 struct symtab_and_line sal); 97 98 static void set_last_displayed_sal (int valid, 99 struct program_space *pspace, 100 CORE_ADDR addr, 101 struct symtab *symtab, 102 int line); 103 104 /* Zero means do things normally; we are interacting directly with the 105 user. One means print the full filename and linenumber when a 106 frame is printed, and do so in a format emacs18/emacs19.22 can 107 parse. Two means print similar annotations, but in many more 108 cases and in a slightly different syntax. */ 109 110 int annotation_level = 0; 111 112 /* These variables hold the last symtab and line we displayed to the user. 113 * This is where we insert a breakpoint or a skiplist entry by default. */ 114 static int last_displayed_sal_valid = 0; 115 static struct program_space *last_displayed_pspace = 0; 116 static CORE_ADDR last_displayed_addr = 0; 117 static struct symtab *last_displayed_symtab = 0; 118 static int last_displayed_line = 0; 119 120 121 /* Return 1 if we should display the address in addition to the location, 122 because we are in the middle of a statement. */ 123 124 static int 125 frame_show_address (struct frame_info *frame, 126 struct symtab_and_line sal) 127 { 128 /* If there is a line number, but no PC, then there is no location 129 information associated with this sal. The only way that should 130 happen is for the call sites of inlined functions (SAL comes from 131 find_frame_sal). Otherwise, we would have some PC range if the 132 SAL came from a line table. */ 133 if (sal.line != 0 && sal.pc == 0 && sal.end == 0) 134 { 135 if (get_next_frame (frame) == NULL) 136 gdb_assert (inline_skipped_frames (inferior_ptid) > 0); 137 else 138 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME); 139 return 0; 140 } 141 142 return get_frame_pc (frame) != sal.pc; 143 } 144 145 /* Show or print a stack frame FRAME briefly. The output is format 146 according to PRINT_LEVEL and PRINT_WHAT printing the frame's 147 relative level, function name, argument list, and file name and 148 line number. If the frame's PC is not at the beginning of the 149 source line, the actual PC is printed at the beginning. */ 150 151 void 152 print_stack_frame (struct frame_info *frame, int print_level, 153 enum print_what print_what) 154 { 155 volatile struct gdb_exception e; 156 157 /* For mi, alway print location and address. */ 158 if (ui_out_is_mi_like_p (current_uiout)) 159 print_what = LOC_AND_ADDRESS; 160 161 TRY_CATCH (e, RETURN_MASK_ERROR) 162 { 163 int center = (print_what == SRC_LINE || print_what == SRC_AND_LOC); 164 165 print_frame_info (frame, print_level, print_what, 1 /* print_args */); 166 set_current_sal_from_frame (frame, center); 167 } 168 } 169 170 /* Print nameless arguments of frame FRAME on STREAM, where START is 171 the offset of the first nameless argument, and NUM is the number of 172 nameless arguments to print. FIRST is nonzero if this is the first 173 argument (not just the first nameless argument). */ 174 175 static void 176 print_frame_nameless_args (struct frame_info *frame, long start, int num, 177 int first, struct ui_file *stream) 178 { 179 struct gdbarch *gdbarch = get_frame_arch (frame); 180 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 181 int i; 182 CORE_ADDR argsaddr; 183 long arg_value; 184 185 for (i = 0; i < num; i++) 186 { 187 QUIT; 188 argsaddr = get_frame_args_address (frame); 189 if (!argsaddr) 190 return; 191 arg_value = read_memory_integer (argsaddr + start, 192 sizeof (int), byte_order); 193 if (!first) 194 fprintf_filtered (stream, ", "); 195 fprintf_filtered (stream, "%ld", arg_value); 196 first = 0; 197 start += sizeof (int); 198 } 199 } 200 201 /* Print single argument of inferior function. ARG must be already 202 read in. 203 204 Errors are printed as if they would be the parameter value. Use zeroed ARG 205 iff it should not be printed accoring to user settings. */ 206 207 static void 208 print_frame_arg (const struct frame_arg *arg) 209 { 210 struct ui_out *uiout = current_uiout; 211 volatile struct gdb_exception except; 212 struct cleanup *old_chain; 213 struct ui_stream *stb; 214 215 stb = ui_out_stream_new (uiout); 216 old_chain = make_cleanup_ui_out_stream_delete (stb); 217 218 gdb_assert (!arg->val || !arg->error); 219 gdb_assert (arg->entry_kind == print_entry_values_no 220 || arg->entry_kind == print_entry_values_only 221 || (!ui_out_is_mi_like_p (uiout) 222 && arg->entry_kind == print_entry_values_compact)); 223 224 annotate_arg_begin (); 225 226 make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 227 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (arg->sym), 228 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI); 229 if (arg->entry_kind == print_entry_values_compact) 230 { 231 /* It is OK to provide invalid MI-like stream as with 232 PRINT_ENTRY_VALUE_COMPACT we never use MI. */ 233 fputs_filtered ("=", stb->stream); 234 235 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (arg->sym), 236 SYMBOL_LANGUAGE (arg->sym), 237 DMGL_PARAMS | DMGL_ANSI); 238 } 239 if (arg->entry_kind == print_entry_values_only 240 || arg->entry_kind == print_entry_values_compact) 241 fputs_filtered ("@entry", stb->stream); 242 ui_out_field_stream (uiout, "name", stb); 243 annotate_arg_name_end (); 244 ui_out_text (uiout, "="); 245 246 if (!arg->val && !arg->error) 247 ui_out_text (uiout, "..."); 248 else 249 { 250 if (arg->error) 251 except.message = arg->error; 252 else 253 { 254 /* TRY_CATCH has two statements, wrap it in a block. */ 255 256 TRY_CATCH (except, RETURN_MASK_ERROR) 257 { 258 const struct language_defn *language; 259 struct value_print_options opts; 260 261 /* Avoid value_print because it will deref ref parameters. We 262 just want to print their addresses. Print ??? for args whose 263 address we do not know. We pass 2 as "recurse" to val_print 264 because our standard indentation here is 4 spaces, and 265 val_print indents 2 for each recurse. */ 266 267 annotate_arg_value (value_type (arg->val)); 268 269 /* Use the appropriate language to display our symbol, unless the 270 user forced the language to a specific language. */ 271 if (language_mode == language_mode_auto) 272 language = language_def (SYMBOL_LANGUAGE (arg->sym)); 273 else 274 language = current_language; 275 276 get_raw_print_options (&opts); 277 opts.deref_ref = 1; 278 279 /* True in "summary" mode, false otherwise. */ 280 opts.summary = !strcmp (print_frame_arguments, "scalars"); 281 282 common_val_print (arg->val, stb->stream, 2, &opts, language); 283 } 284 } 285 if (except.message) 286 fprintf_filtered (stb->stream, _("<error reading variable: %s>"), 287 except.message); 288 } 289 290 ui_out_field_stream (uiout, "value", stb); 291 292 /* Aleo invoke ui_out_tuple_end. */ 293 do_cleanups (old_chain); 294 295 annotate_arg_end (); 296 } 297 298 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is 299 responsible for xfree of ARGP->ERROR. This function never throws an 300 exception. */ 301 302 void 303 read_frame_arg (struct symbol *sym, struct frame_info *frame, 304 struct frame_arg *argp, struct frame_arg *entryargp) 305 { 306 struct value *val = NULL, *entryval = NULL; 307 char *val_error = NULL, *entryval_error = NULL; 308 int val_equal = 0; 309 volatile struct gdb_exception except; 310 311 if (print_entry_values != print_entry_values_only 312 && print_entry_values != print_entry_values_preferred) 313 { 314 TRY_CATCH (except, RETURN_MASK_ERROR) 315 { 316 val = read_var_value (sym, frame); 317 } 318 if (!val) 319 { 320 val_error = alloca (strlen (except.message) + 1); 321 strcpy (val_error, except.message); 322 } 323 } 324 325 if (SYMBOL_CLASS (sym) == LOC_COMPUTED 326 && print_entry_values != print_entry_values_no 327 && (print_entry_values != print_entry_values_if_needed 328 || !val || value_optimized_out (val))) 329 { 330 TRY_CATCH (except, RETURN_MASK_ERROR) 331 { 332 const struct symbol_computed_ops *ops; 333 334 ops = SYMBOL_COMPUTED_OPS (sym); 335 entryval = ops->read_variable_at_entry (sym, frame); 336 } 337 if (!entryval) 338 { 339 entryval_error = alloca (strlen (except.message) + 1); 340 strcpy (entryval_error, except.message); 341 } 342 343 if (except.error == NO_ENTRY_VALUE_ERROR 344 || (entryval && value_optimized_out (entryval))) 345 { 346 entryval = NULL; 347 entryval_error = NULL; 348 } 349 350 if (print_entry_values == print_entry_values_compact 351 || print_entry_values == print_entry_values_default) 352 { 353 /* For MI do not try to use print_entry_values_compact for ARGP. */ 354 355 if (val && entryval && !ui_out_is_mi_like_p (current_uiout)) 356 { 357 unsigned len = TYPE_LENGTH (value_type (val)); 358 359 if (!value_optimized_out (val) && value_lazy (val)) 360 value_fetch_lazy (val); 361 if (!value_optimized_out (val) && value_lazy (entryval)) 362 value_fetch_lazy (entryval); 363 if (!value_optimized_out (val) 364 && value_available_contents_eq (val, 0, entryval, 0, len)) 365 { 366 /* Initialize it just to avoid a GCC false warning. */ 367 struct value *val_deref = NULL, *entryval_deref; 368 369 /* DW_AT_GNU_call_site_value does match with the current 370 value. If it is a reference still try to verify if 371 dereferenced DW_AT_GNU_call_site_data_value does not 372 differ. */ 373 374 TRY_CATCH (except, RETURN_MASK_ERROR) 375 { 376 unsigned len_deref; 377 378 val_deref = coerce_ref (val); 379 if (value_lazy (val_deref)) 380 value_fetch_lazy (val_deref); 381 len_deref = TYPE_LENGTH (value_type (val_deref)); 382 383 entryval_deref = coerce_ref (entryval); 384 if (value_lazy (entryval_deref)) 385 value_fetch_lazy (entryval_deref); 386 387 /* If the reference addresses match but dereferenced 388 content does not match print them. */ 389 if (val != val_deref 390 && value_available_contents_eq (val_deref, 0, 391 entryval_deref, 0, 392 len_deref)) 393 val_equal = 1; 394 } 395 396 /* Value was not a reference; and its content matches. */ 397 if (val == val_deref) 398 val_equal = 1; 399 /* If the dereferenced content could not be fetched do not 400 display anything. */ 401 else if (except.error == NO_ENTRY_VALUE_ERROR) 402 val_equal = 1; 403 else if (except.message) 404 { 405 entryval_error = alloca (strlen (except.message) + 1); 406 strcpy (entryval_error, except.message); 407 } 408 409 if (val_equal) 410 entryval = NULL; 411 } 412 } 413 414 /* Try to remove possibly duplicate error message for ENTRYARGP even 415 in MI mode. */ 416 417 if (val_error && entryval_error 418 && strcmp (val_error, entryval_error) == 0) 419 { 420 entryval_error = NULL; 421 422 /* Do not se VAL_EQUAL as the same error message may be shown for 423 the entry value even if no entry values are present in the 424 inferior. */ 425 } 426 } 427 } 428 429 if (entryval == NULL) 430 { 431 if (print_entry_values == print_entry_values_preferred) 432 { 433 TRY_CATCH (except, RETURN_MASK_ERROR) 434 { 435 val = read_var_value (sym, frame); 436 } 437 if (!val) 438 { 439 val_error = alloca (strlen (except.message) + 1); 440 strcpy (val_error, except.message); 441 } 442 } 443 if (print_entry_values == print_entry_values_only 444 || print_entry_values == print_entry_values_both 445 || (print_entry_values == print_entry_values_preferred 446 && (!val || value_optimized_out (val)))) 447 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym)); 448 } 449 if ((print_entry_values == print_entry_values_compact 450 || print_entry_values == print_entry_values_if_needed 451 || print_entry_values == print_entry_values_preferred) 452 && (!val || value_optimized_out (val)) && entryval != NULL) 453 { 454 val = NULL; 455 val_error = NULL; 456 } 457 458 argp->sym = sym; 459 argp->val = val; 460 argp->error = val_error ? xstrdup (val_error) : NULL; 461 if (!val && !val_error) 462 argp->entry_kind = print_entry_values_only; 463 else if ((print_entry_values == print_entry_values_compact 464 || print_entry_values == print_entry_values_default) && val_equal) 465 { 466 argp->entry_kind = print_entry_values_compact; 467 gdb_assert (!ui_out_is_mi_like_p (current_uiout)); 468 } 469 else 470 argp->entry_kind = print_entry_values_no; 471 472 entryargp->sym = sym; 473 entryargp->val = entryval; 474 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL; 475 if (!entryval && !entryval_error) 476 entryargp->entry_kind = print_entry_values_no; 477 else 478 entryargp->entry_kind = print_entry_values_only; 479 } 480 481 /* Print the arguments of frame FRAME on STREAM, given the function 482 FUNC running in that frame (as a symbol), where NUM is the number 483 of arguments according to the stack frame (or -1 if the number of 484 arguments is unknown). */ 485 486 /* Note that currently the "number of arguments according to the 487 stack frame" is only known on VAX where i refers to the "number of 488 ints of arguments according to the stack frame". */ 489 490 static void 491 print_frame_args (struct symbol *func, struct frame_info *frame, 492 int num, struct ui_file *stream) 493 { 494 struct ui_out *uiout = current_uiout; 495 int first = 1; 496 /* Offset of next stack argument beyond the one we have seen that is 497 at the highest offset, or -1 if we haven't come to a stack 498 argument yet. */ 499 long highest_offset = -1; 500 /* Number of ints of arguments that we have printed so far. */ 501 int args_printed = 0; 502 struct cleanup *old_chain, *list_chain; 503 struct ui_stream *stb; 504 /* True if we should print arguments, false otherwise. */ 505 int print_args = strcmp (print_frame_arguments, "none"); 506 /* True in "summary" mode, false otherwise. */ 507 int summary = !strcmp (print_frame_arguments, "scalars"); 508 509 stb = ui_out_stream_new (uiout); 510 old_chain = make_cleanup_ui_out_stream_delete (stb); 511 512 if (func) 513 { 514 struct block *b = SYMBOL_BLOCK_VALUE (func); 515 struct dict_iterator iter; 516 struct symbol *sym; 517 518 ALL_BLOCK_SYMBOLS (b, iter, sym) 519 { 520 struct frame_arg arg, entryarg; 521 522 QUIT; 523 524 /* Keep track of the highest stack argument offset seen, and 525 skip over any kinds of symbols we don't care about. */ 526 527 if (!SYMBOL_IS_ARGUMENT (sym)) 528 continue; 529 530 switch (SYMBOL_CLASS (sym)) 531 { 532 case LOC_ARG: 533 case LOC_REF_ARG: 534 { 535 long current_offset = SYMBOL_VALUE (sym); 536 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); 537 538 /* Compute address of next argument by adding the size of 539 this argument and rounding to an int boundary. */ 540 current_offset = 541 ((current_offset + arg_size + sizeof (int) - 1) 542 & ~(sizeof (int) - 1)); 543 544 /* If this is the highest offset seen yet, set 545 highest_offset. */ 546 if (highest_offset == -1 547 || (current_offset > highest_offset)) 548 highest_offset = current_offset; 549 550 /* Add the number of ints we're about to print to 551 args_printed. */ 552 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int); 553 } 554 555 /* We care about types of symbols, but don't need to 556 keep track of stack offsets in them. */ 557 case LOC_REGISTER: 558 case LOC_REGPARM_ADDR: 559 case LOC_COMPUTED: 560 case LOC_OPTIMIZED_OUT: 561 default: 562 break; 563 } 564 565 /* We have to look up the symbol because arguments can have 566 two entries (one a parameter, one a local) and the one we 567 want is the local, which lookup_symbol will find for us. 568 This includes gcc1 (not gcc2) on SPARC when passing a 569 small structure and gcc2 when the argument type is float 570 and it is passed as a double and converted to float by 571 the prologue (in the latter case the type of the LOC_ARG 572 symbol is double and the type of the LOC_LOCAL symbol is 573 float). */ 574 /* But if the parameter name is null, don't try it. Null 575 parameter names occur on the RS/6000, for traceback 576 tables. FIXME, should we even print them? */ 577 578 if (*SYMBOL_LINKAGE_NAME (sym)) 579 { 580 struct symbol *nsym; 581 582 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), 583 b, VAR_DOMAIN, NULL); 584 gdb_assert (nsym != NULL); 585 if (SYMBOL_CLASS (nsym) == LOC_REGISTER 586 && !SYMBOL_IS_ARGUMENT (nsym)) 587 { 588 /* There is a LOC_ARG/LOC_REGISTER pair. This means 589 that it was passed on the stack and loaded into a 590 register, or passed in a register and stored in a 591 stack slot. GDB 3.x used the LOC_ARG; GDB 592 4.0-4.11 used the LOC_REGISTER. 593 594 Reasons for using the LOC_ARG: 595 596 (1) Because find_saved_registers may be slow for 597 remote debugging. 598 599 (2) Because registers are often re-used and stack 600 slots rarely (never?) are. Therefore using 601 the stack slot is much less likely to print 602 garbage. 603 604 Reasons why we might want to use the LOC_REGISTER: 605 606 (1) So that the backtrace prints the same value 607 as "print foo". I see no compelling reason 608 why this needs to be the case; having the 609 backtrace print the value which was passed 610 in, and "print foo" print the value as 611 modified within the called function, makes 612 perfect sense to me. 613 614 Additional note: It might be nice if "info args" 615 displayed both values. 616 617 One more note: There is a case with SPARC 618 structure passing where we need to use the 619 LOC_REGISTER, but this is dealt with by creating 620 a single LOC_REGPARM in symbol reading. */ 621 622 /* Leave sym (the LOC_ARG) alone. */ 623 ; 624 } 625 else 626 sym = nsym; 627 } 628 629 /* Print the current arg. */ 630 if (!first) 631 ui_out_text (uiout, ", "); 632 ui_out_wrap_hint (uiout, " "); 633 634 if (!print_args) 635 { 636 memset (&arg, 0, sizeof (arg)); 637 arg.sym = sym; 638 arg.entry_kind = print_entry_values_no; 639 memset (&entryarg, 0, sizeof (entryarg)); 640 entryarg.sym = sym; 641 entryarg.entry_kind = print_entry_values_no; 642 } 643 else 644 read_frame_arg (sym, frame, &arg, &entryarg); 645 646 if (arg.entry_kind != print_entry_values_only) 647 print_frame_arg (&arg); 648 649 if (entryarg.entry_kind != print_entry_values_no) 650 { 651 if (arg.entry_kind != print_entry_values_only) 652 { 653 ui_out_text (uiout, ", "); 654 ui_out_wrap_hint (uiout, " "); 655 } 656 657 print_frame_arg (&entryarg); 658 } 659 660 xfree (arg.error); 661 xfree (entryarg.error); 662 663 first = 0; 664 } 665 } 666 667 /* Don't print nameless args in situations where we don't know 668 enough about the stack to find them. */ 669 if (num != -1) 670 { 671 long start; 672 673 if (highest_offset == -1) 674 start = gdbarch_frame_args_skip (get_frame_arch (frame)); 675 else 676 start = highest_offset; 677 678 print_frame_nameless_args (frame, start, num - args_printed, 679 first, stream); 680 } 681 682 do_cleanups (old_chain); 683 } 684 685 /* Set the current source and line to the location given by frame 686 FRAME, if possible. When CENTER is true, adjust so the relevant 687 line is in the center of the next 'list'. */ 688 689 void 690 set_current_sal_from_frame (struct frame_info *frame, int center) 691 { 692 struct symtab_and_line sal; 693 694 find_frame_sal (frame, &sal); 695 if (sal.symtab) 696 { 697 if (center) 698 sal.line = max (sal.line - get_lines_to_list () / 2, 1); 699 set_current_source_symtab_and_line (&sal); 700 } 701 } 702 703 /* If ON, GDB will display disassembly of the next source line when 704 execution of the program being debugged stops. 705 If AUTO (which is the default), or there's no line info to determine 706 the source line of the next instruction, display disassembly of next 707 instruction instead. */ 708 709 static enum auto_boolean disassemble_next_line; 710 711 static void 712 show_disassemble_next_line (struct ui_file *file, int from_tty, 713 struct cmd_list_element *c, 714 const char *value) 715 { 716 fprintf_filtered (file, 717 _("Debugger's willingness to use " 718 "disassemble-next-line is %s.\n"), 719 value); 720 } 721 722 /* Use TRY_CATCH to catch the exception from the gdb_disassembly 723 because it will be broken by filter sometime. */ 724 725 static void 726 do_gdb_disassembly (struct gdbarch *gdbarch, 727 int how_many, CORE_ADDR low, CORE_ADDR high) 728 { 729 volatile struct gdb_exception exception; 730 731 TRY_CATCH (exception, RETURN_MASK_ERROR) 732 { 733 gdb_disassembly (gdbarch, current_uiout, 0, 734 DISASSEMBLY_RAW_INSN, how_many, 735 low, high); 736 } 737 if (exception.reason < 0) 738 { 739 /* If an exception was thrown while doing the disassembly, print 740 the error message, to give the user a clue of what happened. */ 741 exception_print (gdb_stderr, exception); 742 } 743 } 744 745 /* Print information about frame FRAME. The output is format according 746 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of 747 PRINT_WHAT is: 748 749 SRC_LINE: Print only source line. 750 LOCATION: Print only location. 751 LOC_AND_SRC: Print location and source line. 752 753 Used in "where" output, and to emit breakpoint or step 754 messages. */ 755 756 void 757 print_frame_info (struct frame_info *frame, int print_level, 758 enum print_what print_what, int print_args) 759 { 760 struct gdbarch *gdbarch = get_frame_arch (frame); 761 struct symtab_and_line sal; 762 int source_print; 763 int location_print; 764 struct ui_out *uiout = current_uiout; 765 766 if (get_frame_type (frame) == DUMMY_FRAME 767 || get_frame_type (frame) == SIGTRAMP_FRAME 768 || get_frame_type (frame) == ARCH_FRAME) 769 { 770 struct cleanup *uiout_cleanup 771 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); 772 773 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 774 gdbarch, get_frame_pc (frame)); 775 776 /* Do this regardless of SOURCE because we don't have any source 777 to list for this frame. */ 778 if (print_level) 779 { 780 ui_out_text (uiout, "#"); 781 ui_out_field_fmt_int (uiout, 2, ui_left, "level", 782 frame_relative_level (frame)); 783 } 784 if (ui_out_is_mi_like_p (uiout)) 785 { 786 annotate_frame_address (); 787 ui_out_field_core_addr (uiout, "addr", 788 gdbarch, get_frame_pc (frame)); 789 annotate_frame_address_end (); 790 } 791 792 if (get_frame_type (frame) == DUMMY_FRAME) 793 { 794 annotate_function_call (); 795 ui_out_field_string (uiout, "func", "<function called from gdb>"); 796 } 797 else if (get_frame_type (frame) == SIGTRAMP_FRAME) 798 { 799 annotate_signal_handler_caller (); 800 ui_out_field_string (uiout, "func", "<signal handler called>"); 801 } 802 else if (get_frame_type (frame) == ARCH_FRAME) 803 { 804 ui_out_field_string (uiout, "func", "<cross-architecture call>"); 805 } 806 ui_out_text (uiout, "\n"); 807 annotate_frame_end (); 808 809 do_cleanups (uiout_cleanup); 810 return; 811 } 812 813 /* If FRAME is not the innermost frame, that normally means that 814 FRAME->pc points to *after* the call instruction, and we want to 815 get the line containing the call, never the next line. But if 816 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the 817 next frame was not entered as the result of a call, and we want 818 to get the line containing FRAME->pc. */ 819 find_frame_sal (frame, &sal); 820 821 location_print = (print_what == LOCATION 822 || print_what == LOC_AND_ADDRESS 823 || print_what == SRC_AND_LOC); 824 825 if (location_print || !sal.symtab) 826 print_frame (frame, print_level, print_what, print_args, sal); 827 828 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC); 829 830 /* If disassemble-next-line is set to auto or on and doesn't have 831 the line debug messages for $pc, output the next instruction. */ 832 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO 833 || disassemble_next_line == AUTO_BOOLEAN_TRUE) 834 && source_print && !sal.symtab) 835 do_gdb_disassembly (get_frame_arch (frame), 1, 836 get_frame_pc (frame), get_frame_pc (frame) + 1); 837 838 if (source_print && sal.symtab) 839 { 840 int done = 0; 841 int mid_statement = ((print_what == SRC_LINE) 842 && frame_show_address (frame, sal)); 843 844 if (annotation_level) 845 done = identify_source_line (sal.symtab, sal.line, mid_statement, 846 get_frame_pc (frame)); 847 if (!done) 848 { 849 if (deprecated_print_frame_info_listing_hook) 850 deprecated_print_frame_info_listing_hook (sal.symtab, 851 sal.line, 852 sal.line + 1, 0); 853 else 854 { 855 struct value_print_options opts; 856 857 get_user_print_options (&opts); 858 /* We used to do this earlier, but that is clearly 859 wrong. This function is used by many different 860 parts of gdb, including normal_stop in infrun.c, 861 which uses this to print out the current PC 862 when we stepi/nexti into the middle of a source 863 line. Only the command line really wants this 864 behavior. Other UIs probably would like the 865 ability to decide for themselves if it is desired. */ 866 if (opts.addressprint && mid_statement) 867 { 868 ui_out_field_core_addr (uiout, "addr", 869 gdbarch, get_frame_pc (frame)); 870 ui_out_text (uiout, "\t"); 871 } 872 873 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); 874 } 875 } 876 877 /* If disassemble-next-line is set to on and there is line debug 878 messages, output assembly codes for next line. */ 879 if (disassemble_next_line == AUTO_BOOLEAN_TRUE) 880 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end); 881 } 882 883 if (print_what != LOCATION) 884 { 885 CORE_ADDR pc; 886 887 if (get_frame_pc_if_available (frame, &pc)) 888 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line); 889 else 890 set_last_displayed_sal (0, 0, 0, 0, 0); 891 } 892 893 annotate_frame_end (); 894 895 gdb_flush (gdb_stdout); 896 } 897 898 /* Remember the last symtab and line we displayed, which we use e.g. 899 * as the place to put a breakpoint when the `break' command is 900 * invoked with no arguments. */ 901 902 static void 903 set_last_displayed_sal (int valid, struct program_space *pspace, 904 CORE_ADDR addr, struct symtab *symtab, 905 int line) 906 { 907 last_displayed_sal_valid = valid; 908 last_displayed_pspace = pspace; 909 last_displayed_addr = addr; 910 last_displayed_symtab = symtab; 911 last_displayed_line = line; 912 } 913 914 /* Forget the last sal we displayed. */ 915 916 void 917 clear_last_displayed_sal (void) 918 { 919 last_displayed_sal_valid = 0; 920 last_displayed_pspace = 0; 921 last_displayed_addr = 0; 922 last_displayed_symtab = 0; 923 last_displayed_line = 0; 924 } 925 926 /* Is our record of the last sal we displayed valid? If not, 927 * the get_last_displayed_* functions will return NULL or 0, as 928 * appropriate. */ 929 930 int 931 last_displayed_sal_is_valid (void) 932 { 933 return last_displayed_sal_valid; 934 } 935 936 /* Get the pspace of the last sal we displayed, if it's valid. */ 937 938 struct program_space * 939 get_last_displayed_pspace (void) 940 { 941 if (last_displayed_sal_valid) 942 return last_displayed_pspace; 943 return 0; 944 } 945 946 /* Get the address of the last sal we displayed, if it's valid. */ 947 948 CORE_ADDR 949 get_last_displayed_addr (void) 950 { 951 if (last_displayed_sal_valid) 952 return last_displayed_addr; 953 return 0; 954 } 955 956 /* Get the symtab of the last sal we displayed, if it's valid. */ 957 958 struct symtab* 959 get_last_displayed_symtab (void) 960 { 961 if (last_displayed_sal_valid) 962 return last_displayed_symtab; 963 return 0; 964 } 965 966 /* Get the line of the last sal we displayed, if it's valid. */ 967 968 int 969 get_last_displayed_line (void) 970 { 971 if (last_displayed_sal_valid) 972 return last_displayed_line; 973 return 0; 974 } 975 976 /* Get the last sal we displayed, if it's valid. */ 977 978 void 979 get_last_displayed_sal (struct symtab_and_line *sal) 980 { 981 if (last_displayed_sal_valid) 982 { 983 sal->pspace = last_displayed_pspace; 984 sal->pc = last_displayed_addr; 985 sal->symtab = last_displayed_symtab; 986 sal->line = last_displayed_line; 987 } 988 else 989 { 990 sal->pspace = 0; 991 sal->pc = 0; 992 sal->symtab = 0; 993 sal->line = 0; 994 } 995 } 996 997 998 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function 999 corresponding to FRAME. */ 1000 1001 void 1002 find_frame_funname (struct frame_info *frame, char **funname, 1003 enum language *funlang, struct symbol **funcp) 1004 { 1005 struct symbol *func; 1006 1007 *funname = NULL; 1008 *funlang = language_unknown; 1009 if (funcp) 1010 *funcp = NULL; 1011 1012 func = get_frame_function (frame); 1013 if (func) 1014 { 1015 /* In certain pathological cases, the symtabs give the wrong 1016 function (when we are in the first function in a file which 1017 is compiled without debugging symbols, the previous function 1018 is compiled with debugging symbols, and the "foo.o" symbol 1019 that is supposed to tell us where the file with debugging 1020 symbols ends has been truncated by ar because it is longer 1021 than 15 characters). This also occurs if the user uses asm() 1022 to create a function but not stabs for it (in a file compiled 1023 with -g). 1024 1025 So look in the minimal symbol tables as well, and if it comes 1026 up with a larger address for the function use that instead. 1027 I don't think this can ever cause any problems; there 1028 shouldn't be any minimal symbols in the middle of a function; 1029 if this is ever changed many parts of GDB will need to be 1030 changed (and we'll create a find_pc_minimal_function or some 1031 such). */ 1032 1033 struct minimal_symbol *msymbol = NULL; 1034 1035 /* Don't attempt to do this for inlined functions, which do not 1036 have a corresponding minimal symbol. */ 1037 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func))) 1038 msymbol 1039 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); 1040 1041 if (msymbol != NULL 1042 && (SYMBOL_VALUE_ADDRESS (msymbol) 1043 > BLOCK_START (SYMBOL_BLOCK_VALUE (func)))) 1044 { 1045 /* We also don't know anything about the function besides 1046 its address and name. */ 1047 func = 0; 1048 *funname = SYMBOL_PRINT_NAME (msymbol); 1049 *funlang = SYMBOL_LANGUAGE (msymbol); 1050 } 1051 else 1052 { 1053 *funname = SYMBOL_PRINT_NAME (func); 1054 *funlang = SYMBOL_LANGUAGE (func); 1055 if (funcp) 1056 *funcp = func; 1057 if (*funlang == language_cplus) 1058 { 1059 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, 1060 to display the demangled name that we already have 1061 stored in the symbol table, but we stored a version 1062 with DMGL_PARAMS turned on, and here we don't want to 1063 display parameters. So remove the parameters. */ 1064 char *func_only = cp_remove_params (*funname); 1065 1066 if (func_only) 1067 { 1068 *funname = func_only; 1069 make_cleanup (xfree, func_only); 1070 } 1071 } 1072 } 1073 } 1074 else 1075 { 1076 struct minimal_symbol *msymbol; 1077 CORE_ADDR pc; 1078 1079 if (!get_frame_address_in_block_if_available (frame, &pc)) 1080 return; 1081 1082 msymbol = lookup_minimal_symbol_by_pc (pc); 1083 if (msymbol != NULL) 1084 { 1085 *funname = SYMBOL_PRINT_NAME (msymbol); 1086 *funlang = SYMBOL_LANGUAGE (msymbol); 1087 } 1088 } 1089 } 1090 1091 static void 1092 print_frame (struct frame_info *frame, int print_level, 1093 enum print_what print_what, int print_args, 1094 struct symtab_and_line sal) 1095 { 1096 struct gdbarch *gdbarch = get_frame_arch (frame); 1097 struct ui_out *uiout = current_uiout; 1098 char *funname = NULL; 1099 enum language funlang = language_unknown; 1100 struct ui_stream *stb; 1101 struct cleanup *old_chain, *list_chain; 1102 struct value_print_options opts; 1103 struct symbol *func; 1104 CORE_ADDR pc = 0; 1105 int pc_p; 1106 1107 pc_p = get_frame_pc_if_available (frame, &pc); 1108 1109 stb = ui_out_stream_new (uiout); 1110 old_chain = make_cleanup_ui_out_stream_delete (stb); 1111 1112 find_frame_funname (frame, &funname, &funlang, &func); 1113 1114 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, 1115 gdbarch, pc); 1116 1117 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); 1118 1119 if (print_level) 1120 { 1121 ui_out_text (uiout, "#"); 1122 ui_out_field_fmt_int (uiout, 2, ui_left, "level", 1123 frame_relative_level (frame)); 1124 } 1125 get_user_print_options (&opts); 1126 if (opts.addressprint) 1127 if (!sal.symtab 1128 || frame_show_address (frame, sal) 1129 || print_what == LOC_AND_ADDRESS) 1130 { 1131 annotate_frame_address (); 1132 if (pc_p) 1133 ui_out_field_core_addr (uiout, "addr", gdbarch, pc); 1134 else 1135 ui_out_field_string (uiout, "addr", "<unavailable>"); 1136 annotate_frame_address_end (); 1137 ui_out_text (uiout, " in "); 1138 } 1139 annotate_frame_function_name (); 1140 fprintf_symbol_filtered (stb->stream, funname ? funname : "??", 1141 funlang, DMGL_ANSI); 1142 ui_out_field_stream (uiout, "func", stb); 1143 ui_out_wrap_hint (uiout, " "); 1144 annotate_frame_args (); 1145 1146 ui_out_text (uiout, " ("); 1147 if (print_args) 1148 { 1149 struct gdbarch *gdbarch = get_frame_arch (frame); 1150 int numargs; 1151 struct cleanup *args_list_chain; 1152 volatile struct gdb_exception e; 1153 1154 if (gdbarch_frame_num_args_p (gdbarch)) 1155 { 1156 numargs = gdbarch_frame_num_args (gdbarch, frame); 1157 gdb_assert (numargs >= 0); 1158 } 1159 else 1160 numargs = -1; 1161 1162 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); 1163 TRY_CATCH (e, RETURN_MASK_ERROR) 1164 { 1165 print_frame_args (func, frame, numargs, gdb_stdout); 1166 } 1167 /* FIXME: ARGS must be a list. If one argument is a string it 1168 will have " that will not be properly escaped. */ 1169 /* Invoke ui_out_tuple_end. */ 1170 do_cleanups (args_list_chain); 1171 QUIT; 1172 } 1173 ui_out_text (uiout, ")"); 1174 if (sal.symtab && sal.symtab->filename) 1175 { 1176 annotate_frame_source_begin (); 1177 ui_out_wrap_hint (uiout, " "); 1178 ui_out_text (uiout, " at "); 1179 annotate_frame_source_file (); 1180 ui_out_field_string (uiout, "file", sal.symtab->filename); 1181 if (ui_out_is_mi_like_p (uiout)) 1182 { 1183 const char *fullname = symtab_to_fullname (sal.symtab); 1184 1185 if (fullname != NULL) 1186 ui_out_field_string (uiout, "fullname", fullname); 1187 } 1188 annotate_frame_source_file_end (); 1189 ui_out_text (uiout, ":"); 1190 annotate_frame_source_line (); 1191 ui_out_field_int (uiout, "line", sal.line); 1192 annotate_frame_source_end (); 1193 } 1194 1195 if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename))) 1196 { 1197 #ifdef PC_SOLIB 1198 char *lib = PC_SOLIB (get_frame_pc (frame)); 1199 #else 1200 char *lib = solib_name_from_address (get_frame_program_space (frame), 1201 get_frame_pc (frame)); 1202 #endif 1203 if (lib) 1204 { 1205 annotate_frame_where (); 1206 ui_out_wrap_hint (uiout, " "); 1207 ui_out_text (uiout, " from "); 1208 ui_out_field_string (uiout, "from", lib); 1209 } 1210 } 1211 1212 /* do_cleanups will call ui_out_tuple_end() for us. */ 1213 do_cleanups (list_chain); 1214 ui_out_text (uiout, "\n"); 1215 do_cleanups (old_chain); 1216 } 1217 1218 1219 /* Read a frame specification in whatever the appropriate format is 1220 from FRAME_EXP. Call error(), printing MESSAGE, if the 1221 specification is in any way invalid (so this function never returns 1222 NULL). When SEPECTED_P is non-NULL set its target to indicate that 1223 the default selected frame was used. */ 1224 1225 static struct frame_info * 1226 parse_frame_specification_1 (const char *frame_exp, const char *message, 1227 int *selected_frame_p) 1228 { 1229 int numargs; 1230 struct value *args[4]; 1231 CORE_ADDR addrs[ARRAY_SIZE (args)]; 1232 1233 if (frame_exp == NULL) 1234 numargs = 0; 1235 else 1236 { 1237 numargs = 0; 1238 while (1) 1239 { 1240 char *addr_string; 1241 struct cleanup *cleanup; 1242 const char *p; 1243 1244 /* Skip leading white space, bail of EOL. */ 1245 while (isspace (*frame_exp)) 1246 frame_exp++; 1247 if (!*frame_exp) 1248 break; 1249 1250 /* Parse the argument, extract it, save it. */ 1251 for (p = frame_exp; 1252 *p && !isspace (*p); 1253 p++); 1254 addr_string = savestring (frame_exp, p - frame_exp); 1255 frame_exp = p; 1256 cleanup = make_cleanup (xfree, addr_string); 1257 1258 /* NOTE: Parse and evaluate expression, but do not use 1259 functions such as parse_and_eval_long or 1260 parse_and_eval_address to also extract the value. 1261 Instead value_as_long and value_as_address are used. 1262 This avoids problems with expressions that contain 1263 side-effects. */ 1264 if (numargs >= ARRAY_SIZE (args)) 1265 error (_("Too many args in frame specification")); 1266 args[numargs++] = parse_and_eval (addr_string); 1267 1268 do_cleanups (cleanup); 1269 } 1270 } 1271 1272 /* If no args, default to the selected frame. */ 1273 if (numargs == 0) 1274 { 1275 if (selected_frame_p != NULL) 1276 (*selected_frame_p) = 1; 1277 return get_selected_frame (message); 1278 } 1279 1280 /* None of the remaining use the selected frame. */ 1281 if (selected_frame_p != NULL) 1282 (*selected_frame_p) = 0; 1283 1284 /* Assume the single arg[0] is an integer, and try using that to 1285 select a frame relative to current. */ 1286 if (numargs == 1) 1287 { 1288 struct frame_info *fid; 1289 int level = value_as_long (args[0]); 1290 1291 fid = find_relative_frame (get_current_frame (), &level); 1292 if (level == 0) 1293 /* find_relative_frame was successful. */ 1294 return fid; 1295 } 1296 1297 /* Convert each value into a corresponding address. */ 1298 { 1299 int i; 1300 1301 for (i = 0; i < numargs; i++) 1302 addrs[i] = value_as_address (args[i]); 1303 } 1304 1305 /* Assume that the single arg[0] is an address, use that to identify 1306 a frame with a matching ID. Should this also accept stack/pc or 1307 stack/pc/special. */ 1308 if (numargs == 1) 1309 { 1310 struct frame_id id = frame_id_build_wild (addrs[0]); 1311 struct frame_info *fid; 1312 1313 /* If (s)he specifies the frame with an address, he deserves 1314 what (s)he gets. Still, give the highest one that matches. 1315 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't 1316 know). */ 1317 for (fid = get_current_frame (); 1318 fid != NULL; 1319 fid = get_prev_frame (fid)) 1320 { 1321 if (frame_id_eq (id, get_frame_id (fid))) 1322 { 1323 struct frame_info *prev_frame; 1324 1325 while (1) 1326 { 1327 prev_frame = get_prev_frame (fid); 1328 if (!prev_frame 1329 || !frame_id_eq (id, get_frame_id (prev_frame))) 1330 break; 1331 fid = prev_frame; 1332 } 1333 return fid; 1334 } 1335 } 1336 } 1337 1338 /* We couldn't identify the frame as an existing frame, but 1339 perhaps we can create one with a single argument. */ 1340 if (numargs == 1) 1341 return create_new_frame (addrs[0], 0); 1342 else if (numargs == 2) 1343 return create_new_frame (addrs[0], addrs[1]); 1344 else 1345 error (_("Too many args in frame specification")); 1346 } 1347 1348 static struct frame_info * 1349 parse_frame_specification (char *frame_exp) 1350 { 1351 return parse_frame_specification_1 (frame_exp, NULL, NULL); 1352 } 1353 1354 /* Print verbosely the selected frame or the frame at address 1355 ADDR_EXP. Absolutely all information in the frame is printed. */ 1356 1357 static void 1358 frame_info (char *addr_exp, int from_tty) 1359 { 1360 struct frame_info *fi; 1361 struct symtab_and_line sal; 1362 struct symbol *func; 1363 struct symtab *s; 1364 struct frame_info *calling_frame_info; 1365 int numregs; 1366 char *funname = 0; 1367 enum language funlang = language_unknown; 1368 const char *pc_regname; 1369 int selected_frame_p; 1370 struct gdbarch *gdbarch; 1371 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 1372 CORE_ADDR frame_pc; 1373 int frame_pc_p; 1374 CORE_ADDR caller_pc; 1375 1376 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p); 1377 gdbarch = get_frame_arch (fi); 1378 1379 /* Name of the value returned by get_frame_pc(). Per comments, "pc" 1380 is not a good name. */ 1381 if (gdbarch_pc_regnum (gdbarch) >= 0) 1382 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can 1383 easily not match that of the internal value returned by 1384 get_frame_pc(). */ 1385 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch)); 1386 else 1387 /* But then, this is weird to. Even without gdbarch_pc_regnum, an 1388 architectures will often have a hardware register called "pc", 1389 and that register's value, again, can easily not match 1390 get_frame_pc(). */ 1391 pc_regname = "pc"; 1392 1393 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc); 1394 find_frame_sal (fi, &sal); 1395 func = get_frame_function (fi); 1396 s = sal.symtab; 1397 if (func) 1398 { 1399 funname = SYMBOL_PRINT_NAME (func); 1400 funlang = SYMBOL_LANGUAGE (func); 1401 if (funlang == language_cplus) 1402 { 1403 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, 1404 to display the demangled name that we already have 1405 stored in the symbol table, but we stored a version 1406 with DMGL_PARAMS turned on, and here we don't want to 1407 display parameters. So remove the parameters. */ 1408 char *func_only = cp_remove_params (funname); 1409 1410 if (func_only) 1411 { 1412 funname = func_only; 1413 make_cleanup (xfree, func_only); 1414 } 1415 } 1416 } 1417 else if (frame_pc_p) 1418 { 1419 struct minimal_symbol *msymbol; 1420 1421 msymbol = lookup_minimal_symbol_by_pc (frame_pc); 1422 if (msymbol != NULL) 1423 { 1424 funname = SYMBOL_PRINT_NAME (msymbol); 1425 funlang = SYMBOL_LANGUAGE (msymbol); 1426 } 1427 } 1428 calling_frame_info = get_prev_frame (fi); 1429 1430 if (selected_frame_p && frame_relative_level (fi) >= 0) 1431 { 1432 printf_filtered (_("Stack level %d, frame at "), 1433 frame_relative_level (fi)); 1434 } 1435 else 1436 { 1437 printf_filtered (_("Stack frame at ")); 1438 } 1439 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout); 1440 printf_filtered (":\n"); 1441 printf_filtered (" %s = ", pc_regname); 1442 if (frame_pc_p) 1443 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); 1444 else 1445 fputs_filtered ("<unavailable>", gdb_stdout); 1446 1447 wrap_here (" "); 1448 if (funname) 1449 { 1450 printf_filtered (" in "); 1451 fprintf_symbol_filtered (gdb_stdout, funname, funlang, 1452 DMGL_ANSI | DMGL_PARAMS); 1453 } 1454 wrap_here (" "); 1455 if (sal.symtab) 1456 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line); 1457 puts_filtered ("; "); 1458 wrap_here (" "); 1459 printf_filtered ("saved %s ", pc_regname); 1460 if (frame_unwind_caller_pc_if_available (fi, &caller_pc)) 1461 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); 1462 else 1463 fputs_filtered ("<unavailable>", gdb_stdout); 1464 printf_filtered ("\n"); 1465 1466 if (calling_frame_info == NULL) 1467 { 1468 enum unwind_stop_reason reason; 1469 1470 reason = get_frame_unwind_stop_reason (fi); 1471 if (reason != UNWIND_NO_REASON) 1472 printf_filtered (_(" Outermost frame: %s\n"), 1473 frame_stop_reason_string (reason)); 1474 } 1475 else if (get_frame_type (fi) == TAILCALL_FRAME) 1476 puts_filtered (" tail call frame"); 1477 else if (get_frame_type (fi) == INLINE_FRAME) 1478 printf_filtered (" inlined into frame %d", 1479 frame_relative_level (get_prev_frame (fi))); 1480 else 1481 { 1482 printf_filtered (" called by frame at "); 1483 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)), 1484 gdb_stdout); 1485 } 1486 if (get_next_frame (fi) && calling_frame_info) 1487 puts_filtered (","); 1488 wrap_here (" "); 1489 if (get_next_frame (fi)) 1490 { 1491 printf_filtered (" caller of frame at "); 1492 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))), 1493 gdb_stdout); 1494 } 1495 if (get_next_frame (fi) || calling_frame_info) 1496 puts_filtered ("\n"); 1497 1498 if (s) 1499 printf_filtered (" source language %s.\n", 1500 language_str (s->language)); 1501 1502 { 1503 /* Address of the argument list for this frame, or 0. */ 1504 CORE_ADDR arg_list = get_frame_args_address (fi); 1505 /* Number of args for this frame, or -1 if unknown. */ 1506 int numargs; 1507 1508 if (arg_list == 0) 1509 printf_filtered (" Arglist at unknown address.\n"); 1510 else 1511 { 1512 printf_filtered (" Arglist at "); 1513 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1514 printf_filtered (","); 1515 1516 if (!gdbarch_frame_num_args_p (gdbarch)) 1517 { 1518 numargs = -1; 1519 puts_filtered (" args: "); 1520 } 1521 else 1522 { 1523 numargs = gdbarch_frame_num_args (gdbarch, fi); 1524 gdb_assert (numargs >= 0); 1525 if (numargs == 0) 1526 puts_filtered (" no args."); 1527 else if (numargs == 1) 1528 puts_filtered (" 1 arg: "); 1529 else 1530 printf_filtered (" %d args: ", numargs); 1531 } 1532 print_frame_args (func, fi, numargs, gdb_stdout); 1533 puts_filtered ("\n"); 1534 } 1535 } 1536 { 1537 /* Address of the local variables for this frame, or 0. */ 1538 CORE_ADDR arg_list = get_frame_locals_address (fi); 1539 1540 if (arg_list == 0) 1541 printf_filtered (" Locals at unknown address,"); 1542 else 1543 { 1544 printf_filtered (" Locals at "); 1545 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); 1546 printf_filtered (","); 1547 } 1548 } 1549 1550 /* Print as much information as possible on the location of all the 1551 registers. */ 1552 { 1553 enum lval_type lval; 1554 int optimized; 1555 int unavailable; 1556 CORE_ADDR addr; 1557 int realnum; 1558 int count; 1559 int i; 1560 int need_nl = 1; 1561 1562 /* The sp is special; what's displayed isn't the save address, but 1563 the value of the previous frame's sp. This is a legacy thing, 1564 at one stage the frame cached the previous frame's SP instead 1565 of its address, hence it was easiest to just display the cached 1566 value. */ 1567 if (gdbarch_sp_regnum (gdbarch) >= 0) 1568 { 1569 /* Find out the location of the saved stack pointer with out 1570 actually evaluating it. */ 1571 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), 1572 &optimized, &unavailable, &lval, &addr, 1573 &realnum, NULL); 1574 if (!optimized && !unavailable && lval == not_lval) 1575 { 1576 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 1577 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch)); 1578 gdb_byte value[MAX_REGISTER_SIZE]; 1579 CORE_ADDR sp; 1580 1581 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), 1582 &optimized, &unavailable, &lval, &addr, 1583 &realnum, value); 1584 /* NOTE: cagney/2003-05-22: This is assuming that the 1585 stack pointer was packed as an unsigned integer. That 1586 may or may not be valid. */ 1587 sp = extract_unsigned_integer (value, sp_size, byte_order); 1588 printf_filtered (" Previous frame's sp is "); 1589 fputs_filtered (paddress (gdbarch, sp), gdb_stdout); 1590 printf_filtered ("\n"); 1591 need_nl = 0; 1592 } 1593 else if (!optimized && !unavailable && lval == lval_memory) 1594 { 1595 printf_filtered (" Previous frame's sp at "); 1596 fputs_filtered (paddress (gdbarch, addr), gdb_stdout); 1597 printf_filtered ("\n"); 1598 need_nl = 0; 1599 } 1600 else if (!optimized && !unavailable && lval == lval_register) 1601 { 1602 printf_filtered (" Previous frame's sp in %s\n", 1603 gdbarch_register_name (gdbarch, realnum)); 1604 need_nl = 0; 1605 } 1606 /* else keep quiet. */ 1607 } 1608 1609 count = 0; 1610 numregs = gdbarch_num_regs (gdbarch) 1611 + gdbarch_num_pseudo_regs (gdbarch); 1612 for (i = 0; i < numregs; i++) 1613 if (i != gdbarch_sp_regnum (gdbarch) 1614 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup)) 1615 { 1616 /* Find out the location of the saved register without 1617 fetching the corresponding value. */ 1618 frame_register_unwind (fi, i, &optimized, &unavailable, 1619 &lval, &addr, &realnum, NULL); 1620 /* For moment, only display registers that were saved on the 1621 stack. */ 1622 if (!optimized && !unavailable && lval == lval_memory) 1623 { 1624 if (count == 0) 1625 puts_filtered (" Saved registers:\n "); 1626 else 1627 puts_filtered (","); 1628 wrap_here (" "); 1629 printf_filtered (" %s at ", 1630 gdbarch_register_name (gdbarch, i)); 1631 fputs_filtered (paddress (gdbarch, addr), gdb_stdout); 1632 count++; 1633 } 1634 } 1635 if (count || need_nl) 1636 puts_filtered ("\n"); 1637 } 1638 1639 do_cleanups (back_to); 1640 } 1641 1642 /* Print briefly all stack frames or just the innermost COUNT_EXP 1643 frames. */ 1644 1645 static void 1646 backtrace_command_1 (char *count_exp, int show_locals, int from_tty) 1647 { 1648 struct frame_info *fi; 1649 int count; 1650 int i; 1651 struct frame_info *trailing; 1652 int trailing_level; 1653 1654 if (!target_has_stack) 1655 error (_("No stack.")); 1656 1657 /* The following code must do two things. First, it must set the 1658 variable TRAILING to the frame from which we should start 1659 printing. Second, it must set the variable count to the number 1660 of frames which we should print, or -1 if all of them. */ 1661 trailing = get_current_frame (); 1662 1663 trailing_level = 0; 1664 if (count_exp) 1665 { 1666 count = parse_and_eval_long (count_exp); 1667 if (count < 0) 1668 { 1669 struct frame_info *current; 1670 1671 count = -count; 1672 1673 current = trailing; 1674 while (current && count--) 1675 { 1676 QUIT; 1677 current = get_prev_frame (current); 1678 } 1679 1680 /* Will stop when CURRENT reaches the top of the stack. 1681 TRAILING will be COUNT below it. */ 1682 while (current) 1683 { 1684 QUIT; 1685 trailing = get_prev_frame (trailing); 1686 current = get_prev_frame (current); 1687 trailing_level++; 1688 } 1689 1690 count = -1; 1691 } 1692 } 1693 else 1694 count = -1; 1695 1696 if (info_verbose) 1697 { 1698 /* Read in symbols for all of the frames. Need to do this in a 1699 separate pass so that "Reading in symbols for xxx" messages 1700 don't screw up the appearance of the backtrace. Also if 1701 people have strong opinions against reading symbols for 1702 backtrace this may have to be an option. */ 1703 i = count; 1704 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi)) 1705 { 1706 CORE_ADDR pc; 1707 1708 QUIT; 1709 pc = get_frame_address_in_block (fi); 1710 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc)); 1711 } 1712 } 1713 1714 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi)) 1715 { 1716 QUIT; 1717 1718 /* Don't use print_stack_frame; if an error() occurs it probably 1719 means further attempts to backtrace would fail (on the other 1720 hand, perhaps the code does or could be fixed to make sure 1721 the frame->prev field gets set to NULL in that case). */ 1722 print_frame_info (fi, 1, LOCATION, 1); 1723 if (show_locals) 1724 print_frame_local_vars (fi, 1, gdb_stdout); 1725 1726 /* Save the last frame to check for error conditions. */ 1727 trailing = fi; 1728 } 1729 1730 /* If we've stopped before the end, mention that. */ 1731 if (fi && from_tty) 1732 printf_filtered (_("(More stack frames follow...)\n")); 1733 1734 /* If we've run out of frames, and the reason appears to be an error 1735 condition, print it. */ 1736 if (fi == NULL && trailing != NULL) 1737 { 1738 enum unwind_stop_reason reason; 1739 1740 reason = get_frame_unwind_stop_reason (trailing); 1741 if (reason >= UNWIND_FIRST_ERROR) 1742 printf_filtered (_("Backtrace stopped: %s\n"), 1743 frame_stop_reason_string (reason)); 1744 } 1745 } 1746 1747 static void 1748 backtrace_command (char *arg, int from_tty) 1749 { 1750 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 1751 int fulltrace_arg = -1, arglen = 0, argc = 0; 1752 1753 if (arg) 1754 { 1755 char **argv; 1756 int i; 1757 1758 argv = gdb_buildargv (arg); 1759 make_cleanup_freeargv (argv); 1760 argc = 0; 1761 for (i = 0; argv[i]; i++) 1762 { 1763 unsigned int j; 1764 1765 for (j = 0; j < strlen (argv[i]); j++) 1766 argv[i][j] = tolower (argv[i][j]); 1767 1768 if (fulltrace_arg < 0 && subset_compare (argv[i], "full")) 1769 fulltrace_arg = argc; 1770 else 1771 { 1772 arglen += strlen (argv[i]); 1773 argc++; 1774 } 1775 } 1776 arglen += argc; 1777 if (fulltrace_arg >= 0) 1778 { 1779 if (arglen > 0) 1780 { 1781 arg = xmalloc (arglen + 1); 1782 make_cleanup (xfree, arg); 1783 arg[0] = 0; 1784 for (i = 0; i < (argc + 1); i++) 1785 { 1786 if (i != fulltrace_arg) 1787 { 1788 strcat (arg, argv[i]); 1789 strcat (arg, " "); 1790 } 1791 } 1792 } 1793 else 1794 arg = NULL; 1795 } 1796 } 1797 1798 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty); 1799 1800 do_cleanups (old_chain); 1801 } 1802 1803 static void 1804 backtrace_full_command (char *arg, int from_tty) 1805 { 1806 backtrace_command_1 (arg, 1 /* show_locals */, from_tty); 1807 } 1808 1809 1810 /* Iterate over the local variables of a block B, calling CB with 1811 CB_DATA. */ 1812 1813 static void 1814 iterate_over_block_locals (struct block *b, 1815 iterate_over_block_arg_local_vars_cb cb, 1816 void *cb_data) 1817 { 1818 struct dict_iterator iter; 1819 struct symbol *sym; 1820 1821 ALL_BLOCK_SYMBOLS (b, iter, sym) 1822 { 1823 switch (SYMBOL_CLASS (sym)) 1824 { 1825 case LOC_LOCAL: 1826 case LOC_REGISTER: 1827 case LOC_STATIC: 1828 case LOC_COMPUTED: 1829 if (SYMBOL_IS_ARGUMENT (sym)) 1830 break; 1831 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data); 1832 break; 1833 1834 default: 1835 /* Ignore symbols which are not locals. */ 1836 break; 1837 } 1838 } 1839 } 1840 1841 1842 /* Same, but print labels. */ 1843 1844 #if 0 1845 /* Commented out, as the code using this function has also been 1846 commented out. FIXME:brobecker/2009-01-13: Find out why the code 1847 was commented out in the first place. The discussion introducing 1848 this change (2007-12-04: Support lexical blocks and function bodies 1849 that occupy non-contiguous address ranges) did not explain why 1850 this change was made. */ 1851 static int 1852 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, 1853 int *have_default, struct ui_file *stream) 1854 { 1855 struct dict_iterator iter; 1856 struct symbol *sym; 1857 int values_printed = 0; 1858 1859 ALL_BLOCK_SYMBOLS (b, iter, sym) 1860 { 1861 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0) 1862 { 1863 if (*have_default) 1864 continue; 1865 *have_default = 1; 1866 } 1867 if (SYMBOL_CLASS (sym) == LOC_LABEL) 1868 { 1869 struct symtab_and_line sal; 1870 struct value_print_options opts; 1871 1872 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0); 1873 values_printed = 1; 1874 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); 1875 get_user_print_options (&opts); 1876 if (opts.addressprint) 1877 { 1878 fprintf_filtered (stream, " "); 1879 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)), 1880 stream); 1881 } 1882 fprintf_filtered (stream, " in file %s, line %d\n", 1883 sal.symtab->filename, sal.line); 1884 } 1885 } 1886 1887 return values_printed; 1888 } 1889 #endif 1890 1891 /* Iterate over all the local variables in block B, including all its 1892 superblocks, stopping when the top-level block is reached. */ 1893 1894 void 1895 iterate_over_block_local_vars (struct block *block, 1896 iterate_over_block_arg_local_vars_cb cb, 1897 void *cb_data) 1898 { 1899 while (block) 1900 { 1901 iterate_over_block_locals (block, cb, cb_data); 1902 /* After handling the function's top-level block, stop. Don't 1903 continue to its superblock, the block of per-file 1904 symbols. */ 1905 if (BLOCK_FUNCTION (block)) 1906 break; 1907 block = BLOCK_SUPERBLOCK (block); 1908 } 1909 } 1910 1911 /* Data to be passed around in the calls to the locals and args 1912 iterators. */ 1913 1914 struct print_variable_and_value_data 1915 { 1916 struct frame_info *frame; 1917 int num_tabs; 1918 struct ui_file *stream; 1919 int values_printed; 1920 }; 1921 1922 /* The callback for the locals and args iterators. */ 1923 1924 static void 1925 do_print_variable_and_value (const char *print_name, 1926 struct symbol *sym, 1927 void *cb_data) 1928 { 1929 struct print_variable_and_value_data *p = cb_data; 1930 1931 print_variable_and_value (print_name, sym, 1932 p->frame, p->stream, p->num_tabs); 1933 p->values_printed = 1; 1934 } 1935 1936 static void 1937 print_frame_local_vars (struct frame_info *frame, int num_tabs, 1938 struct ui_file *stream) 1939 { 1940 struct print_variable_and_value_data cb_data; 1941 struct block *block; 1942 CORE_ADDR pc; 1943 1944 if (!get_frame_pc_if_available (frame, &pc)) 1945 { 1946 fprintf_filtered (stream, 1947 _("PC unavailable, cannot determine locals.\n")); 1948 return; 1949 } 1950 1951 block = get_frame_block (frame, 0); 1952 if (block == 0) 1953 { 1954 fprintf_filtered (stream, "No symbol table info available.\n"); 1955 return; 1956 } 1957 1958 cb_data.frame = frame; 1959 cb_data.num_tabs = 4 * num_tabs; 1960 cb_data.stream = stream; 1961 cb_data.values_printed = 0; 1962 1963 iterate_over_block_local_vars (block, 1964 do_print_variable_and_value, 1965 &cb_data); 1966 1967 if (!cb_data.values_printed) 1968 fprintf_filtered (stream, _("No locals.\n")); 1969 } 1970 1971 /* Same, but print labels. */ 1972 1973 static void 1974 print_frame_label_vars (struct frame_info *frame, int this_level_only, 1975 struct ui_file *stream) 1976 { 1977 #if 1 1978 fprintf_filtered (stream, "print_frame_label_vars disabled.\n"); 1979 #else 1980 struct blockvector *bl; 1981 struct block *block = get_frame_block (frame, 0); 1982 struct gdbarch *gdbarch = get_frame_arch (frame); 1983 int values_printed = 0; 1984 int index, have_default = 0; 1985 char *blocks_printed; 1986 CORE_ADDR pc = get_frame_pc (frame); 1987 1988 if (block == 0) 1989 { 1990 fprintf_filtered (stream, "No symbol table info available.\n"); 1991 return; 1992 } 1993 1994 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index); 1995 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1996 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); 1997 1998 while (block != 0) 1999 { 2000 CORE_ADDR end = BLOCK_END (block) - 4; 2001 int last_index; 2002 2003 if (bl != blockvector_for_pc (end, &index)) 2004 error (_("blockvector blotch")); 2005 if (BLOCKVECTOR_BLOCK (bl, index) != block) 2006 error (_("blockvector botch")); 2007 last_index = BLOCKVECTOR_NBLOCKS (bl); 2008 index += 1; 2009 2010 /* Don't print out blocks that have gone by. */ 2011 while (index < last_index 2012 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc) 2013 index++; 2014 2015 while (index < last_index 2016 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end) 2017 { 2018 if (blocks_printed[index] == 0) 2019 { 2020 if (print_block_frame_labels (gdbarch, 2021 BLOCKVECTOR_BLOCK (bl, index), 2022 &have_default, stream)) 2023 values_printed = 1; 2024 blocks_printed[index] = 1; 2025 } 2026 index++; 2027 } 2028 if (have_default) 2029 return; 2030 if (values_printed && this_level_only) 2031 return; 2032 2033 /* After handling the function's top-level block, stop. Don't 2034 continue to its superblock, the block of per-file symbols. 2035 Also do not continue to the containing function of an inlined 2036 function. */ 2037 if (BLOCK_FUNCTION (block)) 2038 break; 2039 block = BLOCK_SUPERBLOCK (block); 2040 } 2041 2042 if (!values_printed && !this_level_only) 2043 fprintf_filtered (stream, _("No catches.\n")); 2044 #endif 2045 } 2046 2047 void 2048 locals_info (char *args, int from_tty) 2049 { 2050 print_frame_local_vars (get_selected_frame (_("No frame selected.")), 2051 0, gdb_stdout); 2052 } 2053 2054 static void 2055 catch_info (char *ignore, int from_tty) 2056 { 2057 /* Assume g++ compiled code; old GDB 4.16 behaviour. */ 2058 print_frame_label_vars (get_selected_frame (_("No frame selected.")), 2059 0, gdb_stdout); 2060 } 2061 2062 /* Iterate over all the argument variables in block B. 2063 2064 Returns 1 if any argument was walked; 0 otherwise. */ 2065 2066 void 2067 iterate_over_block_arg_vars (struct block *b, 2068 iterate_over_block_arg_local_vars_cb cb, 2069 void *cb_data) 2070 { 2071 struct dict_iterator iter; 2072 struct symbol *sym, *sym2; 2073 2074 ALL_BLOCK_SYMBOLS (b, iter, sym) 2075 { 2076 /* Don't worry about things which aren't arguments. */ 2077 if (SYMBOL_IS_ARGUMENT (sym)) 2078 { 2079 /* We have to look up the symbol because arguments can have 2080 two entries (one a parameter, one a local) and the one we 2081 want is the local, which lookup_symbol will find for us. 2082 This includes gcc1 (not gcc2) on the sparc when passing a 2083 small structure and gcc2 when the argument type is float 2084 and it is passed as a double and converted to float by 2085 the prologue (in the latter case the type of the LOC_ARG 2086 symbol is double and the type of the LOC_LOCAL symbol is 2087 float). There are also LOC_ARG/LOC_REGISTER pairs which 2088 are not combined in symbol-reading. */ 2089 2090 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), 2091 b, VAR_DOMAIN, NULL); 2092 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data); 2093 } 2094 } 2095 } 2096 2097 static void 2098 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) 2099 { 2100 struct print_variable_and_value_data cb_data; 2101 struct symbol *func; 2102 CORE_ADDR pc; 2103 2104 if (!get_frame_pc_if_available (frame, &pc)) 2105 { 2106 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n")); 2107 return; 2108 } 2109 2110 func = get_frame_function (frame); 2111 if (func == NULL) 2112 { 2113 fprintf_filtered (stream, _("No symbol table info available.\n")); 2114 return; 2115 } 2116 2117 cb_data.frame = frame; 2118 cb_data.num_tabs = 0; 2119 cb_data.stream = gdb_stdout; 2120 cb_data.values_printed = 0; 2121 2122 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), 2123 do_print_variable_and_value, &cb_data); 2124 2125 if (!cb_data.values_printed) 2126 fprintf_filtered (stream, _("No arguments.\n")); 2127 } 2128 2129 void 2130 args_info (char *ignore, int from_tty) 2131 { 2132 print_frame_arg_vars (get_selected_frame (_("No frame selected.")), 2133 gdb_stdout); 2134 } 2135 2136 2137 static void 2138 args_plus_locals_info (char *ignore, int from_tty) 2139 { 2140 args_info (ignore, from_tty); 2141 locals_info (ignore, from_tty); 2142 } 2143 2144 2145 /* Select frame FRAME. Also print the stack frame and show the source 2146 if this is the tui version. */ 2147 static void 2148 select_and_print_frame (struct frame_info *frame) 2149 { 2150 select_frame (frame); 2151 if (frame) 2152 print_stack_frame (frame, 1, SRC_AND_LOC); 2153 } 2154 2155 /* Return the symbol-block in which the selected frame is executing. 2156 Can return zero under various legitimate circumstances. 2157 2158 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant 2159 code address within the block returned. We use this to decide 2160 which macros are in scope. */ 2161 2162 struct block * 2163 get_selected_block (CORE_ADDR *addr_in_block) 2164 { 2165 if (!has_stack_frames ()) 2166 return 0; 2167 2168 return get_frame_block (get_selected_frame (NULL), addr_in_block); 2169 } 2170 2171 /* Find a frame a certain number of levels away from FRAME. 2172 LEVEL_OFFSET_PTR points to an int containing the number of levels. 2173 Positive means go to earlier frames (up); negative, the reverse. 2174 The int that contains the number of levels is counted toward 2175 zero as the frames for those levels are found. 2176 If the top or bottom frame is reached, that frame is returned, 2177 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates 2178 how much farther the original request asked to go. */ 2179 2180 struct frame_info * 2181 find_relative_frame (struct frame_info *frame, int *level_offset_ptr) 2182 { 2183 /* Going up is simple: just call get_prev_frame enough times or 2184 until the initial frame is reached. */ 2185 while (*level_offset_ptr > 0) 2186 { 2187 struct frame_info *prev = get_prev_frame (frame); 2188 2189 if (!prev) 2190 break; 2191 (*level_offset_ptr)--; 2192 frame = prev; 2193 } 2194 2195 /* Going down is just as simple. */ 2196 while (*level_offset_ptr < 0) 2197 { 2198 struct frame_info *next = get_next_frame (frame); 2199 2200 if (!next) 2201 break; 2202 (*level_offset_ptr)++; 2203 frame = next; 2204 } 2205 2206 return frame; 2207 } 2208 2209 /* The "select_frame" command. With no argument this is a NOP. 2210 Select the frame at level LEVEL_EXP if it is a valid level. 2211 Otherwise, treat LEVEL_EXP as an address expression and select it. 2212 2213 See parse_frame_specification for more info on proper frame 2214 expressions. */ 2215 2216 void 2217 select_frame_command (char *level_exp, int from_tty) 2218 { 2219 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL)); 2220 } 2221 2222 /* The "frame" command. With no argument, print the selected frame 2223 briefly. With an argument, behave like select_frame and then print 2224 the selected frame. */ 2225 2226 static void 2227 frame_command (char *level_exp, int from_tty) 2228 { 2229 select_frame_command (level_exp, from_tty); 2230 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 2231 } 2232 2233 /* The XDB Compatibility command to print the current frame. */ 2234 2235 static void 2236 current_frame_command (char *level_exp, int from_tty) 2237 { 2238 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC); 2239 } 2240 2241 /* Select the frame up one or COUNT_EXP stack levels from the 2242 previously selected frame, and print it briefly. */ 2243 2244 static void 2245 up_silently_base (char *count_exp) 2246 { 2247 struct frame_info *frame; 2248 int count = 1; 2249 2250 if (count_exp) 2251 count = parse_and_eval_long (count_exp); 2252 2253 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 2254 if (count != 0 && count_exp == NULL) 2255 error (_("Initial frame selected; you cannot go up.")); 2256 select_frame (frame); 2257 } 2258 2259 static void 2260 up_silently_command (char *count_exp, int from_tty) 2261 { 2262 up_silently_base (count_exp); 2263 } 2264 2265 static void 2266 up_command (char *count_exp, int from_tty) 2267 { 2268 up_silently_base (count_exp); 2269 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 2270 } 2271 2272 /* Select the frame down one or COUNT_EXP stack levels from the previously 2273 selected frame, and print it briefly. */ 2274 2275 static void 2276 down_silently_base (char *count_exp) 2277 { 2278 struct frame_info *frame; 2279 int count = -1; 2280 2281 if (count_exp) 2282 count = -parse_and_eval_long (count_exp); 2283 2284 frame = find_relative_frame (get_selected_frame ("No stack."), &count); 2285 if (count != 0 && count_exp == NULL) 2286 { 2287 /* We only do this if COUNT_EXP is not specified. That way 2288 "down" means to really go down (and let me know if that is 2289 impossible), but "down 9999" can be used to mean go all the 2290 way down without getting an error. */ 2291 2292 error (_("Bottom (innermost) frame selected; you cannot go down.")); 2293 } 2294 2295 select_frame (frame); 2296 } 2297 2298 static void 2299 down_silently_command (char *count_exp, int from_tty) 2300 { 2301 down_silently_base (count_exp); 2302 } 2303 2304 static void 2305 down_command (char *count_exp, int from_tty) 2306 { 2307 down_silently_base (count_exp); 2308 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 2309 } 2310 2311 2312 void 2313 return_command (char *retval_exp, int from_tty) 2314 { 2315 struct frame_info *thisframe; 2316 struct gdbarch *gdbarch; 2317 struct symbol *thisfun; 2318 struct value *return_value = NULL; 2319 const char *query_prefix = ""; 2320 2321 thisframe = get_selected_frame ("No selected frame."); 2322 thisfun = get_frame_function (thisframe); 2323 gdbarch = get_frame_arch (thisframe); 2324 2325 if (get_frame_type (get_current_frame ()) == INLINE_FRAME) 2326 error (_("Can not force return from an inlined function.")); 2327 2328 /* Compute the return value. If the computation triggers an error, 2329 let it bail. If the return type can't be handled, set 2330 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational 2331 message. */ 2332 if (retval_exp) 2333 { 2334 struct expression *retval_expr = parse_expression (retval_exp); 2335 struct cleanup *old_chain = make_cleanup (xfree, retval_expr); 2336 struct type *return_type = NULL; 2337 2338 /* Compute the return value. Should the computation fail, this 2339 call throws an error. */ 2340 return_value = evaluate_expression (retval_expr); 2341 2342 /* Cast return value to the return type of the function. Should 2343 the cast fail, this call throws an error. */ 2344 if (thisfun != NULL) 2345 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); 2346 if (return_type == NULL) 2347 { 2348 if (retval_expr->elts[0].opcode != UNOP_CAST) 2349 error (_("Return value type not available for selected " 2350 "stack frame.\n" 2351 "Please use an explicit cast of the value to return.")); 2352 return_type = value_type (return_value); 2353 } 2354 do_cleanups (old_chain); 2355 CHECK_TYPEDEF (return_type); 2356 return_value = value_cast (return_type, return_value); 2357 2358 /* Make sure the value is fully evaluated. It may live in the 2359 stack frame we're about to pop. */ 2360 if (value_lazy (return_value)) 2361 value_fetch_lazy (return_value); 2362 2363 if (TYPE_CODE (return_type) == TYPE_CODE_VOID) 2364 /* If the return-type is "void", don't try to find the 2365 return-value's location. However, do still evaluate the 2366 return expression so that, even when the expression result 2367 is discarded, side effects such as "return i++" still 2368 occur. */ 2369 return_value = NULL; 2370 else if (thisfun != NULL 2371 && using_struct_return (gdbarch, 2372 SYMBOL_TYPE (thisfun), return_type)) 2373 { 2374 query_prefix = "The location at which to store the " 2375 "function's return value is unknown.\n" 2376 "If you continue, the return value " 2377 "that you specified will be ignored.\n"; 2378 return_value = NULL; 2379 } 2380 } 2381 2382 /* Does an interactive user really want to do this? Include 2383 information, such as how well GDB can handle the return value, in 2384 the query message. */ 2385 if (from_tty) 2386 { 2387 int confirmed; 2388 2389 if (thisfun == NULL) 2390 confirmed = query (_("%sMake selected stack frame return now? "), 2391 query_prefix); 2392 else 2393 confirmed = query (_("%sMake %s return now? "), query_prefix, 2394 SYMBOL_PRINT_NAME (thisfun)); 2395 if (!confirmed) 2396 error (_("Not confirmed")); 2397 } 2398 2399 /* Discard the selected frame and all frames inner-to it. */ 2400 frame_pop (get_selected_frame (NULL)); 2401 2402 /* Store RETURN_VALUE in the just-returned register set. */ 2403 if (return_value != NULL) 2404 { 2405 struct type *return_type = value_type (return_value); 2406 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ()); 2407 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun); 2408 2409 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL, 2410 NULL, NULL) 2411 == RETURN_VALUE_REGISTER_CONVENTION); 2412 gdbarch_return_value (gdbarch, func_type, return_type, 2413 get_current_regcache (), NULL /*read*/, 2414 value_contents (return_value) /*write*/); 2415 } 2416 2417 /* If we are at the end of a call dummy now, pop the dummy frame 2418 too. */ 2419 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME) 2420 frame_pop (get_current_frame ()); 2421 2422 /* If interactive, print the frame that is now current. */ 2423 if (from_tty) 2424 frame_command ("0", 1); 2425 else 2426 select_frame_command ("0", 0); 2427 } 2428 2429 /* Sets the scope to input function name, provided that the function 2430 is within the current stack frame. */ 2431 2432 struct function_bounds 2433 { 2434 CORE_ADDR low, high; 2435 }; 2436 2437 static void 2438 func_command (char *arg, int from_tty) 2439 { 2440 struct frame_info *frame; 2441 int found = 0; 2442 struct symtabs_and_lines sals; 2443 int i; 2444 int level = 1; 2445 struct function_bounds *func_bounds = NULL; 2446 struct cleanup *cleanups; 2447 2448 if (arg != NULL) 2449 return; 2450 2451 frame = parse_frame_specification ("0"); 2452 sals = decode_line_spec (arg, DECODE_LINE_FUNFIRSTLINE); 2453 cleanups = make_cleanup (xfree, sals.sals); 2454 func_bounds = (struct function_bounds *) xmalloc ( 2455 sizeof (struct function_bounds) * sals.nelts); 2456 make_cleanup (xfree, func_bounds); 2457 for (i = 0; (i < sals.nelts && !found); i++) 2458 { 2459 if (sals.sals[i].pspace != current_program_space) 2460 func_bounds[i].low = func_bounds[i].high = 0; 2461 else if (sals.sals[i].pc == 0 2462 || find_pc_partial_function (sals.sals[i].pc, NULL, 2463 &func_bounds[i].low, 2464 &func_bounds[i].high) == 0) 2465 { 2466 func_bounds[i].low = func_bounds[i].high = 0; 2467 } 2468 } 2469 2470 do 2471 { 2472 for (i = 0; (i < sals.nelts && !found); i++) 2473 found = (get_frame_pc (frame) >= func_bounds[i].low 2474 && get_frame_pc (frame) < func_bounds[i].high); 2475 if (!found) 2476 { 2477 level = 1; 2478 frame = find_relative_frame (frame, &level); 2479 } 2480 } 2481 while (!found && level == 0); 2482 2483 do_cleanups (cleanups); 2484 2485 if (!found) 2486 printf_filtered (_("'%s' not within current stack frame.\n"), arg); 2487 else if (frame != get_selected_frame (NULL)) 2488 select_and_print_frame (frame); 2489 } 2490 2491 /* Gets the language of the current frame. */ 2492 2493 enum language 2494 get_frame_language (void) 2495 { 2496 struct frame_info *frame = deprecated_safe_get_selected_frame (); 2497 2498 if (frame) 2499 { 2500 volatile struct gdb_exception ex; 2501 CORE_ADDR pc = 0; 2502 struct symtab *s; 2503 2504 /* We determine the current frame language by looking up its 2505 associated symtab. To retrieve this symtab, we use the frame 2506 PC. However we cannot use the frame PC as is, because it 2507 usually points to the instruction following the "call", which 2508 is sometimes the first instruction of another function. So 2509 we rely on get_frame_address_in_block(), it provides us with 2510 a PC that is guaranteed to be inside the frame's code 2511 block. */ 2512 2513 TRY_CATCH (ex, RETURN_MASK_ERROR) 2514 { 2515 pc = get_frame_address_in_block (frame); 2516 } 2517 if (ex.reason < 0) 2518 { 2519 if (ex.error != NOT_AVAILABLE_ERROR) 2520 throw_exception (ex); 2521 } 2522 else 2523 { 2524 s = find_pc_symtab (pc); 2525 if (s != NULL) 2526 return s->language; 2527 } 2528 } 2529 2530 return language_unknown; 2531 } 2532 2533 2534 /* Provide a prototype to silence -Wmissing-prototypes. */ 2535 void _initialize_stack (void); 2536 2537 void 2538 _initialize_stack (void) 2539 { 2540 add_com ("return", class_stack, return_command, _("\ 2541 Make selected stack frame return to its caller.\n\ 2542 Control remains in the debugger, but when you continue\n\ 2543 execution will resume in the frame above the one now selected.\n\ 2544 If an argument is given, it is an expression for the value to return.")); 2545 2546 add_com ("up", class_stack, up_command, _("\ 2547 Select and print stack frame that called this one.\n\ 2548 An argument says how many frames up to go.")); 2549 add_com ("up-silently", class_support, up_silently_command, _("\ 2550 Same as the `up' command, but does not print anything.\n\ 2551 This is useful in command scripts.")); 2552 2553 add_com ("down", class_stack, down_command, _("\ 2554 Select and print stack frame called by this one.\n\ 2555 An argument says how many frames down to go.")); 2556 add_com_alias ("do", "down", class_stack, 1); 2557 add_com_alias ("dow", "down", class_stack, 1); 2558 add_com ("down-silently", class_support, down_silently_command, _("\ 2559 Same as the `down' command, but does not print anything.\n\ 2560 This is useful in command scripts.")); 2561 2562 add_com ("frame", class_stack, frame_command, _("\ 2563 Select and print a stack frame.\nWith no argument, \ 2564 print the selected stack frame. (See also \"info frame\").\n\ 2565 An argument specifies the frame to select.\n\ 2566 It can be a stack frame number or the address of the frame.\n\ 2567 With argument, nothing is printed if input is coming from\n\ 2568 a command file or a user-defined command.")); 2569 2570 add_com_alias ("f", "frame", class_stack, 1); 2571 2572 if (xdb_commands) 2573 { 2574 add_com ("L", class_stack, current_frame_command, 2575 _("Print the current stack frame.\n")); 2576 add_com_alias ("V", "frame", class_stack, 1); 2577 } 2578 add_com ("select-frame", class_stack, select_frame_command, _("\ 2579 Select a stack frame without printing anything.\n\ 2580 An argument specifies the frame to select.\n\ 2581 It can be a stack frame number or the address of the frame.\n")); 2582 2583 add_com ("backtrace", class_stack, backtrace_command, _("\ 2584 Print backtrace of all stack frames, or innermost COUNT frames.\n\ 2585 With a negative argument, print outermost -COUNT frames.\nUse of the \ 2586 'full' qualifier also prints the values of the local variables.\n")); 2587 add_com_alias ("bt", "backtrace", class_stack, 0); 2588 if (xdb_commands) 2589 { 2590 add_com_alias ("t", "backtrace", class_stack, 0); 2591 add_com ("T", class_stack, backtrace_full_command, _("\ 2592 Print backtrace of all stack frames, or innermost COUNT frames\n\ 2593 and the values of the local variables.\n\ 2594 With a negative argument, print outermost -COUNT frames.\n\ 2595 Usage: T <count>\n")); 2596 } 2597 2598 add_com_alias ("where", "backtrace", class_alias, 0); 2599 add_info ("stack", backtrace_command, 2600 _("Backtrace of the stack, or innermost COUNT frames.")); 2601 add_info_alias ("s", "stack", 1); 2602 add_info ("frame", frame_info, 2603 _("All about selected stack frame, or frame at ADDR.")); 2604 add_info_alias ("f", "frame", 1); 2605 add_info ("locals", locals_info, 2606 _("Local variables of current stack frame.")); 2607 add_info ("args", args_info, 2608 _("Argument variables of current stack frame.")); 2609 if (xdb_commands) 2610 add_com ("l", class_info, args_plus_locals_info, 2611 _("Argument and local variables of current stack frame.")); 2612 2613 if (dbx_commands) 2614 add_com ("func", class_stack, func_command, _("\ 2615 Select the stack frame that contains <func>.\n\ 2616 Usage: func <name>\n")); 2617 2618 add_info ("catch", catch_info, 2619 _("Exceptions that can be caught in the current stack frame.")); 2620 2621 add_setshow_enum_cmd ("frame-arguments", class_stack, 2622 print_frame_arguments_choices, &print_frame_arguments, 2623 _("Set printing of non-scalar frame arguments"), 2624 _("Show printing of non-scalar frame arguments"), 2625 NULL, NULL, NULL, &setprintlist, &showprintlist); 2626 2627 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, 2628 &disassemble_next_line, _("\ 2629 Set whether to disassemble next source line or insn when execution stops."), 2630 _("\ 2631 Show whether to disassemble next source line or insn when execution stops."), 2632 _("\ 2633 If ON, GDB will display disassembly of the next source line, in addition\n\ 2634 to displaying the source line itself. If the next source line cannot\n\ 2635 be displayed (e.g., source is unavailable or there's no line info), GDB\n\ 2636 will display disassembly of next instruction instead of showing the\n\ 2637 source line.\n\ 2638 If AUTO, display disassembly of next instruction only if the source line\n\ 2639 cannot be displayed.\n\ 2640 If OFF (which is the default), never display the disassembly of the next\n\ 2641 source line."), 2642 NULL, 2643 show_disassemble_next_line, 2644 &setlist, &showlist); 2645 disassemble_next_line = AUTO_BOOLEAN_FALSE; 2646 2647 add_setshow_enum_cmd ("entry-values", class_stack, 2648 print_entry_values_choices, &print_entry_values, 2649 _("Set printing of function arguments at function " 2650 "entry"), 2651 _("Show printing of function arguments at function " 2652 "entry"), 2653 _("\ 2654 GDB can sometimes determine the values of function arguments at entry,\n\ 2655 in addition to their current values. This option tells GDB whether\n\ 2656 to print the current value, the value at entry (marked as val@entry),\n\ 2657 or both. Note that one or both of these values may be <optimized out>."), 2658 NULL, NULL, &setprintlist, &showprintlist); 2659 } 2660