![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to stack.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* Print and select stack frames for GDB, the GNU debugger. ! 2: Copyright (C) 1986, 1987 Free Software Foundation, Inc. ! 3: ! 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the GDB General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute GDB, ! 11: but only under the conditions described in the GDB General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with GDB so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, go ahead and share GDB, but don't try to stop ! 18: anyone else from sharing it farther. Help stamp out software hoarding! ! 19: */ ! 20: ! 21: #include <stdio.h> ! 22: ! 23: #include "defs.h" ! 24: #include "initialize.h" ! 25: #include "param.h" ! 26: #include "symtab.h" ! 27: #include "frame.h" ! 28: ! 29: START_FILE ! 30: ! 31: /* Thie "selected" stack frame is used by default for local and arg access. ! 32: May be zero, for no selected frame. */ ! 33: ! 34: FRAME selected_frame; ! 35: ! 36: /* Level of the selected frame: ! 37: 0 for innermost, 1 for its caller, ... ! 38: or -1 for frame specified by address with no defined level. */ ! 39: ! 40: int selected_frame_level; ! 41: ! 42: /* Nonzero means print the full filename and linenumber ! 43: when a frame is printed, and do so in a format programs can parse. */ ! 44: ! 45: int frame_file_full_name = 0; ! 46: ! 47: static void select_calling_frame (); ! 48: ! 49: void print_frame_info (); ! 50: ! 51: /* Print a stack frame briefly. FRAME should be the frame address ! 52: and LEVEL should be its level in the stack (or -1 for level not defined). ! 53: This prints the level, the function executing, the arguments, ! 54: and the file name and line number. ! 55: If the pc is not at the beginning of the source line, ! 56: the actual pc is printed at the beginning. ! 57: ! 58: If SOURCE is 1, print the source line as well. ! 59: If SOURCE is -1, print ONLY the source line. */ ! 60: ! 61: static void ! 62: print_stack_frame (frame, level, source) ! 63: FRAME frame; ! 64: int level; ! 65: int source; ! 66: { ! 67: struct frame_info fi; ! 68: ! 69: fi = get_frame_info (frame); ! 70: ! 71: print_frame_info (&fi, level, source, 1); ! 72: } ! 73: ! 74: void ! 75: print_frame_info (fi, level, source, args) ! 76: struct frame_info *fi; ! 77: register int level; ! 78: int source; ! 79: int args; ! 80: { ! 81: register FRAME frame = fi->frame; ! 82: struct symtab_and_line sal; ! 83: struct symbol *func; ! 84: register char *funname = 0; ! 85: int numargs; ! 86: ! 87: sal = find_pc_line (fi->pc, fi->next_frame); ! 88: func = get_frame_function (frame); ! 89: if (func) ! 90: funname = SYMBOL_NAME (func); ! 91: else ! 92: { ! 93: register int misc_index = find_pc_misc_function (fi->pc); ! 94: if (misc_index >= 0) ! 95: funname = misc_function_vector[misc_index].name; ! 96: } ! 97: ! 98: if (source >= 0 || !sal.symtab) ! 99: { ! 100: /* This avoids a bug in cc on the sun. */ ! 101: struct frame_info tem; ! 102: tem = *fi; ! 103: ! 104: if (level >= 0) ! 105: printf ("#%-2d ", level); ! 106: if (fi->pc != sal.pc || !sal.symtab) ! 107: printf ("0x%x in ", fi->pc); ! 108: printf ("%s (", funname ? funname : "??"); ! 109: if (args) ! 110: { ! 111: FRAME_NUM_ARGS (numargs, tem); ! 112: print_frame_args (func, FRAME_ARGS_ADDRESS (tem), numargs, stdout); ! 113: } ! 114: printf (")"); ! 115: if (sal.symtab) ! 116: printf (" (%s line %d)", sal.symtab->filename, sal.line); ! 117: printf ("\n"); ! 118: } ! 119: ! 120: if (source != 0 && sal.symtab) ! 121: { ! 122: int done = 0; ! 123: int mid_statement = source < 0 && fi->pc != sal.pc; ! 124: if (frame_file_full_name) ! 125: done = identify_source_line (sal.symtab, sal.line, mid_statement); ! 126: if (!done) ! 127: { ! 128: if (mid_statement) ! 129: printf ("0x%x\t", fi->pc); ! 130: print_source_lines (sal.symtab, sal.line, sal.line + 1, 1); ! 131: } ! 132: current_source_line = max (sal.line - 5, 1); ! 133: } ! 134: if (source != 0) ! 135: set_default_breakpoint (1, fi->pc, sal.symtab, sal.line); ! 136: ! 137: fflush (stdout); ! 138: } ! 139: ! 140: /* Call here to print info on selected frame, after a trap. */ ! 141: ! 142: void ! 143: print_sel_frame (just_source) ! 144: int just_source; ! 145: { ! 146: print_stack_frame (selected_frame, -1, just_source ? -1 : 1); ! 147: } ! 148: ! 149: /* Print info on the selected frame, including level number ! 150: but not source. */ ! 151: ! 152: print_selected_frame () ! 153: { ! 154: print_stack_frame (selected_frame, selected_frame_level, 0); ! 155: } ! 156: ! 157: /* Print verbosely the selected frame or the frame at address ADDR. ! 158: This means absolutely all information in the frame is printed. */ ! 159: ! 160: static void ! 161: frame_info (addr_exp) ! 162: char *addr_exp; ! 163: { ! 164: FRAME frame = addr_exp ? parse_and_eval_address (addr_exp) : selected_frame; ! 165: struct frame_info fi; ! 166: struct frame_saved_regs fsr; ! 167: struct symtab_and_line sal; ! 168: struct symbol *func; ! 169: FRAME calling_frame; ! 170: int i, count; ! 171: char *funname = 0; ! 172: int numargs; ! 173: ! 174: fi = get_frame_info (frame); ! 175: get_frame_saved_regs (&fi, &fsr); ! 176: sal = find_pc_line (fi.pc, fi.next_frame); ! 177: func = get_frame_function (frame); ! 178: if (func) ! 179: funname = SYMBOL_NAME (func); ! 180: else ! 181: { ! 182: register int misc_index = find_pc_misc_function (fi.pc); ! 183: if (misc_index >= 0) ! 184: funname = misc_function_vector[misc_index].name; ! 185: } ! 186: calling_frame = get_prev_frame (frame); ! 187: ! 188: if (!addr_exp && selected_frame_level >= 0) ! 189: printf ("Stack level %d, frame at 0x%x:\n pc = 0x%x", ! 190: selected_frame_level, frame, fi.pc); ! 191: else ! 192: printf ("Stack frame at 0x%x:\n pc = 0x%x", ! 193: frame, fi.pc); ! 194: ! 195: if (funname) ! 196: printf (" in %s", funname); ! 197: if (sal.symtab) ! 198: printf (" (%s line %d)", sal.symtab->filename, sal.line); ! 199: printf ("; saved pc 0x%x\n", FRAME_SAVED_PC (frame)); ! 200: if (calling_frame) ! 201: printf (" called by frame at 0x%x", calling_frame); ! 202: if (fi.next_frame && calling_frame) ! 203: printf (","); ! 204: if (fi.next_frame) ! 205: printf (" caller of frame at 0x%x", fi.next_frame); ! 206: if (fi.next_frame || calling_frame) ! 207: printf ("\n"); ! 208: printf (" Arglist at 0x%x,", FRAME_ARGS_ADDRESS (fi)); ! 209: FRAME_NUM_ARGS (i, fi); ! 210: if (i < 0) ! 211: printf (" args: "); ! 212: else if (i == 0) ! 213: printf (" no args."); ! 214: else if (i == 1) ! 215: printf (" 1 arg: "); ! 216: else ! 217: printf (" %d args: ", i); ! 218: ! 219: FRAME_NUM_ARGS (numargs, fi); ! 220: print_frame_args (func, FRAME_ARGS_ADDRESS (fi), numargs, stdout); ! 221: printf ("\n"); ! 222: count = 0; ! 223: for (i = 0; i < NUM_REGS; i++) ! 224: if (fsr.regs[i]) ! 225: { ! 226: if (count % 4 != 0) ! 227: printf (", "); ! 228: else ! 229: { ! 230: if (count == 0) ! 231: printf (" Saved registers:"); ! 232: printf ("\n "); ! 233: } ! 234: printf ("%s at 0x%x", reg_names[i], fsr.regs[i]); ! 235: count++; ! 236: } ! 237: if (count) ! 238: printf ("\n"); ! 239: } ! 240: ! 241: /* Print briefly all stack frames or just the innermost COUNT frames. */ ! 242: ! 243: static void ! 244: backtrace_command (count_exp) ! 245: char *count_exp; ! 246: { ! 247: struct frame_info fi; ! 248: register int count; ! 249: register FRAME frame; ! 250: register int i; ! 251: ! 252: if (count_exp) ! 253: count = parse_and_eval_address (count_exp); ! 254: else ! 255: count = -1; ! 256: ! 257: for (i = 0, frame = get_current_frame (), fi = get_frame_info (frame); ! 258: frame && count--; ! 259: i++, fi = get_prev_frame_info (fi.frame), frame = fi.frame) ! 260: { ! 261: QUIT; ! 262: print_frame_info (&fi, i, 0, 1); ! 263: } ! 264: } ! 265: ! 266: /* Print the local variables of a block B active in FRAME. */ ! 267: ! 268: static void ! 269: print_block_frame_locals (b, frame, stream) ! 270: struct block *b; ! 271: register FRAME frame; ! 272: register FILE *stream; ! 273: { ! 274: int nsyms; ! 275: register int i; ! 276: register struct symbol *sym; ! 277: ! 278: nsyms = BLOCK_NSYMS (b); ! 279: ! 280: for (i = 0; i < nsyms; i++) ! 281: { ! 282: sym = BLOCK_SYM (b, i); ! 283: if (SYMBOL_CLASS (sym) == LOC_LOCAL ! 284: || SYMBOL_CLASS (sym) == LOC_REGISTER ! 285: || SYMBOL_CLASS (sym) == LOC_STATIC) ! 286: { ! 287: fprintf (stream, "%s = ", SYMBOL_NAME (sym)); ! 288: print_variable_value (sym, frame, stream); ! 289: fprintf (stream, "\n"); ! 290: fflush (stream); ! 291: } ! 292: } ! 293: } ! 294: ! 295: /* Print on STREAM all the local variables in frame FRAME, ! 296: including all the blocks active in that frame ! 297: at its current pc. ! 298: ! 299: Returns 1 if the job was done, ! 300: or 0 if nothing was printed because we have no info ! 301: on the function running in FRAME. */ ! 302: ! 303: static int ! 304: print_frame_local_vars (frame, stream) ! 305: register FRAME frame; ! 306: register FILE *stream; ! 307: { ! 308: register struct block *block = get_frame_block (frame); ! 309: if (block == 0) ! 310: return 0; ! 311: while (block != 0) ! 312: { ! 313: print_block_frame_locals (block, frame, stream); ! 314: /* After handling the function's top-level block, stop. ! 315: Don't continue to its superblock, the block of ! 316: per-file symbols. */ ! 317: if (BLOCK_FUNCTION (block)) ! 318: break; ! 319: block = BLOCK_SUPERBLOCK (block); ! 320: } ! 321: return 1; ! 322: } ! 323: ! 324: static void ! 325: locals_info () ! 326: { ! 327: print_frame_local_vars (selected_frame, stdout); ! 328: } ! 329: ! 330: static int ! 331: print_frame_arg_vars (frame, stream) ! 332: register FRAME frame; ! 333: register FILE *stream; ! 334: { ! 335: struct symbol *func = get_frame_function (frame); ! 336: register struct block *b; ! 337: int nsyms; ! 338: register int i; ! 339: register struct symbol *sym; ! 340: ! 341: if (func == 0) ! 342: return 0; ! 343: ! 344: b = SYMBOL_BLOCK_VALUE (func); ! 345: nsyms = BLOCK_NSYMS (b); ! 346: ! 347: for (i = 0; i < nsyms; i++) ! 348: { ! 349: sym = BLOCK_SYM (b, i); ! 350: if (SYMBOL_CLASS (sym) == LOC_ARG) ! 351: { ! 352: fprintf (stream, "%s = ", SYMBOL_NAME (sym)); ! 353: print_variable_value (sym, frame, stream); ! 354: fprintf (stream, "\n"); ! 355: fflush (stream); ! 356: } ! 357: } ! 358: ! 359: return 1; ! 360: } ! 361: ! 362: static void ! 363: args_info () ! 364: { ! 365: print_frame_arg_vars (selected_frame, stdout); ! 366: } ! 367: ! 368: /* Select frame FRAME, and note that its stack level is LEVEL. ! 369: LEVEL may be -1 if an actual level number is not known. */ ! 370: ! 371: void ! 372: select_frame (frame, level) ! 373: FRAME frame; ! 374: int level; ! 375: { ! 376: selected_frame = frame; ! 377: selected_frame_level = level; ! 378: } ! 379: ! 380: /* Store the selected frame and its level into *FRAMEP and *LEVELP. */ ! 381: ! 382: void ! 383: record_selected_frame (framep, levelp) ! 384: FRAME *framep; ! 385: int *levelp; ! 386: { ! 387: *framep = selected_frame; ! 388: *levelp = selected_frame_level; ! 389: } ! 390: ! 391: /* Return the symbol-block in which the selected frame is executing. ! 392: Can return zero under various legitimate circumstances. */ ! 393: ! 394: struct block * ! 395: get_selected_block () ! 396: { ! 397: if (!have_inferior_p () && !have_core_file_p ()) ! 398: return 0; ! 399: ! 400: if (!selected_frame) ! 401: return get_current_block (); ! 402: return get_frame_block (selected_frame); ! 403: } ! 404: ! 405: /* Find a frame a certain number of levels away from FRAME. ! 406: LEVEL_OFFSET_PTR points to an int containing the number of levels. ! 407: Positive means go to earlier frames (up); negative, the reverse. ! 408: The int that contains the number of levels is counted toward ! 409: zero as the frames for those levels are found. ! 410: If the top or bottom frame is reached, that frame is returned, ! 411: but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates ! 412: how much farther the original request asked to go. */ ! 413: ! 414: FRAME ! 415: find_relative_frame (frame, level_offset_ptr) ! 416: register FRAME frame; ! 417: register int* level_offset_ptr; ! 418: { ! 419: register FRAME prev; ! 420: struct frame_info fi; ! 421: register FRAME frame1, frame2; ! 422: ! 423: /* Going up is simple: just do get_prev_frame enough times ! 424: or until initial frame is reached. */ ! 425: while (*level_offset_ptr > 0) ! 426: { ! 427: prev = get_prev_frame (frame); ! 428: if (prev == 0) ! 429: break; ! 430: (*level_offset_ptr)--; ! 431: frame = prev; ! 432: } ! 433: /* Going down could be done by iterating get_frame_info to ! 434: find the next frame, but that would be quadratic ! 435: since get_frame_info must scan all the way from the current frame. ! 436: The following algotithm is linear. */ ! 437: if (*level_offset_ptr < 0) ! 438: { ! 439: /* First put frame1 at innermost frame ! 440: and frame2 N levels up from there. */ ! 441: frame1 = get_current_frame (); ! 442: frame2 = frame1; ! 443: while (*level_offset_ptr < 0 && frame2 != frame) ! 444: { ! 445: frame2 = get_prev_frame (frame2); ! 446: (*level_offset_ptr) ++; ! 447: } ! 448: /* Then slide frame1 and frame2 up in synchrony ! 449: and when frame2 reaches our starting point ! 450: frame1 must be N levels down from there. */ ! 451: while (frame2 != frame) ! 452: { ! 453: frame1 = get_prev_frame (frame1); ! 454: frame2 = get_prev_frame (frame2); ! 455: } ! 456: return frame1; ! 457: } ! 458: return frame; ! 459: } ! 460: ! 461: /* The "frame" command. With no arg, print selected frame briefly. ! 462: With arg LEVEL, select the frame at level LEVEL and print it. ! 463: With arg larger than 100000, use it as address of frame to select. ! 464: If from command file or user-defined command, don't print anything ! 465: if we have an argument. */ ! 466: ! 467: static void ! 468: frame_command (level_exp, from_tty) ! 469: char *level_exp; ! 470: int from_tty; ! 471: { ! 472: register int i; ! 473: register FRAME frame; ! 474: unsigned int level, level1; ! 475: ! 476: if (level_exp) ! 477: { ! 478: level1 = level = parse_and_eval_address (level_exp); ! 479: if (level > 100000) ! 480: { ! 481: select_frame (level, -1); ! 482: frame_info (0); ! 483: return; ! 484: } ! 485: ! 486: frame = find_relative_frame (get_current_frame (), &level1); ! 487: if (level1 != 0) ! 488: error ("Stack level %d is out of range.", level); ! 489: select_frame (frame, level); ! 490: if (! from_tty) ! 491: return; ! 492: } ! 493: ! 494: print_stack_frame (selected_frame, selected_frame_level, 1); ! 495: } ! 496: ! 497: /* Select the frame up one or COUNT stack levels ! 498: from the previously selected frame, and print it briefly. */ ! 499: ! 500: static void ! 501: up_command (count_exp) ! 502: char *count_exp; ! 503: { ! 504: register FRAME frame; ! 505: int count = 1, count1; ! 506: if (count_exp) ! 507: count = parse_and_eval_address (count_exp); ! 508: count1 = count; ! 509: ! 510: frame = find_relative_frame (selected_frame, &count1); ! 511: if (count1 != 0 && count_exp == 0) ! 512: error ("Initial frame selected; you cannot go up."); ! 513: select_frame (frame, selected_frame_level + count - count1); ! 514: ! 515: print_stack_frame (selected_frame, selected_frame_level, 1); ! 516: } ! 517: ! 518: /* Select the frame down one or COUNT stack levels ! 519: from the previously selected frame, and print it briefly. */ ! 520: ! 521: static void ! 522: down_command (count_exp) ! 523: char *count_exp; ! 524: { ! 525: register FRAME frame; ! 526: int count = -1, count1; ! 527: if (count_exp) ! 528: count = - parse_and_eval_address (count_exp); ! 529: count1 = count; ! 530: ! 531: frame = find_relative_frame (selected_frame, &count1); ! 532: if (count1 != 0 && count_exp == 0) ! 533: error ("Bottom (i.e., innermost) frame selected; you cannot go down."); ! 534: select_frame (frame, selected_frame_level + count - count1); ! 535: ! 536: print_stack_frame (selected_frame, selected_frame_level, 1); ! 537: } ! 538: ! 539: static void ! 540: return_command (retval_exp, from_tty) ! 541: char *retval_exp; ! 542: int from_tty; ! 543: { ! 544: struct symbol *thisfun = get_frame_function (selected_frame); ! 545: ! 546: /* If interactive, require confirmation. */ ! 547: ! 548: if (from_tty) ! 549: { ! 550: if (thisfun != 0) ! 551: { ! 552: if (!query ("Make %s return now? ", SYMBOL_NAME (thisfun))) ! 553: error ("Not confirmed."); ! 554: } ! 555: else ! 556: if (!query ("Make selected stack frame return now? ")) ! 557: error ("Not confirmed."); ! 558: } ! 559: ! 560: /* Do the real work. Pop until the specified frame is current. */ ! 561: ! 562: while (selected_frame != get_current_frame ()) ! 563: POP_FRAME; ! 564: ! 565: /* Then pop that frame. */ ! 566: ! 567: POP_FRAME; ! 568: ! 569: /* Compute the return value (if any) and store in the place ! 570: for return values. */ ! 571: ! 572: if (retval_exp) ! 573: set_return_value (parse_and_eval (retval_exp)); ! 574: ! 575: /* If interactive, print the frame that is now current. */ ! 576: ! 577: if (from_tty) ! 578: frame_command ("0", 1); ! 579: } ! 580: ! 581: static ! 582: initialize () ! 583: { ! 584: add_com ("return", class_stack, return_command, ! 585: "Make selected stack frame return to its caller.\n\ ! 586: Control remains in the debugger, but when you continue\n\ ! 587: execution will resume in the frame above the one now selected.\n\ ! 588: If an argument is given, it is an expression for the value to return."); ! 589: ! 590: add_com ("up", class_stack, up_command, ! 591: "Select and print stack frame that called this one.\n\ ! 592: An argument says how many frames up to go."); ! 593: ! 594: add_com ("down", class_stack, down_command, ! 595: "Select and print stack frame called by this one.\n\ ! 596: An argument says how many frames down to go."); ! 597: add_com_alias ("do", "down", class_stack, 1); ! 598: ! 599: add_com ("frame", class_stack, frame_command, ! 600: "Select and print a stack frame.\n\ ! 601: With no argument, print the selected stack frame. (See also \"info frame\").\n\ ! 602: An argument specifies the frame to select.\n\ ! 603: It can be a stack frame number or the address of the frame.\n\ ! 604: With argument, nothing is printed if input is coming from\n\ ! 605: a command file or a user-defined command."); ! 606: ! 607: add_com_alias ("f", "frame", class_stack, 1); ! 608: ! 609: add_com ("backtrace", class_stack, backtrace_command, ! 610: "Print backtrace of all stack frames, or innermost COUNT frames."); ! 611: add_com_alias ("bt", "backtrace", class_stack, 0); ! 612: add_com_alias ("where", "backtrace", class_alias, 0); ! 613: add_info ("stack", backtrace_command, ! 614: "Backtrace of the stack, or innermost COUNT frames."); ! 615: add_info_alias ("s", "stack", 1); ! 616: add_info ("frame", frame_info, ! 617: "All about selected stack frame, or frame at ADDR."); ! 618: add_info_alias ("f", "frame", 1); ! 619: add_info ("locals", locals_info, ! 620: "Local variables of current stack frame."); ! 621: add_info ("args", args_info, ! 622: "Argument variables of current stack frame."); ! 623: } ! 624: ! 625: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.