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