gdb/printcmd.c

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