gdb/printcmd.c

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