gdb/ada-valprint.c

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