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