gdb/printcmd.c

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