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