![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printcmd.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 printcmd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* Print values for GNU debugger GDB. ! 2: Copyright (C) 1986, 1987, 1988 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: #include "defs.h" ! 23: #include "initialize.h" ! 24: #include "param.h" ! 25: #include "symtab.h" ! 26: #include "value.h" ! 27: #include "expression.h" ! 28: ! 29: struct format_data ! 30: { ! 31: int count; ! 32: char format; ! 33: char size; ! 34: }; ! 35: ! 36: /* Last specified output format. */ ! 37: ! 38: static char last_format = 'x'; ! 39: ! 40: /* Last specified examination size. 'b', 'h', 'w' or `q'. */ ! 41: ! 42: static char last_size = 'w'; ! 43: ! 44: /* Default address to examine next. */ ! 45: ! 46: static CORE_ADDR next_address; ! 47: ! 48: /* Last address examined. */ ! 49: ! 50: static CORE_ADDR last_examine_address; ! 51: ! 52: /* Contents of last address examined. ! 53: This is not valid past the end of the `x' command! */ ! 54: ! 55: static value last_examine_value; ! 56: ! 57: /* Number of auto-display expression currently being displayed. ! 58: So that we can deleted it if we get an error or a signal within it. ! 59: -1 when not doing one. */ ! 60: ! 61: int current_display_number; ! 62: ! 63: static void do_one_display (); ! 64: ! 65: void do_displays (); ! 66: void print_address (); ! 67: void print_scalar_formatted (); ! 68: ! 69: START_FILE ! 70: ! 71: /* Decode a format specification. *STRING_PTR should point to it. ! 72: OFORMAT and OSIZE are used as defaults for the format and size ! 73: if none are given in the format specification. ! 74: The structure returned describes all the data ! 75: found in the specification. In addition, *STRING_PTR is advanced ! 76: past the specification and past all whitespace following it. */ ! 77: ! 78: struct format_data ! 79: decode_format (string_ptr, oformat, osize) ! 80: char **string_ptr; ! 81: char oformat; ! 82: char osize; ! 83: { ! 84: struct format_data val; ! 85: register char *p = *string_ptr; ! 86: ! 87: val.format = oformat; ! 88: val.size = osize; ! 89: val.count = 1; ! 90: ! 91: if (*p >= '0' && *p <= '9') ! 92: val.count = atoi (p); ! 93: while (*p >= '0' && *p <= '9') p++; ! 94: ! 95: /* Now process size or format letters that follow. */ ! 96: ! 97: while (1) ! 98: { ! 99: if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g') ! 100: val.size = *p++; ! 101: else if (*p >= 'a' && *p <= 'z') ! 102: val.format = *p++; ! 103: else ! 104: break; ! 105: } ! 106: ! 107: /* Make sure 'g' size is not used on integer types. */ ! 108: if (val.size == 'g' && val.format != 'f') ! 109: val.size = 'w'; ! 110: ! 111: while (*p == ' ' || *p == '\t') p++; ! 112: *string_ptr = p; ! 113: ! 114: return val; ! 115: } ! 116: ! 117: /* Print value VAL on stdout according to FORMAT, a letter or 0. ! 118: Do not end with a newline. ! 119: 0 means print VAL according to its own type. ! 120: SIZE is the letter for the size of datum being printed. ! 121: This is used to pad hex numbers so they line up. */ ! 122: ! 123: static void ! 124: print_formatted (val, format, size) ! 125: register value val; ! 126: register char format; ! 127: char size; ! 128: { ! 129: register CORE_ADDR val_long; ! 130: int len = TYPE_LENGTH (VALUE_TYPE (val)); ! 131: ! 132: if (VALUE_LVAL (val) == lval_memory) ! 133: next_address = VALUE_ADDRESS (val) + len; ! 134: ! 135: switch (format) ! 136: { ! 137: case 's': ! 138: next_address = VALUE_ADDRESS (val) ! 139: + value_print (value_addr (val), stdout, 0); ! 140: break; ! 141: ! 142: case 'i': ! 143: next_address = VALUE_ADDRESS (val) ! 144: + print_insn (VALUE_ADDRESS (val), stdout); ! 145: break; ! 146: ! 147: default: ! 148: if (format == 0 ! 149: || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_ARRAY ! 150: || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRUCT ! 151: || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION) ! 152: value_print (val, stdout, format); ! 153: else ! 154: print_scalar_formatted (VALUE_CONTENTS (val), VALUE_TYPE (val), ! 155: format, size, stdout); ! 156: } ! 157: } ! 158: ! 159: /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, ! 160: according to letters FORMAT and SIZE on STREAM. ! 161: FORMAT may not be zero. Formats s and i are not supported at this level. ! 162: ! 163: This is how the elements of an array or structure are printed ! 164: with a format. */ ! 165: ! 166: void ! 167: print_scalar_formatted (valaddr, type, format, size, stream) ! 168: char *valaddr; ! 169: struct type *type; ! 170: char format; ! 171: int size; ! 172: FILE *stream; ! 173: { ! 174: long val_long; ! 175: int len = TYPE_LENGTH (type); ! 176: ! 177: val_long = unpack_long (type, valaddr); ! 178: ! 179: /* If value is unsigned, truncate it in case negative. */ ! 180: if (format != 'd') ! 181: { ! 182: if (len == sizeof (char)) ! 183: val_long &= (1 << 8 * sizeof(char)) - 1; ! 184: else if (len == sizeof (short)) ! 185: val_long &= (1 << 8 * sizeof(short)) - 1; ! 186: } ! 187: ! 188: switch (format) ! 189: { ! 190: case 'x': ! 191: switch (size) ! 192: { ! 193: case 'b': ! 194: printf ("0x%02x", val_long); ! 195: break; ! 196: case 'h': ! 197: printf ("0x%04x", val_long); ! 198: break; ! 199: case 0: /* no size specified, like in print */ ! 200: case 'w': ! 201: printf ("0x%08x", val_long); ! 202: break; ! 203: case 'g': ! 204: printf ("0x%16x", val_long); ! 205: break; ! 206: default: ! 207: error ("Undefined output size \"%c\".", size); ! 208: } ! 209: break; ! 210: ! 211: case 'd': ! 212: printf ("%d", val_long); ! 213: break; ! 214: ! 215: case 'u': ! 216: printf ("%u", val_long); ! 217: break; ! 218: ! 219: case 'o': ! 220: if (val_long) ! 221: printf ("0%o", val_long); ! 222: else ! 223: printf ("0"); ! 224: break; ! 225: ! 226: case 'a': ! 227: print_address (val_long, stream); ! 228: break; ! 229: ! 230: case 'c': ! 231: value_print (value_from_long (builtin_type_char, val_long), stream, 0); ! 232: break; ! 233: ! 234: case 'f': ! 235: if (len == sizeof (float)) ! 236: type = builtin_type_float; ! 237: if (len == sizeof (double)) ! 238: type = builtin_type_double; ! 239: #ifdef IEEE_FLOAT ! 240: if (is_nan (unpack_double (type, valaddr))) ! 241: { ! 242: printf ("Nan"); ! 243: break; ! 244: } ! 245: #endif ! 246: printf ("%g", unpack_double (type, valaddr)); ! 247: break; ! 248: ! 249: case 0: ! 250: abort (); ! 251: ! 252: default: ! 253: error ("Undefined output format \"%c\".", format); ! 254: } ! 255: } ! 256: ! 257: /* Specify default address for `x' command. ! 258: `info lines' uses this. */ ! 259: ! 260: void ! 261: set_next_address (addr) ! 262: CORE_ADDR addr; ! 263: { ! 264: next_address = addr; ! 265: ! 266: /* Make address available to the user as $_. */ ! 267: set_internalvar (lookup_internalvar ("_"), ! 268: value_from_long (builtin_type_int, addr)); ! 269: } ! 270: ! 271: /* Print address ADDR symbolically on STREAM. ! 272: First print it as a number. Then perhaps print ! 273: <SYMBOL + OFFSET> after the number. */ ! 274: ! 275: void ! 276: print_address (addr, stream) ! 277: CORE_ADDR addr; ! 278: FILE *stream; ! 279: { ! 280: register int i; ! 281: ! 282: fprintf (stream, "0x%x", addr); ! 283: ! 284: i = find_pc_misc_function (addr); ! 285: if (i >= 0) ! 286: if (misc_function_vector[i].address != addr) ! 287: fprintf (stream, " <%s+%d>", ! 288: misc_function_vector[i].name, ! 289: addr - misc_function_vector[i].address); ! 290: else ! 291: fprintf (stream, " <%s>", misc_function_vector[i].name); ! 292: ! 293: } ! 294: ! 295: /* Examine data at address ADDR in format FMT. ! 296: Fetch it from memory and print on stdout. */ ! 297: ! 298: static void ! 299: do_examine (fmt, addr) ! 300: struct format_data fmt; ! 301: CORE_ADDR addr; ! 302: { ! 303: register char format = 0; ! 304: register char size; ! 305: register int count = 1; ! 306: struct type *val_type; ! 307: register int i; ! 308: register int maxelts; ! 309: ! 310: format = fmt.format; ! 311: size = fmt.size; ! 312: count = fmt.count; ! 313: next_address = addr; ! 314: ! 315: /* String or instruction format implies fetch single bytes ! 316: regardless of the specified size. */ ! 317: if (format == 's' || format == 'i') ! 318: size = 'b'; ! 319: ! 320: if (size == 'b') ! 321: val_type = builtin_type_char; ! 322: else if (size == 'h') ! 323: val_type = builtin_type_short; ! 324: else if (size == 'w') ! 325: val_type = builtin_type_long; ! 326: else if (size == 'g') ! 327: val_type = builtin_type_double; ! 328: ! 329: maxelts = 8; ! 330: if (size == 'w') ! 331: maxelts = 4; ! 332: if (size == 'g') ! 333: maxelts = 2; ! 334: if (format == 's' || format == 'i') ! 335: maxelts = 1; ! 336: ! 337: /* Print as many objects as specified in COUNT, at most maxelts per line, ! 338: with the address of the next one at the start of each line. */ ! 339: ! 340: while (count > 0) ! 341: { ! 342: print_address (next_address, stdout); ! 343: fputc (':', stdout); ! 344: for (i = maxelts; ! 345: i > 0 && count > 0; ! 346: i--, count--) ! 347: { ! 348: fputc ('\t', stdout); ! 349: /* Note that this sets next_address for the next object. */ ! 350: last_examine_address = next_address; ! 351: last_examine_value = value_at (val_type, next_address); ! 352: print_formatted (last_examine_value, format, size); ! 353: } ! 354: fputc ('\n', stdout); ! 355: fflush (stdout); ! 356: } ! 357: } ! 358: ! 359: static void ! 360: validate_format (fmt, cmdname) ! 361: struct format_data fmt; ! 362: char *cmdname; ! 363: { ! 364: if (fmt.size != 0) ! 365: error ("Size letters are meaningless in \"%s\" command.", cmdname); ! 366: if (fmt.count != 1) ! 367: error ("Item count other than 1 is meaningless in \"%s\" command.", ! 368: cmdname); ! 369: if (fmt.format == 'i' || fmt.format == 's') ! 370: error ("Format letter \"%c\" is meaningless in \"%s\" command.", ! 371: fmt.format, cmdname); ! 372: } ! 373: ! 374: static void ! 375: print_command (exp) ! 376: char *exp; ! 377: { ! 378: struct expression *expr; ! 379: register struct cleanup *old_chain = 0; ! 380: register char format = 0; ! 381: register value val; ! 382: struct format_data fmt; ! 383: int histindex; ! 384: int cleanup = 0; ! 385: ! 386: if (exp && *exp == '/') ! 387: { ! 388: exp++; ! 389: fmt = decode_format (&exp, last_format, 0); ! 390: validate_format (fmt, "print"); ! 391: last_format = format = fmt.format; ! 392: } ! 393: ! 394: if (exp && *exp) ! 395: { ! 396: expr = parse_c_expression (exp); ! 397: old_chain = make_cleanup (free_current_contents, &expr); ! 398: cleanup = 1; ! 399: val = evaluate_expression (expr); ! 400: } ! 401: else ! 402: val = access_value_history (0); ! 403: ! 404: histindex = record_latest_value (val); ! 405: printf ("$%d = ", histindex); ! 406: ! 407: print_formatted (val, format, fmt.size); ! 408: printf ("\n"); ! 409: ! 410: if (cleanup) ! 411: do_cleanups (old_chain); ! 412: } ! 413: ! 414: static void ! 415: output_command (exp) ! 416: char *exp; ! 417: { ! 418: struct expression *expr; ! 419: register struct cleanup *old_chain; ! 420: register char format = 0; ! 421: register value val; ! 422: struct format_data fmt; ! 423: ! 424: if (exp && *exp == '/') ! 425: { ! 426: exp++; ! 427: fmt = decode_format (&exp, 0, 0); ! 428: validate_format (fmt, "print"); ! 429: format = fmt.format; ! 430: } ! 431: ! 432: expr = parse_c_expression (exp); ! 433: old_chain = make_cleanup (free_current_contents, &expr); ! 434: ! 435: val = evaluate_expression (expr); ! 436: ! 437: print_formatted (val, format, fmt.size); ! 438: ! 439: do_cleanups (old_chain); ! 440: } ! 441: ! 442: static void ! 443: set_command (exp) ! 444: char *exp; ! 445: { ! 446: struct expression *expr = parse_c_expression (exp); ! 447: register struct cleanup *old_chain ! 448: = make_cleanup (free_current_contents, &expr); ! 449: evaluate_expression (expr); ! 450: do_cleanups (old_chain); ! 451: } ! 452: ! 453: static void ! 454: address_info (exp) ! 455: char *exp; ! 456: { ! 457: register struct symbol *sym; ! 458: register CORE_ADDR val; ! 459: ! 460: if (exp == 0) ! 461: error ("Argument required."); ! 462: ! 463: sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE); ! 464: if (sym == 0) ! 465: { ! 466: register int i; ! 467: ! 468: for (i = 0; i < misc_function_count; i++) ! 469: if (!strcmp (misc_function_vector[i].name, exp)) ! 470: break; ! 471: ! 472: if (i < misc_function_count) ! 473: printf ("Symbol \"%s\" is at 0x%x in a file compiled without -g.\n", ! 474: exp, misc_function_vector[i].address); ! 475: else ! 476: error ("No symbol \"%s\" in current context.", exp); ! 477: return; ! 478: } ! 479: ! 480: printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym)); ! 481: val = SYMBOL_VALUE (sym); ! 482: ! 483: switch (SYMBOL_CLASS (sym)) ! 484: { ! 485: case LOC_CONST: ! 486: case LOC_CONST_BYTES: ! 487: printf ("constant"); ! 488: break; ! 489: ! 490: case LOC_LABEL: ! 491: printf ("a label at address 0x%x", val); ! 492: break; ! 493: ! 494: case LOC_REGISTER: ! 495: printf ("a variable in register %s", reg_names[val]); ! 496: break; ! 497: ! 498: case LOC_STATIC: ! 499: printf ("static at address 0x%x", val); ! 500: break; ! 501: ! 502: case LOC_ARG: ! 503: printf ("an argument at offset %d", val); ! 504: break; ! 505: ! 506: case LOC_LOCAL: ! 507: printf ("a local variable at frame offset %d", val); ! 508: break; ! 509: ! 510: case LOC_TYPEDEF: ! 511: printf ("a typedef"); ! 512: break; ! 513: ! 514: case LOC_BLOCK: ! 515: printf ("a function at address 0x%x", ! 516: BLOCK_START (SYMBOL_BLOCK_VALUE (sym))); ! 517: break; ! 518: } ! 519: printf (".\n"); ! 520: } ! 521: ! 522: static void ! 523: x_command (exp, from_tty) ! 524: char *exp; ! 525: int from_tty; ! 526: { ! 527: struct expression *expr; ! 528: struct format_data fmt; ! 529: struct cleanup *old_chain; ! 530: ! 531: fmt.format = last_format; ! 532: fmt.size = last_size; ! 533: fmt.count = 1; ! 534: ! 535: if (exp && *exp == '/') ! 536: { ! 537: exp++; ! 538: fmt = decode_format (&exp, last_format, last_size); ! 539: last_size = fmt.size; ! 540: last_format = fmt.format; ! 541: } ! 542: ! 543: /* If we have an expression, evaluate it and use it as the address. */ ! 544: ! 545: if (exp != 0 && *exp != 0) ! 546: { ! 547: expr = parse_c_expression (exp); ! 548: /* Cause expression not to be there any more ! 549: if this command is repeated with Newline. ! 550: But don't clobber a user-defined command's definition. */ ! 551: if (from_tty) ! 552: *exp = 0; ! 553: old_chain = make_cleanup (free_current_contents, &expr); ! 554: next_address = value_as_long (evaluate_expression (expr)); ! 555: do_cleanups (old_chain); ! 556: } ! 557: ! 558: do_examine (fmt, next_address); ! 559: ! 560: /* Make last address examined available to the user as $_. */ ! 561: set_internalvar (lookup_internalvar ("_"), ! 562: value_from_long (builtin_type_int, last_examine_address)); ! 563: ! 564: /* Make contents of last address examined available to the user as $__. */ ! 565: set_internalvar (lookup_internalvar ("__"), last_examine_value); ! 566: } ! 567: ! 568: /* Commands for printing types of things. */ ! 569: ! 570: static void ! 571: whatis_command (exp) ! 572: char *exp; ! 573: { ! 574: struct expression *expr; ! 575: register value val; ! 576: register struct cleanup *old_chain; ! 577: ! 578: if (exp) ! 579: { ! 580: expr = parse_c_expression (exp); ! 581: old_chain = make_cleanup (free_current_contents, &expr); ! 582: val = evaluate_type (expr); ! 583: } ! 584: else ! 585: val = access_value_history (0); ! 586: ! 587: printf ("type = "); ! 588: type_print (VALUE_TYPE (val), "", stdout, 1); ! 589: printf ("\n"); ! 590: ! 591: if (exp) ! 592: do_cleanups (old_chain); ! 593: } ! 594: ! 595: static void ! 596: ptype_command (typename) ! 597: char *typename; ! 598: { ! 599: register char *p = typename; ! 600: register int len; ! 601: extern struct block *get_current_block (); ! 602: register struct block *b ! 603: = (have_inferior_p () || have_core_file_p ()) ? get_current_block () : 0; ! 604: register struct type *type; ! 605: ! 606: if (typename == 0) ! 607: error_no_arg ("type name"); ! 608: ! 609: while (*p && *p != ' ' && *p != '\t') p++; ! 610: len = p - typename; ! 611: while (*p == ' ' || *p == '\t') p++; ! 612: ! 613: if (len == 6 && !strncmp (typename, "struct", 6)) ! 614: type = lookup_struct (p, b); ! 615: else if (len == 5 && !strncmp (typename, "union", 5)) ! 616: type = lookup_union (p, b); ! 617: else if (len == 4 && !strncmp (typename, "enum", 4)) ! 618: type = lookup_enum (p, b); ! 619: else ! 620: { ! 621: type = lookup_typename (typename, b, 1); ! 622: if (type == 0) ! 623: { ! 624: register struct symbol *sym ! 625: = lookup_symbol (typename, b, STRUCT_NAMESPACE); ! 626: if (sym == 0) ! 627: error ("No type named %s.", typename); ! 628: printf ("No type named %s, but there is a ", ! 629: typename); ! 630: switch (TYPE_CODE (SYMBOL_TYPE (sym))) ! 631: { ! 632: case TYPE_CODE_STRUCT: ! 633: printf ("struct"); ! 634: break; ! 635: ! 636: case TYPE_CODE_UNION: ! 637: printf ("union"); ! 638: break; ! 639: ! 640: case TYPE_CODE_ENUM: ! 641: printf ("enum"); ! 642: } ! 643: printf (" %s. Type \"help ptype\".\n", typename); ! 644: type = SYMBOL_TYPE (sym); ! 645: } ! 646: } ! 647: ! 648: type_print (type, "", stdout, 1); ! 649: printf ("\n"); ! 650: } ! 651: ! 652: struct display ! 653: { ! 654: /* Chain link to next auto-display item. */ ! 655: struct display *next; ! 656: /* Expression to be evaluated and displayed. */ ! 657: struct expression *exp; ! 658: /* Item number of this auto-display item. */ ! 659: int number; ! 660: /* Display format specified. */ ! 661: struct format_data format; ! 662: /* Block in which expression is to be evaluated. */ ! 663: struct block *block; ! 664: }; ! 665: ! 666: /* Chain of expressions whose values should be displayed ! 667: automatically each time the program stops. */ ! 668: ! 669: static struct display *display_chain; ! 670: ! 671: static int display_number; ! 672: ! 673: /* Add an expression to the auto-display chain. ! 674: Specify the expression. */ ! 675: ! 676: static void ! 677: display_command (exp, from_tty) ! 678: char *exp; ! 679: int from_tty; ! 680: { ! 681: struct format_data fmt; ! 682: register struct expression *expr; ! 683: register struct display *new; ! 684: ! 685: if (exp == 0) ! 686: { ! 687: do_displays (); ! 688: return; ! 689: } ! 690: ! 691: if (*exp == '/') ! 692: { ! 693: exp++; ! 694: fmt = decode_format (&exp, 0, 0); ! 695: if (fmt.size && fmt.format == 0) ! 696: fmt.format = 'x'; ! 697: if (fmt.format == 'i' || fmt.format == 's') ! 698: fmt.size = 'b'; ! 699: } ! 700: else ! 701: { ! 702: fmt.format = 0; ! 703: fmt.size = 0; ! 704: fmt.count = 0; ! 705: } ! 706: ! 707: expr = parse_c_expression (exp); ! 708: ! 709: new = (struct display *) xmalloc (sizeof (struct display)); ! 710: ! 711: new->exp = expr; ! 712: new->next = display_chain; ! 713: new->number = ++display_number; ! 714: new->format = fmt; ! 715: display_chain = new; ! 716: ! 717: if (from_tty) ! 718: do_one_display (new); ! 719: ! 720: dont_repeat (); ! 721: } ! 722: ! 723: static void ! 724: free_display (d) ! 725: struct display *d; ! 726: { ! 727: free (d->exp); ! 728: free (d); ! 729: } ! 730: ! 731: /* Clear out the display_chain. ! 732: Done when new symtabs are loaded, since this invalidates ! 733: the types stored in many expressions. */ ! 734: ! 735: void ! 736: clear_displays () ! 737: { ! 738: register struct display *d; ! 739: ! 740: while (d = display_chain) ! 741: { ! 742: free (d->exp); ! 743: display_chain = d->next; ! 744: free (d); ! 745: } ! 746: } ! 747: ! 748: /* Delete the auto-display number NUM. */ ! 749: ! 750: void ! 751: delete_display (num) ! 752: int num; ! 753: { ! 754: register struct display *d1, *d; ! 755: ! 756: if (!display_chain) ! 757: error ("No display number %d.", num); ! 758: ! 759: if (display_chain->number == num) ! 760: { ! 761: d1 = display_chain; ! 762: display_chain = d1->next; ! 763: free_display (d1); ! 764: } ! 765: else ! 766: for (d = display_chain; ; d = d->next) ! 767: { ! 768: if (d->next == 0) ! 769: error ("No display number %d.", num); ! 770: if (d->next->number == num) ! 771: { ! 772: d1 = d->next; ! 773: d->next = d1->next; ! 774: free_display (d1); ! 775: break; ! 776: } ! 777: } ! 778: } ! 779: ! 780: /* Delete some values from the auto-display chain. ! 781: Specify the element numbers. */ ! 782: ! 783: static void ! 784: undisplay_command (args) ! 785: char *args; ! 786: { ! 787: register char *p = args; ! 788: register char *p1; ! 789: register int num; ! 790: register struct display *d, *d1; ! 791: ! 792: if (args == 0) ! 793: { ! 794: if (query ("Delete all auto-display expressions? ")) ! 795: clear_displays (); ! 796: dont_repeat (); ! 797: return; ! 798: } ! 799: ! 800: while (*p) ! 801: { ! 802: p1 = p; ! 803: while (*p1 >= '0' && *p1 <= '9') p1++; ! 804: if (*p1 && *p1 != ' ' && *p1 != '\t') ! 805: error ("Arguments must be display numbers."); ! 806: ! 807: num = atoi (p); ! 808: ! 809: delete_display (num); ! 810: ! 811: p = p1; ! 812: while (*p == ' ' || *p == '\t') p++; ! 813: } ! 814: dont_repeat (); ! 815: } ! 816: ! 817: /* Display a single auto-display. */ ! 818: ! 819: static void ! 820: do_one_display (d) ! 821: struct display *d; ! 822: { ! 823: current_display_number = d->number; ! 824: ! 825: printf ("%d: ", d->number); ! 826: if (d->format.size) ! 827: { ! 828: printf ("x/"); ! 829: if (d->format.count != 1) ! 830: printf ("%d", d->format.count); ! 831: printf ("%c", d->format.format); ! 832: if (d->format.format != 'i' && d->format.format != 's') ! 833: printf ("%c", d->format.size); ! 834: printf (" "); ! 835: print_expression (d->exp, stdout); ! 836: if (d->format.count != 1) ! 837: printf ("\n"); ! 838: else ! 839: printf (" "); ! 840: do_examine (d->format, ! 841: value_as_long (evaluate_expression (d->exp))); ! 842: } ! 843: else ! 844: { ! 845: if (d->format.format) ! 846: printf ("/%c ", d->format.format); ! 847: print_expression (d->exp, stdout); ! 848: printf (" = "); ! 849: print_formatted (evaluate_expression (d->exp), ! 850: d->format.format, d->format.size); ! 851: printf ("\n"); ! 852: } ! 853: ! 854: fflush (stdout); ! 855: current_display_number = -1; ! 856: } ! 857: ! 858: /* Display all of the values on the auto-display chain. */ ! 859: ! 860: void ! 861: do_displays () ! 862: { ! 863: register struct display *d; ! 864: ! 865: for (d = display_chain; d; d = d->next) ! 866: do_one_display (d); ! 867: } ! 868: ! 869: /* Delete the auto-display which we were in the process of displaying. ! 870: This is done when there is an error or a signal. */ ! 871: ! 872: void ! 873: delete_current_display () ! 874: { ! 875: if (current_display_number >= 0) ! 876: { ! 877: delete_display (current_display_number); ! 878: fprintf (stderr, "Deleting display %d to avoid infinite recursion.\n", ! 879: current_display_number); ! 880: } ! 881: current_display_number = -1; ! 882: } ! 883: ! 884: static void ! 885: display_info () ! 886: { ! 887: register struct display *d; ! 888: ! 889: if (!display_chain) ! 890: printf ("There are no auto-display expressions now.\n"); ! 891: else ! 892: printf ("Auto-display expressions now in effect:\n"); ! 893: for (d = display_chain; d; d = d->next) ! 894: { ! 895: printf ("%d: ", d->number); ! 896: if (d->format.size) ! 897: printf ("/%d%c%c ", d->format.count, d->format.size, ! 898: d->format.format); ! 899: else if (d->format.format) ! 900: printf ("/%c ", d->format.format); ! 901: print_expression (d->exp, stdout); ! 902: printf ("\n"); ! 903: fflush (stdout); ! 904: } ! 905: } ! 906: ! 907: /* Print the value in stack frame FRAME of a variable ! 908: specified by a struct symbol. */ ! 909: ! 910: void ! 911: print_variable_value (var, frame, stream) ! 912: struct symbol *var; ! 913: CORE_ADDR frame; ! 914: FILE *stream; ! 915: { ! 916: value val = read_var_value (var, frame); ! 917: value_print (val, stream, 0); ! 918: } ! 919: ! 920: /* Print the arguments of a stack frame, given the function FUNC ! 921: running in that frame (as a symbol), the address of the arglist, ! 922: and the number of args according to the stack frame (or -1 if unknown). */ ! 923: ! 924: static void print_frame_nameless_args (); ! 925: ! 926: print_frame_args (func, addr, num, stream) ! 927: struct symbol *func; ! 928: register CORE_ADDR addr; ! 929: int num; ! 930: FILE *stream; ! 931: { ! 932: struct block *b; ! 933: int nsyms = 0; ! 934: int first = 1; ! 935: register int i; ! 936: register int last_offset = FRAME_ARGS_SKIP; ! 937: register struct symbol *sym, *nextsym; ! 938: register value val; ! 939: ! 940: if (func) ! 941: { ! 942: b = SYMBOL_BLOCK_VALUE (func); ! 943: nsyms = BLOCK_NSYMS (b); ! 944: } ! 945: ! 946: while (1) ! 947: { ! 948: /* Find first arg that is not before LAST_OFFSET. */ ! 949: nextsym = 0; ! 950: for (i = 0; i < nsyms; i++) ! 951: { ! 952: QUIT; ! 953: sym = BLOCK_SYM (b, i); ! 954: if (SYMBOL_CLASS (sym) == LOC_ARG ! 955: && SYMBOL_VALUE (sym) >= last_offset ! 956: && (nextsym == 0 ! 957: || SYMBOL_VALUE (sym) < SYMBOL_VALUE (nextsym))) ! 958: nextsym = sym; ! 959: } ! 960: if (nextsym == 0) ! 961: break; ! 962: sym = nextsym; ! 963: /* Print any nameless args between the last arg printed ! 964: and the next arg. */ ! 965: if (last_offset != (SYMBOL_VALUE (sym) / sizeof (int)) * sizeof (int)) ! 966: { ! 967: print_frame_nameless_args (addr, last_offset, SYMBOL_VALUE (sym), ! 968: stream); ! 969: first = 0; ! 970: } ! 971: /* Print the next arg. */ ! 972: val = value_at (SYMBOL_TYPE (sym), addr + SYMBOL_VALUE (sym)); ! 973: if (! first) ! 974: fprintf (stream, ", "); ! 975: fprintf (stream, "%s=", SYMBOL_NAME (sym)); ! 976: value_print (val, stream, 0); ! 977: first = 0; ! 978: last_offset = SYMBOL_VALUE (sym) + TYPE_LENGTH (SYMBOL_TYPE (sym)); ! 979: /* Round up address of next arg to multiple of size of int. */ ! 980: last_offset ! 981: = ((last_offset + sizeof (int) - 1) / sizeof (int)) * sizeof (int); ! 982: } ! 983: if (num >= 0 && num * sizeof (int) + FRAME_ARGS_SKIP > last_offset) ! 984: print_frame_nameless_args (addr, last_offset, ! 985: num * sizeof (int) + FRAME_ARGS_SKIP, stream); ! 986: } ! 987: ! 988: static void ! 989: print_frame_nameless_args (argsaddr, start, end, stream) ! 990: CORE_ADDR argsaddr; ! 991: int start; ! 992: int end; ! 993: FILE *stream; ! 994: { ! 995: while (start < end) ! 996: { ! 997: QUIT; ! 998: if (start != FRAME_ARGS_SKIP) ! 999: fprintf (stream, ", "); ! 1000: fprintf (stream, "%d", ! 1001: read_memory_integer (argsaddr + start, sizeof (int))); ! 1002: start += sizeof (int); ! 1003: } ! 1004: } ! 1005: ! 1006: static void ! 1007: printf_command (arg) ! 1008: char *arg; ! 1009: { ! 1010: register char *f; ! 1011: register char *s = arg; ! 1012: char *string; ! 1013: value *val_args; ! 1014: int nargs = 0; ! 1015: int allocated_args = 20; ! 1016: char *arg_bytes; ! 1017: char *argclass; ! 1018: int i; ! 1019: int argindex; ! 1020: int nargs_wanted; ! 1021: ! 1022: val_args = (value *) xmalloc (allocated_args * sizeof (value)); ! 1023: ! 1024: if (s == 0) ! 1025: error_no_arg ("format-control string and values to print"); ! 1026: ! 1027: /* Skip white space before format string */ ! 1028: while (*s == ' ' || *s == '\t') s++; ! 1029: ! 1030: /* A format string should follow, enveloped in double quotes */ ! 1031: if (*s++ != '"') ! 1032: error ("Bad format string, missing '\"'."); ! 1033: ! 1034: /* Parse the format-control string and copy it into the string STRING, ! 1035: processing some kinds of escape sequence. */ ! 1036: ! 1037: f = string = (char *) alloca (strlen (s) + 1); ! 1038: while (*s != '"') ! 1039: { ! 1040: int c = *s++; ! 1041: switch (c) ! 1042: { ! 1043: case '\0': ! 1044: error ("Bad format string, non-terminated '\"'."); ! 1045: /* doesn't return */ ! 1046: ! 1047: case '\\': ! 1048: switch (c = *s++) ! 1049: { ! 1050: case '\\': ! 1051: *f++ = '\\'; ! 1052: break; ! 1053: case 'n': ! 1054: *f++ = '\n'; ! 1055: break; ! 1056: case 't': ! 1057: *f++ = '\t'; ! 1058: break; ! 1059: case 'r': ! 1060: *f++ = '\r'; ! 1061: break; ! 1062: case '"': ! 1063: *f++ = '"'; ! 1064: break; ! 1065: default: ! 1066: /* ??? TODO: handle other escape sequences */ ! 1067: error ("Unrecognized \\ escape character in format string."); ! 1068: } ! 1069: break; ! 1070: ! 1071: default: ! 1072: *f++ = c; ! 1073: } ! 1074: } ! 1075: ! 1076: /* Skip over " and following space and comma. */ ! 1077: s++; ! 1078: *f++ = '\0'; ! 1079: while (*s == ' ' || *s == '\t') s++; ! 1080: ! 1081: if (*s != ',' && *s != 0) ! 1082: error ("Invalid argument syntax"); ! 1083: ! 1084: if (*s == ',') s++; ! 1085: while (*s == ' ' || *s == '\t') s++; ! 1086: ! 1087: /* Now scan the string for %-specs and see what kinds of args they want. ! 1088: argclass[I] is set to 1 if the Ith arg should be a string. */ ! 1089: ! 1090: argclass = (char *) alloca (strlen (s)); ! 1091: nargs_wanted = 0; ! 1092: f = string; ! 1093: while (*f) ! 1094: if (*f++ == '%') ! 1095: { ! 1096: while (index ("0123456789.hlL-+ #", *f)) f++; ! 1097: if (*f == 's') ! 1098: argclass[nargs_wanted++] = 1; ! 1099: else if (*f != '%') ! 1100: argclass[nargs_wanted++] = 0; ! 1101: f++; ! 1102: } ! 1103: ! 1104: /* Now, parse all arguments and evaluate them. ! 1105: Store the VALUEs in VAL_ARGS. */ ! 1106: ! 1107: while (*s != '\0') ! 1108: { ! 1109: char *s1; ! 1110: if (nargs == allocated_args) ! 1111: val_args = (value *) xrealloc (val_args, ! 1112: (allocated_args *= 2) ! 1113: * sizeof (value)); ! 1114: s1 = s; ! 1115: val_args[nargs++] = parse_to_comma_and_eval (&s1); ! 1116: s = s1; ! 1117: if (*s == ',') ! 1118: s++; ! 1119: } ! 1120: ! 1121: if (nargs != nargs_wanted) ! 1122: error ("Wrong number of arguments for specified format-string"); ! 1123: ! 1124: /* Now lay out an argument-list containing the arguments ! 1125: as doubles, integers and C pointers. */ ! 1126: ! 1127: arg_bytes = (char *) alloca (sizeof (double) * nargs); ! 1128: argindex = 0; ! 1129: for (i = 0; i < nargs; i++) ! 1130: { ! 1131: if (argclass[i]) ! 1132: { ! 1133: char *str; ! 1134: int tem, j; ! 1135: tem = value_as_long (val_args[i]); ! 1136: ! 1137: /* This is a %s argument. Find the length of the string. */ ! 1138: for (j = 0; ; j++) ! 1139: { ! 1140: char c; ! 1141: QUIT; ! 1142: read_memory (tem + j, &c, 1); ! 1143: if (c == 0) ! 1144: break; ! 1145: } ! 1146: ! 1147: /* Copy the string contents into a string inside GDB. */ ! 1148: str = (char *) alloca (j + 1); ! 1149: read_memory (tem, str, j); ! 1150: str[j] = 0; ! 1151: ! 1152: /* Pass address of internal copy as the arg to vprintf. */ ! 1153: *((int *) &arg_bytes[argindex]) = (int) str; ! 1154: argindex += sizeof (int); ! 1155: } ! 1156: else if (VALUE_TYPE (val_args[i])->code == TYPE_CODE_FLT) ! 1157: { ! 1158: *((double *) &arg_bytes[argindex]) = value_as_double (val_args[i]); ! 1159: argindex += sizeof (double); ! 1160: } ! 1161: else ! 1162: { ! 1163: *((int *) &arg_bytes[argindex]) = value_as_long (val_args[i]); ! 1164: argindex += sizeof (int); ! 1165: } ! 1166: } ! 1167: ! 1168: vprintf (string, arg_bytes); ! 1169: } ! 1170: ! 1171: static ! 1172: initialize () ! 1173: { ! 1174: current_display_number = -1; ! 1175: ! 1176: add_info ("address", address_info, ! 1177: "Describe where variable VAR is stored."); ! 1178: ! 1179: add_com ("x", class_vars, x_command, ! 1180: "Examine memory: x/FMT ADDRESS.\n\ ! 1181: ADDRESS is an expression for the memory address to examine.\n\ ! 1182: FMT is a repeat count followed by a format letter and a size letter.\n\ ! 1183: Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\ ! 1184: f(float), a(address), i(instruction), c(char) and s(string).\n\ ! 1185: Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\ ! 1186: g is meaningful only with f, for type double.\n\ ! 1187: The specified number of objects of the specified size are printed\n\ ! 1188: according to the format.\n\n\ ! 1189: Defaults for format and size letters are those previously used.\n\ ! 1190: Default count is 1. Default address is following last thing printed\n\ ! 1191: with this command or \"print\"."); ! 1192: ! 1193: add_com ("ptype", class_vars, ptype_command, ! 1194: "Print definition of type TYPE.\n\ ! 1195: Argument may be a type name defined by typedef, or \"struct STRUCTNAME\"\n\ ! 1196: or \"union UNIONNAME\" or \"enum ENUMNAME\".\n\ ! 1197: The selected stack frame's lexical context is used to look up the name."); ! 1198: ! 1199: add_com ("whatis", class_vars, whatis_command, ! 1200: "Print data type of expression EXP."); ! 1201: ! 1202: add_info ("display", display_info, ! 1203: "Expressions to display when program stops, with code numbers."); ! 1204: add_com ("undisplay", class_vars, undisplay_command, ! 1205: "Cancel some expressions to be displayed whenever program stops.\n\ ! 1206: Arguments are the code numbers of the expressions to stop displaying.\n\ ! 1207: No argument means cancel all automatic-display expressions.\n\ ! 1208: Do \"info display\" to see current list of code numbers."); ! 1209: add_com ("display", class_vars, display_command, ! 1210: "Print value of expression EXP each time the program stops.\n\ ! 1211: /FMT may be used before EXP as in the \"print\" command.\n\ ! 1212: /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\ ! 1213: as in the \"x\" command, and then EXP is used to get the address to examine\n\ ! 1214: and examining is done as in the \"x\" command.\n\n\ ! 1215: With no argument, display all currently requested auto-display expressions.\n\ ! 1216: Use \"undisplay\" to cancel display requests previously made."); ! 1217: ! 1218: add_com ("printf", class_vars, printf_command, ! 1219: "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\ ! 1220: This is useful for formatted output in user-defined commands."); ! 1221: add_com ("output", class_vars, output_command, ! 1222: "Like \"print\" but don't put in value history and don't print newline.\n\ ! 1223: This is useful in user-defined commands."); ! 1224: ! 1225: add_com ("set", class_vars, set_command, ! 1226: "Perform an assignment VAR = EXP. You must type the \"=\".\n\ ! 1227: VAR may be a debugger \"convenience\" variables (names starting with $),\n\ ! 1228: a register (a few standard names starting with $), or an actual variable\n\ ! 1229: in the program being debugger. EXP is any expression."); ! 1230: ! 1231: add_com ("print", class_vars, print_command, ! 1232: concat ("Print value of expression EXP.\n\ ! 1233: Variables accessible are those of the lexical environment of the selected\n\ ! 1234: stack frame, plus all those whose scope is global or an entire file.\n\ ! 1235: \n\ ! 1236: $NUM gets previous value number NUM. $ and $$ are the last two values.\n\ ! 1237: $$NUM refers to NUM'th value back from the last one.\n\ ! 1238: Names starting with $ refer to registers (with the values they would have\n\ ! 1239: if the program were to return to the stack frame now selected, restoring\n\ ! 1240: all registers saved by frames farther in) or else to debugger\n\ ! 1241: \"convenience\" variables (any such name not a known register).\n\ ! 1242: Use assignment expressions to give values to convenience variables.\n", ! 1243: "\n\ ! 1244: \{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\ ! 1245: @ is a binary operator for treating consecutive data objects\n\ ! 1246: anywhere in memory as an array. FOO@NUM gives an array whose first\n\ ! 1247: element is FOO, whose second element is stored in the space following\n\ ! 1248: where FOO is stored, etc. FOO must be an expression whose value\n\ ! 1249: resides in memory.\n", ! 1250: "\n\ ! 1251: EXP may be preceded with /FMT, where FMT is a format letter\n\ ! 1252: but no count or size letter (see \"x\" command).")); ! 1253: add_com_alias ("p", "print", class_vars, 1); ! 1254: } ! 1255: ! 1256: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.