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