X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fada-valprint.c;h=61893d5cad3fe2dbfcef0582101e51a03de8b911;hb=348fe36b1d64f12c60e08f6313520b3191663063;hp=010446d70f818a7d83511591e2468029d0ed8a82;hpb=5eb68a39a2c2908fc01f03e79daed72ba85dc14c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c index 010446d70f..61893d5cad 100644 --- a/gdb/ada-valprint.c +++ b/gdb/ada-valprint.c @@ -41,7 +41,7 @@ static int print_field_values (struct value *, struct value *, static void adjust_type_signedness (struct type *type) { - if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE + if (type != NULL && type->code () == TYPE_CODE_RANGE && TYPE_LOW_BOUND (type) >= 0) TYPE_UNSIGNED (type) = 1; } @@ -71,9 +71,9 @@ print_optional_low_bound (struct ui_file *stream, struct type *type, if (low_bound > high_bound) return 0; - index_type = TYPE_INDEX_TYPE (type); + index_type = type->index_type (); - while (TYPE_CODE (index_type) == TYPE_CODE_RANGE) + while (index_type->code () == TYPE_CODE_RANGE) { /* We need to know what the base type is, in order to do the appropriate check below. Otherwise, if this is a subrange @@ -84,7 +84,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type, } /* Don't print the lower bound if it's the default one. */ - switch (TYPE_CODE (index_type)) + switch (index_type->code ()) { case TYPE_CODE_BOOL: case TYPE_CODE_CHAR: @@ -92,8 +92,9 @@ print_optional_low_bound (struct ui_file *stream, struct type *type, return 0; break; case TYPE_CODE_ENUM: - if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0)) + if (low_bound == 0) return 0; + low_bound = TYPE_FIELD_ENUMVAL (index_type, low_bound); break; case TYPE_CODE_UNDEF: index_type = NULL; @@ -130,51 +131,28 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr, LONGEST low = 0; elttype = TYPE_TARGET_TYPE (type); - index_type = TYPE_INDEX_TYPE (type); + index_type = type->index_type (); { LONGEST high; - struct type *base_index_type; if (get_discrete_bounds (index_type, &low, &high) < 0) len = 1; - else - len = high - low + 1; - - if (TYPE_CODE (index_type) == TYPE_CODE_RANGE) - base_index_type = TYPE_TARGET_TYPE (index_type); - else - base_index_type = index_type; - - if (TYPE_CODE (base_index_type) == TYPE_CODE_ENUM) + else if (low > high) { - LONGEST low_pos, high_pos; - - /* Non-contiguous enumerations types can by used as index types - so the array length is computed from the positions of the - first and last literal in the enumeration type, and not from - the values of these literals. */ - - if (!discrete_position (base_index_type, low, &low_pos) - || !discrete_position (base_index_type, high, &high_pos)) - { - warning (_("unable to get positions in array, use bounds instead")); - low_pos = low; - high_pos = high; - } - /* The array length should normally be HIGH_POS - LOW_POS + 1. But in Ada we allow LOW_POS to be greater than HIGH_POS for empty arrays. In that situation, the array length is just zero, not negative! */ - - if (low_pos > high_pos) - len = 0; - else - len = high_pos - low_pos + 1; + len = 0; } + else + len = high - low + 1; } + if (index_type->code () == TYPE_CODE_RANGE) + index_type = TYPE_TARGET_TYPE (index_type); + i = 0; annotate_array_section_begin (i, elttype); @@ -396,11 +374,11 @@ ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream) type = ada_check_typedef (type); - switch (TYPE_CODE (type)) + switch (type->code ()) { case TYPE_CODE_ENUM: - len = TYPE_NFIELDS (type); + len = type->num_fields (); for (i = 0; i < len; i++) { if (TYPE_FIELD_ENUMVAL (type, i) == val) @@ -564,7 +542,7 @@ print_variant_part (struct value *value, int field_num, const struct language_defn *language) { struct type *type = value_type (value); - struct type *var_type = TYPE_FIELD_TYPE (type, field_num); + struct type *var_type = type->field (field_num).type (); int which = ada_which_variant_applies (var_type, outer_value); if (which < 0) @@ -600,7 +578,7 @@ print_field_values (struct value *value, struct value *outer_value, int i, len; struct type *type = value_type (value); - len = TYPE_NFIELDS (type); + len = type->num_fields (); for (i = 0; i < len; i += 1) { @@ -639,7 +617,7 @@ print_field_values (struct value *value, struct value *outer_value, wrap_here (n_spaces (2 + 2 * recurse)); } - annotate_field_begin (TYPE_FIELD_TYPE (type, i)); + annotate_field_begin (type->field (i).type ()); fprintf_filtered (stream, "%.*s", ada_name_prefix_len (TYPE_FIELD_NAME (type, i)), TYPE_FIELD_NAME (type, i)); @@ -663,12 +641,12 @@ print_field_values (struct value *value, struct value *outer_value, int bit_size = TYPE_FIELD_BITSIZE (type, i); struct value_print_options opts; - adjust_type_signedness (TYPE_FIELD_TYPE (type, i)); + adjust_type_signedness (type->field (i).type ()); v = ada_value_primitive_packed_val (value, nullptr, bit_pos / HOST_CHAR_BIT, bit_pos % HOST_CHAR_BIT, - bit_size, TYPE_FIELD_TYPE (type, i)); + bit_size, type->field (i).type ()); opts = *options; opts.deref_ref = 0; common_val_print (v, stream, recurse + 1, &opts, language); @@ -749,13 +727,13 @@ ada_val_print_gnat_array (struct value *val, of the case where ADDRESS is meaningless because original_value was not an lval. */ val = coerce_ref (val); - if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */ + if (type->code () == TYPE_CODE_TYPEDEF) /* array access type. */ val = ada_coerce_to_simple_array_ptr (val); else val = ada_coerce_to_simple_array (val); if (val == NULL) { - gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF); + gdb_assert (type->code () == TYPE_CODE_TYPEDEF); fprintf_filtered (stream, "0x0"); } else @@ -776,10 +754,10 @@ ada_value_print_ptr (struct value *val, struct type *type = ada_check_typedef (value_type (val)); if (ada_is_tag_type (type)) { - const char *name = ada_tag_name (val); + gdb::unique_xmalloc_ptr name = ada_tag_name (val); if (name != NULL) - fprintf_filtered (stream, " (%s)", name); + fprintf_filtered (stream, " (%s)", name.get ()); } } @@ -793,7 +771,7 @@ ada_value_print_num (struct value *val, struct ui_file *stream, int recurse, struct type *type = ada_check_typedef (value_type (val)); const gdb_byte *valaddr = value_contents_for_printing (val); - if (ada_is_fixed_point_type (type)) + if (ada_is_gnat_encoded_fixed_point_type (type)) { struct value *scale = ada_scaling_factor (type); val = value_cast (value_type (scale), val); @@ -805,10 +783,10 @@ ada_value_print_num (struct value *val, struct ui_file *stream, int recurse, fputs_filtered (str.c_str (), stream); return; } - else if (TYPE_CODE (type) == TYPE_CODE_RANGE - && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ENUM - || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_BOOL - || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CHAR)) + else if (type->code () == TYPE_CODE_RANGE + && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_ENUM + || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_BOOL + || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR)) { /* For enum-valued ranges, we want to recurse, because we'll end up printing the constant's name rather than its numeric @@ -886,7 +864,7 @@ ada_val_print_enum (struct value *value, struct ui_file *stream, int recurse, const gdb_byte *valaddr = value_contents_for_printing (value); int offset_aligned = ada_aligned_value_addr (type, valaddr) - valaddr; - len = TYPE_NFIELDS (type); + len = type->num_fields (); val = unpack_long (type, valaddr + offset_aligned); for (i = 0; i < len; i++) { @@ -992,7 +970,7 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr, struct value *deref_val; CORE_ADDR deref_val_int; - if (TYPE_CODE (elttype) == TYPE_CODE_UNDEF) + if (elttype->code () == TYPE_CODE_UNDEF) { fputs_styled ("", metadata_style.style (), stream); @@ -1048,7 +1026,7 @@ ada_value_print_1 (struct value *val, struct ui_file *stream, int recurse, if (ada_is_array_descriptor_type (type) || (ada_is_constrained_packed_array_type (type) - && TYPE_CODE (type) != TYPE_CODE_PTR)) + && type->code () != TYPE_CODE_PTR)) { ada_val_print_gnat_array (val, stream, recurse, options); return; @@ -1069,7 +1047,7 @@ ada_value_print_1 (struct value *val, struct ui_file *stream, int recurse, deprecated_set_value_type (val, type); } - switch (TYPE_CODE (type)) + switch (type->code ()) { default: common_val_print (val, stream, recurse, options, @@ -1145,12 +1123,12 @@ ada_value_print (struct value *val0, struct ui_file *stream, struct value_print_options opts; /* If it is a pointer, indicate what it points to. */ - if (TYPE_CODE (type) == TYPE_CODE_PTR) + if (type->code () == TYPE_CODE_PTR) { /* Hack: don't print (char *) for char strings. Their type is indicated by the quoted string anyway. */ if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char) - || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT + || TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_INT || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type))) { fprintf_filtered (stream, "("); @@ -1163,7 +1141,7 @@ ada_value_print (struct value *val0, struct ui_file *stream, /* We do not print the type description unless TYPE is an array access type (this is encoded by the compiler as a typedef to a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */ - if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) + if (type->code () == TYPE_CODE_TYPEDEF) { fprintf_filtered (stream, "("); type_print (type, "", stream, -1);