X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fada-typeprint.c;h=d7a8360312bc0434ace970658da877cda0292e50;hb=484b3c325d8182cd7b7da4ceeaedc238c7f80b5c;hp=6bae634e98724e3e51dd113277bf0c3b41cd961a;hpb=d2d43431e83ac661e10934eb1c3fb7542c087527;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ada-typeprint.c b/gdb/ada-typeprint.c index 6bae634e98..d7a8360312 100644 --- a/gdb/ada-typeprint.c +++ b/gdb/ada-typeprint.c @@ -1,6 +1,5 @@ /* 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, 2011 Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -33,33 +32,16 @@ #include "c-lang.h" #include "typeprint.h" #include "ada-lang.h" - #include -#include "gdb_string.h" -#include static int print_selected_record_field_types (struct type *, struct type *, int, int, - struct ui_file *, int, int); - -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 int print_choices (struct type *, int, struct ui_file *, - struct type *); - -static void print_range (struct type *, struct ui_file *); + struct ui_file *, int, int, + const struct type_print_options *); -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 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 *); @@ -76,13 +58,13 @@ decoded_type_name (struct type *type) 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); @@ -118,25 +100,95 @@ decoded_type_name (struct type *type) } } -/* 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) != 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) { + 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 (type)) { case TYPE_CODE_RANGE: case TYPE_CODE_ENUM: { struct type *target_type; + LONGEST lo = 0, hi = 0; /* init for gcc -Wall */ + int got_error = 0; + 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); + + TRY + { + lo = ada_discrete_type_low_bound (type); + hi = ada_discrete_type_high_bound (type); + } + CATCH (e, RETURN_MASK_ERROR) + { + /* 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; + } + END_CATCH + + if (!got_error) + { + ada_print_scalar (target_type, lo, stream); + fprintf_filtered (stream, " .. "); + ada_print_scalar (target_type, hi, stream); + } } break; default: @@ -151,7 +203,7 @@ print_range (struct type *type, struct ui_file *stream) 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; @@ -178,8 +230,8 @@ print_range_bound (struct type *type, char *bounds, int *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) @@ -218,14 +270,20 @@ print_dynamic_range_bound (struct type *type, const char *name, int name_len, } /* 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); @@ -238,11 +296,11 @@ print_range_type (struct type *raw_type, struct ui_file *stream) 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; @@ -274,7 +332,8 @@ static void print_enum_type (struct type *type, struct ui_file *stream) { int len = TYPE_NFIELDS (type); - int i, lastval; + int i; + LONGEST lastval; fprintf_filtered (stream, "("); wrap_here (" "); @@ -287,10 +346,11 @@ print_enum_type (struct type *type, struct ui_file *stream) fprintf_filtered (stream, ", "); wrap_here (" "); fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream); - if (lastval != TYPE_FIELD_BITPOS (type, i)) + 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; } @@ -303,7 +363,7 @@ static void print_fixed_point_type (struct type *type, struct ui_file *stream) { DOUBLEST delta = ada_delta (type); - DOUBLEST small = ada_fixed_to_float (type, 1.0); + DOUBLEST small = ada_fixed_to_float (type, 1); if (delta < 0.0) fprintf_filtered (stream, "delta ??"); @@ -322,10 +382,11 @@ print_fixed_point_type (struct type *type, struct ui_file *stream) 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); @@ -356,7 +417,8 @@ print_array_type (struct type *type, struct ui_file *stream, int show, { if (arr_type != type) fprintf_filtered (stream, ", "); - print_range (TYPE_INDEX_TYPE (arr_type), stream); + print_range (TYPE_INDEX_TYPE (arr_type), stream, + 0 /* bounds_prefered_p */); if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0) bitsize = TYPE_FIELD_BITSIZE (arr_type, 0); } @@ -373,7 +435,7 @@ print_array_type (struct type *type, struct ui_file *stream, int show, if (k > 0) fprintf_filtered (stream, ", "); print_range_type (TYPE_FIELD_TYPE (range_desc_type, k), - stream); + stream, 0 /* bounds_prefered_p */); if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0) bitsize = TYPE_FIELD_BITSIZE (arr_type, 0); } @@ -387,11 +449,15 @@ print_array_type (struct type *type, struct ui_file *stream, int show, 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, " ", bitsize); } @@ -486,7 +552,8 @@ Huh: 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; @@ -512,13 +579,14 @@ print_variant_clauses (struct type *type, int field_num, if (print_choices (var_type, i, stream, discr_type)) { if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i), - outer_type, stream, show, level + 4) + 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); + stream, show, level + 4, flags); } } @@ -532,13 +600,14 @@ print_variant_clauses (struct type *type, int field_num, 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))); print_variant_clauses (type, field_num, outer_type, stream, show, - level + 4); + level + 4, flags); fprintf_filtered (stream, "\n%*send case;", level + 4, ""); } @@ -554,7 +623,8 @@ print_variant_part (struct type *type, int field_num, struct type *outer_type, static int print_selected_record_field_types (struct type *type, struct type *outer_type, int fld0, int fld1, - struct ui_file *stream, int show, int level) + struct ui_file *stream, int show, int level, + const struct type_print_options *flags) { int i, flds; @@ -571,10 +641,10 @@ print_selected_record_field_types (struct type *type, struct type *outer_type, ; else if (ada_is_wrapper_field (type, i)) flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type, - stream, show, level); + 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 @@ -583,7 +653,7 @@ print_selected_record_field_types (struct type *type, struct type *outer_type, fprintf_filtered (stream, "\n%*s", level + 4, ""); ada_print_type (TYPE_FIELD_TYPE (type, i), TYPE_FIELD_NAME (type, i), - stream, show - 1, level + 4); + stream, show - 1, level + 4, flags); fprintf_filtered (stream, ";"); } } @@ -596,11 +666,12 @@ print_selected_record_field_types (struct type *type, struct type *outer_type, static int print_record_field_types (struct type *type, 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) { return print_selected_record_field_types (type, outer_type, 0, TYPE_NFIELDS (type) - 1, - stream, show, level); + stream, show, level, flags); } @@ -610,7 +681,7 @@ print_record_field_types (struct type *type, struct type *outer_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; @@ -621,8 +692,17 @@ print_record_type (struct type *type0, struct ui_file *stream, int show, 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 @@ -637,8 +717,9 @@ print_record_type (struct type *type0, struct ui_file *stream, int show, 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, ""); @@ -655,7 +736,8 @@ print_record_type (struct type *type0, struct ui_file *stream, int show, 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"); @@ -673,7 +755,7 @@ print_unchecked_union_type (struct type *type, struct ui_file *stream, level + 12, ""); ada_print_type (TYPE_FIELD_TYPE (type, i), TYPE_FIELD_NAME (type, i), - stream, show - 1, level + 12); + stream, show - 1, level + 12, flags); fprintf_filtered (stream, ";"); } @@ -688,7 +770,8 @@ print_unchecked_union_type (struct type *type, struct ui_file *stream, for function or procedure NAME if NAME is not null. */ static void -print_func_type (struct type *type, struct ui_file *stream, const 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); @@ -711,7 +794,8 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name) 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_TYPE (type, i), "", stream, -1, 0, + flags); } fprintf_filtered (stream, ")"); } @@ -719,7 +803,7 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name) if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != 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); } } @@ -739,7 +823,8 @@ print_func_type (struct type *type, struct ui_file *stream, const char *name) void ada_print_type (struct type *type0, const char *varstring, - struct ui_file *stream, int show, int level) + 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); @@ -769,29 +854,31 @@ ada_print_type (struct type *type0, const char *varstring, } if (ada_is_aligner_type (type)) - ada_print_type (ada_aligned_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) != TYPE_CODE_PTR) - print_array_type (type, stream, show, level); + print_array_type (type, stream, show, level, flags); else switch (TYPE_CODE (type)) { 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, " "); - 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)"); @@ -801,7 +888,7 @@ ada_print_type (struct type *type0, const char *varstring, print_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>"), @@ -809,7 +896,7 @@ ada_print_type (struct type *type0, const char *varstring, else { fprintf_filtered (stream, "range "); - print_range_type (type, stream); + print_range_type (type, stream, 1 /* bounds_prefered_p */); } } break; @@ -822,7 +909,7 @@ ada_print_type (struct type *type0, const char *varstring, else { fprintf_filtered (stream, "range "); - print_range (type, stream); + print_range (type, stream, 1 /* bounds_prefered_p */); } break; case TYPE_CODE_FLT: @@ -836,18 +923,18 @@ ada_print_type (struct type *type0, const char *varstring, 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 ? ()")); 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; } } @@ -859,6 +946,6 @@ ada_print_typedef (struct type *type, struct symbol *new_symbol, struct ui_file *stream) { type = ada_check_typedef (type); - ada_print_type (type, "", stream, 0, 0); + ada_print_type (type, "", stream, 0, 0, &type_print_raw_options); fprintf_filtered (stream, "\n"); }