gdb/ada-valprint.c

   1 /* Support for printing Ada values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002,
   4    2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <ctype.h>
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "demangle.h"
  29 #include "valprint.h"
  30 #include "language.h"
  31 #include "annotate.h"
  32 #include "ada-lang.h"
  33 #include "c-lang.h"
  34 #include "infcall.h"
  35 #include "exceptions.h"
  36
  37 /* Encapsulates arguments to ada_val_print.  */
  38 struct ada_val_print_args
  39 {
  40   struct type *type;
  41   const gdb_byte *valaddr0;
  42   int embedded_offset;
  43   CORE_ADDR address;
  44   struct ui_file *stream;
  45   int format;
  46   int deref_ref;
  47   int recurse;
  48   enum val_prettyprint pretty;
  49 };
  50
  51 static void print_record (struct type *, const gdb_byte *, struct ui_file *,
  52                           int, int, enum val_prettyprint);
  53
  54 static int print_field_values (struct type *, const gdb_byte *,
  55                                struct ui_file *, int, int,
  56                                enum val_prettyprint, int, struct type *,
  57                                const gdb_byte *);
  58
  59 static void adjust_type_signedness (struct type *);
  60
  61 static int ada_val_print_stub (void *args0);
  62
  63 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
  64                             struct ui_file *, int, int, int,
  65                             enum val_prettyprint);
  66 \f
  67
  68 /* Make TYPE unsigned if its range of values includes no negatives.  */
  69 static void
  70 adjust_type_signedness (struct type *type)
  71 {
  72   if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
  73       && TYPE_LOW_BOUND (type) >= 0)
  74     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
  75 }
  76
  77 /* Assuming TYPE is a simple, non-empty array type, prints its lower bound
  78    on STREAM, if non-standard (i.e., other than 1 for numbers, other
  79    than lower bound of index type for enumerated type).  Returns 1
  80    if something printed, otherwise 0.  */
  81
  82 static int
  83 print_optional_low_bound (struct ui_file *stream, struct type *type)
  84 {
  85   struct type *index_type;
  86   long low_bound;
  87
  88   if (print_array_indexes_p ())
  89     return 0;
  90
  91   if (!get_array_low_bound (type, &low_bound))
  92     return 0;
  93
  94   index_type = TYPE_INDEX_TYPE (type);
  95
  96   if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
  97     {
  98       /* We need to know what the base type is, in order to do the
  99          appropriate check below.  Otherwise, if this is a subrange
 100          of an enumerated type, where the underlying value of the
 101          first element is typically 0, we might test the low bound
 102          against the wrong value.  */
 103       index_type = TYPE_TARGET_TYPE (index_type);
 104     }
 105
 106   switch (TYPE_CODE (index_type))
 107     {
 108     case TYPE_CODE_ENUM:
 109       if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
 110         return 0;
 111       break;
 112     case TYPE_CODE_UNDEF:
 113       index_type = builtin_type_long;
 114       /* FALL THROUGH */
 115     default:
 116       if (low_bound == 1)
 117         return 0;
 118       break;
 119     }
 120
 121   ada_print_scalar (index_type, (LONGEST) low_bound, stream);
 122   fprintf_filtered (stream, " => ");
 123   return 1;
 124 }
 125
 126 /*  Version of val_print_array_elements for GNAT-style packed arrays.
 127     Prints elements of packed array of type TYPE at bit offset
 128     BITOFFSET from VALADDR on STREAM.  Formats according to FORMAT and
 129     separates with commas.  RECURSE is the recursion (nesting) level.
 130     If PRETTY, uses "prettier" format.  TYPE must have been decoded (as
 131     by ada_coerce_to_simple_array).  */
 132
 133 static void
 134 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
 135                                  int bitoffset, struct ui_file *stream,
 136                                  int format, int recurse,
 137                                  enum val_prettyprint pretty)
 138 {
 139   unsigned int i;
 140   unsigned int things_printed = 0;
 141   unsigned len;
 142   struct type *elttype, *index_type;
 143   unsigned eltlen;
 144   unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
 145   struct value *mark = value_mark ();
 146   LONGEST low = 0;
 147
 148   elttype = TYPE_TARGET_TYPE (type);
 149   eltlen = TYPE_LENGTH (check_typedef (elttype));
 150   index_type = TYPE_INDEX_TYPE (type);
 151
 152   {
 153     LONGEST high;
 154     if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
 155       len = 1;
 156     else
 157       len = high - low + 1;
 158   }
 159
 160   i = 0;
 161   annotate_array_section_begin (i, elttype);
 162
 163   while (i < len && things_printed < print_max)
 164     {
 165       struct value *v0, *v1;
 166       int i0;
 167
 168       if (i != 0)
 169         {
 170           if (prettyprint_arrays)
 171             {
 172               fprintf_filtered (stream, ",\n");
 173               print_spaces_filtered (2 + 2 * recurse, stream);
 174             }
 175           else
 176             {
 177               fprintf_filtered (stream, ", ");
 178             }
 179         }
 180       wrap_here (n_spaces (2 + 2 * recurse));
 181       maybe_print_array_index (index_type, i + low, stream, format, pretty);
 182
 183       i0 = i;
 184       v0 = ada_value_primitive_packed_val (NULL, valaddr,
 185                                            (i0 * bitsize) / HOST_CHAR_BIT,
 186                                            (i0 * bitsize) % HOST_CHAR_BIT,
 187                                            bitsize, elttype);
 188       while (1)
 189         {
 190           i += 1;
 191           if (i >= len)
 192             break;
 193           v1 = ada_value_primitive_packed_val (NULL, valaddr,
 194                                                (i * bitsize) / HOST_CHAR_BIT,
 195                                                (i * bitsize) % HOST_CHAR_BIT,
 196                                                bitsize, elttype);
 197           if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
 198             break;
 199         }
 200
 201       if (i - i0 > repeat_count_threshold)
 202         {
 203           val_print (elttype, value_contents (v0), 0, 0, stream, format,
 204                      0, recurse + 1, pretty);
 205           annotate_elt_rep (i - i0);
 206           fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
 207           annotate_elt_rep_end ();
 208
 209         }
 210       else
 211         {
 212           int j;
 213           for (j = i0; j < i; j += 1)
 214             {
 215               if (j > i0)
 216                 {
 217                   if (prettyprint_arrays)
 218                     {
 219                       fprintf_filtered (stream, ",\n");
 220                       print_spaces_filtered (2 + 2 * recurse, stream);
 221                     }
 222                   else
 223                     {
 224                       fprintf_filtered (stream, ", ");
 225                     }
 226                   wrap_here (n_spaces (2 + 2 * recurse));
 227                   maybe_print_array_index (index_type, j + low,
 228                                            stream, format, pretty);
 229                 }
 230               val_print (elttype, value_contents (v0), 0, 0, stream, format,
 231                          0, recurse + 1, pretty);
 232               annotate_elt ();
 233             }
 234         }
 235       things_printed += i - i0;
 236     }
 237   annotate_array_section_end ();
 238   if (i < len)
 239     {
 240       fprintf_filtered (stream, "...");
 241     }
 242
 243   value_free_to_mark (mark);
 244 }
 245
 246 static struct type *
 247 printable_val_type (struct type *type, const gdb_byte *valaddr)
 248 {
 249   return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
 250 }
 251
 252 /* Print the character C on STREAM as part of the contents of a literal
 253    string whose delimiter is QUOTER.  TYPE_LEN is the length in bytes
 254    (1 or 2) of the character.  */
 255
 256 void
 257 ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
 258 {
 259   if (type_len != 2)
 260     type_len = 1;
 261
 262   c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
 263
 264   if (isascii (c) && isprint (c))
 265     {
 266       if (c == quoter && c == '"')
 267         fprintf_filtered (stream, "\"\"");
 268       else
 269         fprintf_filtered (stream, "%c", c);
 270     }
 271   else
 272     fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
 273 }
 274
 275 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
 276    or 2) of a character.  */
 277
 278 static int
 279 char_at (const gdb_byte *string, int i, int type_len)
 280 {
 281   if (type_len == 1)
 282     return string[i];
 283   else
 284     return (int) extract_unsigned_integer (string + 2 * i, 2);
 285 }
 286
 287 /* Wrapper around memcpy to make it legal argument to ui_file_put */
 288 static void
 289 ui_memcpy (void *dest, const char *buffer, long len)
 290 {
 291   memcpy (dest, buffer, (size_t) len);
 292   ((char *) dest)[len] = '\0';
 293 }
 294
 295 /* Print a floating-point value of type TYPE, pointed to in GDB by
 296    VALADDR, on STREAM.  Use Ada formatting conventions: there must be
 297    a decimal point, and at least one digit before and after the
 298    point.  We use GNAT format for NaNs and infinities.  */
 299 static void
 300 ada_print_floating (const gdb_byte *valaddr, struct type *type,
 301                     struct ui_file *stream)
 302 {
 303   char buffer[64];
 304   char *s, *result;
 305   int len;
 306   struct ui_file *tmp_stream = mem_fileopen ();
 307   struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
 308
 309   print_floating (valaddr, type, tmp_stream);
 310   ui_file_put (tmp_stream, ui_memcpy, buffer);
 311   do_cleanups (cleanups);
 312
 313   result = buffer;
 314   len = strlen (result);
 315
 316   /* Modify for Ada rules.  */
 317
 318   s = strstr (result, "inf");
 319   if (s == NULL)
 320     s = strstr (result, "Inf");
 321   if (s == NULL)
 322     s = strstr (result, "INF");
 323   if (s != NULL)
 324     strcpy (s, "Inf");
 325
 326   if (s == NULL)
 327     {
 328       s = strstr (result, "nan");
 329       if (s == NULL)
 330         s = strstr (result, "NaN");
 331       if (s == NULL)
 332         s = strstr (result, "Nan");
 333       if (s != NULL)
 334         {
 335           s[0] = s[2] = 'N';
 336           if (result[0] == '-')
 337             result += 1;
 338         }
 339     }
 340
 341   if (s == NULL && strchr (result, '.') == NULL)
 342     {
 343       s = strchr (result, 'e');
 344       if (s == NULL)
 345         fprintf_filtered (stream, "%s.0", result);
 346       else
 347         fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
 348       return;
 349     }
 350   fprintf_filtered (stream, "%s", result);
 351 }
 352
 353 void
 354 ada_printchar (int c, struct ui_file *stream)
 355 {
 356   fputs_filtered ("'", stream);
 357   ada_emit_char (c, stream, '\'', 1);
 358   fputs_filtered ("'", stream);
 359 }
 360
 361 /* [From print_type_scalar in typeprint.c].   Print VAL on STREAM in a
 362    form appropriate for TYPE.  */
 363
 364 void
 365 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 366 {
 367   unsigned int i;
 368   unsigned len;
 369
 370   type = ada_check_typedef (type);
 371
 372   switch (TYPE_CODE (type))
 373     {
 374
 375     case TYPE_CODE_ENUM:
 376       len = TYPE_NFIELDS (type);
 377       for (i = 0; i < len; i++)
 378         {
 379           if (TYPE_FIELD_BITPOS (type, i) == val)
 380             {
 381               break;
 382             }
 383         }
 384       if (i < len)
 385         {
 386           fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
 387         }
 388       else
 389         {
 390           print_longest (stream, 'd', 0, val);
 391         }
 392       break;
 393
 394     case TYPE_CODE_INT:
 395       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 396       break;
 397
 398     case TYPE_CODE_CHAR:
 399       LA_PRINT_CHAR ((unsigned char) val, stream);
 400       break;
 401
 402     case TYPE_CODE_BOOL:
 403       fprintf_filtered (stream, val ? "true" : "false");
 404       break;
 405
 406     case TYPE_CODE_RANGE:
 407       ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
 408       return;
 409
 410     case TYPE_CODE_UNDEF:
 411     case TYPE_CODE_PTR:
 412     case TYPE_CODE_ARRAY:
 413     case TYPE_CODE_STRUCT:
 414     case TYPE_CODE_UNION:
 415     case TYPE_CODE_FUNC:
 416     case TYPE_CODE_FLT:
 417     case TYPE_CODE_VOID:
 418     case TYPE_CODE_SET:
 419     case TYPE_CODE_STRING:
 420     case TYPE_CODE_ERROR:
 421     case TYPE_CODE_MEMBERPTR:
 422     case TYPE_CODE_METHODPTR:
 423     case TYPE_CODE_METHOD:
 424     case TYPE_CODE_REF:
 425       warning (_("internal error: unhandled type in ada_print_scalar"));
 426       break;
 427
 428     default:
 429       error (_("Invalid type code in symbol table."));
 430     }
 431   gdb_flush (stream);
 432 }
 433
 434 /* Print the character string STRING, printing at most LENGTH characters.
 435    Printing stops early if the number hits print_max; repeat counts
 436    are printed as appropriate.  Print ellipses at the end if we
 437    had to stop before printing LENGTH characters, or if
 438    FORCE_ELLIPSES.   TYPE_LEN is the length (1 or 2) of the character type.
 439  */
 440
 441 static void
 442 printstr (struct ui_file *stream, const gdb_byte *string,
 443           unsigned int length, int force_ellipses, int type_len)
 444 {
 445   unsigned int i;
 446   unsigned int things_printed = 0;
 447   int in_quotes = 0;
 448   int need_comma = 0;
 449
 450   if (length == 0)
 451     {
 452       fputs_filtered ("\"\"", stream);
 453       return;
 454     }
 455
 456   for (i = 0; i < length && things_printed < print_max; i += 1)
 457     {
 458       /* Position of the character we are examining
 459          to see whether it is repeated.  */
 460       unsigned int rep1;
 461       /* Number of repetitions we have detected so far.  */
 462       unsigned int reps;
 463
 464       QUIT;
 465
 466       if (need_comma)
 467         {
 468           fputs_filtered (", ", stream);
 469           need_comma = 0;
 470         }
 471
 472       rep1 = i + 1;
 473       reps = 1;
 474       while (rep1 < length
 475              && char_at (string, rep1, type_len) == char_at (string, i,
 476                                                              type_len))
 477         {
 478           rep1 += 1;
 479           reps += 1;
 480         }
 481
 482       if (reps > repeat_count_threshold)
 483         {
 484           if (in_quotes)
 485             {
 486               if (inspect_it)
 487                 fputs_filtered ("\\\", ", stream);
 488               else
 489                 fputs_filtered ("\", ", stream);
 490               in_quotes = 0;
 491             }
 492           fputs_filtered ("'", stream);
 493           ada_emit_char (char_at (string, i, type_len), stream, '\'',
 494                          type_len);
 495           fputs_filtered ("'", stream);
 496           fprintf_filtered (stream, _(" <repeats %u times>"), reps);
 497           i = rep1 - 1;
 498           things_printed += repeat_count_threshold;
 499           need_comma = 1;
 500         }
 501       else
 502         {
 503           if (!in_quotes)
 504             {
 505               if (inspect_it)
 506                 fputs_filtered ("\\\"", stream);
 507               else
 508                 fputs_filtered ("\"", stream);
 509               in_quotes = 1;
 510             }
 511           ada_emit_char (char_at (string, i, type_len), stream, '"',
 512                          type_len);
 513           things_printed += 1;
 514         }
 515     }
 516
 517   /* Terminate the quotes if necessary.  */
 518   if (in_quotes)
 519     {
 520       if (inspect_it)
 521         fputs_filtered ("\\\"", stream);
 522       else
 523         fputs_filtered ("\"", stream);
 524     }
 525
 526   if (force_ellipses || i < length)
 527     fputs_filtered ("...", stream);
 528 }
 529
 530 void
 531 ada_printstr (struct ui_file *stream, const gdb_byte *string,
 532               unsigned int length, int width, int force_ellipses)
 533 {
 534   printstr (stream, string, length, force_ellipses, width);
 535 }
 536
 537
 538 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 539    the inferior at address ADDRESS, onto stdio stream STREAM according to
 540    FORMAT (a letter as for the printf % codes or 0 for natural format).
 541    The data at VALADDR is in target byte order.
 542
 543    If the data is printed as a string, returns the number of string characters
 544    printed.
 545
 546    If DEREF_REF is nonzero, then dereference references, otherwise just print
 547    them like pointers.
 548
 549    RECURSE indicates the amount of indentation to supply before
 550    continuation lines; this amount is roughly twice the value of RECURSE.
 551
 552    When PRETTY is non-zero, prints record fields on separate lines.
 553    (For some reason, the current version of gdb instead uses a global
 554    variable---prettyprint_arrays--- to causes a similar effect on
 555    arrays.)  */
 556
 557 int
 558 ada_val_print (struct type *type, const gdb_byte *valaddr0,
 559                int embedded_offset, CORE_ADDR address,
 560                struct ui_file *stream, int format, int deref_ref,
 561                int recurse, enum val_prettyprint pretty)
 562 {
 563   struct ada_val_print_args args;
 564   args.type = type;
 565   args.valaddr0 = valaddr0;
 566   args.embedded_offset = embedded_offset;
 567   args.address = address;
 568   args.stream = stream;
 569   args.format = format;
 570   args.deref_ref = deref_ref;
 571   args.recurse = recurse;
 572   args.pretty = pretty;
 573
 574   return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
 575 }
 576
 577 /* Helper for ada_val_print; used as argument to catch_errors to
 578    unmarshal the arguments to ada_val_print_1, which does the work.  */
 579 static int
 580 ada_val_print_stub (void *args0)
 581 {
 582   struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
 583   return ada_val_print_1 (argsp->type, argsp->valaddr0,
 584                           argsp->embedded_offset, argsp->address,
 585                           argsp->stream, argsp->format, argsp->deref_ref,
 586                           argsp->recurse, argsp->pretty);
 587 }
 588
 589 /* See the comment on ada_val_print.  This function differs in that it
 590  * does not catch evaluation errors (leaving that to ada_val_print).  */
 591
 592 static int
 593 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
 594                  int embedded_offset, CORE_ADDR address,
 595                  struct ui_file *stream, int format,
 596                  int deref_ref, int recurse, enum val_prettyprint pretty)
 597 {
 598   unsigned int len;
 599   int i;
 600   struct type *elttype;
 601   unsigned int eltlen;
 602   LONGEST val;
 603   const gdb_byte *valaddr = valaddr0 + embedded_offset;
 604
 605   type = ada_check_typedef (type);
 606
 607   if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
 608     {
 609       int retn;
 610       struct value *mark = value_mark ();
 611       struct value *val;
 612       val = value_from_contents_and_address (type, valaddr, address);
 613       val = ada_coerce_to_simple_array_ptr (val);
 614       if (val == NULL)
 615         {
 616           fprintf_filtered (stream, "(null)");
 617           retn = 0;
 618         }
 619       else
 620         retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
 621                                 VALUE_ADDRESS (val), stream, format,
 622                                 deref_ref, recurse, pretty);
 623       value_free_to_mark (mark);
 624       return retn;
 625     }
 626
 627   valaddr = ada_aligned_value_addr (type, valaddr);
 628   embedded_offset -= valaddr - valaddr0 - embedded_offset;
 629   type = printable_val_type (type, valaddr);
 630
 631   switch (TYPE_CODE (type))
 632     {
 633     default:
 634       return c_val_print (type, valaddr0, embedded_offset, address, stream,
 635                           format, deref_ref, recurse, pretty);
 636
 637     case TYPE_CODE_PTR:
 638       {
 639         int ret = c_val_print (type, valaddr0, embedded_offset, address,
 640                                stream, format, deref_ref, recurse, pretty);
 641         if (ada_is_tag_type (type))
 642           {
 643             struct value *val =
 644               value_from_contents_and_address (type, valaddr, address);
 645             const char *name = ada_tag_name (val);
 646             if (name != NULL)
 647               fprintf_filtered (stream, " (%s)", name);
 648             return 0;
 649         }
 650         return ret;
 651       }
 652
 653     case TYPE_CODE_INT:
 654     case TYPE_CODE_RANGE:
 655       if (ada_is_fixed_point_type (type))
 656         {
 657           LONGEST v = unpack_long (type, valaddr);
 658           int len = TYPE_LENGTH (type);
 659
 660           fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
 661                             (double) ada_fixed_to_float (type, v));
 662           return 0;
 663         }
 664       else if (ada_is_vax_floating_type (type))
 665         {
 666           struct value *val =
 667             value_from_contents_and_address (type, valaddr, address);
 668           struct value *func = ada_vax_float_print_function (type);
 669           if (func != 0)
 670             {
 671               static struct type *parray_of_char = NULL;
 672               struct value *printable_val;
 673
 674               if (parray_of_char == NULL)
 675                 parray_of_char =
 676                   make_pointer_type
 677                   (create_array_type
 678                    (NULL, builtin_type_char,
 679                     create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
 680
 681               printable_val =
 682                 value_ind (value_cast (parray_of_char,
 683                                        call_function_by_hand (func, 1,
 684                                                               &val)));
 685
 686               fprintf_filtered (stream, "%s", value_contents (printable_val));
 687               return 0;
 688             }
 689           /* No special printing function.  Do as best we can.  */
 690         }
 691       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
 692         {
 693           struct type *target_type = TYPE_TARGET_TYPE (type);
 694           if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
 695             {
 696               /* Obscure case of range type that has different length from
 697                  its base type.  Perform a conversion, or we will get a
 698                  nonsense value.  Actually, we could use the same
 699                  code regardless of lengths; I'm just avoiding a cast.  */
 700               struct value *v = value_cast (target_type,
 701                                             value_from_contents_and_address
 702                                             (type, valaddr, 0));
 703               return ada_val_print_1 (target_type, value_contents (v), 0, 0,
 704                                       stream, format, 0, recurse + 1, pretty);
 705             }
 706           else
 707             return ada_val_print_1 (TYPE_TARGET_TYPE (type),
 708                                     valaddr0, embedded_offset,
 709                                     address, stream, format, deref_ref,
 710                                     recurse, pretty);
 711         }
 712       else
 713         {
 714           format = format ? format : output_format;
 715           if (format)
 716             {
 717               print_scalar_formatted (valaddr, type, format, 0, stream);
 718             }
 719           else if (ada_is_system_address_type (type))
 720             {
 721               /* FIXME: We want to print System.Address variables using
 722                  the same format as for any access type.  But for some
 723                  reason GNAT encodes the System.Address type as an int,
 724                  so we have to work-around this deficiency by handling
 725                  System.Address values as a special case.  */
 726               fprintf_filtered (stream, "(");
 727               type_print (type, "", stream, -1);
 728               fprintf_filtered (stream, ") ");
 729               fputs_filtered (paddress (extract_typed_address
 730                                         (valaddr, builtin_type_void_data_ptr)),
 731                               stream);
 732             }
 733           else
 734             {
 735               val_print_type_code_int (type, valaddr, stream);
 736               if (ada_is_character_type (type))
 737                 {
 738                   fputs_filtered (" ", stream);
 739                   ada_printchar ((unsigned char) unpack_long (type, valaddr),
 740                                  stream);
 741                 }
 742             }
 743           return 0;
 744         }
 745
 746     case TYPE_CODE_ENUM:
 747       if (format)
 748         {
 749           print_scalar_formatted (valaddr, type, format, 0, stream);
 750           break;
 751         }
 752       len = TYPE_NFIELDS (type);
 753       val = unpack_long (type, valaddr);
 754       for (i = 0; i < len; i++)
 755         {
 756           QUIT;
 757           if (val == TYPE_FIELD_BITPOS (type, i))
 758             {
 759               break;
 760             }
 761         }
 762       if (i < len)
 763         {
 764           const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
 765           if (name[0] == '\'')
 766             fprintf_filtered (stream, "%ld %s", (long) val, name);
 767           else
 768             fputs_filtered (name, stream);
 769         }
 770       else
 771         {
 772           print_longest (stream, 'd', 0, val);
 773         }
 774       break;
 775
 776     case TYPE_CODE_FLAGS:
 777       if (format)
 778           print_scalar_formatted (valaddr, type, format, 0, stream);
 779       else
 780         val_print_type_code_flags (type, valaddr, stream);
 781       break;
 782
 783     case TYPE_CODE_FLT:
 784       if (format)
 785         return c_val_print (type, valaddr0, embedded_offset, address, stream,
 786                             format, deref_ref, recurse, pretty);
 787       else
 788         ada_print_floating (valaddr0 + embedded_offset, type, stream);
 789       break;
 790
 791     case TYPE_CODE_UNION:
 792     case TYPE_CODE_STRUCT:
 793       if (ada_is_bogus_array_descriptor (type))
 794         {
 795           fprintf_filtered (stream, "(...?)");
 796           return 0;
 797         }
 798       else
 799         {
 800           print_record (type, valaddr, stream, format, recurse, pretty);
 801           return 0;
 802         }
 803
 804     case TYPE_CODE_ARRAY:
 805       elttype = TYPE_TARGET_TYPE (type);
 806       if (elttype == NULL)
 807         eltlen = 0;
 808       else
 809         eltlen = TYPE_LENGTH (elttype);
 810       /* FIXME: This doesn't deal with non-empty arrays of
 811          0-length items (not a typical case!) */
 812       if (eltlen == 0)
 813         len = 0;
 814       else
 815         len = TYPE_LENGTH (type) / eltlen;
 816
 817           /* For an array of chars, print with string syntax.  */
 818       if (ada_is_string_type (type) && (format == 0 || format == 's'))
 819         {
 820           if (prettyprint_arrays)
 821             {
 822               print_spaces_filtered (2 + 2 * recurse, stream);
 823             }
 824           /* If requested, look for the first null char and only print
 825              elements up to it.  */
 826           if (stop_print_at_null)
 827             {
 828               int temp_len;
 829
 830               /* Look for a NULL char.  */
 831               for (temp_len = 0;
 832                    temp_len < len && temp_len < print_max
 833                      && char_at (valaddr, temp_len, eltlen) != 0;
 834                    temp_len += 1);
 835               len = temp_len;
 836             }
 837
 838           printstr (stream, valaddr, len, 0, eltlen);
 839         }
 840       else
 841         {
 842           len = 0;
 843           fprintf_filtered (stream, "(");
 844           print_optional_low_bound (stream, type);
 845           if (TYPE_FIELD_BITSIZE (type, 0) > 0)
 846             val_print_packed_array_elements (type, valaddr, 0, stream,
 847                                              format, recurse, pretty);
 848           else
 849             val_print_array_elements (type, valaddr, address, stream,
 850                                       format, deref_ref, recurse,
 851                                       pretty, 0);
 852           fprintf_filtered (stream, ")");
 853         }
 854       gdb_flush (stream);
 855       return len;
 856
 857     case TYPE_CODE_REF:
 858       /* For references, the debugger is expected to print the value as
 859          an address if DEREF_REF is null.  But printing an address in place
 860          of the object value would be confusing to an Ada programmer.
 861          So, for Ada values, we print the actual dereferenced value
 862          regardless.  */
 863       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 864
 865       if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 866         {
 867           LONGEST deref_val_int = (LONGEST)
 868             unpack_pointer (lookup_pointer_type (builtin_type_void),
 869                             valaddr);
 870           if (deref_val_int != 0)
 871             {
 872               struct value *deref_val =
 873                 ada_value_ind (value_from_longest
 874                                (lookup_pointer_type (elttype),
 875                                 deref_val_int));
 876               val_print (value_type (deref_val),
 877                          value_contents (deref_val), 0,
 878                          VALUE_ADDRESS (deref_val), stream, format,
 879                          deref_ref, recurse + 1, pretty);
 880             }
 881           else
 882             fputs_filtered ("(null)", stream);
 883         }
 884       else
 885         fputs_filtered ("???", stream);
 886
 887       break;
 888     }
 889   gdb_flush (stream);
 890   return 0;
 891 }
 892
 893 static int
 894 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
 895                     struct ui_file *stream, int format, int recurse,
 896                     enum val_prettyprint pretty, int comma_needed,
 897                     struct type *outer_type, const gdb_byte *outer_valaddr)
 898 {
 899   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
 900   int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
 901
 902   if (which < 0)
 903     return 0;
 904   else
 905     return print_field_values
 906       (TYPE_FIELD_TYPE (var_type, which),
 907        valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
 908        + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
 909        stream, format, recurse, pretty,
 910        comma_needed, outer_type, outer_valaddr);
 911 }
 912
 913 int
 914 ada_value_print (struct value *val0, struct ui_file *stream, int format,
 915                  enum val_prettyprint pretty)
 916 {
 917   const gdb_byte *valaddr = value_contents (val0);
 918   CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
 919   struct type *type =
 920     ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
 921   struct value *val =
 922     value_from_contents_and_address (type, valaddr, address);
 923
 924   /* If it is a pointer, indicate what it points to.  */
 925   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 926     {
 927       /* Hack:  don't print (char *) for char strings.  Their
 928          type is indicated by the quoted string anyway.  */
 929       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
 930           || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
 931           || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
 932         {
 933           fprintf_filtered (stream, "(");
 934           type_print (type, "", stream, -1);
 935           fprintf_filtered (stream, ") ");
 936         }
 937     }
 938   else if (ada_is_array_descriptor_type (type))
 939     {
 940       fprintf_filtered (stream, "(");
 941       type_print (type, "", stream, -1);
 942       fprintf_filtered (stream, ") ");
 943     }
 944   else if (ada_is_bogus_array_descriptor (type))
 945     {
 946       fprintf_filtered (stream, "(");
 947       type_print (type, "", stream, -1);
 948       fprintf_filtered (stream, ") (...?)");
 949       return 0;
 950     }
 951
 952   if (TYPE_CODE (type) == TYPE_CODE_ARRAY
 953       && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == 0
 954       && TYPE_CODE (TYPE_INDEX_TYPE (type)) == TYPE_CODE_RANGE)
 955     {
 956       /* This is an array of zero-length elements, that is an array
 957          of null records.  This array needs to be printed by hand,
 958          as the standard routine to print arrays relies on the size of
 959          the array elements to be nonzero.  This is because it computes
 960          the number of elements in the array by dividing the array size
 961          by the array element size.  */
 962       fprintf_filtered (stream, "(%d .. %d => ())",
 963                         TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
 964                         TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type)));
 965       return 0;
 966     }
 967
 968   return (val_print (type, value_contents (val), 0, address,
 969                      stream, format, 1, 0, pretty));
 970 }
 971
 972 static void
 973 print_record (struct type *type, const gdb_byte *valaddr,
 974               struct ui_file *stream, int format, int recurse,
 975               enum val_prettyprint pretty)
 976 {
 977   type = ada_check_typedef (type);
 978
 979   fprintf_filtered (stream, "(");
 980
 981   if (print_field_values (type, valaddr, stream, format, recurse, pretty,
 982                           0, type, valaddr) != 0 && pretty)
 983     {
 984       fprintf_filtered (stream, "\n");
 985       print_spaces_filtered (2 * recurse, stream);
 986     }
 987
 988   fprintf_filtered (stream, ")");
 989 }
 990
 991 /* Print out fields of value at VALADDR having structure type TYPE.
 992
 993    TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
 994    same meanings as in ada_print_value and ada_val_print.
 995
 996    OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
 997    (used to get discriminant values when printing variant parts).
 998
 999    COMMA_NEEDED is 1 if fields have been printed at the current recursion
1000    level, so that a comma is needed before any field printed by this
1001    call.
1002
1003    Returns 1 if COMMA_NEEDED or any fields were printed.  */
1004
1005 static int
1006 print_field_values (struct type *type, const gdb_byte *valaddr,
1007                     struct ui_file *stream, int format, int recurse,
1008                     enum val_prettyprint pretty, int comma_needed,
1009                     struct type *outer_type, const gdb_byte *outer_valaddr)
1010 {
1011   int i, len;
1012
1013   len = TYPE_NFIELDS (type);
1014
1015   for (i = 0; i < len; i += 1)
1016     {
1017       if (ada_is_ignored_field (type, i))
1018         continue;
1019
1020       if (ada_is_wrapper_field (type, i))
1021         {
1022           comma_needed =
1023             print_field_values (TYPE_FIELD_TYPE (type, i),
1024                                 valaddr
1025                                 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1026                                 stream, format, recurse, pretty,
1027                                 comma_needed, type, valaddr);
1028           continue;
1029         }
1030       else if (ada_is_variant_part (type, i))
1031         {
1032           comma_needed =
1033             print_variant_part (type, i, valaddr,
1034                                 stream, format, recurse, pretty, comma_needed,
1035                                 outer_type, outer_valaddr);
1036           continue;
1037         }
1038
1039       if (comma_needed)
1040         fprintf_filtered (stream, ", ");
1041       comma_needed = 1;
1042
1043       if (pretty)
1044         {
1045           fprintf_filtered (stream, "\n");
1046           print_spaces_filtered (2 + 2 * recurse, stream);
1047         }
1048       else
1049         {
1050           wrap_here (n_spaces (2 + 2 * recurse));
1051         }
1052       if (inspect_it)
1053         {
1054           if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1055             fputs_filtered ("\"( ptr \"", stream);
1056           else
1057             fputs_filtered ("\"( nodef \"", stream);
1058           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1059                                    language_cplus, DMGL_NO_OPTS);
1060           fputs_filtered ("\" \"", stream);
1061           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1062                                    language_cplus, DMGL_NO_OPTS);
1063           fputs_filtered ("\") \"", stream);
1064         }
1065       else
1066         {
1067           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1068           fprintf_filtered (stream, "%.*s",
1069                             ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1070                             TYPE_FIELD_NAME (type, i));
1071           annotate_field_name_end ();
1072           fputs_filtered (" => ", stream);
1073           annotate_field_value ();
1074         }
1075
1076       if (TYPE_FIELD_PACKED (type, i))
1077         {
1078           struct value *v;
1079
1080           /* Bitfields require special handling, especially due to byte
1081              order problems.  */
1082           if (TYPE_CPLUS_SPECIFIC (type) != NULL
1083               && TYPE_FIELD_IGNORE (type, i))
1084             {
1085               fputs_filtered (_("<optimized out or zero length>"), stream);
1086             }
1087           else
1088             {
1089               int bit_pos = TYPE_FIELD_BITPOS (type, i);
1090               int bit_size = TYPE_FIELD_BITSIZE (type, i);
1091
1092               adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1093               v = ada_value_primitive_packed_val (NULL, valaddr,
1094                                                   bit_pos / HOST_CHAR_BIT,
1095                                                   bit_pos % HOST_CHAR_BIT,
1096                                                   bit_size,
1097                                                   TYPE_FIELD_TYPE (type, i));
1098               val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1099                          stream, format, 0, recurse + 1, pretty);
1100             }
1101         }
1102       else
1103         ada_val_print (TYPE_FIELD_TYPE (type, i),
1104                        valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1105                        0, 0, stream, format, 0, recurse + 1, pretty);
1106       annotate_field_end ();
1107     }
1108
1109   return comma_needed;
1110 }