gdb/printcmd.c

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