gdb/ada-valprint.c

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