From: Sanimir Agovic Date: Mon, 14 Oct 2013 07:36:13 +0000 (+0100) Subject: vla: update type from newly created value X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=bcd629a44fff61527430f353cf77e20fe3afc395;p=binutils-gdb.git vla: update type from newly created value Constructing a value based on a type and address might change the type of the newly constructed value. Thus re-fetch type via value_type to ensure we have the correct type at hand. * ada-lang.c (ada_value_primitive_packed_val): Re-fetch type from value. (ada_template_to_fixed_record_type_1): Likewise. (ada_to_fixed_type_1): Likewise. * cp-valprint.c (cp_print_value_fields_rtti): Likewise. (cp_print_value): Likewise. * d-valprint.c (dynamic_array_type): Likewise. * eval.c (evaluate_subexp_with_coercion): Likewise. * findvar.c (address_of_variable): Likewise. * jv-valprint.c (java_value_print): Likewise. * valops.c (value_ind): Likewise. * value.c (coerce_ref): Likewise. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 1b989aec1d4..d0bf6c86c55 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,17 @@ +2014-04-11 Sanimir Agovic + + * ada-lang.c (ada_value_primitive_packed_val): Re-fetch type from value. + (ada_template_to_fixed_record_type_1): Likewise. + (ada_to_fixed_type_1): Likewise. + * cp-valprint.c (cp_print_value_fields_rtti): Likewise. + (cp_print_value): Likewise. + * d-valprint.c (dynamic_array_type): Likewise. + * eval.c (evaluate_subexp_with_coercion): Likewise. + * findvar.c (address_of_variable): Likewise. + * jv-valprint.c (java_value_print): Likewise. + * valops.c (value_ind): Likewise. + * value.c (coerce_ref): Likewise. + 2014-04-11 Sanimir Agovic * eval.c (evaluate_subexp_for_sizeof) : Create an indirect diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 95447585964..e268ebad3aa 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -2406,6 +2406,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr, else if (VALUE_LVAL (obj) == lval_memory && value_lazy (obj)) { v = value_at (type, value_address (obj)); + type = value_type (v); bytes = (unsigned char *) alloca (len); read_memory (value_address (v) + offset, bytes, len); } @@ -7888,6 +7889,7 @@ ada_template_to_fixed_record_type_1 (struct type *type, size first before creating the value. */ check_size (rtype); dval = value_from_contents_and_address (rtype, valaddr, address); + rtype = value_type (dval); } else dval = dval0; @@ -7990,7 +7992,10 @@ ada_template_to_fixed_record_type_1 (struct type *type, off = TYPE_FIELD_BITPOS (rtype, variant_field); if (dval0 == NULL) - dval = value_from_contents_and_address (rtype, valaddr, address); + { + dval = value_from_contents_and_address (rtype, valaddr, address); + rtype = value_type (dval); + } else dval = dval0; @@ -8131,7 +8136,10 @@ to_record_with_fixed_variant_part (struct type *type, const gdb_byte *valaddr, return type; if (dval0 == NULL) - dval = value_from_contents_and_address (type, valaddr, address); + { + dval = value_from_contents_and_address (type, valaddr, address); + type = value_type (dval); + } else dval = dval0; @@ -8429,6 +8437,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr, value_from_contents_and_address (fixed_record_type, valaddr, address); + fixed_record_type = value_type (obj); if (real_type != NULL) return to_fixed_record_type (real_type, NULL, diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c index 2d366b9b182..3e1d6ededd5 100644 --- a/gdb/cp-valprint.c +++ b/gdb/cp-valprint.c @@ -443,6 +443,7 @@ cp_print_value_fields_rtti (struct type *type, /* Ugh, we have to convert back to a value here. */ value = value_from_contents_and_address (type, valaddr + offset, address + offset); + type = value_type (value); /* We don't actually care about most of the result here -- just the type. We already have the correct offset, due to how val_print was initially called. */ @@ -545,6 +546,7 @@ cp_print_value (struct type *type, struct type *real_type, base_val = value_from_contents_and_address (baseclass, buf, address + boffset); + baseclass = value_type (base_val); thisoffset = 0; boffset = 0; thistype = baseclass; diff --git a/gdb/d-valprint.c b/gdb/d-valprint.c index 90095cd53e5..755f180dc51 100644 --- a/gdb/d-valprint.c +++ b/gdb/d-valprint.c @@ -59,6 +59,7 @@ dynamic_array_type (struct type *type, const gdb_byte *valaddr, true_type = lookup_array_range_type (true_type, 0, length - 1); ival = value_at (true_type, addr); + true_type = value_type (ival); d_val_print (true_type, value_contents_for_printing (ival), diff --git a/gdb/eval.c b/gdb/eval.c index 1f4c8697e0b..1074e1db6e4 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -2984,6 +2984,7 @@ evaluate_subexp_with_coercion (struct expression *exp, { (*pos) += 4; val = address_of_variable (var, exp->elts[pc + 1].block); + type = value_type (val); return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)), val); } diff --git a/gdb/jv-valprint.c b/gdb/jv-valprint.c index 82bdd9bf32b..a7bb4944f62 100644 --- a/gdb/jv-valprint.c +++ b/gdb/jv-valprint.c @@ -65,6 +65,7 @@ java_value_print (struct value *val, struct ui_file *stream, type = lookup_pointer_type (type); val = value_at (type, address); + type = value_type (val); } } diff --git a/gdb/valops.c b/gdb/valops.c index 46e2639ab9f..a1553795e5e 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -266,6 +266,7 @@ value_cast_structs (struct type *type, struct value *v2) { v = value_full_object (v2, real_type, full, top, using_enc); v = value_at_lazy (real_type, value_address (v)); + real_type = value_type (v); /* We might be trying to cast to the outermost enclosing type, in which case search_struct_field won't work. */ @@ -801,6 +802,7 @@ value_dynamic_cast (struct type *type, struct value *arg) return value_at_lazy (type, addr); tem = value_at (type, addr); + type = value_type (tem); /* The first dynamic check specified in 5.2.7. */ if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type))) @@ -1320,6 +1322,7 @@ address_of_variable (struct symbol *var, const struct block *b) Lazy evaluation pays off here. */ val = value_of_variable (var, b); + type = value_type (val); if ((VALUE_LVAL (val) == lval_memory && value_lazy (val)) || TYPE_CODE (type) == TYPE_CODE_FUNC) @@ -1568,6 +1571,7 @@ value_ind (struct value *arg1) (value_as_address (arg1) - value_pointed_to_offset (arg1))); + enc_type = value_type (arg2); return readjust_indirect_value_type (arg2, enc_type, base_type, arg1); } diff --git a/gdb/value.c b/gdb/value.c index 9cc5e4469e5..d125a0913a9 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -3505,6 +3505,7 @@ coerce_ref (struct value *arg) retval = value_at_lazy (enc_type, unpack_pointer (value_type (arg), value_contents (arg))); + enc_type = value_type (retval); return readjust_indirect_value_type (retval, enc_type, value_type_arg_tmp, arg); }