gdb/printcmd.c

   1 /* Print values for GNU debugger GDB.
   2    Copyright 1986-1991, 1993-1995, 1998, 2000 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include "frame.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "value.h"
  27 #include "language.h"
  28 #include "expression.h"
  29 #include "gdbcore.h"
  30 #include "gdbcmd.h"
  31 #include "target.h"
  32 #include "breakpoint.h"
  33 #include "demangle.h"
  34 #include "valprint.h"
  35 #include "annotate.h"
  36 #include "symfile.h"            /* for overlay functions */
  37 #include "objfiles.h"           /* ditto */
  38 #ifdef UI_OUT
  39 #include "ui-out.h"
  40 #endif
  41
  42 extern int asm_demangle;        /* Whether to demangle syms in asm printouts */
  43 extern int addressprint;        /* Whether to print hex addresses in HLL " */
  44
  45 struct format_data
  46   {
  47     int count;
  48     char format;
  49     char size;
  50   };
  51
  52 /* Last specified output format.  */
  53
  54 static char last_format = 'x';
  55
  56 /* Last specified examination size.  'b', 'h', 'w' or `q'.  */
  57
  58 static char last_size = 'w';
  59
  60 /* Default address to examine next.  */
  61
  62 static CORE_ADDR next_address;
  63
  64 /* Default section to examine next. */
  65
  66 static asection *next_section;
  67
  68 /* Last address examined.  */
  69
  70 static CORE_ADDR last_examine_address;
  71
  72 /* Contents of last address examined.
  73    This is not valid past the end of the `x' command!  */
  74
  75 static value_ptr last_examine_value;
  76
  77 /* Largest offset between a symbolic value and an address, that will be
  78    printed as `0x1234 <symbol+offset>'.  */
  79
  80 static unsigned int max_symbolic_offset = UINT_MAX;
  81
  82 /* Append the source filename and linenumber of the symbol when
  83    printing a symbolic value as `<symbol at filename:linenum>' if set.  */
  84 static int print_symbol_filename = 0;
  85
  86 /* Number of auto-display expression currently being displayed.
  87    So that we can disable it if we get an error or a signal within it.
  88    -1 when not doing one.  */
  89
  90 int current_display_number;
  91
  92 /* Flag to low-level print routines that this value is being printed
  93    in an epoch window.  We'd like to pass this as a parameter, but
  94    every routine would need to take it.  Perhaps we can encapsulate
  95    this in the I/O stream once we have GNU stdio. */
  96
  97 int inspect_it = 0;
  98
  99 struct display
 100   {
 101     /* Chain link to next auto-display item.  */
 102     struct display *next;
 103     /* Expression to be evaluated and displayed.  */
 104     struct expression *exp;
 105     /* Item number of this auto-display item.  */
 106     int number;
 107     /* Display format specified.  */
 108     struct format_data format;
 109     /* Innermost block required by this expression when evaluated */
 110     struct block *block;
 111     /* Status of this display (enabled or disabled) */
 112     enum enable status;
 113   };
 114
 115 /* Chain of expressions whose values should be displayed
 116    automatically each time the program stops.  */
 117
 118 static struct display *display_chain;
 119
 120 static int display_number;
 121
 122 /* Prototypes for exported functions. */
 123
 124 void output_command PARAMS ((char *, int));
 125
 126 void _initialize_printcmd PARAMS ((void));
 127
 128 /* Prototypes for local functions. */
 129
 130 static void delete_display PARAMS ((int));
 131
 132 static void enable_display PARAMS ((char *, int));
 133
 134 static void disable_display_command PARAMS ((char *, int));
 135
 136 static void disassemble_command PARAMS ((char *, int));
 137
 138 static void printf_command PARAMS ((char *, int));
 139
 140 static void print_frame_nameless_args (struct frame_info *, long,
 141                                        int, int, struct ui_file *);
 142
 143 static void display_info PARAMS ((char *, int));
 144
 145 static void do_one_display PARAMS ((struct display *));
 146
 147 static void undisplay_command PARAMS ((char *, int));
 148
 149 static void free_display PARAMS ((struct display *));
 150
 151 static void display_command PARAMS ((char *, int));
 152
 153 void x_command PARAMS ((char *, int));
 154
 155 static void address_info PARAMS ((char *, int));
 156
 157 static void set_command PARAMS ((char *, int));
 158
 159 static void call_command PARAMS ((char *, int));
 160
 161 static void inspect_command PARAMS ((char *, int));
 162
 163 static void print_command PARAMS ((char *, int));
 164
 165 static void print_command_1 PARAMS ((char *, int, int));
 166
 167 static void validate_format PARAMS ((struct format_data, char *));
 168
 169 static void do_examine PARAMS ((struct format_data, CORE_ADDR addr, asection * section));
 170
 171 static void print_formatted (value_ptr, int, int, struct ui_file *);
 172
 173 static struct format_data decode_format PARAMS ((char **, int, int));
 174
 175 static int print_insn (CORE_ADDR, struct ui_file *);
 176
 177 static void sym_info PARAMS ((char *, int));
 178 \f
 179
 180 /* Decode a format specification.  *STRING_PTR should point to it.
 181    OFORMAT and OSIZE are used as defaults for the format and size
 182    if none are given in the format specification.
 183    If OSIZE is zero, then the size field of the returned value
 184    should be set only if a size is explicitly specified by the
 185    user.
 186    The structure returned describes all the data
 187    found in the specification.  In addition, *STRING_PTR is advanced
 188    past the specification and past all whitespace following it.  */
 189
 190 static struct format_data
 191 decode_format (string_ptr, oformat, osize)
 192      char **string_ptr;
 193      int oformat;
 194      int osize;
 195 {
 196   struct format_data val;
 197   register char *p = *string_ptr;
 198
 199   val.format = '?';
 200   val.size = '?';
 201   val.count = 1;
 202
 203   if (*p >= '0' && *p <= '9')
 204     val.count = atoi (p);
 205   while (*p >= '0' && *p <= '9')
 206     p++;
 207
 208   /* Now process size or format letters that follow.  */
 209
 210   while (1)
 211     {
 212       if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
 213         val.size = *p++;
 214       else if (*p >= 'a' && *p <= 'z')
 215         val.format = *p++;
 216       else
 217         break;
 218     }
 219
 220   while (*p == ' ' || *p == '\t')
 221     p++;
 222   *string_ptr = p;
 223
 224   /* Set defaults for format and size if not specified.  */
 225   if (val.format == '?')
 226     {
 227       if (val.size == '?')
 228         {
 229           /* Neither has been specified.  */
 230           val.format = oformat;
 231           val.size = osize;
 232         }
 233       else
 234         /* If a size is specified, any format makes a reasonable
 235            default except 'i'.  */
 236         val.format = oformat == 'i' ? 'x' : oformat;
 237     }
 238   else if (val.size == '?')
 239     switch (val.format)
 240       {
 241       case 'a':
 242       case 's':
 243         /* Pick the appropriate size for an address.  */
 244         if (TARGET_PTR_BIT == 64)
 245           val.size = osize ? 'g' : osize;
 246         else if (TARGET_PTR_BIT == 32)
 247           val.size = osize ? 'w' : osize;
 248         else if (TARGET_PTR_BIT == 16)
 249           val.size = osize ? 'h' : osize;
 250         else
 251           /* Bad value for TARGET_PTR_BIT */
 252           abort ();
 253         break;
 254       case 'f':
 255         /* Floating point has to be word or giantword.  */
 256         if (osize == 'w' || osize == 'g')
 257           val.size = osize;
 258         else
 259           /* Default it to giantword if the last used size is not
 260              appropriate.  */
 261           val.size = osize ? 'g' : osize;
 262         break;
 263       case 'c':
 264         /* Characters default to one byte.  */
 265         val.size = osize ? 'b' : osize;
 266         break;
 267       default:
 268         /* The default is the size most recently specified.  */
 269         val.size = osize;
 270       }
 271
 272   return val;
 273 }
 274 \f
 275 /* Print value VAL on stream according to FORMAT, a letter or 0.
 276    Do not end with a newline.
 277    0 means print VAL according to its own type.
 278    SIZE is the letter for the size of datum being printed.
 279    This is used to pad hex numbers so they line up.  */
 280
 281 static void
 282 print_formatted (val, format, size, stream)
 283      register value_ptr val;
 284      register int format;
 285      int size;
 286      struct ui_file *stream;
 287 {
 288   struct type *type = check_typedef (VALUE_TYPE (val));
 289   int len = TYPE_LENGTH (type);
 290
 291   if (VALUE_LVAL (val) == lval_memory)
 292     {
 293       next_address = VALUE_ADDRESS (val) + len;
 294       next_section = VALUE_BFD_SECTION (val);
 295     }
 296
 297   switch (format)
 298     {
 299     case 's':
 300       /* FIXME: Need to handle wchar_t's here... */
 301       next_address = VALUE_ADDRESS (val)
 302         + val_print_string (VALUE_ADDRESS (val), -1, 1, stream);
 303       next_section = VALUE_BFD_SECTION (val);
 304       break;
 305
 306     case 'i':
 307       /* The old comment says
 308          "Force output out, print_insn not using _filtered".
 309          I'm not completely sure what that means, I suspect most print_insn
 310          now do use _filtered, so I guess it's obsolete.
 311          --Yes, it does filter now, and so this is obsolete.  -JB  */
 312
 313       /* We often wrap here if there are long symbolic names.  */
 314       wrap_here ("    ");
 315       next_address = VALUE_ADDRESS (val)
 316         + print_insn (VALUE_ADDRESS (val), stream);
 317       next_section = VALUE_BFD_SECTION (val);
 318       break;
 319
 320     default:
 321       if (format == 0
 322           || TYPE_CODE (type) == TYPE_CODE_ARRAY
 323           || TYPE_CODE (type) == TYPE_CODE_STRING
 324           || TYPE_CODE (type) == TYPE_CODE_STRUCT
 325           || TYPE_CODE (type) == TYPE_CODE_UNION)
 326         /* If format is 0, use the 'natural' format for
 327          * that type of value.  If the type is non-scalar,
 328          * we have to use language rules to print it as
 329          * a series of scalars.
 330          */
 331         value_print (val, stream, format, Val_pretty_default);
 332       else
 333         /* User specified format, so don't look to the
 334          * the type to tell us what to do.
 335          */
 336         print_scalar_formatted (VALUE_CONTENTS (val), type,
 337                                 format, size, stream);
 338     }
 339 }
 340
 341 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
 342    according to letters FORMAT and SIZE on STREAM.
 343    FORMAT may not be zero.  Formats s and i are not supported at this level.
 344
 345    This is how the elements of an array or structure are printed
 346    with a format.  */
 347
 348 void
 349 print_scalar_formatted (valaddr, type, format, size, stream)
 350      char *valaddr;
 351      struct type *type;
 352      int format;
 353      int size;
 354      struct ui_file *stream;
 355 {
 356   LONGEST val_long;
 357   unsigned int len = TYPE_LENGTH (type);
 358
 359   if (len > sizeof (LONGEST)
 360       && (format == 't'
 361           || format == 'c'
 362           || format == 'o'
 363           || format == 'u'
 364           || format == 'd'
 365           || format == 'x'))
 366     {
 367       if (!TYPE_UNSIGNED (type)
 368           || !extract_long_unsigned_integer (valaddr, len, &val_long))
 369         {
 370           /* We can't print it normally, but we can print it in hex.
 371              Printing it in the wrong radix is more useful than saying
 372              "use /x, you dummy".  */
 373           /* FIXME:  we could also do octal or binary if that was the
 374              desired format.  */
 375           /* FIXME:  we should be using the size field to give us a
 376              minimum field width to print.  */
 377
 378           if (format == 'o')
 379             print_octal_chars (stream, valaddr, len);
 380           else if (format == 'd')
 381             print_decimal_chars (stream, valaddr, len);
 382           else if (format == 't')
 383             print_binary_chars (stream, valaddr, len);
 384           else
 385             /* replace with call to print_hex_chars? Looks
 386                like val_print_type_code_int is redoing
 387                work.  - edie */
 388
 389             val_print_type_code_int (type, valaddr, stream);
 390
 391           return;
 392         }
 393
 394       /* If we get here, extract_long_unsigned_integer set val_long.  */
 395     }
 396   else if (format != 'f')
 397     val_long = unpack_long (type, valaddr);
 398
 399   /* If we are printing it as unsigned, truncate it in case it is actually
 400      a negative signed value (e.g. "print/u (short)-1" should print 65535
 401      (if shorts are 16 bits) instead of 4294967295).  */
 402   if (format != 'd')
 403     {
 404       if (len < sizeof (LONGEST))
 405         val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
 406     }
 407
 408   switch (format)
 409     {
 410     case 'x':
 411       if (!size)
 412         {
 413           /* no size specified, like in print.  Print varying # of digits. */
 414           print_longest (stream, 'x', 1, val_long);
 415         }
 416       else
 417         switch (size)
 418           {
 419           case 'b':
 420           case 'h':
 421           case 'w':
 422           case 'g':
 423             print_longest (stream, size, 1, val_long);
 424             break;
 425           default:
 426             error ("Undefined output size \"%c\".", size);
 427           }
 428       break;
 429
 430     case 'd':
 431       print_longest (stream, 'd', 1, val_long);
 432       break;
 433
 434     case 'u':
 435       print_longest (stream, 'u', 0, val_long);
 436       break;
 437
 438     case 'o':
 439       if (val_long)
 440         print_longest (stream, 'o', 1, val_long);
 441       else
 442         fprintf_filtered (stream, "0");
 443       break;
 444
 445     case 'a':
 446       print_address (unpack_pointer (type, valaddr), stream);
 447       break;
 448
 449     case 'c':
 450       value_print (value_from_longest (builtin_type_true_char, val_long),
 451                    stream, 0, Val_pretty_default);
 452       break;
 453
 454     case 'f':
 455       if (len == sizeof (float))
 456           type = builtin_type_float;
 457       else if (len == sizeof (double))
 458           type = builtin_type_double;
 459       print_floating (valaddr, type, stream);
 460       break;
 461
 462     case 0:
 463       abort ();
 464
 465     case 't':
 466       /* Binary; 't' stands for "two".  */
 467       {
 468         char bits[8 * (sizeof val_long) + 1];
 469         char buf[8 * (sizeof val_long) + 32];
 470         char *cp = bits;
 471         int width;
 472
 473         if (!size)
 474           width = 8 * (sizeof val_long);
 475         else
 476           switch (size)
 477             {
 478             case 'b':
 479               width = 8;
 480               break;
 481             case 'h':
 482               width = 16;
 483               break;
 484             case 'w':
 485               width = 32;
 486               break;
 487             case 'g':
 488               width = 64;
 489               break;
 490             default:
 491               error ("Undefined output size \"%c\".", size);
 492             }
 493
 494         bits[width] = '\0';
 495         while (width-- > 0)
 496           {
 497             bits[width] = (val_long & 1) ? '1' : '0';
 498             val_long >>= 1;
 499           }
 500         if (!size)
 501           {
 502             while (*cp && *cp == '0')
 503               cp++;
 504             if (*cp == '\0')
 505               cp--;
 506           }
 507         strcpy (buf, local_binary_format_prefix ());
 508         strcat (buf, cp);
 509         strcat (buf, local_binary_format_suffix ());
 510         fprintf_filtered (stream, buf);
 511       }
 512       break;
 513
 514     default:
 515       error ("Undefined output format \"%c\".", format);
 516     }
 517 }
 518
 519 /* Specify default address for `x' command.
 520    `info lines' uses this.  */
 521
 522 void
 523 set_next_address (addr)
 524      CORE_ADDR addr;
 525 {
 526   next_address = addr;
 527
 528   /* Make address available to the user as $_.  */
 529   set_internalvar (lookup_internalvar ("_"),
 530                 value_from_longest (lookup_pointer_type (builtin_type_void),
 531                                     (LONGEST) addr));
 532 }
 533
 534 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
 535    after LEADIN.  Print nothing if no symbolic name is found nearby.
 536    Optionally also print source file and line number, if available.
 537    DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
 538    or to interpret it as a possible C++ name and convert it back to source
 539    form.  However note that DO_DEMANGLE can be overridden by the specific
 540    settings of the demangle and asm_demangle variables.  */
 541
 542 void
 543 print_address_symbolic (addr, stream, do_demangle, leadin)
 544      CORE_ADDR addr;
 545      struct ui_file *stream;
 546      int do_demangle;
 547      char *leadin;
 548 {
 549   struct minimal_symbol *msymbol;
 550   struct symbol *symbol;
 551   struct symtab *symtab = 0;
 552   CORE_ADDR name_location = 0;
 553   char *name = "";
 554   asection *section = 0;
 555   int unmapped = 0;
 556
 557   /* Determine if the address is in an overlay, and whether it is mapped. */
 558   if (overlay_debugging)
 559     {
 560       section = find_pc_overlay (addr);
 561       if (pc_in_unmapped_range (addr, section))
 562         {
 563           unmapped = 1;
 564           addr = overlay_mapped_address (addr, section);
 565         }
 566     }
 567
 568   /* On some targets, add in extra "flag" bits to PC for
 569      disassembly.  This should ensure that "rounding errors" in
 570      symbol addresses that are masked for disassembly favour the
 571      the correct symbol. */
 572
 573 #ifdef GDB_TARGET_UNMASK_DISAS_PC
 574   addr = GDB_TARGET_UNMASK_DISAS_PC (addr);
 575 #endif
 576
 577   /* First try to find the address in the symbol table, then
 578      in the minsyms.  Take the closest one.  */
 579
 580   /* This is defective in the sense that it only finds text symbols.  So
 581      really this is kind of pointless--we should make sure that the
 582      minimal symbols have everything we need (by changing that we could
 583      save some memory, but for many debug format--ELF/DWARF or
 584      anything/stabs--it would be inconvenient to eliminate those minimal
 585      symbols anyway).  */
 586   msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
 587   symbol = find_pc_sect_function (addr, section);
 588
 589   if (symbol)
 590     {
 591       name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
 592       if (do_demangle)
 593         name = SYMBOL_SOURCE_NAME (symbol);
 594       else
 595         name = SYMBOL_LINKAGE_NAME (symbol);
 596     }
 597
 598   if (msymbol != NULL)
 599     {
 600       if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
 601         {
 602           /* The msymbol is closer to the address than the symbol;
 603              use the msymbol instead.  */
 604           symbol = 0;
 605           symtab = 0;
 606           name_location = SYMBOL_VALUE_ADDRESS (msymbol);
 607           if (do_demangle)
 608             name = SYMBOL_SOURCE_NAME (msymbol);
 609           else
 610             name = SYMBOL_LINKAGE_NAME (msymbol);
 611         }
 612     }
 613   if (symbol == NULL && msymbol == NULL)
 614     return;
 615
 616   /* On some targets, mask out extra "flag" bits from PC for handsome
 617      disassembly. */
 618
 619 #ifdef GDB_TARGET_MASK_DISAS_PC
 620   name_location = GDB_TARGET_MASK_DISAS_PC (name_location);
 621   addr = GDB_TARGET_MASK_DISAS_PC (addr);
 622 #endif
 623
 624   /* If the nearest symbol is too far away, don't print anything symbolic.  */
 625
 626   /* For when CORE_ADDR is larger than unsigned int, we do math in
 627      CORE_ADDR.  But when we detect unsigned wraparound in the
 628      CORE_ADDR math, we ignore this test and print the offset,
 629      because addr+max_symbolic_offset has wrapped through the end
 630      of the address space back to the beginning, giving bogus comparison.  */
 631   if (addr > name_location + max_symbolic_offset
 632       && name_location + max_symbolic_offset > name_location)
 633     return;
 634
 635   fputs_filtered (leadin, stream);
 636   if (unmapped)
 637     fputs_filtered ("<*", stream);
 638   else
 639     fputs_filtered ("<", stream);
 640   fputs_filtered (name, stream);
 641   if (addr != name_location)
 642     fprintf_filtered (stream, "+%u", (unsigned int) (addr - name_location));
 643
 644   /* Append source filename and line number if desired.  Give specific
 645      line # of this addr, if we have it; else line # of the nearest symbol.  */
 646   if (print_symbol_filename)
 647     {
 648       struct symtab_and_line sal;
 649
 650       sal = find_pc_sect_line (addr, section, 0);
 651
 652       if (sal.symtab)
 653         fprintf_filtered (stream, " at %s:%d", sal.symtab->filename, sal.line);
 654       else if (symtab && symbol && symbol->line)
 655         fprintf_filtered (stream, " at %s:%d", symtab->filename, symbol->line);
 656       else if (symtab)
 657         fprintf_filtered (stream, " in %s", symtab->filename);
 658     }
 659   if (unmapped)
 660     fputs_filtered ("*>", stream);
 661   else
 662     fputs_filtered (">", stream);
 663 }
 664
 665
 666 /* Print address ADDR on STREAM.  USE_LOCAL means the same thing as for
 667    print_longest.  */
 668 void
 669 print_address_numeric (addr, use_local, stream)
 670      CORE_ADDR addr;
 671      int use_local;
 672      struct ui_file *stream;
 673 {
 674   /* This assumes a CORE_ADDR can fit in a LONGEST.  Probably a safe
 675      assumption.  */
 676   print_longest (stream, 'x', use_local, (ULONGEST) addr);
 677 }
 678
 679 /* Print address ADDR symbolically on STREAM.
 680    First print it as a number.  Then perhaps print
 681    <SYMBOL + OFFSET> after the number.  */
 682
 683 void
 684 print_address (addr, stream)
 685      CORE_ADDR addr;
 686      struct ui_file *stream;
 687 {
 688   print_address_numeric (addr, 1, stream);
 689   print_address_symbolic (addr, stream, asm_demangle, " ");
 690 }
 691
 692 /* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE
 693    controls whether to print the symbolic name "raw" or demangled.
 694    Global setting "addressprint" controls whether to print hex address
 695    or not.  */
 696
 697 void
 698 print_address_demangle (addr, stream, do_demangle)
 699      CORE_ADDR addr;
 700      struct ui_file *stream;
 701      int do_demangle;
 702 {
 703   if (addr == 0)
 704     {
 705       fprintf_filtered (stream, "0");
 706     }
 707   else if (addressprint)
 708     {
 709       print_address_numeric (addr, 1, stream);
 710       print_address_symbolic (addr, stream, do_demangle, " ");
 711     }
 712   else
 713     {
 714       print_address_symbolic (addr, stream, do_demangle, "");
 715     }
 716 }
 717 \f
 718
 719 /* These are the types that $__ will get after an examine command of one
 720    of these sizes.  */
 721
 722 static struct type *examine_i_type;
 723
 724 static struct type *examine_b_type;
 725 static struct type *examine_h_type;
 726 static struct type *examine_w_type;
 727 static struct type *examine_g_type;
 728
 729 /* Examine data at address ADDR in format FMT.
 730    Fetch it from memory and print on gdb_stdout.  */
 731
 732 static void
 733 do_examine (fmt, addr, sect)
 734      struct format_data fmt;
 735      CORE_ADDR addr;
 736      asection *sect;
 737 {
 738   register char format = 0;
 739   register char size;
 740   register int count = 1;
 741   struct type *val_type = NULL;
 742   register int i;
 743   register int maxelts;
 744
 745   format = fmt.format;
 746   size = fmt.size;
 747   count = fmt.count;
 748   next_address = addr;
 749   next_section = sect;
 750
 751   /* String or instruction format implies fetch single bytes
 752      regardless of the specified size.  */
 753   if (format == 's' || format == 'i')
 754     size = 'b';
 755
 756   if (format == 'i')
 757     val_type = examine_i_type;
 758   else if (size == 'b')
 759     val_type = examine_b_type;
 760   else if (size == 'h')
 761     val_type = examine_h_type;
 762   else if (size == 'w')
 763     val_type = examine_w_type;
 764   else if (size == 'g')
 765     val_type = examine_g_type;
 766
 767   maxelts = 8;
 768   if (size == 'w')
 769     maxelts = 4;
 770   if (size == 'g')
 771     maxelts = 2;
 772   if (format == 's' || format == 'i')
 773     maxelts = 1;
 774
 775   /* Print as many objects as specified in COUNT, at most maxelts per line,
 776      with the address of the next one at the start of each line.  */
 777
 778   while (count > 0)
 779     {
 780       QUIT;
 781       print_address (next_address, gdb_stdout);
 782       printf_filtered (":");
 783       for (i = maxelts;
 784            i > 0 && count > 0;
 785            i--, count--)
 786         {
 787           printf_filtered ("\t");
 788           /* Note that print_formatted sets next_address for the next
 789              object.  */
 790           last_examine_address = next_address;
 791
 792           if (last_examine_value)
 793             value_free (last_examine_value);
 794
 795           /* The value to be displayed is not fetched greedily.
 796              Instead, to avoid the posibility of a fetched value not
 797              being used, its retreval is delayed until the print code
 798              uses it.  When examining an instruction stream, the
 799              disassembler will perform its own memory fetch using just
 800              the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
 801              the disassembler be modified so that LAST_EXAMINE_VALUE
 802              is left with the byte sequence from the last complete
 803              instruction fetched from memory? */
 804           last_examine_value = value_at_lazy (val_type, next_address, sect);
 805
 806           if (last_examine_value)
 807             release_value (last_examine_value);
 808
 809           print_formatted (last_examine_value, format, size, gdb_stdout);
 810         }
 811       printf_filtered ("\n");
 812       gdb_flush (gdb_stdout);
 813     }
 814 }
 815 \f
 816 static void
 817 validate_format (fmt, cmdname)
 818      struct format_data fmt;
 819      char *cmdname;
 820 {
 821   if (fmt.size != 0)
 822     error ("Size letters are meaningless in \"%s\" command.", cmdname);
 823   if (fmt.count != 1)
 824     error ("Item count other than 1 is meaningless in \"%s\" command.",
 825            cmdname);
 826   if (fmt.format == 'i' || fmt.format == 's')
 827     error ("Format letter \"%c\" is meaningless in \"%s\" command.",
 828            fmt.format, cmdname);
 829 }
 830
 831 /*  Evaluate string EXP as an expression in the current language and
 832    print the resulting value.  EXP may contain a format specifier as the
 833    first argument ("/x myvar" for example, to print myvar in hex).
 834  */
 835
 836 static void
 837 print_command_1 (exp, inspect, voidprint)
 838      char *exp;
 839      int inspect;
 840      int voidprint;
 841 {
 842   struct expression *expr;
 843   register struct cleanup *old_chain = 0;
 844   register char format = 0;
 845   register value_ptr val;
 846   struct format_data fmt;
 847   int cleanup = 0;
 848
 849   /* Pass inspect flag to the rest of the print routines in a global (sigh). */
 850   inspect_it = inspect;
 851
 852   if (exp && *exp == '/')
 853     {
 854       exp++;
 855       fmt = decode_format (&exp, last_format, 0);
 856       validate_format (fmt, "print");
 857       last_format = format = fmt.format;
 858     }
 859   else
 860     {
 861       fmt.count = 1;
 862       fmt.format = 0;
 863       fmt.size = 0;
 864     }
 865
 866   if (exp && *exp)
 867     {
 868       struct type *type;
 869       expr = parse_expression (exp);
 870       old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
 871                                 &expr);
 872       cleanup = 1;
 873       val = evaluate_expression (expr);
 874
 875       /* C++: figure out what type we actually want to print it as.  */
 876       type = VALUE_TYPE (val);
 877
 878       if (objectprint
 879           && (TYPE_CODE (type) == TYPE_CODE_PTR
 880               || TYPE_CODE (type) == TYPE_CODE_REF)
 881           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT
 882               || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_UNION))
 883         {
 884           value_ptr v;
 885
 886           v = value_from_vtable_info (val, TYPE_TARGET_TYPE (type));
 887           if (v != 0)
 888             {
 889               val = v;
 890               type = VALUE_TYPE (val);
 891             }
 892         }
 893     }
 894   else
 895     val = access_value_history (0);
 896
 897   if (voidprint || (val && VALUE_TYPE (val) &&
 898                     TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
 899     {
 900       int histindex = record_latest_value (val);
 901
 902       if (histindex >= 0)
 903         annotate_value_history_begin (histindex, VALUE_TYPE (val));
 904       else
 905         annotate_value_begin (VALUE_TYPE (val));
 906
 907       if (inspect)
 908         printf_unfiltered ("\031(gdb-makebuffer \"%s\"  %d '(\"", exp, histindex);
 909       else if (histindex >= 0)
 910         printf_filtered ("$%d = ", histindex);
 911
 912       if (histindex >= 0)
 913         annotate_value_history_value ();
 914
 915       print_formatted (val, format, fmt.size, gdb_stdout);
 916       printf_filtered ("\n");
 917
 918       if (histindex >= 0)
 919         annotate_value_history_end ();
 920       else
 921         annotate_value_end ();
 922
 923       if (inspect)
 924         printf_unfiltered ("\") )\030");
 925     }
 926
 927   if (cleanup)
 928     do_cleanups (old_chain);
 929   inspect_it = 0;               /* Reset print routines to normal */
 930 }
 931
 932 /* ARGSUSED */
 933 static void
 934 print_command (exp, from_tty)
 935      char *exp;
 936      int from_tty;
 937 {
 938   print_command_1 (exp, 0, 1);
 939 }
 940
 941 /* Same as print, except in epoch, it gets its own window */
 942 /* ARGSUSED */
 943 static void
 944 inspect_command (exp, from_tty)
 945      char *exp;
 946      int from_tty;
 947 {
 948   extern int epoch_interface;
 949
 950   print_command_1 (exp, epoch_interface, 1);
 951 }
 952
 953 /* Same as print, except it doesn't print void results. */
 954 /* ARGSUSED */
 955 static void
 956 call_command (exp, from_tty)
 957      char *exp;
 958      int from_tty;
 959 {
 960   print_command_1 (exp, 0, 0);
 961 }
 962
 963 /* ARGSUSED */
 964 void
 965 output_command (exp, from_tty)
 966      char *exp;
 967      int from_tty;
 968 {
 969   struct expression *expr;
 970   register struct cleanup *old_chain;
 971   register char format = 0;
 972   register value_ptr val;
 973   struct format_data fmt;
 974
 975   if (exp && *exp == '/')
 976     {
 977       exp++;
 978       fmt = decode_format (&exp, 0, 0);
 979       validate_format (fmt, "output");
 980       format = fmt.format;
 981     }
 982
 983   expr = parse_expression (exp);
 984   old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
 985
 986   val = evaluate_expression (expr);
 987
 988   annotate_value_begin (VALUE_TYPE (val));
 989
 990   print_formatted (val, format, fmt.size, gdb_stdout);
 991
 992   annotate_value_end ();
 993
 994   wrap_here ("");
 995   gdb_flush (gdb_stdout);
 996
 997   do_cleanups (old_chain);
 998 }
 999
1000 /* ARGSUSED */
1001 static void
1002 set_command (exp, from_tty)
1003      char *exp;
1004      int from_tty;
1005 {
1006   struct expression *expr = parse_expression (exp);
1007   register struct cleanup *old_chain
1008   = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
1009   evaluate_expression (expr);
1010   do_cleanups (old_chain);
1011 }
1012
1013 /* ARGSUSED */
1014 static void
1015 sym_info (arg, from_tty)
1016      char *arg;
1017      int from_tty;
1018 {
1019   struct minimal_symbol *msymbol;
1020   struct objfile *objfile;
1021   struct obj_section *osect;
1022   asection *sect;
1023   CORE_ADDR addr, sect_addr;
1024   int matches = 0;
1025   unsigned int offset;
1026
1027   if (!arg)
1028     error_no_arg ("address");
1029
1030   addr = parse_and_eval_address (arg);
1031   ALL_OBJSECTIONS (objfile, osect)
1032   {
1033     sect = osect->the_bfd_section;
1034     sect_addr = overlay_mapped_address (addr, sect);
1035
1036     if (osect->addr <= sect_addr && sect_addr < osect->endaddr &&
1037         (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect)))
1038       {
1039         matches = 1;
1040         offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
1041         if (offset)
1042           printf_filtered ("%s + %u in ",
1043                            SYMBOL_SOURCE_NAME (msymbol), offset);
1044         else
1045           printf_filtered ("%s in ",
1046                            SYMBOL_SOURCE_NAME (msymbol));
1047         if (pc_in_unmapped_range (addr, sect))
1048           printf_filtered ("load address range of ");
1049         if (section_is_overlay (sect))
1050           printf_filtered ("%s overlay ",
1051                            section_is_mapped (sect) ? "mapped" : "unmapped");
1052         printf_filtered ("section %s", sect->name);
1053         printf_filtered ("\n");
1054       }
1055   }
1056   if (matches == 0)
1057     printf_filtered ("No symbol matches %s.\n", arg);
1058 }
1059
1060 /* ARGSUSED */
1061 static void
1062 address_info (exp, from_tty)
1063      char *exp;
1064      int from_tty;
1065 {
1066   register struct symbol *sym;
1067   register struct minimal_symbol *msymbol;
1068   register long val;
1069   register long basereg;
1070   asection *section;
1071   CORE_ADDR load_addr;
1072   int is_a_field_of_this;       /* C++: lookup_symbol sets this to nonzero
1073                                    if exp is a field of `this'. */
1074
1075   if (exp == 0)
1076     error ("Argument required.");
1077
1078   sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE,
1079                        &is_a_field_of_this, (struct symtab **) NULL);
1080   if (sym == NULL)
1081     {
1082       if (is_a_field_of_this)
1083         {
1084           printf_filtered ("Symbol \"");
1085           fprintf_symbol_filtered (gdb_stdout, exp,
1086                                    current_language->la_language, DMGL_ANSI);
1087           printf_filtered ("\" is a field of the local class variable `this'\n");
1088           return;
1089         }
1090
1091       msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1092
1093       if (msymbol != NULL)
1094         {
1095           load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1096
1097           printf_filtered ("Symbol \"");
1098           fprintf_symbol_filtered (gdb_stdout, exp,
1099                                    current_language->la_language, DMGL_ANSI);
1100           printf_filtered ("\" is at ");
1101           print_address_numeric (load_addr, 1, gdb_stdout);
1102           printf_filtered (" in a file compiled without debugging");
1103           section = SYMBOL_BFD_SECTION (msymbol);
1104           if (section_is_overlay (section))
1105             {
1106               load_addr = overlay_unmapped_address (load_addr, section);
1107               printf_filtered (",\n -- loaded at ");
1108               print_address_numeric (load_addr, 1, gdb_stdout);
1109               printf_filtered (" in overlay section %s", section->name);
1110             }
1111           printf_filtered (".\n");
1112         }
1113       else
1114         error ("No symbol \"%s\" in current context.", exp);
1115       return;
1116     }
1117
1118   printf_filtered ("Symbol \"");
1119   fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
1120                            current_language->la_language, DMGL_ANSI);
1121   printf_filtered ("\" is ");
1122   val = SYMBOL_VALUE (sym);
1123   basereg = SYMBOL_BASEREG (sym);
1124   section = SYMBOL_BFD_SECTION (sym);
1125
1126   switch (SYMBOL_CLASS (sym))
1127     {
1128     case LOC_CONST:
1129     case LOC_CONST_BYTES:
1130       printf_filtered ("constant");
1131       break;
1132
1133     case LOC_LABEL:
1134       printf_filtered ("a label at address ");
1135       print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1136                              1, gdb_stdout);
1137       if (section_is_overlay (section))
1138         {
1139           load_addr = overlay_unmapped_address (load_addr, section);
1140           printf_filtered (",\n -- loaded at ");
1141           print_address_numeric (load_addr, 1, gdb_stdout);
1142           printf_filtered (" in overlay section %s", section->name);
1143         }
1144       break;
1145
1146     case LOC_REGISTER:
1147       printf_filtered ("a variable in register %s", REGISTER_NAME (val));
1148       break;
1149
1150     case LOC_STATIC:
1151       printf_filtered ("static storage at address ");
1152       print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1153                              1, gdb_stdout);
1154       if (section_is_overlay (section))
1155         {
1156           load_addr = overlay_unmapped_address (load_addr, section);
1157           printf_filtered (",\n -- loaded at ");
1158           print_address_numeric (load_addr, 1, gdb_stdout);
1159           printf_filtered (" in overlay section %s", section->name);
1160         }
1161       break;
1162
1163     case LOC_INDIRECT:
1164       printf_filtered ("external global (indirect addressing), at address *(");
1165       print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1166                              1, gdb_stdout);
1167       printf_filtered (")");
1168       if (section_is_overlay (section))
1169         {
1170           load_addr = overlay_unmapped_address (load_addr, section);
1171           printf_filtered (",\n -- loaded at ");
1172           print_address_numeric (load_addr, 1, gdb_stdout);
1173           printf_filtered (" in overlay section %s", section->name);
1174         }
1175       break;
1176
1177     case LOC_REGPARM:
1178       printf_filtered ("an argument in register %s", REGISTER_NAME (val));
1179       break;
1180
1181     case LOC_REGPARM_ADDR:
1182       printf_filtered ("address of an argument in register %s", REGISTER_NAME (val));
1183       break;
1184
1185     case LOC_ARG:
1186       printf_filtered ("an argument at offset %ld", val);
1187       break;
1188
1189     case LOC_LOCAL_ARG:
1190       printf_filtered ("an argument at frame offset %ld", val);
1191       break;
1192
1193     case LOC_LOCAL:
1194       printf_filtered ("a local variable at frame offset %ld", val);
1195       break;
1196
1197     case LOC_REF_ARG:
1198       printf_filtered ("a reference argument at offset %ld", val);
1199       break;
1200
1201     case LOC_BASEREG:
1202       printf_filtered ("a variable at offset %ld from register %s",
1203                        val, REGISTER_NAME (basereg));
1204       break;
1205
1206     case LOC_BASEREG_ARG:
1207       printf_filtered ("an argument at offset %ld from register %s",
1208                        val, REGISTER_NAME (basereg));
1209       break;
1210
1211     case LOC_TYPEDEF:
1212       printf_filtered ("a typedef");
1213       break;
1214
1215     case LOC_BLOCK:
1216       printf_filtered ("a function at address ");
1217 #ifdef GDB_TARGET_MASK_DISAS_PC
1218       print_address_numeric
1219         (load_addr = GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))),
1220          1, gdb_stdout);
1221 #else
1222       print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
1223                              1, gdb_stdout);
1224 #endif
1225       if (section_is_overlay (section))
1226         {
1227           load_addr = overlay_unmapped_address (load_addr, section);
1228           printf_filtered (",\n -- loaded at ");
1229           print_address_numeric (load_addr, 1, gdb_stdout);
1230           printf_filtered (" in overlay section %s", section->name);
1231         }
1232       break;
1233
1234     case LOC_UNRESOLVED:
1235       {
1236         struct minimal_symbol *msym;
1237
1238         msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
1239         if (msym == NULL)
1240           printf_filtered ("unresolved");
1241         else
1242           {
1243             section = SYMBOL_BFD_SECTION (msym);
1244             printf_filtered ("static storage at address ");
1245             print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym),
1246                                    1, gdb_stdout);
1247             if (section_is_overlay (section))
1248               {
1249                 load_addr = overlay_unmapped_address (load_addr, section);
1250                 printf_filtered (",\n -- loaded at ");
1251                 print_address_numeric (load_addr, 1, gdb_stdout);
1252                 printf_filtered (" in overlay section %s", section->name);
1253               }
1254           }
1255       }
1256       break;
1257
1258     case LOC_THREAD_LOCAL_STATIC:
1259       printf_filtered (
1260                         "a thread-local variable at offset %ld from the thread base register %s",
1261                         val, REGISTER_NAME (basereg));
1262       break;
1263
1264     case LOC_OPTIMIZED_OUT:
1265       printf_filtered ("optimized out");
1266       break;
1267
1268     default:
1269       printf_filtered ("of unknown (botched) type");
1270       break;
1271     }
1272   printf_filtered (".\n");
1273 }
1274 \f
1275 void
1276 x_command (exp, from_tty)
1277      char *exp;
1278      int from_tty;
1279 {
1280   struct expression *expr;
1281   struct format_data fmt;
1282   struct cleanup *old_chain;
1283   struct value *val;
1284
1285   fmt.format = last_format;
1286   fmt.size = last_size;
1287   fmt.count = 1;
1288
1289   if (exp && *exp == '/')
1290     {
1291       exp++;
1292       fmt = decode_format (&exp, last_format, last_size);
1293     }
1294
1295   /* If we have an expression, evaluate it and use it as the address.  */
1296
1297   if (exp != 0 && *exp != 0)
1298     {
1299       expr = parse_expression (exp);
1300       /* Cause expression not to be there any more
1301          if this command is repeated with Newline.
1302          But don't clobber a user-defined command's definition.  */
1303       if (from_tty)
1304         *exp = 0;
1305       old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
1306                                 &expr);
1307       val = evaluate_expression (expr);
1308       if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
1309         val = value_ind (val);
1310       /* In rvalue contexts, such as this, functions are coerced into
1311          pointers to functions.  This makes "x/i main" work.  */
1312       if (                      /* last_format == 'i'
1313                                    && */ TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
1314            && VALUE_LVAL (val) == lval_memory)
1315         next_address = VALUE_ADDRESS (val);
1316       else
1317         next_address = value_as_pointer (val);
1318       if (VALUE_BFD_SECTION (val))
1319         next_section = VALUE_BFD_SECTION (val);
1320       do_cleanups (old_chain);
1321     }
1322
1323   do_examine (fmt, next_address, next_section);
1324
1325   /* If the examine succeeds, we remember its size and format for next time.  */
1326   last_size = fmt.size;
1327   last_format = fmt.format;
1328
1329   /* Set a couple of internal variables if appropriate. */
1330   if (last_examine_value)
1331     {
1332       /* Make last address examined available to the user as $_.  Use
1333          the correct pointer type.  */
1334       set_internalvar (lookup_internalvar ("_"),
1335                        value_from_longest (
1336                       lookup_pointer_type (VALUE_TYPE (last_examine_value)),
1337                                             (LONGEST) last_examine_address));
1338
1339       /* Make contents of last address examined available to the user as $__. */
1340       /* If the last value has not been fetched from memory then don't
1341          fetch it now - instead mark it by voiding the $__ variable. */
1342       if (VALUE_LAZY (last_examine_value))
1343         set_internalvar (lookup_internalvar ("__"),
1344                          allocate_value (builtin_type_void));
1345       else
1346         set_internalvar (lookup_internalvar ("__"), last_examine_value);
1347     }
1348 }
1349 \f
1350
1351 /* Add an expression to the auto-display chain.
1352    Specify the expression.  */
1353
1354 static void
1355 display_command (exp, from_tty)
1356      char *exp;
1357      int from_tty;
1358 {
1359   struct format_data fmt;
1360   register struct expression *expr;
1361   register struct display *new;
1362   int display_it = 1;
1363
1364 #if defined(TUI)
1365   if (tui_version && *exp == '$')
1366     display_it = ((TuiStatus) tuiDo (
1367                   (TuiOpaqueFuncPtr) tui_vSetLayoutTo, exp) == TUI_FAILURE);
1368 #endif
1369
1370   if (display_it)
1371     {
1372       if (exp == 0)
1373         {
1374           do_displays ();
1375           return;
1376         }
1377
1378       if (*exp == '/')
1379         {
1380           exp++;
1381           fmt = decode_format (&exp, 0, 0);
1382           if (fmt.size && fmt.format == 0)
1383             fmt.format = 'x';
1384           if (fmt.format == 'i' || fmt.format == 's')
1385             fmt.size = 'b';
1386         }
1387       else
1388         {
1389           fmt.format = 0;
1390           fmt.size = 0;
1391           fmt.count = 0;
1392         }
1393
1394       innermost_block = 0;
1395       expr = parse_expression (exp);
1396
1397       new = (struct display *) xmalloc (sizeof (struct display));
1398
1399       new->exp = expr;
1400       new->block = innermost_block;
1401       new->next = display_chain;
1402       new->number = ++display_number;
1403       new->format = fmt;
1404       new->status = enabled;
1405       display_chain = new;
1406
1407       if (from_tty && target_has_execution)
1408         do_one_display (new);
1409
1410       dont_repeat ();
1411     }
1412 }
1413
1414 static void
1415 free_display (d)
1416      struct display *d;
1417 {
1418   free ((PTR) d->exp);
1419   free ((PTR) d);
1420 }
1421
1422 /* Clear out the display_chain.
1423    Done when new symtabs are loaded, since this invalidates
1424    the types stored in many expressions.  */
1425
1426 void
1427 clear_displays ()
1428 {
1429   register struct display *d;
1430
1431   while ((d = display_chain) != NULL)
1432     {
1433       free ((PTR) d->exp);
1434       display_chain = d->next;
1435       free ((PTR) d);
1436     }
1437 }
1438
1439 /* Delete the auto-display number NUM.  */
1440
1441 static void
1442 delete_display (num)
1443      int num;
1444 {
1445   register struct display *d1, *d;
1446
1447   if (!display_chain)
1448     error ("No display number %d.", num);
1449
1450   if (display_chain->number == num)
1451     {
1452       d1 = display_chain;
1453       display_chain = d1->next;
1454       free_display (d1);
1455     }
1456   else
1457     for (d = display_chain;; d = d->next)
1458       {
1459         if (d->next == 0)
1460           error ("No display number %d.", num);
1461         if (d->next->number == num)
1462           {
1463             d1 = d->next;
1464             d->next = d1->next;
1465             free_display (d1);
1466             break;
1467           }
1468       }
1469 }
1470
1471 /* Delete some values from the auto-display chain.
1472    Specify the element numbers.  */
1473
1474 static void
1475 undisplay_command (args, from_tty)
1476      char *args;
1477      int from_tty;
1478 {
1479   register char *p = args;
1480   register char *p1;
1481   register int num;
1482
1483   if (args == 0)
1484     {
1485       if (query ("Delete all auto-display expressions? "))
1486         clear_displays ();
1487       dont_repeat ();
1488       return;
1489     }
1490
1491   while (*p)
1492     {
1493       p1 = p;
1494       while (*p1 >= '0' && *p1 <= '9')
1495         p1++;
1496       if (*p1 && *p1 != ' ' && *p1 != '\t')
1497         error ("Arguments must be display numbers.");
1498
1499       num = atoi (p);
1500
1501       delete_display (num);
1502
1503       p = p1;
1504       while (*p == ' ' || *p == '\t')
1505         p++;
1506     }
1507   dont_repeat ();
1508 }
1509
1510 /* Display a single auto-display.
1511    Do nothing if the display cannot be printed in the current context,
1512    or if the display is disabled. */
1513
1514 static void
1515 do_one_display (d)
1516      struct display *d;
1517 {
1518   int within_current_scope;
1519
1520   if (d->status == disabled)
1521     return;
1522
1523   if (d->block)
1524     within_current_scope = contained_in (get_selected_block (), d->block);
1525   else
1526     within_current_scope = 1;
1527   if (!within_current_scope)
1528     return;
1529
1530   current_display_number = d->number;
1531
1532   annotate_display_begin ();
1533   printf_filtered ("%d", d->number);
1534   annotate_display_number_end ();
1535   printf_filtered (": ");
1536   if (d->format.size)
1537     {
1538       CORE_ADDR addr;
1539       value_ptr val;
1540
1541       annotate_display_format ();
1542
1543       printf_filtered ("x/");
1544       if (d->format.count != 1)
1545         printf_filtered ("%d", d->format.count);
1546       printf_filtered ("%c", d->format.format);
1547       if (d->format.format != 'i' && d->format.format != 's')
1548         printf_filtered ("%c", d->format.size);
1549       printf_filtered (" ");
1550
1551       annotate_display_expression ();
1552
1553       print_expression (d->exp, gdb_stdout);
1554       annotate_display_expression_end ();
1555
1556       if (d->format.count != 1)
1557         printf_filtered ("\n");
1558       else
1559         printf_filtered ("  ");
1560
1561       val = evaluate_expression (d->exp);
1562       addr = value_as_pointer (val);
1563       if (d->format.format == 'i')
1564         addr = ADDR_BITS_REMOVE (addr);
1565
1566       annotate_display_value ();
1567
1568       do_examine (d->format, addr, VALUE_BFD_SECTION (val));
1569     }
1570   else
1571     {
1572       annotate_display_format ();
1573
1574       if (d->format.format)
1575         printf_filtered ("/%c ", d->format.format);
1576
1577       annotate_display_expression ();
1578
1579       print_expression (d->exp, gdb_stdout);
1580       annotate_display_expression_end ();
1581
1582       printf_filtered (" = ");
1583
1584       annotate_display_expression ();
1585
1586       print_formatted (evaluate_expression (d->exp),
1587                        d->format.format, d->format.size, gdb_stdout);
1588       printf_filtered ("\n");
1589     }
1590
1591   annotate_display_end ();
1592
1593   gdb_flush (gdb_stdout);
1594   current_display_number = -1;
1595 }
1596
1597 /* Display all of the values on the auto-display chain which can be
1598    evaluated in the current scope.  */
1599
1600 void
1601 do_displays ()
1602 {
1603   register struct display *d;
1604
1605   for (d = display_chain; d; d = d->next)
1606     do_one_display (d);
1607 }
1608
1609 /* Delete the auto-display which we were in the process of displaying.
1610    This is done when there is an error or a signal.  */
1611
1612 void
1613 disable_display (num)
1614      int num;
1615 {
1616   register struct display *d;
1617
1618   for (d = display_chain; d; d = d->next)
1619     if (d->number == num)
1620       {
1621         d->status = disabled;
1622         return;
1623       }
1624   printf_unfiltered ("No display number %d.\n", num);
1625 }
1626
1627 void
1628 disable_current_display ()
1629 {
1630   if (current_display_number >= 0)
1631     {
1632       disable_display (current_display_number);
1633       fprintf_unfiltered (gdb_stderr, "Disabling display %d to avoid infinite recursion.\n",
1634                           current_display_number);
1635     }
1636   current_display_number = -1;
1637 }
1638
1639 static void
1640 display_info (ignore, from_tty)
1641      char *ignore;
1642      int from_tty;
1643 {
1644   register struct display *d;
1645
1646   if (!display_chain)
1647     printf_unfiltered ("There are no auto-display expressions now.\n");
1648   else
1649     printf_filtered ("Auto-display expressions now in effect:\n\
1650 Num Enb Expression\n");
1651
1652   for (d = display_chain; d; d = d->next)
1653     {
1654       printf_filtered ("%d:   %c  ", d->number, "ny"[(int) d->status]);
1655       if (d->format.size)
1656         printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1657                          d->format.format);
1658       else if (d->format.format)
1659         printf_filtered ("/%c ", d->format.format);
1660       print_expression (d->exp, gdb_stdout);
1661       if (d->block && !contained_in (get_selected_block (), d->block))
1662         printf_filtered (" (cannot be evaluated in the current context)");
1663       printf_filtered ("\n");
1664       gdb_flush (gdb_stdout);
1665     }
1666 }
1667
1668 static void
1669 enable_display (args, from_tty)
1670      char *args;
1671      int from_tty;
1672 {
1673   register char *p = args;
1674   register char *p1;
1675   register int num;
1676   register struct display *d;
1677
1678   if (p == 0)
1679     {
1680       for (d = display_chain; d; d = d->next)
1681         d->status = enabled;
1682     }
1683   else
1684     while (*p)
1685       {
1686         p1 = p;
1687         while (*p1 >= '0' && *p1 <= '9')
1688           p1++;
1689         if (*p1 && *p1 != ' ' && *p1 != '\t')
1690           error ("Arguments must be display numbers.");
1691
1692         num = atoi (p);
1693
1694         for (d = display_chain; d; d = d->next)
1695           if (d->number == num)
1696             {
1697               d->status = enabled;
1698               goto win;
1699             }
1700         printf_unfiltered ("No display number %d.\n", num);
1701       win:
1702         p = p1;
1703         while (*p == ' ' || *p == '\t')
1704           p++;
1705       }
1706 }
1707
1708 /* ARGSUSED */
1709 static void
1710 disable_display_command (args, from_tty)
1711      char *args;
1712      int from_tty;
1713 {
1714   register char *p = args;
1715   register char *p1;
1716   register struct display *d;
1717
1718   if (p == 0)
1719     {
1720       for (d = display_chain; d; d = d->next)
1721         d->status = disabled;
1722     }
1723   else
1724     while (*p)
1725       {
1726         p1 = p;
1727         while (*p1 >= '0' && *p1 <= '9')
1728           p1++;
1729         if (*p1 && *p1 != ' ' && *p1 != '\t')
1730           error ("Arguments must be display numbers.");
1731
1732         disable_display (atoi (p));
1733
1734         p = p1;
1735         while (*p == ' ' || *p == '\t')
1736           p++;
1737       }
1738 }
1739 \f
1740
1741 /* Print the value in stack frame FRAME of a variable
1742    specified by a struct symbol.  */
1743
1744 void
1745 print_variable_value (var, frame, stream)
1746      struct symbol *var;
1747      struct frame_info *frame;
1748      struct ui_file *stream;
1749 {
1750   value_ptr val = read_var_value (var, frame);
1751
1752   value_print (val, stream, 0, Val_pretty_default);
1753 }
1754
1755 /* Print the arguments of a stack frame, given the function FUNC
1756    running in that frame (as a symbol), the info on the frame,
1757    and the number of args according to the stack frame (or -1 if unknown).  */
1758
1759 /* References here and elsewhere to "number of args according to the
1760    stack frame" appear in all cases to refer to "number of ints of args
1761    according to the stack frame".  At least for VAX, i386, isi.  */
1762
1763 void
1764 print_frame_args (func, fi, num, stream)
1765      struct symbol *func;
1766      struct frame_info *fi;
1767      int num;
1768      struct ui_file *stream;
1769 {
1770   struct block *b = NULL;
1771   int nsyms = 0;
1772   int first = 1;
1773   register int i;
1774   register struct symbol *sym;
1775   register value_ptr val;
1776   /* Offset of next stack argument beyond the one we have seen that is
1777      at the highest offset.
1778      -1 if we haven't come to a stack argument yet.  */
1779   long highest_offset = -1;
1780   int arg_size;
1781   /* Number of ints of arguments that we have printed so far.  */
1782   int args_printed = 0;
1783 #ifdef UI_OUT
1784   struct cleanup *old_chain;
1785   struct ui_stream *stb;
1786
1787   stb = ui_out_stream_new (uiout);
1788   old_chain = make_cleanup ((make_cleanup_func) ui_out_stream_delete, stb);
1789 #endif /* UI_OUT */
1790
1791   if (func)
1792     {
1793       b = SYMBOL_BLOCK_VALUE (func);
1794       nsyms = BLOCK_NSYMS (b);
1795     }
1796
1797   for (i = 0; i < nsyms; i++)
1798     {
1799       QUIT;
1800       sym = BLOCK_SYM (b, i);
1801
1802       /* Keep track of the highest stack argument offset seen, and
1803          skip over any kinds of symbols we don't care about.  */
1804
1805       switch (SYMBOL_CLASS (sym))
1806         {
1807         case LOC_ARG:
1808         case LOC_REF_ARG:
1809           {
1810             long current_offset = SYMBOL_VALUE (sym);
1811             arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
1812
1813             /* Compute address of next argument by adding the size of
1814                this argument and rounding to an int boundary.  */
1815             current_offset
1816               = ((current_offset + arg_size + sizeof (int) - 1)
1817                  & ~(sizeof (int) - 1));
1818
1819             /* If this is the highest offset seen yet, set highest_offset.  */
1820             if (highest_offset == -1
1821                 || (current_offset > highest_offset))
1822               highest_offset = current_offset;
1823
1824             /* Add the number of ints we're about to print to args_printed.  */
1825             args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
1826           }
1827
1828           /* We care about types of symbols, but don't need to keep track of
1829              stack offsets in them.  */
1830         case LOC_REGPARM:
1831         case LOC_REGPARM_ADDR:
1832         case LOC_LOCAL_ARG:
1833         case LOC_BASEREG_ARG:
1834           break;
1835
1836           /* Other types of symbols we just skip over.  */
1837         default:
1838           continue;
1839         }
1840
1841       /* We have to look up the symbol because arguments can have
1842          two entries (one a parameter, one a local) and the one we
1843          want is the local, which lookup_symbol will find for us.
1844          This includes gcc1 (not gcc2) on the sparc when passing a
1845          small structure and gcc2 when the argument type is float
1846          and it is passed as a double and converted to float by
1847          the prologue (in the latter case the type of the LOC_ARG
1848          symbol is double and the type of the LOC_LOCAL symbol is
1849          float).  */
1850       /* But if the parameter name is null, don't try it.
1851          Null parameter names occur on the RS/6000, for traceback tables.
1852          FIXME, should we even print them?  */
1853
1854       if (*SYMBOL_NAME (sym))
1855         {
1856           struct symbol *nsym;
1857           nsym = lookup_symbol
1858             (SYMBOL_NAME (sym),
1859              b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
1860           if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
1861             {
1862               /* There is a LOC_ARG/LOC_REGISTER pair.  This means that
1863                  it was passed on the stack and loaded into a register,
1864                  or passed in a register and stored in a stack slot.
1865                  GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1866
1867                  Reasons for using the LOC_ARG:
1868                  (1) because find_saved_registers may be slow for remote
1869                  debugging,
1870                  (2) because registers are often re-used and stack slots
1871                  rarely (never?) are.  Therefore using the stack slot is
1872                  much less likely to print garbage.
1873
1874                  Reasons why we might want to use the LOC_REGISTER:
1875                  (1) So that the backtrace prints the same value as
1876                  "print foo".  I see no compelling reason why this needs
1877                  to be the case; having the backtrace print the value which
1878                  was passed in, and "print foo" print the value as modified
1879                  within the called function, makes perfect sense to me.
1880
1881                  Additional note:  It might be nice if "info args" displayed
1882                  both values.
1883                  One more note:  There is a case with sparc structure passing
1884                  where we need to use the LOC_REGISTER, but this is dealt with
1885                  by creating a single LOC_REGPARM in symbol reading.  */
1886
1887               /* Leave sym (the LOC_ARG) alone.  */
1888               ;
1889             }
1890           else
1891             sym = nsym;
1892         }
1893
1894 #ifdef UI_OUT
1895       /* Print the current arg.  */
1896       if (!first)
1897         ui_out_text (uiout, ", ");
1898       ui_out_wrap_hint (uiout, "    ");
1899
1900       annotate_arg_begin ();
1901
1902       ui_out_list_begin (uiout, NULL);
1903       fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym),
1904                             SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
1905       ui_out_field_stream (uiout, "name", stb);
1906       annotate_arg_name_end ();
1907       ui_out_text (uiout, "=");
1908 #else
1909       /* Print the current arg.  */
1910       if (!first)
1911         fprintf_filtered (stream, ", ");
1912       wrap_here ("    ");
1913
1914       annotate_arg_begin ();
1915
1916       fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym),
1917                             SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
1918       annotate_arg_name_end ();
1919       fputs_filtered ("=", stream);
1920 #endif
1921
1922       /* Avoid value_print because it will deref ref parameters.  We just
1923          want to print their addresses.  Print ??? for args whose address
1924          we do not know.  We pass 2 as "recurse" to val_print because our
1925          standard indentation here is 4 spaces, and val_print indents
1926          2 for each recurse.  */
1927       val = read_var_value (sym, fi);
1928
1929       annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
1930
1931       if (val)
1932         {
1933           if (GDB_TARGET_IS_D10V
1934               && SYMBOL_CLASS (sym) == LOC_REGPARM && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_PTR)
1935             TYPE_LENGTH (VALUE_TYPE (val)) = 2;
1936 #ifdef UI_OUT
1937           val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
1938                      VALUE_ADDRESS (val),
1939                      stb->stream, 0, 0, 2, Val_no_prettyprint);
1940           ui_out_field_stream (uiout, "value", stb);
1941         }
1942       else
1943         ui_out_text (uiout, "???");
1944
1945       ui_out_list_end (uiout);
1946 #else
1947           val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
1948                      VALUE_ADDRESS (val),
1949                      stream, 0, 0, 2, Val_no_prettyprint);
1950         }
1951       else
1952         fputs_filtered ("???", stream);
1953 #endif
1954
1955       annotate_arg_end ();
1956
1957       first = 0;
1958     }
1959
1960   /* Don't print nameless args in situations where we don't know
1961      enough about the stack to find them.  */
1962   if (num != -1)
1963     {
1964       long start;
1965
1966       if (highest_offset == -1)
1967         start = FRAME_ARGS_SKIP;
1968       else
1969         start = highest_offset;
1970
1971       print_frame_nameless_args (fi, start, num - args_printed,
1972                                  first, stream);
1973     }
1974 #ifdef UI_OUT
1975   do_cleanups (old_chain);
1976 #endif /* no UI_OUT */
1977 }
1978
1979 /* Print nameless args on STREAM.
1980    FI is the frameinfo for this frame, START is the offset
1981    of the first nameless arg, and NUM is the number of nameless args to
1982    print.  FIRST is nonzero if this is the first argument (not just
1983    the first nameless arg).  */
1984
1985 static void
1986 print_frame_nameless_args (fi, start, num, first, stream)
1987      struct frame_info *fi;
1988      long start;
1989      int num;
1990      int first;
1991      struct ui_file *stream;
1992 {
1993   int i;
1994   CORE_ADDR argsaddr;
1995   long arg_value;
1996
1997   for (i = 0; i < num; i++)
1998     {
1999       QUIT;
2000 #ifdef NAMELESS_ARG_VALUE
2001       NAMELESS_ARG_VALUE (fi, start, &arg_value);
2002 #else
2003       argsaddr = FRAME_ARGS_ADDRESS (fi);
2004       if (!argsaddr)
2005         return;
2006
2007       arg_value = read_memory_integer (argsaddr + start, sizeof (int));
2008 #endif
2009
2010       if (!first)
2011         fprintf_filtered (stream, ", ");
2012
2013 #ifdef  PRINT_NAMELESS_INTEGER
2014       PRINT_NAMELESS_INTEGER (stream, arg_value);
2015 #else
2016 #ifdef PRINT_TYPELESS_INTEGER
2017       PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
2018 #else
2019       fprintf_filtered (stream, "%ld", arg_value);
2020 #endif /* PRINT_TYPELESS_INTEGER */
2021 #endif /* PRINT_NAMELESS_INTEGER */
2022       first = 0;
2023       start += sizeof (int);
2024     }
2025 }
2026 \f
2027 /* ARGSUSED */
2028 static void
2029 printf_command (arg, from_tty)
2030      char *arg;
2031      int from_tty;
2032 {
2033   register char *f = NULL;
2034   register char *s = arg;
2035   char *string = NULL;
2036   value_ptr *val_args;
2037   char *substrings;
2038   char *current_substring;
2039   int nargs = 0;
2040   int allocated_args = 20;
2041   struct cleanup *old_cleanups;
2042
2043   val_args = (value_ptr *) xmalloc (allocated_args * sizeof (value_ptr));
2044   old_cleanups = make_cleanup ((make_cleanup_func) free_current_contents,
2045                                &val_args);
2046
2047   if (s == 0)
2048     error_no_arg ("format-control string and values to print");
2049
2050   /* Skip white space before format string */
2051   while (*s == ' ' || *s == '\t')
2052     s++;
2053
2054   /* A format string should follow, enveloped in double quotes */
2055   if (*s++ != '"')
2056     error ("Bad format string, missing '\"'.");
2057
2058   /* Parse the format-control string and copy it into the string STRING,
2059      processing some kinds of escape sequence.  */
2060
2061   f = string = (char *) alloca (strlen (s) + 1);
2062
2063   while (*s != '"')
2064     {
2065       int c = *s++;
2066       switch (c)
2067         {
2068         case '\0':
2069           error ("Bad format string, non-terminated '\"'.");
2070
2071         case '\\':
2072           switch (c = *s++)
2073             {
2074             case '\\':
2075               *f++ = '\\';
2076               break;
2077             case 'a':
2078 #ifdef __STDC__
2079               *f++ = '\a';
2080 #else
2081               *f++ = '\007';    /* Bell */
2082 #endif
2083               break;
2084             case 'b':
2085               *f++ = '\b';
2086               break;
2087             case 'f':
2088               *f++ = '\f';
2089               break;
2090             case 'n':
2091               *f++ = '\n';
2092               break;
2093             case 'r':
2094               *f++ = '\r';
2095               break;
2096             case 't':
2097               *f++ = '\t';
2098               break;
2099             case 'v':
2100               *f++ = '\v';
2101               break;
2102             case '"':
2103               *f++ = '"';
2104               break;
2105             default:
2106               /* ??? TODO: handle other escape sequences */
2107               error ("Unrecognized escape character \\%c in format string.",
2108                      c);
2109             }
2110           break;
2111
2112         default:
2113           *f++ = c;
2114         }
2115     }
2116
2117   /* Skip over " and following space and comma.  */
2118   s++;
2119   *f++ = '\0';
2120   while (*s == ' ' || *s == '\t')
2121     s++;
2122
2123   if (*s != ',' && *s != 0)
2124     error ("Invalid argument syntax");
2125
2126   if (*s == ',')
2127     s++;
2128   while (*s == ' ' || *s == '\t')
2129     s++;
2130
2131   /* Need extra space for the '\0's.  Doubling the size is sufficient.  */
2132   substrings = alloca (strlen (string) * 2);
2133   current_substring = substrings;
2134
2135   {
2136     /* Now scan the string for %-specs and see what kinds of args they want.
2137        argclass[I] classifies the %-specs so we can give printf_filtered
2138        something of the right size.  */
2139
2140     enum argclass
2141       {
2142         no_arg, int_arg, string_arg, double_arg, long_long_arg
2143       };
2144     enum argclass *argclass;
2145     enum argclass this_argclass;
2146     char *last_arg;
2147     int nargs_wanted;
2148     int lcount;
2149     int i;
2150
2151     argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
2152     nargs_wanted = 0;
2153     f = string;
2154     last_arg = string;
2155     while (*f)
2156       if (*f++ == '%')
2157         {
2158           lcount = 0;
2159           while (strchr ("0123456789.hlL-+ #", *f))
2160             {
2161               if (*f == 'l' || *f == 'L')
2162                 lcount++;
2163               f++;
2164             }
2165           switch (*f)
2166             {
2167             case 's':
2168               this_argclass = string_arg;
2169               break;
2170
2171             case 'e':
2172             case 'f':
2173             case 'g':
2174               this_argclass = double_arg;
2175               break;
2176
2177             case '*':
2178               error ("`*' not supported for precision or width in printf");
2179
2180             case 'n':
2181               error ("Format specifier `n' not supported in printf");
2182
2183             case '%':
2184               this_argclass = no_arg;
2185               break;
2186
2187             default:
2188               if (lcount > 1)
2189                 this_argclass = long_long_arg;
2190               else
2191                 this_argclass = int_arg;
2192               break;
2193             }
2194           f++;
2195           if (this_argclass != no_arg)
2196             {
2197               strncpy (current_substring, last_arg, f - last_arg);
2198               current_substring += f - last_arg;
2199               *current_substring++ = '\0';
2200               last_arg = f;
2201               argclass[nargs_wanted++] = this_argclass;
2202             }
2203         }
2204
2205     /* Now, parse all arguments and evaluate them.
2206        Store the VALUEs in VAL_ARGS.  */
2207
2208     while (*s != '\0')
2209       {
2210         char *s1;
2211         if (nargs == allocated_args)
2212           val_args = (value_ptr *) xrealloc ((char *) val_args,
2213                                              (allocated_args *= 2)
2214                                              * sizeof (value_ptr));
2215         s1 = s;
2216         val_args[nargs] = parse_to_comma_and_eval (&s1);
2217
2218         /* If format string wants a float, unchecked-convert the value to
2219            floating point of the same size */
2220
2221         if (argclass[nargs] == double_arg)
2222           {
2223             struct type *type = VALUE_TYPE (val_args[nargs]);
2224             if (TYPE_LENGTH (type) == sizeof (float))
2225                 VALUE_TYPE (val_args[nargs]) = builtin_type_float;
2226             if (TYPE_LENGTH (type) == sizeof (double))
2227                 VALUE_TYPE (val_args[nargs]) = builtin_type_double;
2228           }
2229         nargs++;
2230         s = s1;
2231         if (*s == ',')
2232           s++;
2233       }
2234
2235     if (nargs != nargs_wanted)
2236       error ("Wrong number of arguments for specified format-string");
2237
2238     /* Now actually print them.  */
2239     current_substring = substrings;
2240     for (i = 0; i < nargs; i++)
2241       {
2242         switch (argclass[i])
2243           {
2244           case string_arg:
2245             {
2246               char *str;
2247               CORE_ADDR tem;
2248               int j;
2249               tem = value_as_pointer (val_args[i]);
2250
2251               /* This is a %s argument.  Find the length of the string.  */
2252               for (j = 0;; j++)
2253                 {
2254                   char c;
2255                   QUIT;
2256                   read_memory_section (tem + j, &c, 1,
2257                                        VALUE_BFD_SECTION (val_args[i]));
2258                   if (c == 0)
2259                     break;
2260                 }
2261
2262               /* Copy the string contents into a string inside GDB.  */
2263               str = (char *) alloca (j + 1);
2264               read_memory_section (tem, str, j, VALUE_BFD_SECTION (val_args[i]));
2265               str[j] = 0;
2266
2267               printf_filtered (current_substring, str);
2268             }
2269             break;
2270           case double_arg:
2271             {
2272               double val = value_as_double (val_args[i]);
2273               printf_filtered (current_substring, val);
2274               break;
2275             }
2276           case long_long_arg:
2277 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2278             {
2279               long long val = value_as_long (val_args[i]);
2280               printf_filtered (current_substring, val);
2281               break;
2282             }
2283 #else
2284             error ("long long not supported in printf");
2285 #endif
2286           case int_arg:
2287             {
2288               /* FIXME: there should be separate int_arg and long_arg.  */
2289               long val = value_as_long (val_args[i]);
2290               printf_filtered (current_substring, val);
2291               break;
2292             }
2293           default:              /* purecov: deadcode */
2294             error ("internal error in printf_command");         /* purecov: deadcode */
2295           }
2296         /* Skip to the next substring.  */
2297         current_substring += strlen (current_substring) + 1;
2298       }
2299     /* Print the portion of the format string after the last argument.  */
2300     printf_filtered (last_arg);
2301   }
2302   do_cleanups (old_cleanups);
2303 }
2304 \f
2305 /* Dump a specified section of assembly code.  With no command line
2306    arguments, this command will dump the assembly code for the
2307    function surrounding the pc value in the selected frame.  With one
2308    argument, it will dump the assembly code surrounding that pc value.
2309    Two arguments are interpeted as bounds within which to dump
2310    assembly.  */
2311
2312 /* ARGSUSED */
2313 static void
2314 disassemble_command (arg, from_tty)
2315      char *arg;
2316      int from_tty;
2317 {
2318   CORE_ADDR low, high;
2319   char *name;
2320   CORE_ADDR pc, pc_masked;
2321   char *space_index;
2322 #if 0
2323   asection *section;
2324 #endif
2325
2326   name = NULL;
2327   if (!arg)
2328     {
2329       if (!selected_frame)
2330         error ("No frame selected.\n");
2331
2332       pc = get_frame_pc (selected_frame);
2333       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
2334         error ("No function contains program counter for selected frame.\n");
2335 #if defined(TUI)
2336       else if (tui_version)
2337         low = (CORE_ADDR) tuiDo ((TuiOpaqueFuncPtr) tui_vGetLowDisassemblyAddress,
2338                                  (Opaque) low,
2339                                  (Opaque) pc);
2340 #endif
2341       low += FUNCTION_START_OFFSET;
2342     }
2343   else if (!(space_index = (char *) strchr (arg, ' ')))
2344     {
2345       /* One argument.  */
2346       pc = parse_and_eval_address (arg);
2347       if (find_pc_partial_function (pc, &name, &low, &high) == 0)
2348         error ("No function contains specified address.\n");
2349 #if defined(TUI)
2350       else if (tui_version)
2351         low = (CORE_ADDR) tuiDo ((TuiOpaqueFuncPtr) tui_vGetLowDisassemblyAddress,
2352                                  (Opaque) low,
2353                                  (Opaque) pc);
2354 #endif
2355 #if 0
2356       if (overlay_debugging)
2357         {
2358           section = find_pc_overlay (pc);
2359           if (pc_in_unmapped_range (pc, section))
2360             {
2361               /* find_pc_partial_function will have returned low and high
2362                  relative to the symbolic (mapped) address range.  Need to
2363                  translate them back to the unmapped range where PC is.  */
2364               low = overlay_unmapped_address (low, section);
2365               high = overlay_unmapped_address (high, section);
2366             }
2367         }
2368 #endif
2369       low += FUNCTION_START_OFFSET;
2370     }
2371   else
2372     {
2373       /* Two arguments.  */
2374       *space_index = '\0';
2375       low = parse_and_eval_address (arg);
2376       high = parse_and_eval_address (space_index + 1);
2377     }
2378
2379 #if defined(TUI)
2380   if (!tui_version ||
2381       m_winPtrIsNull (disassemWin) || !disassemWin->generic.isVisible)
2382 #endif
2383     {
2384       printf_filtered ("Dump of assembler code ");
2385       if (name != NULL)
2386         {
2387           printf_filtered ("for function %s:\n", name);
2388         }
2389       else
2390         {
2391           printf_filtered ("from ");
2392           print_address_numeric (low, 1, gdb_stdout);
2393           printf_filtered (" to ");
2394           print_address_numeric (high, 1, gdb_stdout);
2395           printf_filtered (":\n");
2396         }
2397
2398       /* Dump the specified range.  */
2399       pc = low;
2400
2401 #ifdef GDB_TARGET_MASK_DISAS_PC
2402       pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
2403 #else
2404       pc_masked = pc;
2405 #endif
2406
2407       while (pc_masked < high)
2408         {
2409           QUIT;
2410           print_address (pc_masked, gdb_stdout);
2411           printf_filtered (":\t");
2412           /* We often wrap here if there are long symbolic names.  */
2413           wrap_here ("    ");
2414           pc += print_insn (pc, gdb_stdout);
2415           printf_filtered ("\n");
2416
2417 #ifdef GDB_TARGET_MASK_DISAS_PC
2418           pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
2419 #else
2420           pc_masked = pc;
2421 #endif
2422         }
2423       printf_filtered ("End of assembler dump.\n");
2424       gdb_flush (gdb_stdout);
2425     }
2426 #if defined(TUI)
2427   else
2428     {
2429       tuiDo ((TuiOpaqueFuncPtr) tui_vAddWinToLayout, DISASSEM_WIN);
2430       tuiDo ((TuiOpaqueFuncPtr) tui_vUpdateSourceWindowsWithAddr, low);
2431     }
2432 #endif
2433 }
2434
2435 /* Print the instruction at address MEMADDR in debugged memory,
2436    on STREAM.  Returns length of the instruction, in bytes.  */
2437
2438 static int
2439 print_insn (memaddr, stream)
2440      CORE_ADDR memaddr;
2441      struct ui_file *stream;
2442 {
2443   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
2444     TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_BIG;
2445   else
2446     TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_LITTLE;
2447
2448   if (TARGET_ARCHITECTURE != NULL)
2449     TARGET_PRINT_INSN_INFO->mach = TARGET_ARCHITECTURE->mach;
2450   /* else: should set .mach=0 but some disassemblers don't grok this */
2451
2452   return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
2453 }
2454 \f
2455
2456 void
2457 _initialize_printcmd ()
2458 {
2459   current_display_number = -1;
2460
2461   add_info ("address", address_info,
2462             "Describe where symbol SYM is stored.");
2463
2464   add_info ("symbol", sym_info,
2465             "Describe what symbol is at location ADDR.\n\
2466 Only for symbols with fixed locations (global or static scope).");
2467
2468   add_com ("x", class_vars, x_command,
2469            concat ("Examine memory: x/FMT ADDRESS.\n\
2470 ADDRESS is an expression for the memory address to examine.\n\
2471 FMT is a repeat count followed by a format letter and a size letter.\n\
2472 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2473   t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
2474                    "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2475 The specified number of objects of the specified size are printed\n\
2476 according to the format.\n\n\
2477 Defaults for format and size letters are those previously used.\n\
2478 Default count is 1.  Default address is following last thing printed\n\
2479 with this command or \"print\".", NULL));
2480
2481   add_com ("disassemble", class_vars, disassemble_command,
2482            "Disassemble a specified section of memory.\n\
2483 Default is the function surrounding the pc of the selected frame.\n\
2484 With a single argument, the function surrounding that address is dumped.\n\
2485 Two arguments are taken as a range of memory to dump.");
2486   if (xdb_commands)
2487     add_com_alias ("va", "disassemble", class_xdb, 0);
2488
2489 #if 0
2490   add_com ("whereis", class_vars, whereis_command,
2491            "Print line number and file of definition of variable.");
2492 #endif
2493
2494   add_info ("display", display_info,
2495             "Expressions to display when program stops, with code numbers.");
2496
2497   add_cmd ("undisplay", class_vars, undisplay_command,
2498            "Cancel some expressions to be displayed when program stops.\n\
2499 Arguments are the code numbers of the expressions to stop displaying.\n\
2500 No argument means cancel all automatic-display expressions.\n\
2501 \"delete display\" has the same effect as this command.\n\
2502 Do \"info display\" to see current list of code numbers.",
2503            &cmdlist);
2504
2505   add_com ("display", class_vars, display_command,
2506            "Print value of expression EXP each time the program stops.\n\
2507 /FMT may be used before EXP as in the \"print\" command.\n\
2508 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2509 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2510 and examining is done as in the \"x\" command.\n\n\
2511 With no argument, display all currently requested auto-display expressions.\n\
2512 Use \"undisplay\" to cancel display requests previously made."
2513     );
2514
2515   add_cmd ("display", class_vars, enable_display,
2516            "Enable some expressions to be displayed when program stops.\n\
2517 Arguments are the code numbers of the expressions to resume displaying.\n\
2518 No argument means enable all automatic-display expressions.\n\
2519 Do \"info display\" to see current list of code numbers.", &enablelist);
2520
2521   add_cmd ("display", class_vars, disable_display_command,
2522            "Disable some expressions to be displayed when program stops.\n\
2523 Arguments are the code numbers of the expressions to stop displaying.\n\
2524 No argument means disable all automatic-display expressions.\n\
2525 Do \"info display\" to see current list of code numbers.", &disablelist);
2526
2527   add_cmd ("display", class_vars, undisplay_command,
2528            "Cancel some expressions to be displayed when program stops.\n\
2529 Arguments are the code numbers of the expressions to stop displaying.\n\
2530 No argument means cancel all automatic-display expressions.\n\
2531 Do \"info display\" to see current list of code numbers.", &deletelist);
2532
2533   add_com ("printf", class_vars, printf_command,
2534            "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2535 This is useful for formatted output in user-defined commands.");
2536
2537   add_com ("output", class_vars, output_command,
2538            "Like \"print\" but don't put in value history and don't print newline.\n\
2539 This is useful in user-defined commands.");
2540
2541   add_prefix_cmd ("set", class_vars, set_command,
2542                   concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2543 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2544 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2545 with $), a register (a few standard names starting with $), or an actual\n\
2546 variable in the program being debugged.  EXP is any valid expression.\n",
2547                           "Use \"set variable\" for variables with names identical to set subcommands.\n\
2548 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2549 You can see these environment settings with the \"show\" command.", NULL),
2550                   &setlist, "set ", 1, &cmdlist);
2551   if (dbx_commands)
2552     add_com ("assign", class_vars, set_command, concat ("Evaluate expression \
2553 EXP and assign result to variable VAR, using assignment\n\
2554 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2555 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2556 with $), a register (a few standard names starting with $), or an actual\n\
2557 variable in the program being debugged.  EXP is any valid expression.\n",
2558                                                         "Use \"set variable\" for variables with names identical to set subcommands.\n\
2559 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2560 You can see these environment settings with the \"show\" command.", NULL));
2561
2562   /* "call" is the same as "set", but handy for dbx users to call fns. */
2563   add_com ("call", class_vars, call_command,
2564            "Call a function in the program.\n\
2565 The argument is the function name and arguments, in the notation of the\n\
2566 current working language.  The result is printed and saved in the value\n\
2567 history, if it is not void.");
2568
2569   add_cmd ("variable", class_vars, set_command,
2570            "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2571 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2572 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2573 with $), a register (a few standard names starting with $), or an actual\n\
2574 variable in the program being debugged.  EXP is any valid expression.\n\
2575 This may usually be abbreviated to simply \"set\".",
2576            &setlist);
2577
2578   add_com ("print", class_vars, print_command,
2579            concat ("Print value of expression EXP.\n\
2580 Variables accessible are those of the lexical environment of the selected\n\
2581 stack frame, plus all those whose scope is global or an entire file.\n\
2582 \n\
2583 $NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
2584 $$NUM refers to NUM'th value back from the last one.\n\
2585 Names starting with $ refer to registers (with the values they would have\n",
2586                    "if the program were to return to the stack frame now selected, restoring\n\
2587 all registers saved by frames farther in) or else to debugger\n\
2588 \"convenience\" variables (any such name not a known register).\n\
2589 Use assignment expressions to give values to convenience variables.\n",
2590                    "\n\
2591 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2592 @ is a binary operator for treating consecutive data objects\n\
2593 anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
2594 element is FOO, whose second element is stored in the space following\n\
2595 where FOO is stored, etc.  FOO must be an expression whose value\n\
2596 resides in memory.\n",
2597                    "\n\
2598 EXP may be preceded with /FMT, where FMT is a format letter\n\
2599 but no count or size letter (see \"x\" command).", NULL));
2600   add_com_alias ("p", "print", class_vars, 1);
2601
2602   add_com ("inspect", class_vars, inspect_command,
2603            "Same as \"print\" command, except that if you are running in the epoch\n\
2604 environment, the value is printed in its own window.");
2605
2606   add_show_from_set (
2607                  add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,
2608                               (char *) &max_symbolic_offset,
2609        "Set the largest offset that will be printed in <symbol+1234> form.",
2610                               &setprintlist),
2611                       &showprintlist);
2612   add_show_from_set (
2613                       add_set_cmd ("symbol-filename", no_class, var_boolean,
2614                                    (char *) &print_symbol_filename,
2615            "Set printing of source filename and line number with <symbol>.",
2616                                    &setprintlist),
2617                       &showprintlist);
2618
2619   /* For examine/instruction a single byte quantity is specified as
2620      the data.  This avoids problems with value_at_lazy() requiring a
2621      valid data type (and rejecting VOID). */
2622   examine_i_type = init_type (TYPE_CODE_INT, 1, 0, "examine_i_type", NULL);
2623
2624   examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL);
2625   examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL);
2626   examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL);
2627   examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL);
2628
2629 }