X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalue.c;h=cb56849eee68bad403151fff3e4a7b238406f19c;hb=492d29ea1c9a8b2c7d5193908119a4e27c045687;hp=0e13b763a81c7e23210d51fd0a669ec6631c4b35;hpb=98b1cfdcc8998ad3e35896ade0fdba04ceda8d74;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.c b/gdb/value.c index 0e13b763a8..cb56849eee 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -1,6 +1,6 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. - Copyright (C) 1986-2014 Free Software Foundation, Inc. + Copyright (C) 1986-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -19,7 +19,6 @@ #include "defs.h" #include "arch-utils.h" -#include #include "symtab.h" #include "gdbtypes.h" #include "value.h" @@ -30,15 +29,13 @@ #include "language.h" #include "demangle.h" #include "doublest.h" -#include "gdb_assert.h" #include "regcache.h" #include "block.h" #include "dfp.h" #include "objfiles.h" #include "valprint.h" #include "cli/cli-decode.h" -#include "exceptions.h" -#include "python/python.h" +#include "extension.h" #include #include "tracepoint.h" #include "cp-abi.h" @@ -197,15 +194,6 @@ struct value reset, be sure to consider this use as well! */ unsigned int lazy : 1; - /* If nonzero, this is the value of a variable that does not - actually exist in the program. If nonzero, and LVAL is - lval_register, this is a register ($pc, $sp, etc., never a - program variable) that has not been saved in the frame. All - optimized-out values are treated pretty much the same, except - registers have a different string representation and related - error strings. */ - unsigned int optimized_out : 1; - /* If value is a variable, is it initialized or not. */ unsigned int initialized : 1; @@ -230,6 +218,9 @@ struct value /* Pointer to internal variable. */ struct internalvar *internalvar; + /* Pointer to xmethod worker. */ + struct xmethod_worker *xm_worker; + /* If lval == lval_computed, this is a set of function pointers to use to access and describe the value, and a closure pointer for them to use. */ @@ -333,9 +324,20 @@ struct value /* Unavailable ranges in CONTENTS. We mark unavailable ranges, rather than available, since the common and default case is for a - value to be available. This is filled in at value read time. The - unavailable ranges are tracked in bits. */ + value to be available. This is filled in at value read time. + The unavailable ranges are tracked in bits. Note that a contents + bit that has been optimized out doesn't really exist in the + program, so it can't be marked unavailable either. */ VEC(range_s) *unavailable; + + /* Likewise, but for optimized out contents (a chunk of the value of + a variable that does not actually exist in the program). If LVAL + is lval_register, this is a register ($pc, $sp, etc., never a + program variable) that has not been saved in the frame. Not + saved registers and optimized-out program variables values are + treated pretty much the same, except not-saved registers have a + different string representation and related error strings. */ + VEC(range_s) *optimized_out; }; int @@ -354,6 +356,14 @@ value_bytes_available (const struct value *value, int offset, int length) length * TARGET_CHAR_BIT); } +int +value_bits_any_optimized_out (const struct value *value, int bit_offset, int bit_length) +{ + gdb_assert (!value->lazy); + + return ranges_contain (value->optimized_out, bit_offset, bit_length); +} + int value_entirely_available (struct value *value) { @@ -367,17 +377,22 @@ value_entirely_available (struct value *value) return 0; } -int -value_entirely_unavailable (struct value *value) +/* Returns true if VALUE is entirely covered by RANGES. If the value + is lazy, it'll be read now. Note that RANGE is a pointer to + pointer because reading the value might change *RANGE. */ + +static int +value_entirely_covered_by_range_vector (struct value *value, + VEC(range_s) **ranges) { - /* We can only tell whether the whole value is available when we try - to read it. */ + /* We can only tell whether the whole value is optimized out / + unavailable when we try to read it. */ if (value->lazy) value_fetch_lazy (value); - if (VEC_length (range_s, value->unavailable) == 1) + if (VEC_length (range_s, *ranges) == 1) { - struct range *t = VEC_index (range_s, value->unavailable, 0); + struct range *t = VEC_index (range_s, *ranges, 0); if (t->offset == 0 && t->length == (TARGET_CHAR_BIT @@ -388,8 +403,23 @@ value_entirely_unavailable (struct value *value) return 0; } -void -mark_value_bits_unavailable (struct value *value, int offset, int length) +int +value_entirely_unavailable (struct value *value) +{ + return value_entirely_covered_by_range_vector (value, &value->unavailable); +} + +int +value_entirely_optimized_out (struct value *value) +{ + return value_entirely_covered_by_range_vector (value, &value->optimized_out); +} + +/* Insert into the vector pointed to by VECTORP the bit range starting of + OFFSET bits, and extending for the next LENGTH bits. */ + +static void +insert_into_bit_range_vector (VEC(range_s) **vectorp, int offset, int length) { range_s newr; int i; @@ -480,10 +510,10 @@ mark_value_bits_unavailable (struct value *value, int offset, int length) */ - i = VEC_lower_bound (range_s, value->unavailable, &newr, range_lessthan); + i = VEC_lower_bound (range_s, *vectorp, &newr, range_lessthan); if (i > 0) { - struct range *bef = VEC_index (range_s, value->unavailable, i - 1); + struct range *bef = VEC_index (range_s, *vectorp, i - 1); if (ranges_overlap (bef->offset, bef->length, offset, length)) { @@ -504,18 +534,18 @@ mark_value_bits_unavailable (struct value *value, int offset, int length) else { /* #3 */ - VEC_safe_insert (range_s, value->unavailable, i, &newr); + VEC_safe_insert (range_s, *vectorp, i, &newr); } } else { /* #4 */ - VEC_safe_insert (range_s, value->unavailable, i, &newr); + VEC_safe_insert (range_s, *vectorp, i, &newr); } /* Check whether the ranges following the one we've just added or touched can be folded in (#5 above). */ - if (i + 1 < VEC_length (range_s, value->unavailable)) + if (i + 1 < VEC_length (range_s, *vectorp)) { struct range *t; struct range *r; @@ -523,11 +553,11 @@ mark_value_bits_unavailable (struct value *value, int offset, int length) int next = i + 1; /* Get the range we just touched. */ - t = VEC_index (range_s, value->unavailable, i); + t = VEC_index (range_s, *vectorp, i); removed = 0; i = next; - for (; VEC_iterate (range_s, value->unavailable, i, r); i++) + for (; VEC_iterate (range_s, *vectorp, i, r); i++) if (r->offset <= t->offset + t->length) { ULONGEST l, h; @@ -549,10 +579,16 @@ mark_value_bits_unavailable (struct value *value, int offset, int length) } if (removed != 0) - VEC_block_remove (range_s, value->unavailable, next, removed); + VEC_block_remove (range_s, *vectorp, next, removed); } } +void +mark_value_bits_unavailable (struct value *value, int offset, int length) +{ + insert_into_bit_range_vector (&value->unavailable, offset, length); +} + void mark_value_bytes_unavailable (struct value *value, int offset, int length) { @@ -681,48 +717,53 @@ memcmp_with_bit_offsets (const gdb_byte *ptr1, size_t offset1_bits, return 0; } -/* Helper function for value_available_contents_eq. The only difference is - that this function is bit rather than byte based. +/* Helper struct for find_first_range_overlap_and_match and + value_contents_bits_eq. Keep track of which slot of a given ranges + vector have we last looked at. */ - Compare LENGTH bits of VAL1's contents starting at OFFSET1 bits with - LENGTH bits of VAL2's contents starting at OFFSET2 bits. Return true - if the available bits match. */ +struct ranges_and_idx +{ + /* The ranges. */ + VEC(range_s) *ranges; + + /* The range we've last found in RANGES. Given ranges are sorted, + we can start the next lookup here. */ + int idx; +}; + +/* Helper function for value_contents_bits_eq. Compare LENGTH bits of + RP1's ranges starting at OFFSET1 bits with LENGTH bits of RP2's + ranges starting at OFFSET2 bits. Return true if the ranges match + and fill in *L and *H with the overlapping window relative to + (both) OFFSET1 or OFFSET2. */ static int -value_available_contents_bits_eq (const struct value *val1, int offset1, - const struct value *val2, int offset2, - int length) +find_first_range_overlap_and_match (struct ranges_and_idx *rp1, + struct ranges_and_idx *rp2, + int offset1, int offset2, + int length, ULONGEST *l, ULONGEST *h) { - int idx1 = 0, idx2 = 0; - - /* See function description in value.h. */ - gdb_assert (!val1->lazy && !val2->lazy); + rp1->idx = find_first_range_overlap (rp1->ranges, rp1->idx, + offset1, length); + rp2->idx = find_first_range_overlap (rp2->ranges, rp2->idx, + offset2, length); - while (length > 0) + if (rp1->idx == -1 && rp2->idx == -1) + { + *l = length; + *h = length; + return 1; + } + else if (rp1->idx == -1 || rp2->idx == -1) + return 0; + else { range_s *r1, *r2; ULONGEST l1, h1; ULONGEST l2, h2; - idx1 = find_first_range_overlap (val1->unavailable, idx1, - offset1, length); - idx2 = find_first_range_overlap (val2->unavailable, idx2, - offset2, length); - - /* The usual case is for both values to be completely available. */ - if (idx1 == -1 && idx2 == -1) - return (memcmp_with_bit_offsets (val1->contents, offset1, - val2->contents, offset2, - length) == 0); - /* The contents only match equal if the available set matches as - well. */ - else if (idx1 == -1 || idx2 == -1) - return 0; - - gdb_assert (idx1 != -1 && idx2 != -1); - - r1 = VEC_index (range_s, val1->unavailable, idx1); - r2 = VEC_index (range_s, val2->unavailable, idx2); + r1 = VEC_index (range_s, rp1->ranges, rp1->idx); + r2 = VEC_index (range_s, rp2->ranges, rp2->idx); /* Get the unavailable windows intersected by the incoming ranges. The first and last ranges that overlap the argument @@ -731,7 +772,7 @@ value_available_contents_bits_eq (const struct value *val1, int offset1, h1 = min (offset1 + length, r1->offset + r1->length); l2 = max (offset2, r2->offset); - h2 = min (offset2 + length, r2->offset + r2->length); + h2 = min (offset2 + length, offset2 + r2->length); /* Make them relative to the respective start offsets, so we can compare them for equality. */ @@ -741,31 +782,93 @@ value_available_contents_bits_eq (const struct value *val1, int offset1, l2 -= offset2; h2 -= offset2; - /* Different availability, no match. */ + /* Different ranges, no match. */ if (l1 != l2 || h1 != h2) return 0; - /* Compare the _available_ contents. */ + *h = h1; + *l = l1; + return 1; + } +} + +/* Helper function for value_contents_eq. The only difference is that + this function is bit rather than byte based. + + Compare LENGTH bits of VAL1's contents starting at OFFSET1 bits + with LENGTH bits of VAL2's contents starting at OFFSET2 bits. + Return true if the available bits match. */ + +static int +value_contents_bits_eq (const struct value *val1, int offset1, + const struct value *val2, int offset2, + int length) +{ + /* Each array element corresponds to a ranges source (unavailable, + optimized out). '1' is for VAL1, '2' for VAL2. */ + struct ranges_and_idx rp1[2], rp2[2]; + + /* See function description in value.h. */ + gdb_assert (!val1->lazy && !val2->lazy); + + /* We shouldn't be trying to compare past the end of the values. */ + gdb_assert (offset1 + length + <= TYPE_LENGTH (val1->enclosing_type) * TARGET_CHAR_BIT); + gdb_assert (offset2 + length + <= TYPE_LENGTH (val2->enclosing_type) * TARGET_CHAR_BIT); + + memset (&rp1, 0, sizeof (rp1)); + memset (&rp2, 0, sizeof (rp2)); + rp1[0].ranges = val1->unavailable; + rp2[0].ranges = val2->unavailable; + rp1[1].ranges = val1->optimized_out; + rp2[1].ranges = val2->optimized_out; + + while (length > 0) + { + ULONGEST l = 0, h = 0; /* init for gcc -Wall */ + int i; + + for (i = 0; i < 2; i++) + { + ULONGEST l_tmp, h_tmp; + + /* The contents only match equal if the invalid/unavailable + contents ranges match as well. */ + if (!find_first_range_overlap_and_match (&rp1[i], &rp2[i], + offset1, offset2, length, + &l_tmp, &h_tmp)) + return 0; + + /* We're interested in the lowest/first range found. */ + if (i == 0 || l_tmp < l) + { + l = l_tmp; + h = h_tmp; + } + } + + /* Compare the available/valid contents. */ if (memcmp_with_bit_offsets (val1->contents, offset1, - val2->contents, offset2, l1) != 0) + val2->contents, offset2, l) != 0) return 0; - length -= h1; - offset1 += h1; - offset2 += h1; + length -= h; + offset1 += h; + offset2 += h; } return 1; } int -value_available_contents_eq (const struct value *val1, int offset1, - const struct value *val2, int offset2, - int length) +value_contents_eq (const struct value *val1, int offset1, + const struct value *val2, int offset2, + int length) { - return value_available_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT, - val2, offset2 * TARGET_CHAR_BIT, - length * TARGET_CHAR_BIT); + return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT, + val2, offset2 * TARGET_CHAR_BIT, + length * TARGET_CHAR_BIT); } /* Prototypes for local functions. */ @@ -833,7 +936,6 @@ allocate_value_lazy (struct type *type) val->bitsize = 0; VALUE_REGNUM (val) = -1; val->lazy = 1; - val->optimized_out = 0; val->embedded_offset = 0; val->pointed_to_offset = 0; val->modifiable = 1; @@ -902,7 +1004,7 @@ allocate_optimized_out_value (struct type *type) { struct value *retval = allocate_value_lazy (type); - set_value_optimized_out (retval, 1); + mark_value_bytes_optimized_out (retval, 0, TYPE_LENGTH (type)); set_value_lazy (retval, 0); return retval; } @@ -1051,7 +1153,7 @@ error_value_optimized_out (void) static void require_not_optimized_out (const struct value *value) { - if (value->optimized_out) + if (!VEC_empty (range_s, value->optimized_out)) { if (value->lval == lval_register) error (_("register has not been saved in frame")); @@ -1091,6 +1193,47 @@ value_contents_all (struct value *value) return result; } +/* Copy ranges in SRC_RANGE that overlap [SRC_BIT_OFFSET, + SRC_BIT_OFFSET+BIT_LENGTH) ranges into *DST_RANGE, adjusted. */ + +static void +ranges_copy_adjusted (VEC (range_s) **dst_range, int dst_bit_offset, + VEC (range_s) *src_range, int src_bit_offset, + int bit_length) +{ + range_s *r; + int i; + + for (i = 0; VEC_iterate (range_s, src_range, i, r); i++) + { + ULONGEST h, l; + + l = max (r->offset, src_bit_offset); + h = min (r->offset + r->length, src_bit_offset + bit_length); + + if (l < h) + insert_into_bit_range_vector (dst_range, + dst_bit_offset + (l - src_bit_offset), + h - l); + } +} + +/* Copy the ranges metadata in SRC that overlaps [SRC_BIT_OFFSET, + SRC_BIT_OFFSET+BIT_LENGTH) into DST, adjusted. */ + +static void +value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset, + const struct value *src, int src_bit_offset, + int bit_length) +{ + ranges_copy_adjusted (&dst->unavailable, dst_bit_offset, + src->unavailable, src_bit_offset, + bit_length); + ranges_copy_adjusted (&dst->optimized_out, dst_bit_offset, + src->optimized_out, src_bit_offset, + bit_length); +} + /* Copy LENGTH bytes of SRC value's (all) contents (value_contents_all) starting at SRC_OFFSET, into DST value's (all) contents, starting at DST_OFFSET. If unavailable contents are @@ -1119,6 +1262,9 @@ value_contents_copy_raw (struct value *dst, int dst_offset, replaced. Make sure to remember to implement replacing if it turns out actually necessary. */ gdb_assert (value_bytes_available (dst, dst_offset, length)); + gdb_assert (!value_bits_any_optimized_out (dst, + TARGET_CHAR_BIT * dst_offset, + TARGET_CHAR_BIT * length)); /* Copy the data. */ memcpy (value_contents_all_raw (dst) + dst_offset, @@ -1129,18 +1275,10 @@ value_contents_copy_raw (struct value *dst, int dst_offset, src_bit_offset = src_offset * TARGET_CHAR_BIT; dst_bit_offset = dst_offset * TARGET_CHAR_BIT; bit_length = length * TARGET_CHAR_BIT; - for (i = 0; VEC_iterate (range_s, src->unavailable, i, r); i++) - { - ULONGEST h, l; - l = max (r->offset, src_bit_offset); - h = min (r->offset + r->length, src_bit_offset + bit_length); - - if (l < h) - mark_value_bits_unavailable (dst, - dst_bit_offset + (l - src_bit_offset), - h - l); - } + value_ranges_copy_adjusted (dst, dst_bit_offset, + src, src_bit_offset, + bit_length); } /* Copy LENGTH bytes of SRC value's (all) contents @@ -1148,8 +1286,7 @@ value_contents_copy_raw (struct value *dst, int dst_offset, (all) contents, starting at DST_OFFSET. If unavailable contents are being copied from SRC, the corresponding DST contents are marked unavailable accordingly. DST must not be lazy. If SRC is - lazy, it will be fetched now. If SRC is not valid (is optimized - out), an error is thrown. + lazy, it will be fetched now. It is assumed the contents of DST in the [DST_OFFSET, DST_OFFSET+LENGTH) range are wholly available. */ @@ -1158,8 +1295,6 @@ void value_contents_copy (struct value *dst, int dst_offset, struct value *src, int src_offset, int length) { - require_not_optimized_out (src); - if (src->lazy) value_fetch_lazy (src); @@ -1207,69 +1342,34 @@ value_contents_writeable (struct value *value) return value_contents_raw (value); } -/* Return non-zero if VAL1 and VAL2 have the same contents. Note that - this function is different from value_equal; in C the operator == - can return 0 even if the two values being compared are equal. */ - -int -value_contents_equal (struct value *val1, struct value *val2) -{ - struct type *type1; - struct type *type2; - - type1 = check_typedef (value_type (val1)); - type2 = check_typedef (value_type (val2)); - if (TYPE_LENGTH (type1) != TYPE_LENGTH (type2)) - return 0; - - return (memcmp (value_contents (val1), value_contents (val2), - TYPE_LENGTH (type1)) == 0); -} - int value_optimized_out (struct value *value) { /* We can only know if a value is optimized out once we have tried to fetch it. */ - if (!value->optimized_out && value->lazy) + if (VEC_empty (range_s, value->optimized_out) && value->lazy) value_fetch_lazy (value); - return value->optimized_out; + return !VEC_empty (range_s, value->optimized_out); } -int -value_optimized_out_const (const struct value *value) -{ - return value->optimized_out; -} +/* Mark contents of VALUE as optimized out, starting at OFFSET bytes, and + the following LENGTH bytes. */ void -set_value_optimized_out (struct value *value, int val) +mark_value_bytes_optimized_out (struct value *value, int offset, int length) { - value->optimized_out = val; + mark_value_bits_optimized_out (value, + offset * TARGET_CHAR_BIT, + length * TARGET_CHAR_BIT); } -int -value_entirely_optimized_out (const struct value *value) -{ - if (!value->optimized_out) - return 0; - if (value->lval != lval_computed - || !value->location.computed.funcs->check_any_valid) - return 1; - return !value->location.computed.funcs->check_any_valid (value); -} +/* See value.h. */ -int -value_bits_valid (const struct value *value, int offset, int length) +void +mark_value_bits_optimized_out (struct value *value, int offset, int length) { - if (!value->optimized_out) - return 1; - if (value->lval != lval_computed - || !value->location.computed.funcs->check_validity) - return 0; - return value->location.computed.funcs->check_validity (value, offset, - length); + insert_into_bit_range_vector (&value->optimized_out, offset, length); } int @@ -1340,7 +1440,8 @@ CORE_ADDR value_address (const struct value *value) { if (value->lval == lval_internalvar - || value->lval == lval_internalvar_component) + || value->lval == lval_internalvar_component + || value->lval == lval_xcallable) return 0; if (value->parent != NULL) return value_address (value->parent) + value->offset; @@ -1352,7 +1453,8 @@ CORE_ADDR value_raw_address (struct value *value) { if (value->lval == lval_internalvar - || value->lval == lval_internalvar_component) + || value->lval == lval_internalvar_component + || value->lval == lval_xcallable) return 0; return value->location.address; } @@ -1361,7 +1463,8 @@ void set_value_address (struct value *value, CORE_ADDR addr) { gdb_assert (value->lval != lval_internalvar - && value->lval != lval_internalvar_component); + && value->lval != lval_internalvar_component + && value->lval != lval_xcallable); value->location.address = addr; } @@ -1433,6 +1536,8 @@ value_free (struct value *val) if (funcs->free_closure) funcs->free_closure (val); } + else if (VALUE_LVAL (val) == lval_xcallable) + free_xmethod_worker (val->location.xm_worker); xfree (val->contents); VEC_free (range_s, val->unavailable); @@ -1577,7 +1682,6 @@ value_copy (struct value *arg) VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg); VALUE_REGNUM (val) = VALUE_REGNUM (arg); val->lazy = arg->lazy; - val->optimized_out = arg->optimized_out; val->embedded_offset = value_embedded_offset (arg); val->pointed_to_offset = arg->pointed_to_offset; val->modifiable = arg->modifiable; @@ -1588,6 +1692,7 @@ value_copy (struct value *arg) } val->unavailable = VEC_copy (range_s, arg->unavailable); + val->optimized_out = VEC_copy (range_s, arg->optimized_out); set_value_parent (val, arg->parent); if (VALUE_LVAL (val) == lval_computed) { @@ -1619,10 +1724,24 @@ value_non_lval (struct value *arg) return arg; } +/* Write contents of V at ADDR and set its lval type to be LVAL_MEMORY. */ + +void +value_force_lval (struct value *v, CORE_ADDR addr) +{ + gdb_assert (VALUE_LVAL (v) == not_lval); + + write_memory (addr, value_contents_raw (v), TYPE_LENGTH (value_type (v))); + v->lval = lval_memory; + v->location.address = addr; +} + void set_value_component_location (struct value *component, const struct value *whole) { + gdb_assert (whole->lval != lval_xcallable); + if (whole->lval == lval_internalvar) VALUE_LVAL (component) = lval_internalvar_component; else @@ -1642,9 +1761,7 @@ set_value_component_location (struct value *component, /* Access to the value history. */ /* Record a new value in the value history. - Returns the absolute history index of the entry. - Result of -1 indicates the value was not saved; otherwise it is the - value history index of this new item. */ + Returns the absolute history index of the entry. */ int record_latest_value (struct value *val) @@ -1661,7 +1778,11 @@ record_latest_value (struct value *val) from. This is a bit dubious, because then *&$1 does not just return $1 but the current contents of that location. c'est la vie... */ val->modifiable = 0; - release_value (val); + + /* The value may have already been released, in which case we're adding a + new reference for its entry in the history. That is why we call + release_value_or_incref here instead of release_value. */ + release_value_or_incref (val); /* Here we treat value_history_count as origin-zero and applying to the value being stored now. */ @@ -1669,13 +1790,13 @@ record_latest_value (struct value *val) i = value_history_count % VALUE_HISTORY_CHUNK; if (i == 0) { - struct value_history_chunk *new + struct value_history_chunk *newobj = (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk)); - memset (new->values, 0, sizeof new->values); - new->next = value_history_chain; - value_history_chain = new; + memset (newobj->values, 0, sizeof newobj->values); + newobj->next = value_history_chain; + value_history_chain = newobj; } value_history_chain->values[i] = val; @@ -1770,6 +1891,66 @@ show_values (char *num_exp, int from_tty) } } +enum internalvar_kind +{ + /* The internal variable is empty. */ + INTERNALVAR_VOID, + + /* The value of the internal variable is provided directly as + a GDB value object. */ + INTERNALVAR_VALUE, + + /* A fresh value is computed via a call-back routine on every + access to the internal variable. */ + INTERNALVAR_MAKE_VALUE, + + /* The internal variable holds a GDB internal convenience function. */ + INTERNALVAR_FUNCTION, + + /* The variable holds an integer value. */ + INTERNALVAR_INTEGER, + + /* The variable holds a GDB-provided string. */ + INTERNALVAR_STRING, +}; + +union internalvar_data +{ + /* A value object used with INTERNALVAR_VALUE. */ + struct value *value; + + /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */ + struct + { + /* The functions to call. */ + const struct internalvar_funcs *functions; + + /* The function's user-data. */ + void *data; + } make_value; + + /* The internal function used with INTERNALVAR_FUNCTION. */ + struct + { + struct internal_function *function; + /* True if this is the canonical name for the function. */ + int canonical; + } fn; + + /* An integer value used with INTERNALVAR_INTEGER. */ + struct + { + /* If type is non-NULL, it will be used as the type to generate + a value for this internal variable. If type is NULL, a default + integer type for the architecture is used. */ + struct type *type; + LONGEST val; + } integer; + + /* A string value used with INTERNALVAR_STRING. */ + char *string; +}; + /* Internal variables. These are variables within the debugger that hold values assigned by debugger commands. The user refers to them with a '$' prefix @@ -1784,66 +1965,9 @@ struct internalvar enum internalvar_kind specifies the kind, and union internalvar_data provides the data associated with this particular kind. */ - enum internalvar_kind - { - /* The internal variable is empty. */ - INTERNALVAR_VOID, - - /* The value of the internal variable is provided directly as - a GDB value object. */ - INTERNALVAR_VALUE, - - /* A fresh value is computed via a call-back routine on every - access to the internal variable. */ - INTERNALVAR_MAKE_VALUE, - - /* The internal variable holds a GDB internal convenience function. */ - INTERNALVAR_FUNCTION, - - /* The variable holds an integer value. */ - INTERNALVAR_INTEGER, - - /* The variable holds a GDB-provided string. */ - INTERNALVAR_STRING, + enum internalvar_kind kind; - } kind; - - union internalvar_data - { - /* A value object used with INTERNALVAR_VALUE. */ - struct value *value; - - /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */ - struct - { - /* The functions to call. */ - const struct internalvar_funcs *functions; - - /* The function's user-data. */ - void *data; - } make_value; - - /* The internal function used with INTERNALVAR_FUNCTION. */ - struct - { - struct internal_function *function; - /* True if this is the canonical name for the function. */ - int canonical; - } fn; - - /* An integer value used with INTERNALVAR_INTEGER. */ - struct - { - /* If type is non-NULL, it will be used as the type to generate - a value for this internal variable. If type is NULL, a default - integer type for the architecture is used. */ - struct type *type; - LONGEST val; - } integer; - - /* A string value used with INTERNALVAR_STRING. */ - char *string; - } u; + union internalvar_data u; }; static struct internalvar *internalvars; @@ -2319,7 +2443,7 @@ static void function_destroyer (struct cmd_list_element *self, void *ignore) { xfree ((char *) self->name); - xfree (self->doc); + xfree ((char *) self->doc); } /* Add a new internal function. NAME is the name of the function; DOC @@ -2405,7 +2529,7 @@ preserve_values (struct objfile *objfile) for (var = internalvars; var; var = var->next) preserve_one_internalvar (var, objfile, copied_types); - preserve_python_values (objfile, copied_types); + preserve_ext_lang_values (objfile, copied_types); htab_delete (copied_types); } @@ -2421,7 +2545,6 @@ show_convenience (char *ignore, int from_tty) get_user_print_options (&opts); for (var = internalvars; var; var = var->next) { - volatile struct gdb_exception ex; if (!varseen) { @@ -2429,15 +2552,19 @@ show_convenience (char *ignore, int from_tty) } printf_filtered (("$%s = "), var->name); - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { struct value *val; val = value_of_internalvar (gdbarch, var); value_print (val, gdb_stdout, &opts); } - if (ex.reason < 0) - fprintf_filtered (gdb_stdout, _(""), ex.message); + CATCH (ex, RETURN_MASK_ERROR) + { + fprintf_filtered (gdb_stdout, _(""), ex.message); + } + END_CATCH + printf_filtered (("\n")); } if (!varseen) @@ -2454,6 +2581,37 @@ show_convenience (char *ignore, int from_tty) } } +/* Return the TYPE_CODE_XMETHOD value corresponding to WORKER. */ + +struct value * +value_of_xmethod (struct xmethod_worker *worker) +{ + if (worker->value == NULL) + { + struct value *v; + + v = allocate_value (builtin_type (target_gdbarch ())->xmethod); + v->lval = lval_xcallable; + v->location.xm_worker = worker; + v->modifiable = 0; + worker->value = v; + } + + return worker->value; +} + +/* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */ + +struct value * +call_xmethod (struct value *method, int argc, struct value **argv) +{ + gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD + && method->lval == lval_xcallable && argc > 0); + + return invoke_xmethod (method->location.xm_worker, + argv[0], argv + 1, argc - 1); +} + /* Extract a value as a C number (either long or double). Knows how to convert fixed values to double, or floating values to long. @@ -2752,15 +2910,15 @@ value_static_field (struct type *type, int fieldno) { /* With some compilers, e.g. HP aCC, static data members are reported as non-debuggable symbols. */ - struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, - NULL, NULL); + struct bound_minimal_symbol msym + = lookup_minimal_symbol (phys_name, NULL, NULL); - if (!msym) + if (!msym.minsym) return allocate_optimized_out_value (type); else { retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno), - SYMBOL_VALUE_ADDRESS (msym)); + BMSYMBOL_VALUE_ADDRESS (msym)); } } else @@ -2827,24 +2985,19 @@ value_primitive_field (struct value *arg1, int offset, int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno); int container_bitsize = TYPE_LENGTH (type) * 8; - if (arg1->optimized_out) - v = allocate_optimized_out_value (type); + v = allocate_value_lazy (type); + v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno); + if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize + && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)) + v->bitpos = bitpos % container_bitsize; else - { - v = allocate_value_lazy (type); - v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno); - if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize - && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)) - v->bitpos = bitpos % container_bitsize; - else - v->bitpos = bitpos % 8; - v->offset = (value_embedded_offset (arg1) - + offset - + (bitpos - v->bitpos) / 8); - set_value_parent (v, arg1); - if (!value_lazy (arg1)) - value_fetch_lazy (v); - } + v->bitpos = bitpos % 8; + v->offset = (value_embedded_offset (arg1) + + offset + + (bitpos - v->bitpos) / 8); + set_value_parent (v, arg1); + if (!value_lazy (arg1)) + value_fetch_lazy (v); } else if (fieldno < TYPE_N_BASECLASSES (arg_type)) { @@ -2857,37 +3010,29 @@ value_primitive_field (struct value *arg1, int offset, if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1)) value_fetch_lazy (arg1); - /* The optimized_out flag is only set correctly once a lazy value is - loaded, having just loaded some lazy values we should check the - optimized out case now. */ - if (arg1->optimized_out) - v = allocate_optimized_out_value (type); + /* We special case virtual inheritance here because this + requires access to the contents, which we would rather avoid + for references to ordinary fields of unavailable values. */ + if (BASETYPE_VIA_VIRTUAL (arg_type, fieldno)) + boffset = baseclass_offset (arg_type, fieldno, + value_contents (arg1), + value_embedded_offset (arg1), + value_address (arg1), + arg1); else - { - /* We special case virtual inheritance here because this - requires access to the contents, which we would rather avoid - for references to ordinary fields of unavailable values. */ - if (BASETYPE_VIA_VIRTUAL (arg_type, fieldno)) - boffset = baseclass_offset (arg_type, fieldno, - value_contents (arg1), - value_embedded_offset (arg1), - value_address (arg1), - arg1); - else - boffset = TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; + boffset = TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; - if (value_lazy (arg1)) - v = allocate_value_lazy (value_enclosing_type (arg1)); - else - { - v = allocate_value (value_enclosing_type (arg1)); - value_contents_copy_raw (v, 0, arg1, 0, - TYPE_LENGTH (value_enclosing_type (arg1))); - } - v->type = type; - v->offset = value_offset (arg1); - v->embedded_offset = offset + value_embedded_offset (arg1) + boffset; + if (value_lazy (arg1)) + v = allocate_value_lazy (value_enclosing_type (arg1)); + else + { + v = allocate_value (value_enclosing_type (arg1)); + value_contents_copy_raw (v, 0, arg1, 0, + TYPE_LENGTH (value_enclosing_type (arg1))); } + v->type = type; + v->offset = value_offset (arg1); + v->embedded_offset = offset + value_embedded_offset (arg1) + boffset; } else { @@ -2898,12 +3043,7 @@ value_primitive_field (struct value *arg1, int offset, if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1)) value_fetch_lazy (arg1); - /* The optimized_out flag is only set correctly once a lazy value is - loaded, having just loaded some lazy values we should check for - the optimized out case now. */ - if (arg1->optimized_out) - v = allocate_optimized_out_value (type); - else if (value_lazy (arg1)) + if (value_lazy (arg1)) v = allocate_value_lazy (type); else { @@ -2976,7 +3116,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f, set_value_address (v, gdbarch_convert_from_func_ptr_addr - (gdbarch, SYMBOL_VALUE_ADDRESS (msym.minsym), ¤t_target)); + (gdbarch, BMSYMBOL_VALUE_ADDRESS (msym), ¤t_target)); } if (arg1p) @@ -2994,16 +3134,24 @@ value_fn_field (struct value **arg1p, struct fn_field *f, -/* Helper function for both unpack_value_bits_as_long and - unpack_bits_as_long. See those functions for more details on the - interface; the only difference is that this function accepts either - a NULL or a non-NULL ORIGINAL_VALUE. */ +/* Unpack a bitfield of the specified FIELD_TYPE, from the object at + VALADDR, and store the result in *RESULT. + The bitfield starts at BITPOS bits and contains BITSIZE bits. -static int -unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr, - int embedded_offset, int bitpos, int bitsize, - const struct value *original_value, - LONGEST *result) + Extracting bits depends on endianness of the machine. Compute the + number of least significant bits to discard. For big endian machines, + we compute the total number of bits in the anonymous object, subtract + off the bit count from the MSB of the object to the MSB of the + bitfield, then the size of the bitfield, which leaves the LSB discard + count. For little endian machines, the discard count is simply the + number of bits from the LSB of the anonymous object to the LSB of the + bitfield. + + If the field is signed, we also do sign extension. */ + +static LONGEST +unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, + int bitpos, int bitsize) { enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type)); ULONGEST val; @@ -3022,12 +3170,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr, read_offset = bitpos / 8; - if (original_value != NULL - && !value_bits_available (original_value, embedded_offset + bitpos, - bitsize)) - return 0; - - val = extract_unsigned_integer (valaddr + embedded_offset + read_offset, + val = extract_unsigned_integer (valaddr + read_offset, bytes_read, byte_order); /* Extract bits. See comment above. */ @@ -3054,60 +3197,7 @@ unpack_value_bits_as_long_1 (struct type *field_type, const gdb_byte *valaddr, } } - *result = val; - return 1; -} - -/* Unpack a bitfield of the specified FIELD_TYPE, from the object at - VALADDR + EMBEDDED_OFFSET, and store the result in *RESULT. - VALADDR points to the contents of ORIGINAL_VALUE, which must not be - NULL. The bitfield starts at BITPOS bits and contains BITSIZE - bits. - - Returns false if the value contents are unavailable, otherwise - returns true, indicating a valid value has been stored in *RESULT. - - Extracting bits depends on endianness of the machine. Compute the - number of least significant bits to discard. For big endian machines, - we compute the total number of bits in the anonymous object, subtract - off the bit count from the MSB of the object to the MSB of the - bitfield, then the size of the bitfield, which leaves the LSB discard - count. For little endian machines, the discard count is simply the - number of bits from the LSB of the anonymous object to the LSB of the - bitfield. - - If the field is signed, we also do sign extension. */ - -int -unpack_value_bits_as_long (struct type *field_type, const gdb_byte *valaddr, - int embedded_offset, int bitpos, int bitsize, - const struct value *original_value, - LONGEST *result) -{ - gdb_assert (original_value != NULL); - - return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset, - bitpos, bitsize, original_value, result); - -} - -/* Unpack a field FIELDNO of the specified TYPE, from the object at - VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of - ORIGINAL_VALUE. See unpack_value_bits_as_long for more - details. */ - -static int -unpack_value_field_as_long_1 (struct type *type, const gdb_byte *valaddr, - int embedded_offset, int fieldno, - const struct value *val, LONGEST *result) -{ - int bitpos = TYPE_FIELD_BITPOS (type, fieldno); - int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); - struct type *field_type = TYPE_FIELD_TYPE (type, fieldno); - - return unpack_value_bits_as_long_1 (field_type, valaddr, embedded_offset, - bitpos, bitsize, val, - result); + return val; } /* Unpack a field FIELDNO of the specified TYPE, from the object at @@ -3120,51 +3210,95 @@ unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr, int embedded_offset, int fieldno, const struct value *val, LONGEST *result) { + int bitpos = TYPE_FIELD_BITPOS (type, fieldno); + int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); + struct type *field_type = TYPE_FIELD_TYPE (type, fieldno); + int bit_offset; + gdb_assert (val != NULL); - return unpack_value_field_as_long_1 (type, valaddr, embedded_offset, - fieldno, val, result); + bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos; + if (value_bits_any_optimized_out (val, bit_offset, bitsize) + || !value_bits_available (val, bit_offset, bitsize)) + return 0; + + *result = unpack_bits_as_long (field_type, valaddr + embedded_offset, + bitpos, bitsize); + return 1; } /* Unpack a field FIELDNO of the specified TYPE, from the anonymous - object at VALADDR. See unpack_value_bits_as_long for more details. - This function differs from unpack_value_field_as_long in that it - operates without a struct value object. */ + object at VALADDR. See unpack_bits_as_long for more details. */ LONGEST unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno) { - LONGEST result; + int bitpos = TYPE_FIELD_BITPOS (type, fieldno); + int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); + struct type *field_type = TYPE_FIELD_TYPE (type, fieldno); - unpack_value_field_as_long_1 (type, valaddr, 0, fieldno, NULL, &result); - return result; + return unpack_bits_as_long (field_type, valaddr, bitpos, bitsize); +} + +/* Unpack a bitfield of BITSIZE bits found at BITPOS in the object at + VALADDR + EMBEDDEDOFFSET that has the type of DEST_VAL and store + the contents in DEST_VAL, zero or sign extending if the type of + DEST_VAL is wider than BITSIZE. VALADDR points to the contents of + VAL. If the VAL's contents required to extract the bitfield from + are unavailable/optimized out, DEST_VAL is correspondingly + marked unavailable/optimized out. */ + +void +unpack_value_bitfield (struct value *dest_val, + int bitpos, int bitsize, + const gdb_byte *valaddr, int embedded_offset, + const struct value *val) +{ + enum bfd_endian byte_order; + int src_bit_offset; + int dst_bit_offset; + LONGEST num; + struct type *field_type = value_type (dest_val); + + /* First, unpack and sign extend the bitfield as if it was wholly + available. Invalid/unavailable bits are read as zero, but that's + OK, as they'll end up marked below. */ + byte_order = gdbarch_byte_order (get_type_arch (field_type)); + num = unpack_bits_as_long (field_type, valaddr + embedded_offset, + bitpos, bitsize); + store_signed_integer (value_contents_raw (dest_val), + TYPE_LENGTH (field_type), byte_order, num); + + /* Now copy the optimized out / unavailability ranges to the right + bits. */ + src_bit_offset = embedded_offset * TARGET_CHAR_BIT + bitpos; + if (byte_order == BFD_ENDIAN_BIG) + dst_bit_offset = TYPE_LENGTH (field_type) * TARGET_CHAR_BIT - bitsize; + else + dst_bit_offset = 0; + value_ranges_copy_adjusted (dest_val, dst_bit_offset, + val, src_bit_offset, bitsize); } /* Return a new value with type TYPE, which is FIELDNO field of the object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents of VAL. If the VAL's contents required to extract the bitfield - from are unavailable, the new value is correspondingly marked as - unavailable. */ + from are unavailable/optimized out, the new value is + correspondingly marked unavailable/optimized out. */ struct value * value_field_bitfield (struct type *type, int fieldno, const gdb_byte *valaddr, int embedded_offset, const struct value *val) { - LONGEST l; + int bitpos = TYPE_FIELD_BITPOS (type, fieldno); + int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); + struct value *res_val = allocate_value (TYPE_FIELD_TYPE (type, fieldno)); - if (!unpack_value_field_as_long (type, valaddr, embedded_offset, fieldno, - val, &l)) - { - struct type *field_type = TYPE_FIELD_TYPE (type, fieldno); - struct value *retval = allocate_value (field_type); - mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (field_type)); - return retval; - } - else - { - return value_from_longest (TYPE_FIELD_TYPE (type, fieldno), l); - } + unpack_value_bitfield (res_val, bitpos, bitsize, + valaddr, embedded_offset, val); + + return res_val; } /* Modify the value of a bitfield. ADDR points to a block of memory in @@ -3318,31 +3452,62 @@ value_from_ulongest (struct type *type, ULONGEST num) /* Create a value representing a pointer of type TYPE to the address ADDR. */ + struct value * value_from_pointer (struct type *type, CORE_ADDR addr) { struct value *val = allocate_value (type); - store_typed_address (value_contents_raw (val), check_typedef (type), addr); + store_typed_address (value_contents_raw (val), + check_typedef (type), addr); return val; } /* Create a value of type TYPE whose contents come from VALADDR, if it is non-null, and whose memory address (in the inferior) is - ADDRESS. */ + ADDRESS. The type of the created value may differ from the passed + type TYPE. Make sure to retrieve values new type after this call. + Note that TYPE is not passed through resolve_dynamic_type; this is + a special API intended for use only by Ada. */ + +struct value * +value_from_contents_and_address_unresolved (struct type *type, + const gdb_byte *valaddr, + CORE_ADDR address) +{ + struct value *v; + + if (valaddr == NULL) + v = allocate_value_lazy (type); + else + v = value_from_contents (type, valaddr); + set_value_address (v, address); + VALUE_LVAL (v) = lval_memory; + return v; +} + +/* Create a value of type TYPE whose contents come from VALADDR, if it + is non-null, and whose memory address (in the inferior) is + ADDRESS. The type of the created value may differ from the passed + type TYPE. Make sure to retrieve values new type after this call. */ struct value * value_from_contents_and_address (struct type *type, const gdb_byte *valaddr, CORE_ADDR address) { + struct type *resolved_type = resolve_dynamic_type (type, address); + struct type *resolved_type_no_typedef = check_typedef (resolved_type); struct value *v; if (valaddr == NULL) - v = allocate_value_lazy (type); + v = allocate_value_lazy (resolved_type); else - v = value_from_contents (type, valaddr); + v = value_from_contents (resolved_type, valaddr); + if (TYPE_DATA_LOCATION (resolved_type_no_typedef) != NULL + && TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST) + address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef); set_value_address (v, address); VALUE_LVAL (v) = lval_memory; return v; @@ -3392,7 +3557,7 @@ value_from_decfloat (struct type *type, const gdb_byte *dec) for details. */ struct value * -value_from_history_ref (char *h, char **endp) +value_from_history_ref (const char *h, const char **endp) { int index, len; @@ -3423,7 +3588,12 @@ value_from_history_ref (char *h, char **endp) *endp += len; } else - index = -strtol (&h[2], endp, 10); + { + char *local_end; + + index = -strtol (&h[2], &local_end, 10); + *endp = local_end; + } } else { @@ -3434,7 +3604,12 @@ value_from_history_ref (char *h, char **endp) *endp += len; } else - index = strtol (&h[1], endp, 10); + { + char *local_end; + + index = strtol (&h[1], &local_end, 10); + *endp = local_end; + } } return access_value_history (index); @@ -3496,6 +3671,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); } @@ -3591,6 +3767,11 @@ value_fetch_lazy (struct value *val) { gdb_assert (value_lazy (val)); allocate_value_contents (val); + /* A value is either lazy, or fully fetched. The + availability/validity is only established as we try to fetch a + value. */ + gdb_assert (VEC_empty (range_s, val->optimized_out)); + gdb_assert (VEC_empty (range_s, val->unavailable)); if (value_bitsize (val)) { /* To read a lazy bitfield, read the entire enclosing value. This @@ -3599,29 +3780,15 @@ value_fetch_lazy (struct value *val) word, but we have no way to record that just specific bits of a value have been fetched. */ struct type *type = check_typedef (value_type (val)); - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); struct value *parent = value_parent (val); - LONGEST offset = value_offset (val); - LONGEST num; if (value_lazy (parent)) value_fetch_lazy (parent); - if (!value_bits_valid (parent, - TARGET_CHAR_BIT * offset + value_bitpos (val), - value_bitsize (val))) - set_value_optimized_out (val, 1); - else if (!unpack_value_bits_as_long (value_type (val), - value_contents_for_printing (parent), - offset, - value_bitpos (val), - value_bitsize (val), parent, &num)) - mark_value_bytes_unavailable (val, - value_embedded_offset (val), - TYPE_LENGTH (type)); - else - store_signed_integer (value_contents_raw (val), TYPE_LENGTH (type), - byte_order, num); + unpack_value_bitfield (val, + value_bitpos (val), value_bitsize (val), + value_contents_for_printing (parent), + value_offset (val), parent); } else if (VALUE_LVAL (val) == lval_memory) { @@ -3685,16 +3852,12 @@ value_fetch_lazy (struct value *val) if (value_lazy (new_val)) value_fetch_lazy (new_val); - /* If the register was not saved, mark it optimized out. */ - if (value_optimized_out (new_val)) - set_value_optimized_out (val, 1); - else - { - set_value_lazy (val, 0); - value_contents_copy (val, value_embedded_offset (val), - new_val, value_embedded_offset (new_val), - TYPE_LENGTH (type)); - } + /* Copy the contents and the unavailability/optimized-out + meta-data from NEW_VAL to VAL. */ + set_value_lazy (val, 0); + value_contents_copy (val, value_embedded_offset (val), + new_val, value_embedded_offset (new_val), + TYPE_LENGTH (type)); if (frame_debug) { @@ -3747,11 +3910,6 @@ value_fetch_lazy (struct value *val) else if (VALUE_LVAL (val) == lval_computed && value_computed_funcs (val)->read != NULL) value_computed_funcs (val)->read (val); - /* Don't call value_optimized_out on val, doing so would result in a - recursive call back to value_fetch_lazy, instead check the - optimized_out flag directly. */ - else if (val->optimized_out) - /* Keep it optimized out. */; else internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));