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