gdb/printcmd.c

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