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