gdb/printcmd.c

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