gdb/ada-typeprint.c

   1 /* Support for printing Ada types for GDB, the GNU debugger.
   2    Copyright (C) 1986-2020 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "bfd.h"                /* Binary File Description */
  21 #include "gdbtypes.h"
  22 #include "value.h"
  23 #include "c-lang.h"
  24 #include "cli/cli-style.h"
  25 #include "typeprint.h"
  26 #include "target-float.h"
  27 #include "ada-lang.h"
  28 #include <ctype.h>
  29
  30 static int print_selected_record_field_types (struct type *, struct type *,
  31                                               int, int,
  32                                               struct ui_file *, int, int,
  33                                               const struct type_print_options *);
  34
  35 static int print_record_field_types (struct type *, struct type *,
  36                                      struct ui_file *, int, int,
  37                                      const struct type_print_options *);
  38 \f
  39
  40
  41 static char *name_buffer;
  42 static int name_buffer_len;
  43
  44 /* The (decoded) Ada name of TYPE.  This value persists until the
  45    next call.  */
  46
  47 static char *
  48 decoded_type_name (struct type *type)
  49 {
  50   if (ada_type_name (type) == NULL)
  51     return NULL;
  52   else
  53     {
  54       const char *raw_name = ada_type_name (type);
  55       char *s, *q;
  56
  57       if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
  58         {
  59           name_buffer_len = 16 + 2 * strlen (raw_name);
  60           name_buffer = (char *) xrealloc (name_buffer, name_buffer_len);
  61         }
  62       strcpy (name_buffer, raw_name);
  63
  64       s = (char *) strstr (name_buffer, "___");
  65       if (s != NULL)
  66         *s = '\0';
  67
  68       s = name_buffer + strlen (name_buffer) - 1;
  69       while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
  70         s -= 1;
  71
  72       if (s == name_buffer)
  73         return name_buffer;
  74
  75       if (!islower (s[1]))
  76         return NULL;
  77
  78       for (s = q = name_buffer; *s != '\0'; q += 1)
  79         {
  80           if (s[0] == '_' && s[1] == '_')
  81             {
  82               *q = '.';
  83               s += 2;
  84             }
  85           else
  86             {
  87               *q = *s;
  88               s += 1;
  89             }
  90         }
  91       *q = '\0';
  92       return name_buffer;
  93     }
  94 }
  95
  96 /* Return nonzero if TYPE is a subrange type, and its bounds
  97    are identical to the bounds of its subtype.  */
  98
  99 static int
 100 type_is_full_subrange_of_target_type (struct type *type)
 101 {
 102   struct type *subtype;
 103
 104   if (type->code () != TYPE_CODE_RANGE)
 105     return 0;
 106
 107   subtype = TYPE_TARGET_TYPE (type);
 108   if (subtype == NULL)
 109     return 0;
 110
 111   if (is_dynamic_type (type))
 112     return 0;
 113
 114   if (ada_discrete_type_low_bound (type)
 115       != ada_discrete_type_low_bound (subtype))
 116     return 0;
 117
 118   if (ada_discrete_type_high_bound (type)
 119       != ada_discrete_type_high_bound (subtype))
 120     return 0;
 121
 122   return 1;
 123 }
 124
 125 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
 126    is nonzero.  */
 127
 128 static void
 129 print_range (struct type *type, struct ui_file *stream,
 130              int bounds_prefered_p)
 131 {
 132   if (!bounds_prefered_p)
 133     {
 134       /* Try stripping all TYPE_CODE_RANGE layers whose bounds
 135          are identical to the bounds of their subtype.  When
 136          the bounds of both types match, it can allow us to
 137          print a range using the name of its base type, which
 138          is easier to read.  For instance, we would print...
 139
 140              array (character) of ...
 141
 142          ... instead of...
 143
 144              array ('["00"]' .. '["ff"]') of ...  */
 145       while (type_is_full_subrange_of_target_type (type))
 146         type = TYPE_TARGET_TYPE (type);
 147     }
 148
 149   switch (type->code ())
 150     {
 151     case TYPE_CODE_RANGE:
 152     case TYPE_CODE_ENUM:
 153       {
 154         LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
 155         int got_error = 0;
 156
 157         try
 158           {
 159             lo = ada_discrete_type_low_bound (type);
 160             hi = ada_discrete_type_high_bound (type);
 161           }
 162         catch (const gdb_exception_error &e)
 163           {
 164             /* This can happen when the range is dynamic.  Sometimes,
 165                resolving dynamic property values requires us to have
 166                access to an actual object, which is not available
 167                when the user is using the "ptype" command on a type.
 168                Print the range as an unbounded range.  */
 169             fprintf_filtered (stream, "<>");
 170             got_error = 1;
 171           }
 172
 173         if (!got_error)
 174           {
 175             ada_print_scalar (type, lo, stream);
 176             fprintf_filtered (stream, " .. ");
 177             ada_print_scalar (type, hi, stream);
 178           }
 179       }
 180       break;
 181     default:
 182       fprintf_filtered (stream, "%.*s",
 183                         ada_name_prefix_len (type->name ()),
 184                         type->name ());
 185       break;
 186     }
 187 }
 188
 189 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
 190    set *N past the bound and its delimiter, if any.  */
 191
 192 static void
 193 print_range_bound (struct type *type, const char *bounds, int *n,
 194                    struct ui_file *stream)
 195 {
 196   LONGEST B;
 197
 198   if (ada_scan_number (bounds, *n, &B, n))
 199     {
 200       /* STABS decodes all range types which bounds are 0 .. -1 as
 201          unsigned integers (ie. the type code is TYPE_CODE_INT, not
 202          TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
 203          on the unsigned flag to determine whether the bound should
 204          be printed as a signed or an unsigned value.  This causes
 205          the upper bound of the 0 .. -1 range types to be printed as
 206          a very large unsigned number instead of -1.
 207          To workaround this stabs deficiency, we replace the TYPE by NULL
 208          to indicate default output when we detect that the bound is negative,
 209          and the type is a TYPE_CODE_INT.  The bound is negative when
 210          'm' is the last character of the number scanned in BOUNDS.  */
 211       if (bounds[*n - 1] == 'm' && type->code () == TYPE_CODE_INT)
 212         type = NULL;
 213       ada_print_scalar (type, B, stream);
 214       if (bounds[*n] == '_')
 215         *n += 2;
 216     }
 217   else
 218     {
 219       int bound_len;
 220       const char *bound = bounds + *n;
 221       const char *pend;
 222
 223       pend = strstr (bound, "__");
 224       if (pend == NULL)
 225         *n += bound_len = strlen (bound);
 226       else
 227         {
 228           bound_len = pend - bound;
 229           *n += bound_len + 2;
 230         }
 231       fprintf_filtered (stream, "%.*s", bound_len, bound);
 232     }
 233 }
 234
 235 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
 236    the value (if found) of the bound indicated by SUFFIX ("___L" or
 237    "___U") according to the ___XD conventions.  */
 238
 239 static void
 240 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
 241                            const char *suffix, struct ui_file *stream)
 242 {
 243   LONGEST B;
 244   std::string name_buf (name, name_len);
 245   name_buf += suffix;
 246
 247   if (get_int_var_value (name_buf.c_str (), B))
 248     ada_print_scalar (type, B, stream);
 249   else
 250     fprintf_filtered (stream, "?");
 251 }
 252
 253 /* Print RAW_TYPE as a range type, using any bound information
 254    following the GNAT encoding (if available).
 255
 256    If BOUNDS_PREFERED_P is nonzero, force the printing of the range
 257    using its bounds.  Otherwise, try printing the range without
 258    printing the value of the bounds, if possible (this is only
 259    considered a hint, not a guaranty).  */
 260
 261 static void
 262 print_range_type (struct type *raw_type, struct ui_file *stream,
 263                   int bounds_prefered_p)
 264 {
 265   const char *name;
 266   struct type *base_type;
 267   const char *subtype_info;
 268
 269   gdb_assert (raw_type != NULL);
 270   name = raw_type->name ();
 271   gdb_assert (name != NULL);
 272
 273   if (raw_type->code () == TYPE_CODE_RANGE)
 274     base_type = TYPE_TARGET_TYPE (raw_type);
 275   else
 276     base_type = raw_type;
 277
 278   subtype_info = strstr (name, "___XD");
 279   if (subtype_info == NULL)
 280     print_range (raw_type, stream, bounds_prefered_p);
 281   else
 282     {
 283       int prefix_len = subtype_info - name;
 284       const char *bounds_str;
 285       int n;
 286
 287       subtype_info += 5;
 288       bounds_str = strchr (subtype_info, '_');
 289       n = 1;
 290
 291       if (*subtype_info == 'L')
 292         {
 293           print_range_bound (base_type, bounds_str, &n, stream);
 294           subtype_info += 1;
 295         }
 296       else
 297         print_dynamic_range_bound (base_type, name, prefix_len, "___L",
 298                                    stream);
 299
 300       fprintf_filtered (stream, " .. ");
 301
 302       if (*subtype_info == 'U')
 303         print_range_bound (base_type, bounds_str, &n, stream);
 304       else
 305         print_dynamic_range_bound (base_type, name, prefix_len, "___U",
 306                                    stream);
 307     }
 308 }
 309
 310 /* Print enumerated type TYPE on STREAM.  */
 311
 312 static void
 313 print_enum_type (struct type *type, struct ui_file *stream)
 314 {
 315   int len = type->num_fields ();
 316   int i;
 317   LONGEST lastval;
 318
 319   fprintf_filtered (stream, "(");
 320   wrap_here (" ");
 321
 322   lastval = 0;
 323   for (i = 0; i < len; i++)
 324     {
 325       QUIT;
 326       if (i)
 327         fprintf_filtered (stream, ", ");
 328       wrap_here ("    ");
 329       fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type, i)),
 330                     variable_name_style.style (), stream);
 331       if (lastval != TYPE_FIELD_ENUMVAL (type, i))
 332         {
 333           fprintf_filtered (stream, " => %s",
 334                             plongest (TYPE_FIELD_ENUMVAL (type, i)));
 335           lastval = TYPE_FIELD_ENUMVAL (type, i);
 336         }
 337       lastval += 1;
 338     }
 339   fprintf_filtered (stream, ")");
 340 }
 341
 342 /* Print representation of Ada fixed-point type TYPE on STREAM.  */
 343
 344 static void
 345 print_gnat_encoded_fixed_point_type (struct type *type, struct ui_file *stream)
 346 {
 347   struct value *delta = gnat_encoded_fixed_point_delta (type);
 348   struct value *small = ada_scaling_factor (type);
 349
 350   if (delta == nullptr)
 351     fprintf_filtered (stream, "delta ??");
 352   else
 353     {
 354       std::string str;
 355       str = target_float_to_string (value_contents (delta),
 356                                     value_type (delta), "%g");
 357       fprintf_filtered (stream, "delta %s", str.c_str());
 358       if (!value_equal (delta, small))
 359         {
 360           str = target_float_to_string (value_contents (small),
 361                                         value_type (small), "%g");
 362           fprintf_filtered (stream, " <'small = %s>", str.c_str());
 363         }
 364     }
 365 }
 366
 367 /* Print simple (constrained) array type TYPE on STREAM.  LEVEL is the
 368    recursion (indentation) level, in case the element type itself has
 369    nested structure, and SHOW is the number of levels of internal
 370    structure to show (see ada_print_type).  */
 371
 372 static void
 373 print_array_type (struct type *type, struct ui_file *stream, int show,
 374                   int level, const struct type_print_options *flags)
 375 {
 376   int bitsize;
 377   int n_indices;
 378   struct type *elt_type = NULL;
 379
 380   if (ada_is_constrained_packed_array_type (type))
 381     type = ada_coerce_to_simple_array_type (type);
 382
 383   bitsize = 0;
 384   fprintf_filtered (stream, "array (");
 385
 386   if (type == NULL)
 387     {
 388       fprintf_styled (stream, metadata_style.style (),
 389                       _("<undecipherable array type>"));
 390       return;
 391     }
 392
 393   n_indices = -1;
 394   if (ada_is_simple_array_type (type))
 395     {
 396       struct type *range_desc_type;
 397       struct type *arr_type;
 398
 399       range_desc_type = ada_find_parallel_type (type, "___XA");
 400       ada_fixup_array_indexes_type (range_desc_type);
 401
 402       bitsize = 0;
 403       if (range_desc_type == NULL)
 404         {
 405           for (arr_type = type; arr_type->code () == TYPE_CODE_ARRAY;
 406                arr_type = TYPE_TARGET_TYPE (arr_type))
 407             {
 408               if (arr_type != type)
 409                 fprintf_filtered (stream, ", ");
 410               print_range (arr_type->index_type (), stream,
 411                            0 /* bounds_prefered_p */);
 412               if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 413                 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 414             }
 415         }
 416       else
 417         {
 418           int k;
 419
 420           n_indices = range_desc_type->num_fields ();
 421           for (k = 0, arr_type = type;
 422                k < n_indices;
 423                k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
 424             {
 425               if (k > 0)
 426                 fprintf_filtered (stream, ", ");
 427               print_range_type (range_desc_type->field (k).type (),
 428                                 stream, 0 /* bounds_prefered_p */);
 429               if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 430                 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 431             }
 432         }
 433     }
 434   else
 435     {
 436       int i, i0;
 437
 438       for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
 439         fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
 440     }
 441
 442   elt_type = ada_array_element_type (type, n_indices);
 443   fprintf_filtered (stream, ") of ");
 444   wrap_here ("");
 445   ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
 446                   flags);
 447   /* Arrays with variable-length elements are never bit-packed in practice but
 448      compilers have to describe their stride so that we can properly fetch
 449      individual elements.  Do not say the array is packed in this case.  */
 450   if (bitsize > 0 && !is_dynamic_type (elt_type))
 451     fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
 452 }
 453
 454 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
 455    STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
 456    values.  Return non-zero if the field is an encoding of
 457    discriminant values, as in a standard variant record, and 0 if the
 458    field is not so encoded (as happens with single-component variants
 459    in types annotated with pragma Unchecked_Union).  */
 460
 461 static int
 462 print_choices (struct type *type, int field_num, struct ui_file *stream,
 463                struct type *val_type)
 464 {
 465   int have_output;
 466   int p;
 467   const char *name = TYPE_FIELD_NAME (type, field_num);
 468
 469   have_output = 0;
 470
 471   /* Skip over leading 'V': NOTE soon to be obsolete.  */
 472   if (name[0] == 'V')
 473     {
 474       if (!ada_scan_number (name, 1, NULL, &p))
 475         goto Huh;
 476     }
 477   else
 478     p = 0;
 479
 480   while (1)
 481     {
 482       switch (name[p])
 483         {
 484         default:
 485           goto Huh;
 486         case '_':
 487         case '\0':
 488           fprintf_filtered (stream, " =>");
 489           return 1;
 490         case 'S':
 491         case 'R':
 492         case 'O':
 493           if (have_output)
 494             fprintf_filtered (stream, " | ");
 495           have_output = 1;
 496           break;
 497         }
 498
 499       switch (name[p])
 500         {
 501         case 'S':
 502           {
 503             LONGEST W;
 504
 505             if (!ada_scan_number (name, p + 1, &W, &p))
 506               goto Huh;
 507             ada_print_scalar (val_type, W, stream);
 508             break;
 509           }
 510         case 'R':
 511           {
 512             LONGEST L, U;
 513
 514             if (!ada_scan_number (name, p + 1, &L, &p)
 515                 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
 516               goto Huh;
 517             ada_print_scalar (val_type, L, stream);
 518             fprintf_filtered (stream, " .. ");
 519             ada_print_scalar (val_type, U, stream);
 520             break;
 521           }
 522         case 'O':
 523           fprintf_filtered (stream, "others");
 524           p += 1;
 525           break;
 526         }
 527     }
 528
 529 Huh:
 530   fprintf_filtered (stream, "? =>");
 531   return 0;
 532 }
 533
 534 /* Assuming that field FIELD_NUM of TYPE represents variants whose
 535    discriminant is contained in OUTER_TYPE, print its components on STREAM.
 536    LEVEL is the recursion (indentation) level, in case any of the fields
 537    themselves have nested structure, and SHOW is the number of levels of
 538    internal structure to show (see ada_print_type).  For this purpose,
 539    fields nested in a variant part are taken to be at the same level as
 540    the fields immediately outside the variant part.  */
 541
 542 static void
 543 print_variant_clauses (struct type *type, int field_num,
 544                        struct type *outer_type, struct ui_file *stream,
 545                        int show, int level,
 546                        const struct type_print_options *flags)
 547 {
 548   int i;
 549   struct type *var_type, *par_type;
 550   struct type *discr_type;
 551
 552   var_type = type->field (field_num).type ();
 553   discr_type = ada_variant_discrim_type (var_type, outer_type);
 554
 555   if (var_type->code () == TYPE_CODE_PTR)
 556     {
 557       var_type = TYPE_TARGET_TYPE (var_type);
 558       if (var_type == NULL || var_type->code () != TYPE_CODE_UNION)
 559         return;
 560     }
 561
 562   par_type = ada_find_parallel_type (var_type, "___XVU");
 563   if (par_type != NULL)
 564     var_type = par_type;
 565
 566   for (i = 0; i < var_type->num_fields (); i += 1)
 567     {
 568       fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
 569       if (print_choices (var_type, i, stream, discr_type))
 570         {
 571           if (print_record_field_types (var_type->field (i).type (),
 572                                         outer_type, stream, show, level + 4,
 573                                         flags)
 574               <= 0)
 575             fprintf_filtered (stream, " null;");
 576         }
 577       else
 578         print_selected_record_field_types (var_type, outer_type, i, i,
 579                                            stream, show, level + 4, flags);
 580     }
 581 }
 582
 583 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
 584    discriminants are contained in OUTER_TYPE, print a description of it
 585    on STREAM.  LEVEL is the recursion (indentation) level, in case any of
 586    the fields themselves have nested structure, and SHOW is the number of
 587    levels of internal structure to show (see ada_print_type).  For this
 588    purpose, fields nested in a variant part are taken to be at the same
 589    level as the fields immediately outside the variant part.  */
 590
 591 static void
 592 print_variant_part (struct type *type, int field_num, struct type *outer_type,
 593                     struct ui_file *stream, int show, int level,
 594                     const struct type_print_options *flags)
 595 {
 596   const char *variant
 597     = ada_variant_discrim_name (type->field (field_num).type ());
 598   if (*variant == '\0')
 599     variant = "?";
 600
 601   fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", variant);
 602   print_variant_clauses (type, field_num, outer_type, stream, show,
 603                          level + 4, flags);
 604   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 605 }
 606
 607 /* Print a description on STREAM of the fields FLD0 through FLD1 in
 608    record or union type TYPE, whose discriminants are in OUTER_TYPE.
 609    LEVEL is the recursion (indentation) level, in case any of the
 610    fields themselves have nested structure, and SHOW is the number of
 611    levels of internal structure to show (see ada_print_type).  Does
 612    not print parent type information of TYPE.  Returns 0 if no fields
 613    printed, -1 for an incomplete type, else > 0.  Prints each field
 614    beginning on a new line, but does not put a new line at end.  */
 615
 616 static int
 617 print_selected_record_field_types (struct type *type, struct type *outer_type,
 618                                    int fld0, int fld1,
 619                                    struct ui_file *stream, int show, int level,
 620                                    const struct type_print_options *flags)
 621 {
 622   int i, flds;
 623
 624   flds = 0;
 625
 626   if (fld0 > fld1 && TYPE_STUB (type))
 627     return -1;
 628
 629   for (i = fld0; i <= fld1; i += 1)
 630     {
 631       QUIT;
 632
 633       if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
 634         ;
 635       else if (ada_is_wrapper_field (type, i))
 636         flds += print_record_field_types (type->field (i).type (), type,
 637                                           stream, show, level, flags);
 638       else if (ada_is_variant_part (type, i))
 639         {
 640           print_variant_part (type, i, outer_type, stream, show, level, flags);
 641           flds = 1;
 642         }
 643       else
 644         {
 645           flds += 1;
 646           fprintf_filtered (stream, "\n%*s", level + 4, "");
 647           ada_print_type (type->field (i).type (),
 648                           TYPE_FIELD_NAME (type, i),
 649                           stream, show - 1, level + 4, flags);
 650           fprintf_filtered (stream, ";");
 651         }
 652     }
 653
 654   return flds;
 655 }
 656
 657 static void print_record_field_types_dynamic
 658   (const gdb::array_view<variant_part> &parts,
 659    int from, int to, struct type *type, struct ui_file *stream,
 660    int show, int level, const struct type_print_options *flags);
 661
 662 /* Print the choices encoded by VARIANT on STREAM.  LEVEL is the
 663    indentation level.  The type of the discriminant for VARIANT is
 664    given by DISR_TYPE.  */
 665
 666 static void
 667 print_choices (struct type *discr_type, const variant &variant,
 668                struct ui_file *stream, int level)
 669 {
 670   fprintf_filtered (stream, "\n%*swhen ", level, "");
 671   if (variant.is_default ())
 672     fprintf_filtered (stream, "others");
 673   else
 674     {
 675       bool first = true;
 676       for (const discriminant_range &range : variant.discriminants)
 677         {
 678           if (!first)
 679             fprintf_filtered (stream, " | ");
 680           first = false;
 681
 682           ada_print_scalar (discr_type, range.low, stream);
 683           if (range.low != range.high)
 684             ada_print_scalar (discr_type, range.high, stream);
 685         }
 686     }
 687
 688   fprintf_filtered (stream, " =>");
 689 }
 690
 691 /* Print a single variant part, PART, on STREAM.  TYPE is the
 692    enclosing type.  SHOW, LEVEL, and FLAGS are the usual type-printing
 693    settings.  This prints information about PART and the fields it
 694    controls.  It returns the index of the next field that should be
 695    shown -- that is, one after the last field printed by this
 696    call.  */
 697
 698 static int
 699 print_variant_part (const variant_part &part,
 700                     struct type *type, struct ui_file *stream,
 701                     int show, int level,
 702                     const struct type_print_options *flags)
 703 {
 704   struct type *discr_type = nullptr;
 705   const char *name;
 706   if (part.discriminant_index == -1)
 707     name = "?";
 708   else
 709     {
 710       name = TYPE_FIELD_NAME (type, part.discriminant_index);
 711       discr_type = type->field (part.discriminant_index).type ();
 712     }
 713
 714   fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", name);
 715
 716   int last_field = -1;
 717   for (const variant &variant : part.variants)
 718     {
 719       print_choices (discr_type, variant, stream, level + 8);
 720
 721       if (variant.first_field == variant.last_field)
 722         fprintf_filtered (stream, " null;");
 723       else
 724         {
 725           print_record_field_types_dynamic (variant.parts,
 726                                             variant.first_field,
 727                                             variant.last_field, type, stream,
 728                                             show, level + 8, flags);
 729           last_field = variant.last_field;
 730         }
 731     }
 732
 733   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 734
 735   return last_field;
 736 }
 737
 738 /* Print some fields of TYPE to STREAM.  SHOW, LEVEL, and FLAGS are
 739    the usual type-printing settings.  PARTS is the array of variant
 740    parts that correspond to the range of fields to be printed.  FROM
 741    and TO are the range of fields to print.  */
 742
 743 static void
 744 print_record_field_types_dynamic (const gdb::array_view<variant_part> &parts,
 745                                   int from, int to,
 746                                   struct type *type, struct ui_file *stream,
 747                                   int show, int level,
 748                                   const struct type_print_options *flags)
 749 {
 750   int field = from;
 751
 752   for (const variant_part &part : parts)
 753     {
 754       if (part.variants.empty ())
 755         continue;
 756
 757       /* Print any non-varying fields.  */
 758       int first_varying = part.variants[0].first_field;
 759       print_selected_record_field_types (type, type, field,
 760                                          first_varying - 1, stream,
 761                                          show, level, flags);
 762
 763       field = print_variant_part (part, type, stream, show, level, flags);
 764     }
 765
 766   /* Print any trailing fields that we were asked to print.  */
 767   print_selected_record_field_types (type, type, field, to - 1, stream, show,
 768                                      level, flags);
 769 }
 770
 771 /* Print a description on STREAM of all fields of record or union type
 772    TYPE, as for print_selected_record_field_types, above.  */
 773
 774 static int
 775 print_record_field_types (struct type *type, struct type *outer_type,
 776                           struct ui_file *stream, int show, int level,
 777                           const struct type_print_options *flags)
 778 {
 779   struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
 780   if (prop != nullptr)
 781     {
 782       if (prop->kind == PROP_TYPE)
 783         {
 784           type = prop->data.original_type;
 785           prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
 786         }
 787       gdb_assert (prop->kind == PROP_VARIANT_PARTS);
 788       print_record_field_types_dynamic (*prop->data.variant_parts,
 789                                         0, type->num_fields (),
 790                                         type, stream, show, level, flags);
 791       return type->num_fields ();
 792     }
 793
 794   return print_selected_record_field_types (type, outer_type,
 795                                             0, type->num_fields () - 1,
 796                                             stream, show, level, flags);
 797 }
 798
 799
 800 /* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
 801    level, in case the element type itself has nested structure, and SHOW is
 802    the number of levels of internal structure to show (see ada_print_type).  */
 803
 804 static void
 805 print_record_type (struct type *type0, struct ui_file *stream, int show,
 806                    int level, const struct type_print_options *flags)
 807 {
 808   struct type *parent_type;
 809   struct type *type;
 810
 811   type = ada_find_parallel_type (type0, "___XVE");
 812   if (type == NULL)
 813     type = type0;
 814
 815   parent_type = ada_parent_type (type);
 816   if (ada_type_name (parent_type) != NULL)
 817     {
 818       const char *parent_name = decoded_type_name (parent_type);
 819
 820       /* If we fail to decode the parent type name, then use the parent
 821          type name as is.  Not pretty, but should never happen except
 822          when the debugging info is incomplete or incorrect.  This
 823          prevents a crash trying to print a NULL pointer.  */
 824       if (parent_name == NULL)
 825         parent_name = ada_type_name (parent_type);
 826       fprintf_filtered (stream, "new %s with record", parent_name);
 827     }
 828   else if (parent_type == NULL && ada_is_tagged_type (type, 0))
 829     fprintf_filtered (stream, "tagged record");
 830   else
 831     fprintf_filtered (stream, "record");
 832
 833   if (show < 0)
 834     fprintf_filtered (stream, " ... end record");
 835   else
 836     {
 837       int flds;
 838
 839       flds = 0;
 840       if (parent_type != NULL && ada_type_name (parent_type) == NULL)
 841         flds += print_record_field_types (parent_type, parent_type,
 842                                           stream, show, level, flags);
 843       flds += print_record_field_types (type, type, stream, show, level,
 844                                         flags);
 845
 846       if (flds > 0)
 847         fprintf_filtered (stream, "\n%*send record", level, "");
 848       else if (flds < 0)
 849         fprintf_filtered (stream, _(" <incomplete type> end record"));
 850       else
 851         fprintf_filtered (stream, " null; end record");
 852     }
 853 }
 854
 855 /* Print the unchecked union type TYPE in something resembling Ada
 856    format on STREAM.  LEVEL is the recursion (indentation) level
 857    in case the element type itself has nested structure, and SHOW is the
 858    number of levels of internal structure to show (see ada_print_type).  */
 859 static void
 860 print_unchecked_union_type (struct type *type, struct ui_file *stream,
 861                             int show, int level,
 862                             const struct type_print_options *flags)
 863 {
 864   if (show < 0)
 865     fprintf_filtered (stream, "record (?) is ... end record");
 866   else if (type->num_fields () == 0)
 867     fprintf_filtered (stream, "record (?) is null; end record");
 868   else
 869     {
 870       int i;
 871
 872       fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
 873
 874       for (i = 0; i < type->num_fields (); i += 1)
 875         {
 876           fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
 877                             level + 12, "");
 878           ada_print_type (type->field (i).type (),
 879                           TYPE_FIELD_NAME (type, i),
 880                           stream, show - 1, level + 12, flags);
 881           fprintf_filtered (stream, ";");
 882         }
 883
 884       fprintf_filtered (stream, "\n%*send case;\n%*send record",
 885                         level + 4, "", level, "");
 886     }
 887 }
 888
 889
 890
 891 /* Print function or procedure type TYPE on STREAM.  Make it a header
 892    for function or procedure NAME if NAME is not null.  */
 893
 894 static void
 895 print_func_type (struct type *type, struct ui_file *stream, const char *name,
 896                  const struct type_print_options *flags)
 897 {
 898   int i, len = type->num_fields ();
 899
 900   if (TYPE_TARGET_TYPE (type) != NULL
 901       && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID)
 902     fprintf_filtered (stream, "procedure");
 903   else
 904     fprintf_filtered (stream, "function");
 905
 906   if (name != NULL && name[0] != '\0')
 907     {
 908       fputs_filtered (" ", stream);
 909       fputs_styled (name, function_name_style.style (), stream);
 910     }
 911
 912   if (len > 0)
 913     {
 914       fprintf_filtered (stream, " (");
 915       for (i = 0; i < len; i += 1)
 916         {
 917           if (i > 0)
 918             {
 919               fputs_filtered ("; ", stream);
 920               wrap_here ("    ");
 921             }
 922           fprintf_filtered (stream, "a%d: ", i + 1);
 923           ada_print_type (type->field (i).type (), "", stream, -1, 0,
 924                           flags);
 925         }
 926       fprintf_filtered (stream, ")");
 927     }
 928
 929   if (TYPE_TARGET_TYPE (type) == NULL)
 930     fprintf_filtered (stream, " return <unknown return type>");
 931   else if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 932     {
 933       fprintf_filtered (stream, " return ");
 934       ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
 935     }
 936 }
 937
 938
 939 /* Print a description of a type TYPE0.
 940    Output goes to STREAM (via stdio).
 941    If VARSTRING is a non-empty string, print as an Ada variable/field
 942        declaration.
 943    SHOW+1 is the maximum number of levels of internal type structure
 944       to show (this applies to record types, enumerated types, and
 945       array types).
 946    SHOW is the number of levels of internal type structure to show
 947       when there is a type name for the SHOWth deepest level (0th is
 948       outer level).
 949    When SHOW<0, no inner structure is shown.
 950    LEVEL indicates level of recursion (for nested definitions).  */
 951
 952 void
 953 ada_print_type (struct type *type0, const char *varstring,
 954                 struct ui_file *stream, int show, int level,
 955                 const struct type_print_options *flags)
 956 {
 957   struct type *type = ada_check_typedef (ada_get_base_type (type0));
 958   char *type_name = decoded_type_name (type0);
 959   int is_var_decl = (varstring != NULL && varstring[0] != '\0');
 960
 961   if (type == NULL)
 962     {
 963       if (is_var_decl)
 964         fprintf_filtered (stream, "%.*s: ",
 965                           ada_name_prefix_len (varstring), varstring);
 966       fprintf_styled (stream, metadata_style.style (), "<null type?>");
 967       return;
 968     }
 969
 970   if (show > 0)
 971     type = ada_check_typedef (type);
 972
 973   if (is_var_decl && type->code () != TYPE_CODE_FUNC)
 974     fprintf_filtered (stream, "%.*s: ",
 975                       ada_name_prefix_len (varstring), varstring);
 976
 977   if (type_name != NULL && show <= 0 && !ada_is_aligner_type (type))
 978     {
 979       fprintf_filtered (stream, "%.*s",
 980                         ada_name_prefix_len (type_name), type_name);
 981       return;
 982     }
 983
 984   if (ada_is_aligner_type (type))
 985     ada_print_type (ada_aligned_type (type), "", stream, show, level, flags);
 986   else if (ada_is_constrained_packed_array_type (type)
 987            && type->code () != TYPE_CODE_PTR)
 988     print_array_type (type, stream, show, level, flags);
 989   else
 990     switch (type->code ())
 991       {
 992       default:
 993         fprintf_filtered (stream, "<");
 994         c_print_type (type, "", stream, show, level, flags);
 995         fprintf_filtered (stream, ">");
 996         break;
 997       case TYPE_CODE_PTR:
 998       case TYPE_CODE_TYPEDEF:
 999         fprintf_filtered (stream, "access ");
1000         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
1001                         flags);
1002         break;
1003       case TYPE_CODE_REF:
1004         fprintf_filtered (stream, "<ref> ");
1005         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
1006                         flags);
1007         break;
1008       case TYPE_CODE_ARRAY:
1009         print_array_type (type, stream, show, level, flags);
1010         break;
1011       case TYPE_CODE_BOOL:
1012         fprintf_filtered (stream, "(false, true)");
1013         break;
1014       case TYPE_CODE_INT:
1015         if (ada_is_gnat_encoded_fixed_point_type (type))
1016           print_gnat_encoded_fixed_point_type (type, stream);
1017         else
1018           {
1019             const char *name = ada_type_name (type);
1020
1021             if (!ada_is_range_type_name (name))
1022               fprintf_styled (stream, metadata_style.style (),
1023                               _("<%s-byte integer>"),
1024                               pulongest (TYPE_LENGTH (type)));
1025             else
1026               {
1027                 fprintf_filtered (stream, "range ");
1028                 print_range_type (type, stream, 1 /* bounds_prefered_p */);
1029               }
1030           }
1031         break;
1032       case TYPE_CODE_RANGE:
1033         if (ada_is_gnat_encoded_fixed_point_type (type))
1034           print_gnat_encoded_fixed_point_type (type, stream);
1035         else if (ada_is_modular_type (type))
1036           fprintf_filtered (stream, "mod %s",
1037                             int_string (ada_modulus (type), 10, 0, 0, 1));
1038         else
1039           {
1040             fprintf_filtered (stream, "range ");
1041             print_range (type, stream, 1 /* bounds_prefered_p */);
1042           }
1043         break;
1044       case TYPE_CODE_FLT:
1045         fprintf_styled (stream, metadata_style.style (),
1046                         _("<%s-byte float>"),
1047                         pulongest (TYPE_LENGTH (type)));
1048         break;
1049       case TYPE_CODE_ENUM:
1050         if (show < 0)
1051           fprintf_filtered (stream, "(...)");
1052         else
1053           print_enum_type (type, stream);
1054         break;
1055       case TYPE_CODE_STRUCT:
1056         if (ada_is_array_descriptor_type (type))
1057           print_array_type (type, stream, show, level, flags);
1058         else if (ada_is_bogus_array_descriptor (type))
1059           fprintf_filtered (stream,
1060                             _("array (?) of ? (<mal-formed descriptor>)"));
1061         else
1062           print_record_type (type, stream, show, level, flags);
1063         break;
1064       case TYPE_CODE_UNION:
1065         print_unchecked_union_type (type, stream, show, level, flags);
1066         break;
1067       case TYPE_CODE_FUNC:
1068         print_func_type (type, stream, varstring, flags);
1069         break;
1070       }
1071 }
1072
1073 /* Implement the la_print_typedef language method for Ada.  */
1074
1075 void
1076 ada_print_typedef (struct type *type, struct symbol *new_symbol,
1077                    struct ui_file *stream)
1078 {
1079   type = ada_check_typedef (type);
1080   ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
1081 }