/* Support for printing Ada types for GDB, the GNU debugger.
- Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_obstack.h"
#include "bfd.h" /* Binary File Description */
-#include "symtab.h"
#include "gdbtypes.h"
-#include "expression.h"
#include "value.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "command.h"
-#include "gdbcmd.h"
-#include "language.h"
-#include "demangle.h"
#include "c-lang.h"
+#include "cli/cli-style.h"
#include "typeprint.h"
+#include "target-float.h"
#include "ada-lang.h"
-
#include <ctype.h>
-#include "gdb_string.h"
-#include <errno.h>
-
-static int print_record_field_types (struct type *, struct type *,
- struct ui_file *, int, int);
-
-static void print_array_type (struct type *, struct ui_file *, int, int);
-static void print_choices (struct type *, int, struct ui_file *,
- struct type *);
-
-static void print_range (struct type *, struct ui_file *);
-
-static void print_range_bound (struct type *, char *, int *,
- struct ui_file *);
-
-static void
-print_dynamic_range_bound (struct type *, const char *, int,
- const char *, struct ui_file *);
+static int print_selected_record_field_types (struct type *, struct type *,
+ int, int,
+ struct ui_file *, int, int,
+ const struct type_print_options *);
-static void print_range_type (struct type *, struct ui_file *);
+static int print_record_field_types (struct type *, struct type *,
+ struct ui_file *, int, int,
+ const struct type_print_options *);
\f
return NULL;
else
{
- char *raw_name = ada_type_name (type);
+ const char *raw_name = ada_type_name (type);
char *s, *q;
if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
{
name_buffer_len = 16 + 2 * strlen (raw_name);
- name_buffer = xrealloc (name_buffer, name_buffer_len);
+ name_buffer = (char *) xrealloc (name_buffer, name_buffer_len);
}
strcpy (name_buffer, raw_name);
}
}
-/* Print TYPE on STREAM, preferably as a range. */
+/* Return nonzero if TYPE is a subrange type, and its bounds
+ are identical to the bounds of its subtype. */
+
+static int
+type_is_full_subrange_of_target_type (struct type *type)
+{
+ struct type *subtype;
+
+ if (type->code () != TYPE_CODE_RANGE)
+ return 0;
+
+ subtype = TYPE_TARGET_TYPE (type);
+ if (subtype == NULL)
+ return 0;
+
+ if (is_dynamic_type (type))
+ return 0;
+
+ if (ada_discrete_type_low_bound (type)
+ != ada_discrete_type_low_bound (subtype))
+ return 0;
+
+ if (ada_discrete_type_high_bound (type)
+ != ada_discrete_type_high_bound (subtype))
+ return 0;
+
+ return 1;
+}
+
+/* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
+ is nonzero. */
static void
-print_range (struct type *type, struct ui_file *stream)
+print_range (struct type *type, struct ui_file *stream,
+ int bounds_prefered_p)
{
- switch (TYPE_CODE (type))
+ if (!bounds_prefered_p)
+ {
+ /* Try stripping all TYPE_CODE_RANGE layers whose bounds
+ are identical to the bounds of their subtype. When
+ the bounds of both types match, it can allow us to
+ print a range using the name of its base type, which
+ is easier to read. For instance, we would print...
+
+ array (character) of ...
+
+ ... instead of...
+
+ array ('["00"]' .. '["ff"]') of ... */
+ while (type_is_full_subrange_of_target_type (type))
+ type = TYPE_TARGET_TYPE (type);
+ }
+
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
{
- struct type *target_type;
- target_type = TYPE_TARGET_TYPE (type);
- if (target_type == NULL)
- target_type = type;
- ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
- stream);
- fprintf_filtered (stream, " .. ");
- ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
- stream);
+ LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
+ int got_error = 0;
+
+ try
+ {
+ lo = ada_discrete_type_low_bound (type);
+ hi = ada_discrete_type_high_bound (type);
+ }
+ catch (const gdb_exception_error &e)
+ {
+ /* This can happen when the range is dynamic. Sometimes,
+ resolving dynamic property values requires us to have
+ access to an actual object, which is not available
+ when the user is using the "ptype" command on a type.
+ Print the range as an unbounded range. */
+ fprintf_filtered (stream, "<>");
+ got_error = 1;
+ }
+
+ if (!got_error)
+ {
+ ada_print_scalar (type, lo, stream);
+ fprintf_filtered (stream, " .. ");
+ ada_print_scalar (type, hi, stream);
+ }
}
break;
default:
fprintf_filtered (stream, "%.*s",
- ada_name_prefix_len (TYPE_NAME (type)),
- TYPE_NAME (type));
+ ada_name_prefix_len (type->name ()),
+ type->name ());
break;
}
}
set *N past the bound and its delimiter, if any. */
static void
-print_range_bound (struct type *type, char *bounds, int *n,
+print_range_bound (struct type *type, const char *bounds, int *n,
struct ui_file *stream)
{
LONGEST B;
to indicate default output when we detect that the bound is negative,
and the type is a TYPE_CODE_INT. The bound is negative when
'm' is the last character of the number scanned in BOUNDS. */
- if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
+ if (bounds[*n - 1] == 'm' && type->code () == TYPE_CODE_INT)
type = NULL;
ada_print_scalar (type, B, stream);
if (bounds[*n] == '_')
else
{
int bound_len;
- char *bound = bounds + *n;
- char *pend;
+ const char *bound = bounds + *n;
+ const char *pend;
pend = strstr (bound, "__");
if (pend == NULL)
print_dynamic_range_bound (struct type *type, const char *name, int name_len,
const char *suffix, struct ui_file *stream)
{
- static char *name_buf = NULL;
- static size_t name_buf_len = 0;
LONGEST B;
- int OK;
-
- GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
- strncpy (name_buf, name, name_len);
- strcpy (name_buf + name_len, suffix);
+ std::string name_buf (name, name_len);
+ name_buf += suffix;
- B = get_int_var_value (name_buf, &OK);
- if (OK)
+ if (get_int_var_value (name_buf.c_str (), B))
ada_print_scalar (type, B, stream);
else
fprintf_filtered (stream, "?");
}
/* Print RAW_TYPE as a range type, using any bound information
- following the GNAT encoding (if available). */
+ following the GNAT encoding (if available).
+
+ If BOUNDS_PREFERED_P is nonzero, force the printing of the range
+ using its bounds. Otherwise, try printing the range without
+ printing the value of the bounds, if possible (this is only
+ considered a hint, not a guaranty). */
static void
-print_range_type (struct type *raw_type, struct ui_file *stream)
+print_range_type (struct type *raw_type, struct ui_file *stream,
+ int bounds_prefered_p)
{
- char *name;
+ const char *name;
struct type *base_type;
- char *subtype_info;
+ const char *subtype_info;
gdb_assert (raw_type != NULL);
- name = TYPE_NAME (raw_type);
+ name = raw_type->name ();
gdb_assert (name != NULL);
- if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
+ if (raw_type->code () == TYPE_CODE_RANGE)
base_type = TYPE_TARGET_TYPE (raw_type);
else
base_type = raw_type;
subtype_info = strstr (name, "___XD");
if (subtype_info == NULL)
- print_range (raw_type, stream);
+ print_range (raw_type, stream, bounds_prefered_p);
else
{
int prefix_len = subtype_info - name;
- char *bounds_str;
+ const char *bounds_str;
int n;
subtype_info += 5;
static void
print_enum_type (struct type *type, struct ui_file *stream)
{
- int len = TYPE_NFIELDS (type);
- int i, lastval;
+ int len = type->num_fields ();
+ int i;
+ LONGEST lastval;
fprintf_filtered (stream, "(");
wrap_here (" ");
if (i)
fprintf_filtered (stream, ", ");
wrap_here (" ");
- fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
- if (lastval != TYPE_FIELD_BITPOS (type, i))
+ fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type, i)),
+ variable_name_style.style (), stream);
+ if (lastval != TYPE_FIELD_ENUMVAL (type, i))
{
- fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
- lastval = TYPE_FIELD_BITPOS (type, i);
+ fprintf_filtered (stream, " => %s",
+ plongest (TYPE_FIELD_ENUMVAL (type, i)));
+ lastval = TYPE_FIELD_ENUMVAL (type, i);
}
lastval += 1;
}
/* Print representation of Ada fixed-point type TYPE on STREAM. */
static void
-print_fixed_point_type (struct type *type, struct ui_file *stream)
+print_gnat_encoded_fixed_point_type (struct type *type, struct ui_file *stream)
{
- DOUBLEST delta = ada_delta (type);
- DOUBLEST small = ada_fixed_to_float (type, 1.0);
+ struct value *delta = gnat_encoded_fixed_point_delta (type);
+ struct value *small = ada_scaling_factor (type);
- if (delta < 0.0)
+ if (delta == nullptr)
fprintf_filtered (stream, "delta ??");
else
{
- fprintf_filtered (stream, "delta %g", (double) delta);
- if (delta != small)
- fprintf_filtered (stream, " <'small = %g>", (double) small);
+ std::string str;
+ str = target_float_to_string (value_contents (delta),
+ value_type (delta), "%g");
+ fprintf_filtered (stream, "delta %s", str.c_str());
+ if (!value_equal (delta, small))
+ {
+ str = target_float_to_string (value_contents (small),
+ value_type (small), "%g");
+ fprintf_filtered (stream, " <'small = %s>", str.c_str());
+ }
}
}
static void
print_array_type (struct type *type, struct ui_file *stream, int show,
- int level)
+ int level, const struct type_print_options *flags)
{
int bitsize;
int n_indices;
+ struct type *elt_type = NULL;
if (ada_is_constrained_packed_array_type (type))
type = ada_coerce_to_simple_array_type (type);
if (type == NULL)
{
- fprintf_filtered (stream, _("<undecipherable array type>"));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<undecipherable array type>"));
return;
}
n_indices = -1;
- if (show < 0)
- fprintf_filtered (stream, "...");
- else
+ if (ada_is_simple_array_type (type))
{
- if (ada_is_simple_array_type (type))
- {
- struct type *range_desc_type;
- struct type *arr_type;
+ struct type *range_desc_type;
+ struct type *arr_type;
- range_desc_type = ada_find_parallel_type (type, "___XA");
- ada_fixup_array_indexes_type (range_desc_type);
+ range_desc_type = ada_find_parallel_type (type, "___XA");
+ ada_fixup_array_indexes_type (range_desc_type);
- bitsize = 0;
- if (range_desc_type == NULL)
- {
- for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
- arr_type = TYPE_TARGET_TYPE (arr_type))
- {
- if (arr_type != type)
- fprintf_filtered (stream, ", ");
- print_range (TYPE_INDEX_TYPE (arr_type), stream);
- if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
- bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
- }
- }
- else
+ bitsize = 0;
+ if (range_desc_type == NULL)
+ {
+ for (arr_type = type; arr_type->code () == TYPE_CODE_ARRAY;
+ arr_type = TYPE_TARGET_TYPE (arr_type))
{
- int k;
-
- n_indices = TYPE_NFIELDS (range_desc_type);
- for (k = 0, arr_type = type;
- k < n_indices;
- k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
- {
- if (k > 0)
- fprintf_filtered (stream, ", ");
- print_range_type (TYPE_FIELD_TYPE (range_desc_type, k),
- stream);
- if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
- bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
- }
+ if (arr_type != type)
+ fprintf_filtered (stream, ", ");
+ print_range (arr_type->index_type (), stream,
+ 0 /* bounds_prefered_p */);
+ if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
+ bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
}
}
else
{
- int i, i0;
+ int k;
- for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
- fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
+ n_indices = range_desc_type->num_fields ();
+ for (k = 0, arr_type = type;
+ k < n_indices;
+ k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
+ {
+ if (k > 0)
+ fprintf_filtered (stream, ", ");
+ print_range_type (range_desc_type->field (k).type (),
+ stream, 0 /* bounds_prefered_p */);
+ if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
+ bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
+ }
}
}
+ else
+ {
+ int i, i0;
+
+ for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
+ fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
+ }
+ elt_type = ada_array_element_type (type, n_indices);
fprintf_filtered (stream, ") of ");
wrap_here ("");
- ada_print_type (ada_array_element_type (type, n_indices), "", stream,
- show == 0 ? 0 : show - 1, level + 1);
- if (bitsize > 0)
+ ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
+ flags);
+ /* Arrays with variable-length elements are never bit-packed in practice but
+ compilers have to describe their stride so that we can properly fetch
+ individual elements. Do not say the array is packed in this case. */
+ if (bitsize > 0 && !is_dynamic_type (elt_type))
fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
}
/* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
- STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values. */
+ STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
+ values. Return non-zero if the field is an encoding of
+ discriminant values, as in a standard variant record, and 0 if the
+ field is not so encoded (as happens with single-component variants
+ in types annotated with pragma Unchecked_Union). */
-static void
+static int
print_choices (struct type *type, int field_num, struct ui_file *stream,
struct type *val_type)
{
switch (name[p])
{
default:
- return;
+ goto Huh;
+ case '_':
+ case '\0':
+ fprintf_filtered (stream, " =>");
+ return 1;
case 'S':
case 'R':
case 'O':
}
Huh:
- fprintf_filtered (stream, "??");
-
+ fprintf_filtered (stream, "? =>");
+ return 0;
}
-/* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
- discriminant is contained in OUTER_TYPE, print its variants on STREAM.
- LEVEL is the recursion
- (indentation) level, in case any of the fields themselves have
- nested structure, and SHOW is the number of levels of internal structure
- to show (see ada_print_type). For this purpose, fields nested in a
- variant part are taken to be at the same level as the fields
- immediately outside the variant part. */
+/* Assuming that field FIELD_NUM of TYPE represents variants whose
+ discriminant is contained in OUTER_TYPE, print its components on STREAM.
+ LEVEL is the recursion (indentation) level, in case any of the fields
+ themselves have nested structure, and SHOW is the number of levels of
+ internal structure to show (see ada_print_type). For this purpose,
+ fields nested in a variant part are taken to be at the same level as
+ the fields immediately outside the variant part. */
static void
print_variant_clauses (struct type *type, int field_num,
struct type *outer_type, struct ui_file *stream,
- int show, int level)
+ int show, int level,
+ const struct type_print_options *flags)
{
int i;
struct type *var_type, *par_type;
struct type *discr_type;
- var_type = TYPE_FIELD_TYPE (type, field_num);
+ var_type = type->field (field_num).type ();
discr_type = ada_variant_discrim_type (var_type, outer_type);
- if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
+ if (var_type->code () == TYPE_CODE_PTR)
{
var_type = TYPE_TARGET_TYPE (var_type);
- if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
+ if (var_type == NULL || var_type->code () != TYPE_CODE_UNION)
return;
}
if (par_type != NULL)
var_type = par_type;
- for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
+ for (i = 0; i < var_type->num_fields (); i += 1)
{
fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
- print_choices (var_type, i, stream, discr_type);
- fprintf_filtered (stream, " =>");
- if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
- outer_type, stream, show, level + 4) <= 0)
- fprintf_filtered (stream, " null;");
+ if (print_choices (var_type, i, stream, discr_type))
+ {
+ if (print_record_field_types (var_type->field (i).type (),
+ outer_type, stream, show, level + 4,
+ flags)
+ <= 0)
+ fprintf_filtered (stream, " null;");
+ }
+ else
+ print_selected_record_field_types (var_type, outer_type, i, i,
+ stream, show, level + 4, flags);
}
}
static void
print_variant_part (struct type *type, int field_num, struct type *outer_type,
- struct ui_file *stream, int show, int level)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
- fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
- ada_variant_discrim_name
- (TYPE_FIELD_TYPE (type, field_num)));
+ const char *variant
+ = ada_variant_discrim_name (type->field (field_num).type ());
+ if (*variant == '\0')
+ variant = "?";
+
+ fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", variant);
print_variant_clauses (type, field_num, outer_type, stream, show,
- level + 4);
+ level + 4, flags);
fprintf_filtered (stream, "\n%*send case;", level + 4, "");
}
-/* Print a description on STREAM of the fields in record type TYPE, whose
- discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
- level, in case any of the fields themselves have nested structure,
- and SHOW is the number of levels of internal structure to show
- (see ada_print_type). Does not print parent type information of TYPE.
- Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
- Prints each field beginning on a new line, but does not put a new line at
- end. */
+/* Print a description on STREAM of the fields FLD0 through FLD1 in
+ record or union type TYPE, whose discriminants are in OUTER_TYPE.
+ LEVEL is the recursion (indentation) level, in case any of the
+ fields themselves have nested structure, and SHOW is the number of
+ levels of internal structure to show (see ada_print_type). Does
+ not print parent type information of TYPE. Returns 0 if no fields
+ printed, -1 for an incomplete type, else > 0. Prints each field
+ beginning on a new line, but does not put a new line at end. */
static int
-print_record_field_types (struct type *type, struct type *outer_type,
- struct ui_file *stream, int show, int level)
+print_selected_record_field_types (struct type *type, struct type *outer_type,
+ int fld0, int fld1,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
- int len, i, flds;
+ int i, flds;
flds = 0;
- len = TYPE_NFIELDS (type);
- if (len == 0 && TYPE_STUB (type))
+ if (fld0 > fld1 && TYPE_STUB (type))
return -1;
- for (i = 0; i < len; i += 1)
+ for (i = fld0; i <= fld1; i += 1)
{
QUIT;
if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
;
else if (ada_is_wrapper_field (type, i))
- flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
- stream, show, level);
+ flds += print_record_field_types (type->field (i).type (), type,
+ stream, show, level, flags);
else if (ada_is_variant_part (type, i))
{
- print_variant_part (type, i, outer_type, stream, show, level);
+ print_variant_part (type, i, outer_type, stream, show, level, flags);
flds = 1;
}
else
{
flds += 1;
fprintf_filtered (stream, "\n%*s", level + 4, "");
- ada_print_type (TYPE_FIELD_TYPE (type, i),
+ ada_print_type (type->field (i).type (),
TYPE_FIELD_NAME (type, i),
- stream, show - 1, level + 4);
+ stream, show - 1, level + 4, flags);
fprintf_filtered (stream, ";");
}
}
return flds;
}
+static void print_record_field_types_dynamic
+ (const gdb::array_view<variant_part> &parts,
+ int from, int to, struct type *type, struct ui_file *stream,
+ int show, int level, const struct type_print_options *flags);
+
+/* Print the choices encoded by VARIANT on STREAM. LEVEL is the
+ indentation level. The type of the discriminant for VARIANT is
+ given by DISR_TYPE. */
+
+static void
+print_choices (struct type *discr_type, const variant &variant,
+ struct ui_file *stream, int level)
+{
+ fprintf_filtered (stream, "\n%*swhen ", level, "");
+ if (variant.is_default ())
+ fprintf_filtered (stream, "others");
+ else
+ {
+ bool first = true;
+ for (const discriminant_range &range : variant.discriminants)
+ {
+ if (!first)
+ fprintf_filtered (stream, " | ");
+ first = false;
+
+ ada_print_scalar (discr_type, range.low, stream);
+ if (range.low != range.high)
+ ada_print_scalar (discr_type, range.high, stream);
+ }
+ }
+
+ fprintf_filtered (stream, " =>");
+}
+
+/* Print a single variant part, PART, on STREAM. TYPE is the
+ enclosing type. SHOW, LEVEL, and FLAGS are the usual type-printing
+ settings. This prints information about PART and the fields it
+ controls. It returns the index of the next field that should be
+ shown -- that is, one after the last field printed by this
+ call. */
+
+static int
+print_variant_part (const variant_part &part,
+ struct type *type, struct ui_file *stream,
+ int show, int level,
+ const struct type_print_options *flags)
+{
+ struct type *discr_type = nullptr;
+ const char *name;
+ if (part.discriminant_index == -1)
+ name = "?";
+ else
+ {
+ name = TYPE_FIELD_NAME (type, part.discriminant_index);
+ discr_type = type->field (part.discriminant_index).type ();
+ }
+
+ fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", name);
+
+ int last_field = -1;
+ for (const variant &variant : part.variants)
+ {
+ print_choices (discr_type, variant, stream, level + 8);
+
+ if (variant.first_field == variant.last_field)
+ fprintf_filtered (stream, " null;");
+ else
+ {
+ print_record_field_types_dynamic (variant.parts,
+ variant.first_field,
+ variant.last_field, type, stream,
+ show, level + 8, flags);
+ last_field = variant.last_field;
+ }
+ }
+
+ fprintf_filtered (stream, "\n%*send case;", level + 4, "");
+
+ return last_field;
+}
+
+/* Print some fields of TYPE to STREAM. SHOW, LEVEL, and FLAGS are
+ the usual type-printing settings. PARTS is the array of variant
+ parts that correspond to the range of fields to be printed. FROM
+ and TO are the range of fields to print. */
+
+static void
+print_record_field_types_dynamic (const gdb::array_view<variant_part> &parts,
+ int from, int to,
+ struct type *type, struct ui_file *stream,
+ int show, int level,
+ const struct type_print_options *flags)
+{
+ int field = from;
+
+ for (const variant_part &part : parts)
+ {
+ if (part.variants.empty ())
+ continue;
+
+ /* Print any non-varying fields. */
+ int first_varying = part.variants[0].first_field;
+ print_selected_record_field_types (type, type, field,
+ first_varying - 1, stream,
+ show, level, flags);
+
+ field = print_variant_part (part, type, stream, show, level, flags);
+ }
+
+ /* Print any trailing fields that we were asked to print. */
+ print_selected_record_field_types (type, type, field, to - 1, stream, show,
+ level, flags);
+}
+
+/* Print a description on STREAM of all fields of record or union type
+ TYPE, as for print_selected_record_field_types, above. */
+
+static int
+print_record_field_types (struct type *type, struct type *outer_type,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
+{
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ if (prop != nullptr)
+ {
+ if (prop->kind == PROP_TYPE)
+ {
+ type = prop->data.original_type;
+ prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ }
+ gdb_assert (prop->kind == PROP_VARIANT_PARTS);
+ print_record_field_types_dynamic (*prop->data.variant_parts,
+ 0, type->num_fields (),
+ type, stream, show, level, flags);
+ return type->num_fields ();
+ }
+
+ return print_selected_record_field_types (type, outer_type,
+ 0, type->num_fields () - 1,
+ stream, show, level, flags);
+}
+
+
/* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
level, in case the element type itself has nested structure, and SHOW is
the number of levels of internal structure to show (see ada_print_type). */
static void
print_record_type (struct type *type0, struct ui_file *stream, int show,
- int level)
+ int level, const struct type_print_options *flags)
{
struct type *parent_type;
struct type *type;
parent_type = ada_parent_type (type);
if (ada_type_name (parent_type) != NULL)
- fprintf_filtered (stream, "new %s with record",
- decoded_type_name (parent_type));
+ {
+ const char *parent_name = decoded_type_name (parent_type);
+
+ /* If we fail to decode the parent type name, then use the parent
+ type name as is. Not pretty, but should never happen except
+ when the debugging info is incomplete or incorrect. This
+ prevents a crash trying to print a NULL pointer. */
+ if (parent_name == NULL)
+ parent_name = ada_type_name (parent_type);
+ fprintf_filtered (stream, "new %s with record", parent_name);
+ }
else if (parent_type == NULL && ada_is_tagged_type (type, 0))
fprintf_filtered (stream, "tagged record");
else
flds = 0;
if (parent_type != NULL && ada_type_name (parent_type) == NULL)
flds += print_record_field_types (parent_type, parent_type,
- stream, show, level);
- flds += print_record_field_types (type, type, stream, show, level);
+ stream, show, level, flags);
+ flds += print_record_field_types (type, type, stream, show, level,
+ flags);
if (flds > 0)
fprintf_filtered (stream, "\n%*send record", level, "");
number of levels of internal structure to show (see ada_print_type). */
static void
print_unchecked_union_type (struct type *type, struct ui_file *stream,
- int show, int level)
+ int show, int level,
+ const struct type_print_options *flags)
{
if (show < 0)
fprintf_filtered (stream, "record (?) is ... end record");
- else if (TYPE_NFIELDS (type) == 0)
+ else if (type->num_fields () == 0)
fprintf_filtered (stream, "record (?) is null; end record");
else
{
fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
level + 12, "");
- ada_print_type (TYPE_FIELD_TYPE (type, i),
+ ada_print_type (type->field (i).type (),
TYPE_FIELD_NAME (type, i),
- stream, show - 1, level + 12);
+ stream, show - 1, level + 12, flags);
fprintf_filtered (stream, ";");
}
for function or procedure NAME if NAME is not null. */
static void
-print_func_type (struct type *type, struct ui_file *stream, char *name)
+print_func_type (struct type *type, struct ui_file *stream, const char *name,
+ const struct type_print_options *flags)
{
- int i, len = TYPE_NFIELDS (type);
+ int i, len = type->num_fields ();
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (type) != NULL
+ && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID)
fprintf_filtered (stream, "procedure");
else
fprintf_filtered (stream, "function");
if (name != NULL && name[0] != '\0')
- fprintf_filtered (stream, " %s", name);
+ {
+ fputs_filtered (" ", stream);
+ fputs_styled (name, function_name_style.style (), stream);
+ }
if (len > 0)
{
wrap_here (" ");
}
fprintf_filtered (stream, "a%d: ", i + 1);
- ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
+ ada_print_type (type->field (i).type (), "", stream, -1, 0,
+ flags);
}
fprintf_filtered (stream, ")");
}
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (type) == NULL)
+ fprintf_filtered (stream, " return <unknown return type>");
+ else if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
{
fprintf_filtered (stream, " return ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
}
}
LEVEL indicates level of recursion (for nested definitions). */
void
-ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
- int show, int level)
+ada_print_type (struct type *type0, const char *varstring,
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
struct type *type = ada_check_typedef (ada_get_base_type (type0));
char *type_name = decoded_type_name (type0);
if (is_var_decl)
fprintf_filtered (stream, "%.*s: ",
ada_name_prefix_len (varstring), varstring);
- fprintf_filtered (stream, "<null type?>");
+ fprintf_styled (stream, metadata_style.style (), "<null type?>");
return;
}
if (show > 0)
type = ada_check_typedef (type);
- if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
+ if (is_var_decl && type->code () != TYPE_CODE_FUNC)
fprintf_filtered (stream, "%.*s: ",
ada_name_prefix_len (varstring), varstring);
- if (type_name != NULL && show <= 0)
+ if (type_name != NULL && show <= 0 && !ada_is_aligner_type (type))
{
fprintf_filtered (stream, "%.*s",
ada_name_prefix_len (type_name), type_name);
}
if (ada_is_aligner_type (type))
- ada_print_type (ada_aligned_type (type), "", stream, show, level);
- else if (ada_is_constrained_packed_array_type (type))
- {
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- {
- fprintf_filtered (stream, "access ");
- print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
- }
- else
- {
- print_array_type (type, stream, show, level);
- }
- }
+ ada_print_type (ada_aligned_type (type), "", stream, show, level, flags);
+ else if (ada_is_constrained_packed_array_type (type)
+ && type->code () != TYPE_CODE_PTR)
+ print_array_type (type, stream, show, level, flags);
else
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
default:
fprintf_filtered (stream, "<");
- c_print_type (type, "", stream, show, level);
+ c_print_type (type, "", stream, show, level, flags);
fprintf_filtered (stream, ">");
break;
case TYPE_CODE_PTR:
+ case TYPE_CODE_TYPEDEF:
fprintf_filtered (stream, "access ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+ flags);
break;
case TYPE_CODE_REF:
fprintf_filtered (stream, "<ref> ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+ flags);
break;
case TYPE_CODE_ARRAY:
- print_array_type (type, stream, show, level);
+ print_array_type (type, stream, show, level, flags);
break;
case TYPE_CODE_BOOL:
fprintf_filtered (stream, "(false, true)");
break;
case TYPE_CODE_INT:
- if (ada_is_fixed_point_type (type))
- print_fixed_point_type (type, stream);
+ if (ada_is_gnat_encoded_fixed_point_type (type))
+ print_gnat_encoded_fixed_point_type (type, stream);
else
{
- char *name = ada_type_name (type);
+ const char *name = ada_type_name (type);
if (!ada_is_range_type_name (name))
- fprintf_filtered (stream, _("<%d-byte integer>"),
- TYPE_LENGTH (type));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<%s-byte integer>"),
+ pulongest (TYPE_LENGTH (type)));
else
{
fprintf_filtered (stream, "range ");
- print_range_type (type, stream);
+ print_range_type (type, stream, 1 /* bounds_prefered_p */);
}
}
break;
case TYPE_CODE_RANGE:
- if (ada_is_fixed_point_type (type))
- print_fixed_point_type (type, stream);
+ if (ada_is_gnat_encoded_fixed_point_type (type))
+ print_gnat_encoded_fixed_point_type (type, stream);
else if (ada_is_modular_type (type))
fprintf_filtered (stream, "mod %s",
int_string (ada_modulus (type), 10, 0, 0, 1));
else
{
fprintf_filtered (stream, "range ");
- print_range (type, stream);
+ print_range (type, stream, 1 /* bounds_prefered_p */);
}
break;
case TYPE_CODE_FLT:
- fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<%s-byte float>"),
+ pulongest (TYPE_LENGTH (type)));
break;
case TYPE_CODE_ENUM:
if (show < 0)
break;
case TYPE_CODE_STRUCT:
if (ada_is_array_descriptor_type (type))
- print_array_type (type, stream, show, level);
+ print_array_type (type, stream, show, level, flags);
else if (ada_is_bogus_array_descriptor (type))
fprintf_filtered (stream,
_("array (?) of ? (<mal-formed descriptor>)"));
else
- print_record_type (type, stream, show, level);
+ print_record_type (type, stream, show, level, flags);
break;
case TYPE_CODE_UNION:
- print_unchecked_union_type (type, stream, show, level);
+ print_unchecked_union_type (type, stream, show, level, flags);
break;
case TYPE_CODE_FUNC:
- print_func_type (type, stream, varstring);
+ print_func_type (type, stream, varstring, flags);
break;
}
}
struct ui_file *stream)
{
type = ada_check_typedef (type);
- ada_print_type (type, "", stream, 0, 0);
- fprintf_filtered (stream, "\n");
+ ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
}
projects / deliverable / binutils-gdb.git / blobdiff