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