gdb/ada-typeprint.c

   1 /* Support for printing Ada types for GDB, the GNU debugger.
   2    Copyright (C) 1986-2021 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 (i).name ()),
 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 simple (constrained) array type TYPE on STREAM.  LEVEL is the
 343    recursion (indentation) level, in case the element type itself has
 344    nested structure, and SHOW is the number of levels of internal
 345    structure to show (see ada_print_type).  */
 346
 347 static void
 348 print_array_type (struct type *type, struct ui_file *stream, int show,
 349                   int level, const struct type_print_options *flags)
 350 {
 351   int bitsize;
 352   int n_indices;
 353   struct type *elt_type = NULL;
 354
 355   if (ada_is_constrained_packed_array_type (type))
 356     type = ada_coerce_to_simple_array_type (type);
 357
 358   bitsize = 0;
 359   fprintf_filtered (stream, "array (");
 360
 361   if (type == NULL)
 362     {
 363       fprintf_styled (stream, metadata_style.style (),
 364                       _("<undecipherable array type>"));
 365       return;
 366     }
 367
 368   n_indices = -1;
 369   if (ada_is_simple_array_type (type))
 370     {
 371       struct type *range_desc_type;
 372       struct type *arr_type;
 373
 374       range_desc_type = ada_find_parallel_type (type, "___XA");
 375       ada_fixup_array_indexes_type (range_desc_type);
 376
 377       bitsize = 0;
 378       if (range_desc_type == NULL)
 379         {
 380           for (arr_type = type; arr_type->code () == TYPE_CODE_ARRAY;
 381                arr_type = TYPE_TARGET_TYPE (arr_type))
 382             {
 383               if (arr_type != type)
 384                 fprintf_filtered (stream, ", ");
 385               print_range (arr_type->index_type (), stream,
 386                            0 /* bounds_prefered_p */);
 387               if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 388                 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 389             }
 390         }
 391       else
 392         {
 393           int k;
 394
 395           n_indices = range_desc_type->num_fields ();
 396           for (k = 0, arr_type = type;
 397                k < n_indices;
 398                k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
 399             {
 400               if (k > 0)
 401                 fprintf_filtered (stream, ", ");
 402               print_range_type (range_desc_type->field (k).type (),
 403                                 stream, 0 /* bounds_prefered_p */);
 404               if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 405                 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 406             }
 407         }
 408     }
 409   else
 410     {
 411       int i, i0;
 412
 413       for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
 414         fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
 415     }
 416
 417   elt_type = ada_array_element_type (type, n_indices);
 418   fprintf_filtered (stream, ") of ");
 419   wrap_here ("");
 420   ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
 421                   flags);
 422   /* Arrays with variable-length elements are never bit-packed in practice but
 423      compilers have to describe their stride so that we can properly fetch
 424      individual elements.  Do not say the array is packed in this case.  */
 425   if (bitsize > 0 && !is_dynamic_type (elt_type))
 426     fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
 427 }
 428
 429 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
 430    STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
 431    values.  Return non-zero if the field is an encoding of
 432    discriminant values, as in a standard variant record, and 0 if the
 433    field is not so encoded (as happens with single-component variants
 434    in types annotated with pragma Unchecked_Union).  */
 435
 436 static int
 437 print_choices (struct type *type, int field_num, struct ui_file *stream,
 438                struct type *val_type)
 439 {
 440   int have_output;
 441   int p;
 442   const char *name = type->field (field_num).name ();
 443
 444   have_output = 0;
 445
 446   /* Skip over leading 'V': NOTE soon to be obsolete.  */
 447   if (name[0] == 'V')
 448     {
 449       if (!ada_scan_number (name, 1, NULL, &p))
 450         goto Huh;
 451     }
 452   else
 453     p = 0;
 454
 455   while (1)
 456     {
 457       switch (name[p])
 458         {
 459         default:
 460           goto Huh;
 461         case '_':
 462         case '\0':
 463           fprintf_filtered (stream, " =>");
 464           return 1;
 465         case 'S':
 466         case 'R':
 467         case 'O':
 468           if (have_output)
 469             fprintf_filtered (stream, " | ");
 470           have_output = 1;
 471           break;
 472         }
 473
 474       switch (name[p])
 475         {
 476         case 'S':
 477           {
 478             LONGEST W;
 479
 480             if (!ada_scan_number (name, p + 1, &W, &p))
 481               goto Huh;
 482             ada_print_scalar (val_type, W, stream);
 483             break;
 484           }
 485         case 'R':
 486           {
 487             LONGEST L, U;
 488
 489             if (!ada_scan_number (name, p + 1, &L, &p)
 490                 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
 491               goto Huh;
 492             ada_print_scalar (val_type, L, stream);
 493             fprintf_filtered (stream, " .. ");
 494             ada_print_scalar (val_type, U, stream);
 495             break;
 496           }
 497         case 'O':
 498           fprintf_filtered (stream, "others");
 499           p += 1;
 500           break;
 501         }
 502     }
 503
 504 Huh:
 505   fprintf_filtered (stream, "? =>");
 506   return 0;
 507 }
 508
 509 /* Assuming that field FIELD_NUM of TYPE represents variants whose
 510    discriminant is contained in OUTER_TYPE, print its components on STREAM.
 511    LEVEL is the recursion (indentation) level, in case any of the fields
 512    themselves have nested structure, and SHOW is the number of levels of
 513    internal structure to show (see ada_print_type).  For this purpose,
 514    fields nested in a variant part are taken to be at the same level as
 515    the fields immediately outside the variant part.  */
 516
 517 static void
 518 print_variant_clauses (struct type *type, int field_num,
 519                        struct type *outer_type, struct ui_file *stream,
 520                        int show, int level,
 521                        const struct type_print_options *flags)
 522 {
 523   int i;
 524   struct type *var_type, *par_type;
 525   struct type *discr_type;
 526
 527   var_type = type->field (field_num).type ();
 528   discr_type = ada_variant_discrim_type (var_type, outer_type);
 529
 530   if (var_type->code () == TYPE_CODE_PTR)
 531     {
 532       var_type = TYPE_TARGET_TYPE (var_type);
 533       if (var_type == NULL || var_type->code () != TYPE_CODE_UNION)
 534         return;
 535     }
 536
 537   par_type = ada_find_parallel_type (var_type, "___XVU");
 538   if (par_type != NULL)
 539     var_type = par_type;
 540
 541   for (i = 0; i < var_type->num_fields (); i += 1)
 542     {
 543       fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
 544       if (print_choices (var_type, i, stream, discr_type))
 545         {
 546           if (print_record_field_types (var_type->field (i).type (),
 547                                         outer_type, stream, show, level + 4,
 548                                         flags)
 549               <= 0)
 550             fprintf_filtered (stream, " null;");
 551         }
 552       else
 553         print_selected_record_field_types (var_type, outer_type, i, i,
 554                                            stream, show, level + 4, flags);
 555     }
 556 }
 557
 558 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
 559    discriminants are contained in OUTER_TYPE, print a description of it
 560    on STREAM.  LEVEL is the recursion (indentation) level, in case any of
 561    the fields themselves have nested structure, and SHOW is the number of
 562    levels of internal structure to show (see ada_print_type).  For this
 563    purpose, fields nested in a variant part are taken to be at the same
 564    level as the fields immediately outside the variant part.  */
 565
 566 static void
 567 print_variant_part (struct type *type, int field_num, struct type *outer_type,
 568                     struct ui_file *stream, int show, int level,
 569                     const struct type_print_options *flags)
 570 {
 571   const char *variant
 572     = ada_variant_discrim_name (type->field (field_num).type ());
 573   if (*variant == '\0')
 574     variant = "?";
 575
 576   fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", variant);
 577   print_variant_clauses (type, field_num, outer_type, stream, show,
 578                          level + 4, flags);
 579   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 580 }
 581
 582 /* Print a description on STREAM of the fields FLD0 through FLD1 in
 583    record or union type TYPE, whose discriminants are in OUTER_TYPE.
 584    LEVEL is the recursion (indentation) level, in case any of the
 585    fields themselves have nested structure, and SHOW is the number of
 586    levels of internal structure to show (see ada_print_type).  Does
 587    not print parent type information of TYPE.  Returns 0 if no fields
 588    printed, -1 for an incomplete type, else > 0.  Prints each field
 589    beginning on a new line, but does not put a new line at end.  */
 590
 591 static int
 592 print_selected_record_field_types (struct type *type, struct type *outer_type,
 593                                    int fld0, int fld1,
 594                                    struct ui_file *stream, int show, int level,
 595                                    const struct type_print_options *flags)
 596 {
 597   int i, flds;
 598
 599   flds = 0;
 600
 601   if (fld0 > fld1 && type->is_stub ())
 602     return -1;
 603
 604   for (i = fld0; i <= fld1; i += 1)
 605     {
 606       QUIT;
 607
 608       if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
 609         ;
 610       else if (ada_is_wrapper_field (type, i))
 611         flds += print_record_field_types (type->field (i).type (), type,
 612                                           stream, show, level, flags);
 613       else if (ada_is_variant_part (type, i))
 614         {
 615           print_variant_part (type, i, outer_type, stream, show, level, flags);
 616           flds = 1;
 617         }
 618       else
 619         {
 620           flds += 1;
 621           fprintf_filtered (stream, "\n%*s", level + 4, "");
 622           ada_print_type (type->field (i).type (),
 623                           type->field (i).name (),
 624                           stream, show - 1, level + 4, flags);
 625           fprintf_filtered (stream, ";");
 626         }
 627     }
 628
 629   return flds;
 630 }
 631
 632 static void print_record_field_types_dynamic
 633   (const gdb::array_view<variant_part> &parts,
 634    int from, int to, struct type *type, struct ui_file *stream,
 635    int show, int level, const struct type_print_options *flags);
 636
 637 /* Print the choices encoded by VARIANT on STREAM.  LEVEL is the
 638    indentation level.  The type of the discriminant for VARIANT is
 639    given by DISR_TYPE.  */
 640
 641 static void
 642 print_choices (struct type *discr_type, const variant &variant,
 643                struct ui_file *stream, int level)
 644 {
 645   fprintf_filtered (stream, "\n%*swhen ", level, "");
 646   if (variant.is_default ())
 647     fprintf_filtered (stream, "others");
 648   else
 649     {
 650       bool first = true;
 651       for (const discriminant_range &range : variant.discriminants)
 652         {
 653           if (!first)
 654             fprintf_filtered (stream, " | ");
 655           first = false;
 656
 657           ada_print_scalar (discr_type, range.low, stream);
 658           if (range.low != range.high)
 659             ada_print_scalar (discr_type, range.high, stream);
 660         }
 661     }
 662
 663   fprintf_filtered (stream, " =>");
 664 }
 665
 666 /* Print a single variant part, PART, on STREAM.  TYPE is the
 667    enclosing type.  SHOW, LEVEL, and FLAGS are the usual type-printing
 668    settings.  This prints information about PART and the fields it
 669    controls.  It returns the index of the next field that should be
 670    shown -- that is, one after the last field printed by this
 671    call.  */
 672
 673 static int
 674 print_variant_part (const variant_part &part,
 675                     struct type *type, struct ui_file *stream,
 676                     int show, int level,
 677                     const struct type_print_options *flags)
 678 {
 679   struct type *discr_type = nullptr;
 680   const char *name;
 681   if (part.discriminant_index == -1)
 682     name = "?";
 683   else
 684     {
 685       name = type->field (part.discriminant_index).name ();;
 686       discr_type = type->field (part.discriminant_index).type ();
 687     }
 688
 689   fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", name);
 690
 691   int last_field = -1;
 692   for (const variant &variant : part.variants)
 693     {
 694       print_choices (discr_type, variant, stream, level + 8);
 695
 696       if (variant.first_field == variant.last_field)
 697         fprintf_filtered (stream, " null;");
 698       else
 699         {
 700           print_record_field_types_dynamic (variant.parts,
 701                                             variant.first_field,
 702                                             variant.last_field, type, stream,
 703                                             show, level + 8, flags);
 704           last_field = variant.last_field;
 705         }
 706     }
 707
 708   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 709
 710   return last_field;
 711 }
 712
 713 /* Print some fields of TYPE to STREAM.  SHOW, LEVEL, and FLAGS are
 714    the usual type-printing settings.  PARTS is the array of variant
 715    parts that correspond to the range of fields to be printed.  FROM
 716    and TO are the range of fields to print.  */
 717
 718 static void
 719 print_record_field_types_dynamic (const gdb::array_view<variant_part> &parts,
 720                                   int from, int to,
 721                                   struct type *type, struct ui_file *stream,
 722                                   int show, int level,
 723                                   const struct type_print_options *flags)
 724 {
 725   int field = from;
 726
 727   for (const variant_part &part : parts)
 728     {
 729       if (part.variants.empty ())
 730         continue;
 731
 732       /* Print any non-varying fields.  */
 733       int first_varying = part.variants[0].first_field;
 734       print_selected_record_field_types (type, type, field,
 735                                          first_varying - 1, stream,
 736                                          show, level, flags);
 737
 738       field = print_variant_part (part, type, stream, show, level, flags);
 739     }
 740
 741   /* Print any trailing fields that we were asked to print.  */
 742   print_selected_record_field_types (type, type, field, to - 1, stream, show,
 743                                      level, flags);
 744 }
 745
 746 /* Print a description on STREAM of all fields of record or union type
 747    TYPE, as for print_selected_record_field_types, above.  */
 748
 749 static int
 750 print_record_field_types (struct type *type, struct type *outer_type,
 751                           struct ui_file *stream, int show, int level,
 752                           const struct type_print_options *flags)
 753 {
 754   struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
 755   if (prop != nullptr)
 756     {
 757       if (prop->kind () == PROP_TYPE)
 758         {
 759           type = prop->original_type ();
 760           prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
 761         }
 762       gdb_assert (prop->kind () == PROP_VARIANT_PARTS);
 763       print_record_field_types_dynamic (*prop->variant_parts (),
 764                                         0, type->num_fields (),
 765                                         type, stream, show, level, flags);
 766       return type->num_fields ();
 767     }
 768
 769   return print_selected_record_field_types (type, outer_type,
 770                                             0, type->num_fields () - 1,
 771                                             stream, show, level, flags);
 772 }
 773
 774
 775 /* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
 776    level, in case the element type itself has nested structure, and SHOW is
 777    the number of levels of internal structure to show (see ada_print_type).  */
 778
 779 static void
 780 print_record_type (struct type *type0, struct ui_file *stream, int show,
 781                    int level, const struct type_print_options *flags)
 782 {
 783   struct type *parent_type;
 784   struct type *type;
 785
 786   type = ada_find_parallel_type (type0, "___XVE");
 787   if (type == NULL)
 788     type = type0;
 789
 790   parent_type = ada_parent_type (type);
 791   if (ada_type_name (parent_type) != NULL)
 792     {
 793       const char *parent_name = decoded_type_name (parent_type);
 794
 795       /* If we fail to decode the parent type name, then use the parent
 796          type name as is.  Not pretty, but should never happen except
 797          when the debugging info is incomplete or incorrect.  This
 798          prevents a crash trying to print a NULL pointer.  */
 799       if (parent_name == NULL)
 800         parent_name = ada_type_name (parent_type);
 801       fprintf_filtered (stream, "new %s with record", parent_name);
 802     }
 803   else if (parent_type == NULL && ada_is_tagged_type (type, 0))
 804     fprintf_filtered (stream, "tagged record");
 805   else
 806     fprintf_filtered (stream, "record");
 807
 808   if (show < 0)
 809     fprintf_filtered (stream, " ... end record");
 810   else
 811     {
 812       int flds;
 813
 814       flds = 0;
 815       if (parent_type != NULL && ada_type_name (parent_type) == NULL)
 816         flds += print_record_field_types (parent_type, parent_type,
 817                                           stream, show, level, flags);
 818       flds += print_record_field_types (type, type, stream, show, level,
 819                                         flags);
 820
 821       if (flds > 0)
 822         fprintf_filtered (stream, "\n%*send record", level, "");
 823       else if (flds < 0)
 824         fprintf_filtered (stream, _(" <incomplete type> end record"));
 825       else
 826         fprintf_filtered (stream, " null; end record");
 827     }
 828 }
 829
 830 /* Print the unchecked union type TYPE in something resembling Ada
 831    format on STREAM.  LEVEL is the recursion (indentation) level
 832    in case the element type itself has nested structure, and SHOW is the
 833    number of levels of internal structure to show (see ada_print_type).  */
 834 static void
 835 print_unchecked_union_type (struct type *type, struct ui_file *stream,
 836                             int show, int level,
 837                             const struct type_print_options *flags)
 838 {
 839   if (show < 0)
 840     fprintf_filtered (stream, "record (?) is ... end record");
 841   else if (type->num_fields () == 0)
 842     fprintf_filtered (stream, "record (?) is null; end record");
 843   else
 844     {
 845       int i;
 846
 847       fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
 848
 849       for (i = 0; i < type->num_fields (); i += 1)
 850         {
 851           fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
 852                             level + 12, "");
 853           ada_print_type (type->field (i).type (),
 854                           type->field (i).name (),
 855                           stream, show - 1, level + 12, flags);
 856           fprintf_filtered (stream, ";");
 857         }
 858
 859       fprintf_filtered (stream, "\n%*send case;\n%*send record",
 860                         level + 4, "", level, "");
 861     }
 862 }
 863
 864
 865
 866 /* Print function or procedure type TYPE on STREAM.  Make it a header
 867    for function or procedure NAME if NAME is not null.  */
 868
 869 static void
 870 print_func_type (struct type *type, struct ui_file *stream, const char *name,
 871                  const struct type_print_options *flags)
 872 {
 873   int i, len = type->num_fields ();
 874
 875   if (TYPE_TARGET_TYPE (type) != NULL
 876       && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID)
 877     fprintf_filtered (stream, "procedure");
 878   else
 879     fprintf_filtered (stream, "function");
 880
 881   if (name != NULL && name[0] != '\0')
 882     {
 883       fputs_filtered (" ", stream);
 884       fputs_styled (name, function_name_style.style (), stream);
 885     }
 886
 887   if (len > 0)
 888     {
 889       fprintf_filtered (stream, " (");
 890       for (i = 0; i < len; i += 1)
 891         {
 892           if (i > 0)
 893             {
 894               fputs_filtered ("; ", stream);
 895               wrap_here ("    ");
 896             }
 897           fprintf_filtered (stream, "a%d: ", i + 1);
 898           ada_print_type (type->field (i).type (), "", stream, -1, 0,
 899                           flags);
 900         }
 901       fprintf_filtered (stream, ")");
 902     }
 903
 904   if (TYPE_TARGET_TYPE (type) == NULL)
 905     fprintf_filtered (stream, " return <unknown return type>");
 906   else if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
 907     {
 908       fprintf_filtered (stream, " return ");
 909       ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
 910     }
 911 }
 912
 913
 914 /* Print a description of a type TYPE0.
 915    Output goes to STREAM (via stdio).
 916    If VARSTRING is a non-empty string, print as an Ada variable/field
 917        declaration.
 918    SHOW+1 is the maximum number of levels of internal type structure
 919       to show (this applies to record types, enumerated types, and
 920       array types).
 921    SHOW is the number of levels of internal type structure to show
 922       when there is a type name for the SHOWth deepest level (0th is
 923       outer level).
 924    When SHOW<0, no inner structure is shown.
 925    LEVEL indicates level of recursion (for nested definitions).  */
 926
 927 void
 928 ada_print_type (struct type *type0, const char *varstring,
 929                 struct ui_file *stream, int show, int level,
 930                 const struct type_print_options *flags)
 931 {
 932   struct type *type = ada_check_typedef (ada_get_base_type (type0));
 933   /* If we can decode the original type name, use it.  However, there
 934      are cases where the original type is an internally-generated type
 935      with a name that can't be decoded (and whose encoded name might
 936      not actually bear any relation to the type actually declared in
 937      the sources). In that case, try using the name of the base type
 938      in its place.
 939
 940      Note that we looked at the possibility of always using the name
 941      of the base type. This does not always work, unfortunately, as
 942      there are situations where it's the base type which has an
 943      internally-generated name.  */
 944   const char *type_name = decoded_type_name (type0);
 945   if (type_name == nullptr)
 946     type_name = decoded_type_name (type);
 947   int is_var_decl = (varstring != NULL && varstring[0] != '\0');
 948
 949   if (type == NULL)
 950     {
 951       if (is_var_decl)
 952         fprintf_filtered (stream, "%.*s: ",
 953                           ada_name_prefix_len (varstring), varstring);
 954       fprintf_styled (stream, metadata_style.style (), "<null type?>");
 955       return;
 956     }
 957
 958   if (is_var_decl && type->code () != TYPE_CODE_FUNC)
 959     fprintf_filtered (stream, "%.*s: ",
 960                       ada_name_prefix_len (varstring), varstring);
 961
 962   if (type_name != NULL && show <= 0 && !ada_is_aligner_type (type))
 963     {
 964       fprintf_filtered (stream, "%.*s",
 965                         ada_name_prefix_len (type_name), type_name);
 966       return;
 967     }
 968
 969   if (ada_is_aligner_type (type))
 970     ada_print_type (ada_aligned_type (type), "", stream, show, level, flags);
 971   else if (ada_is_constrained_packed_array_type (type)
 972            && type->code () != TYPE_CODE_PTR)
 973     print_array_type (type, stream, show, level, flags);
 974   else
 975     switch (type->code ())
 976       {
 977       default:
 978         fprintf_filtered (stream, "<");
 979         c_print_type (type, "", stream, show, level, flags);
 980         fprintf_filtered (stream, ">");
 981         break;
 982       case TYPE_CODE_PTR:
 983       case TYPE_CODE_TYPEDEF:
 984         /* An __XVL field is not truly a pointer, so don't print
 985            "access" in this case.  */
 986         if (type->code () != TYPE_CODE_PTR
 987             || strstr (varstring, "___XVL") == nullptr)
 988           fprintf_filtered (stream, "access ");
 989         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
 990                         flags);
 991         break;
 992       case TYPE_CODE_REF:
 993         fprintf_filtered (stream, "<ref> ");
 994         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
 995                         flags);
 996         break;
 997       case TYPE_CODE_ARRAY:
 998         print_array_type (type, stream, show, level, flags);
 999         break;
1000       case TYPE_CODE_BOOL:
1001         fprintf_filtered (stream, "(false, true)");
1002         break;
1003       case TYPE_CODE_INT:
1004         {
1005           const char *name = ada_type_name (type);
1006
1007           if (!ada_is_range_type_name (name))
1008             fprintf_styled (stream, metadata_style.style (),
1009                             _("<%s-byte integer>"),
1010                             pulongest (TYPE_LENGTH (type)));
1011           else
1012             {
1013               fprintf_filtered (stream, "range ");
1014               print_range_type (type, stream, 1 /* bounds_prefered_p */);
1015             }
1016         }
1017         break;
1018       case TYPE_CODE_RANGE:
1019         if (is_fixed_point_type (type))
1020           {
1021             fprintf_filtered (stream, "<");
1022             print_type_fixed_point (type, stream);
1023             fprintf_filtered (stream, ">");
1024           }
1025         else if (ada_is_modular_type (type))
1026           fprintf_filtered (stream, "mod %s",
1027                             int_string (ada_modulus (type), 10, 0, 0, 1));
1028         else
1029           {
1030             fprintf_filtered (stream, "range ");
1031             print_range (type, stream, 1 /* bounds_prefered_p */);
1032           }
1033         break;
1034       case TYPE_CODE_FLT:
1035         fprintf_styled (stream, metadata_style.style (),
1036                         _("<%s-byte float>"),
1037                         pulongest (TYPE_LENGTH (type)));
1038         break;
1039       case TYPE_CODE_ENUM:
1040         if (show < 0)
1041           fprintf_filtered (stream, "(...)");
1042         else
1043           print_enum_type (type, stream);
1044         break;
1045       case TYPE_CODE_STRUCT:
1046         if (ada_is_array_descriptor_type (type))
1047           print_array_type (type, stream, show, level, flags);
1048         else if (ada_is_bogus_array_descriptor (type))
1049           fprintf_filtered (stream,
1050                             _("array (?) of ? (<mal-formed descriptor>)"));
1051         else
1052           print_record_type (type, stream, show, level, flags);
1053         break;
1054       case TYPE_CODE_UNION:
1055         print_unchecked_union_type (type, stream, show, level, flags);
1056         break;
1057       case TYPE_CODE_FUNC:
1058         print_func_type (type, stream, varstring, flags);
1059         break;
1060       }
1061 }
1062
1063 /* Implement the la_print_typedef language method for Ada.  */
1064
1065 void
1066 ada_print_typedef (struct type *type, struct symbol *new_symbol,
1067                    struct ui_file *stream)
1068 {
1069   type = ada_check_typedef (type);
1070   ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
1071 }