X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=b94c411f062619311eae84be313fd4ee8429d84d;hb=714f19d5576e314d5b9c3b674b11bf4212a3faeb;hp=09be6ddbb5b3fead802c1c74bd2229a3e9a09c53;hpb=a42952252f6cfaf3b84072997bd187c39b2088bb;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 09be6ddbb5..b94c411f06 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -2,7 +2,7 @@ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009 Free Software Foundation, Inc. + 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. @@ -53,12 +53,12 @@ extern int overload_debug; static int typecmp (int staticp, int varargs, int nargs, struct field t1[], struct value *t2[]); -static struct value *search_struct_field (char *, struct value *, +static struct value *search_struct_field (const char *, struct value *, int, struct type *, int); -static struct value *search_struct_method (char *, struct value **, - struct value **, - int, int *, struct type *); +static struct value *search_struct_method (const char *, struct value **, + struct value **, + int, int *, struct type *); static int find_oload_champ_namespace (struct type **, int, const char *, const char *, @@ -100,7 +100,7 @@ static CORE_ADDR allocate_space_in_inferior (int); static struct value *cast_into_complex (struct type *, struct value *); -static struct fn_field *find_method_list (struct value **, char *, +static struct fn_field *find_method_list (struct value **, const char *, int, struct type *, int *, struct type **, int *); @@ -232,6 +232,11 @@ value_cast_structs (struct type *type, struct value *v2) || TYPE_CODE (t2) == TYPE_CODE_UNION) && !!"Precondition is that value is of STRUCT or UNION kind"); + if (TYPE_NAME (t1) != NULL + && TYPE_NAME (t2) != NULL + && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2))) + return NULL; + /* Upcasting: look in the type of the source to see if it contains the type of the target as a superclass. If so, we'll need to offset the pointer rather than just change its type. */ @@ -245,19 +250,40 @@ value_cast_structs (struct type *type, struct value *v2) /* Downcasting: look in the type of the target to see if it contains the type of the source as a superclass. If so, we'll need to - offset the pointer rather than just change its type. - FIXME: This fails silently with virtual inheritance. */ + offset the pointer rather than just change its type. */ if (TYPE_NAME (t2) != NULL) { + /* Try downcasting using the run-time type of the value. */ + int full, top, using_enc; + struct type *real_type; + + real_type = value_rtti_type (v2, &full, &top, &using_enc); + if (real_type) + { + v = value_full_object (v2, real_type, full, top, using_enc); + v = value_at_lazy (real_type, value_address (v)); + + /* We might be trying to cast to the outermost enclosing + type, in which case search_struct_field won't work. */ + if (TYPE_NAME (real_type) != NULL + && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1))) + return v; + + v = search_struct_field (type_name_no_tag (t2), v, 0, real_type, 1); + if (v) + return v; + } + + /* Try downcasting using information from the destination type + T2. This wouldn't work properly for classes with virtual + bases, but those were handled above. */ v = search_struct_field (type_name_no_tag (t2), value_zero (t1, not_lval), 0, t1, 1); if (v) { /* Downcasting is possible (t1 is superclass of v2). */ - CORE_ADDR addr2 = VALUE_ADDRESS (v2); - addr2 -= (VALUE_ADDRESS (v) - + value_offset (v) - + value_embedded_offset (v)); + CORE_ADDR addr2 = value_address (v2); + addr2 -= value_address (v) + value_embedded_offset (v); return value_at (type, addr2); } } @@ -424,17 +450,18 @@ value_cast (struct type *type, struct value *arg2) return value_from_double (type, value_as_double (arg2)); else if (code1 == TYPE_CODE_DECFLOAT && scalar) { + enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); int dec_len = TYPE_LENGTH (type); gdb_byte dec[16]; if (code2 == TYPE_CODE_FLT) - decimal_from_floating (arg2, dec, dec_len); + decimal_from_floating (arg2, dec, dec_len, byte_order); else if (code2 == TYPE_CODE_DECFLOAT) decimal_convert (value_contents (arg2), TYPE_LENGTH (type2), - dec, dec_len); + byte_order, dec, dec_len, byte_order); else /* The only option left is an integral type. */ - decimal_from_integral (arg2, dec, dec_len); + decimal_from_integral (arg2, dec, dec_len, byte_order); return value_from_decfloat (type, dec); } @@ -452,8 +479,9 @@ value_cast (struct type *type, struct value *arg2) sees a cast as a simple reinterpretation of the pointer's bits. */ if (code2 == TYPE_CODE_PTR) - longest = extract_unsigned_integer (value_contents (arg2), - TYPE_LENGTH (type2)); + longest = extract_unsigned_integer + (value_contents (arg2), TYPE_LENGTH (type2), + gdbarch_byte_order (get_type_arch (type2))); else longest = value_as_long (arg2); return value_from_longest (type, convert_to_boolean ? @@ -473,7 +501,7 @@ value_cast (struct type *type, struct value *arg2) otherwise occur when dealing with a target having two byte pointers and four byte addresses. */ - int addr_bit = gdbarch_addr_bit (current_gdbarch); + int addr_bit = gdbarch_addr_bit (get_type_arch (type2)); LONGEST longest = value_as_long (arg2); if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT) @@ -510,11 +538,10 @@ value_cast (struct type *type, struct value *arg2) return arg2; } else if (VALUE_LVAL (arg2) == lval_memory) - return value_at_lazy (type, - VALUE_ADDRESS (arg2) + value_offset (arg2)); + return value_at_lazy (type, value_address (arg2)); else if (code1 == TYPE_CODE_VOID) { - return value_zero (builtin_type_void, not_lval); + return value_zero (type, not_lval); } else { @@ -523,6 +550,258 @@ value_cast (struct type *type, struct value *arg2) } } +/* The C++ reinterpret_cast operator. */ + +struct value * +value_reinterpret_cast (struct type *type, struct value *arg) +{ + struct value *result; + struct type *real_type = check_typedef (type); + struct type *arg_type, *dest_type; + int is_ref = 0; + enum type_code dest_code, arg_code; + + /* Do reference, function, and array conversion. */ + arg = coerce_array (arg); + + /* Attempt to preserve the type the user asked for. */ + dest_type = type; + + /* If we are casting to a reference type, transform + reinterpret_cast(V) to *reinterpret_cast(&V). */ + if (TYPE_CODE (real_type) == TYPE_CODE_REF) + { + is_ref = 1; + arg = value_addr (arg); + dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type)); + real_type = lookup_pointer_type (real_type); + } + + arg_type = value_type (arg); + + dest_code = TYPE_CODE (real_type); + arg_code = TYPE_CODE (arg_type); + + /* We can convert pointer types, or any pointer type to int, or int + type to pointer. */ + if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT) + || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR) + || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT) + || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR) + || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT) + || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR) + || (dest_code == arg_code + && (dest_code == TYPE_CODE_PTR + || dest_code == TYPE_CODE_METHODPTR + || dest_code == TYPE_CODE_MEMBERPTR))) + result = value_cast (dest_type, arg); + else + error (_("Invalid reinterpret_cast")); + + if (is_ref) + result = value_cast (type, value_ref (value_ind (result))); + + return result; +} + +/* A helper for value_dynamic_cast. This implements the first of two + runtime checks: we iterate over all the base classes of the value's + class which are equal to the desired class; if only one of these + holds the value, then it is the answer. */ + +static int +dynamic_cast_check_1 (struct type *desired_type, + const bfd_byte *contents, + CORE_ADDR address, + struct type *search_type, + CORE_ADDR arg_addr, + struct type *arg_type, + struct value **result) +{ + int i, result_count = 0; + + for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) + { + int offset = baseclass_offset (search_type, i, contents, address); + if (offset == -1) + error (_("virtual baseclass botch")); + if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i))) + { + if (address + offset >= arg_addr + && address + offset < arg_addr + TYPE_LENGTH (arg_type)) + { + ++result_count; + if (!*result) + *result = value_at_lazy (TYPE_BASECLASS (search_type, i), + address + offset); + } + } + else + result_count += dynamic_cast_check_1 (desired_type, + contents + offset, + address + offset, + TYPE_BASECLASS (search_type, i), + arg_addr, + arg_type, + result); + } + + return result_count; +} + +/* A helper for value_dynamic_cast. This implements the second of two + runtime checks: we look for a unique public sibling class of the + argument's declared class. */ + +static int +dynamic_cast_check_2 (struct type *desired_type, + const bfd_byte *contents, + CORE_ADDR address, + struct type *search_type, + struct value **result) +{ + int i, result_count = 0; + + for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) + { + int offset; + + if (! BASETYPE_VIA_PUBLIC (search_type, i)) + continue; + + offset = baseclass_offset (search_type, i, contents, address); + if (offset == -1) + error (_("virtual baseclass botch")); + if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i))) + { + ++result_count; + if (*result == NULL) + *result = value_at_lazy (TYPE_BASECLASS (search_type, i), + address + offset); + } + else + result_count += dynamic_cast_check_2 (desired_type, + contents + offset, + address + offset, + TYPE_BASECLASS (search_type, i), + result); + } + + return result_count; +} + +/* The C++ dynamic_cast operator. */ + +struct value * +value_dynamic_cast (struct type *type, struct value *arg) +{ + int unambiguous = 0, full, top, using_enc; + struct type *resolved_type = check_typedef (type); + struct type *arg_type = check_typedef (value_type (arg)); + struct type *class_type, *rtti_type; + struct value *result, *tem, *original_arg = arg; + CORE_ADDR addr; + int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF; + + if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR + && TYPE_CODE (resolved_type) != TYPE_CODE_REF) + error (_("Argument to dynamic_cast must be a pointer or reference type")); + if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID + && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_CLASS) + error (_("Argument to dynamic_cast must be pointer to class or `void *'")); + + class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type)); + if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) + { + if (TYPE_CODE (arg_type) != TYPE_CODE_PTR + && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT + && value_as_long (arg) == 0)) + error (_("Argument to dynamic_cast does not have pointer type")); + if (TYPE_CODE (arg_type) == TYPE_CODE_PTR) + { + arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type)); + if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS) + error (_("Argument to dynamic_cast does not have pointer to class type")); + } + + /* Handle NULL pointers. */ + if (value_as_long (arg) == 0) + return value_zero (type, not_lval); + + arg = value_ind (arg); + } + else + { + if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS) + error (_("Argument to dynamic_cast does not have class type")); + } + + /* If the classes are the same, just return the argument. */ + if (class_types_same_p (class_type, arg_type)) + return value_cast (type, arg); + + /* If the target type is a unique base class of the argument's + declared type, just cast it. */ + if (is_ancestor (class_type, arg_type)) + { + if (is_unique_ancestor (class_type, arg)) + return value_cast (type, original_arg); + error (_("Ambiguous dynamic_cast")); + } + + rtti_type = value_rtti_type (arg, &full, &top, &using_enc); + if (! rtti_type) + error (_("Couldn't determine value's most derived type for dynamic_cast")); + + /* Compute the most derived object's address. */ + addr = value_address (arg); + if (full) + { + /* Done. */ + } + else if (using_enc) + addr += top; + else + addr += top + value_embedded_offset (arg); + + /* dynamic_cast means to return a pointer to the + most-derived object. */ + if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR + && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID) + return value_at_lazy (type, addr); + + tem = value_at (type, addr); + + /* The first dynamic check specified in 5.2.7. */ + if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type))) + { + if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type))) + return tem; + result = NULL; + if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type), + value_contents (tem), value_address (tem), + rtti_type, addr, + arg_type, + &result) == 1) + return value_cast (type, + is_ref ? value_ref (result) : value_addr (result)); + } + + /* The second dynamic check specified in 5.2.7. */ + result = NULL; + if (is_public_ancestor (arg_type, rtti_type) + && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type), + value_contents (tem), value_address (tem), + rtti_type, &result) == 1) + return value_cast (type, + is_ref ? value_ref (result) : value_addr (result)); + + if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR) + return value_zero (type, not_lval); + + error (_("dynamic_cast failed")); +} + /* Create a value of type TYPE that is zero, and return it. */ struct value * @@ -540,15 +819,13 @@ struct value * value_one (struct type *type, enum lval_type lv) { struct type *type1 = check_typedef (type); - struct value *val = NULL; /* avoid -Wall warning */ + struct value *val; if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT) { - struct value *int_one = value_from_longest (builtin_type_int32, 1); - struct value *val; + enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); gdb_byte v[16]; - - decimal_from_integral (int_one, v, TYPE_LENGTH (builtin_type_int32)); + decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1"); val = value_from_decfloat (type, v); } else if (TYPE_CODE (type1) == TYPE_CODE_FLT) @@ -568,6 +845,32 @@ value_one (struct type *type, enum lval_type lv) return val; } +/* Helper function for value_at, value_at_lazy, and value_at_lazy_stack. */ + +static struct value * +get_value_at (struct type *type, CORE_ADDR addr, int lazy) +{ + struct value *val; + + if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) + error (_("Attempt to dereference a generic pointer.")); + + if (lazy) + { + val = allocate_value_lazy (type); + } + else + { + val = allocate_value (type); + read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type)); + } + + VALUE_LVAL (val) = lval_memory; + set_value_address (val, addr); + + return val; +} + /* Return a value with type TYPE located at ADDR. Call value_at only if the data needs to be fetched immediately; @@ -583,19 +886,7 @@ value_one (struct type *type, enum lval_type lv) struct value * value_at (struct type *type, CORE_ADDR addr) { - struct value *val; - - if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) - error (_("Attempt to dereference a generic pointer.")); - - val = allocate_value (type); - - read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type)); - - VALUE_LVAL (val) = lval_memory; - VALUE_ADDRESS (val) = addr; - - return val; + return get_value_at (type, addr, 0); } /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */ @@ -603,17 +894,7 @@ value_at (struct type *type, CORE_ADDR addr) struct value * value_at_lazy (struct type *type, CORE_ADDR addr) { - struct value *val; - - if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) - error (_("Attempt to dereference a generic pointer.")); - - val = allocate_value_lazy (type); - - VALUE_LVAL (val) = lval_memory; - VALUE_ADDRESS (val) = addr; - - return val; + return get_value_at (type, addr, 1); } /* Called only from the value_contents and value_contents_all() @@ -635,13 +916,36 @@ value_fetch_lazy (struct value *val) { gdb_assert (value_lazy (val)); allocate_value_contents (val); - if (VALUE_LVAL (val) == lval_memory) + if (value_bitsize (val)) { - CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val); + /* To read a lazy bitfield, read the entire enclosing value. This + prevents reading the same block of (possibly volatile) memory once + per bitfield. It would be even better to read only the containing + 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 = unpack_bits_as_long (value_type (val), + value_contents (parent) + offset, + value_bitpos (val), + value_bitsize (val)); + int length = TYPE_LENGTH (type); + store_signed_integer (value_contents_raw (val), length, byte_order, num); + } + else if (VALUE_LVAL (val) == lval_memory) + { + CORE_ADDR addr = value_address (val); int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val))); if (length) - read_memory (addr, value_contents_all_raw (val), length); + { + if (value_stack (val)) + read_stack (addr, value_contents_all_raw (val), length); + else + read_memory (addr, value_contents_all_raw (val), length); + } } else if (VALUE_LVAL (val) == lval_register) { @@ -708,8 +1012,9 @@ value_fetch_lazy (struct value *val) fprintf_unfiltered (gdb_stdlog, " register=%d", VALUE_REGNUM (new_val)); else if (VALUE_LVAL (new_val) == lval_memory) - fprintf_unfiltered (gdb_stdlog, " address=0x%s", - paddr_nz (VALUE_ADDRESS (new_val))); + fprintf_unfiltered (gdb_stdlog, " address=%s", + paddress (gdbarch, + value_address (new_val))); else fprintf_unfiltered (gdb_stdlog, " computed"); @@ -727,6 +1032,8 @@ value_fetch_lazy (struct value *val) watchpoints from trying to watch the saved frame pointer. */ value_free_to_mark (mark); } + else if (VALUE_LVAL (val) == lval_computed) + value_computed_funcs (val)->read (val); else internal_error (__FILE__, __LINE__, "Unexpected lazy value type."); @@ -775,7 +1082,7 @@ value_assign (struct value *toval, struct value *fromval) { case lval_internalvar: set_internalvar (VALUE_INTERNALVAR (toval), fromval); - val = value_copy (VALUE_INTERNALVAR (toval)->value); + val = value_copy (fromval); val = value_change_enclosing_type (val, value_enclosing_type (fromval)); set_value_embedded_offset (val, value_embedded_offset (fromval)); @@ -800,40 +1107,49 @@ value_assign (struct value *toval, struct value *fromval) if (value_bitsize (toval)) { - /* We assume that the argument to read_memory is in units - of host chars. FIXME: Is that correct? */ + struct value *parent = value_parent (toval); + changed_addr = value_address (parent) + value_offset (toval); + changed_len = (value_bitpos (toval) + value_bitsize (toval) + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; + /* If we can read-modify-write exactly the size of the + containing type (e.g. short or int) then do so. This + is safer for volatile bitfields mapped to hardware + registers. */ + if (changed_len < TYPE_LENGTH (type) + && TYPE_LENGTH (type) <= (int) sizeof (LONGEST) + && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0) + changed_len = TYPE_LENGTH (type); + if (changed_len > (int) sizeof (LONGEST)) error (_("Can't handle bitfields which don't fit in a %d bit word."), (int) sizeof (LONGEST) * HOST_CHAR_BIT); - read_memory (VALUE_ADDRESS (toval) + value_offset (toval), - buffer, changed_len); - modify_field (buffer, value_as_long (fromval), + read_memory (changed_addr, buffer, changed_len); + modify_field (type, buffer, value_as_long (fromval), value_bitpos (toval), value_bitsize (toval)); - changed_addr = VALUE_ADDRESS (toval) + value_offset (toval); dest_buffer = buffer; } else { - changed_addr = VALUE_ADDRESS (toval) + value_offset (toval); + changed_addr = value_address (toval); changed_len = TYPE_LENGTH (type); dest_buffer = value_contents (fromval); } write_memory (changed_addr, dest_buffer, changed_len); - if (deprecated_memory_changed_hook) - deprecated_memory_changed_hook (changed_addr, changed_len); + observer_notify_memory_changed (changed_addr, changed_len, + dest_buffer); } break; case lval_register: { struct frame_info *frame; + struct gdbarch *gdbarch; int value_reg; /* Figure out which frame this is in currently. */ @@ -842,14 +1158,14 @@ value_assign (struct value *toval, struct value *fromval) if (!frame) error (_("Value being assigned to is no longer active.")); - - if (gdbarch_convert_register_p - (current_gdbarch, VALUE_REGNUM (toval), type)) + + gdbarch = get_frame_arch (frame); + if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), type)) { /* If TOVAL is a special machine register requiring conversion of program values to a special raw format. */ - gdbarch_value_to_register (current_gdbarch, frame, + gdbarch_value_to_register (gdbarch, frame, VALUE_REGNUM (toval), type, value_contents (fromval)); } @@ -857,6 +1173,8 @@ value_assign (struct value *toval, struct value *fromval) { if (value_bitsize (toval)) { + struct value *parent = value_parent (toval); + int offset = value_offset (parent) + value_offset (toval); int changed_len; gdb_byte buffer[sizeof (LONGEST)]; @@ -869,16 +1187,13 @@ value_assign (struct value *toval, struct value *fromval) error (_("Can't handle bitfields which don't fit in a %d bit word."), (int) sizeof (LONGEST) * HOST_CHAR_BIT); - get_frame_register_bytes (frame, value_reg, - value_offset (toval), + get_frame_register_bytes (frame, value_reg, offset, changed_len, buffer); - modify_field (buffer, value_as_long (fromval), - value_bitpos (toval), - value_bitsize (toval)); + modify_field (type, buffer, value_as_long (fromval), + value_bitpos (toval), value_bitsize (toval)); - put_frame_register_bytes (frame, value_reg, - value_offset (toval), + put_frame_register_bytes (frame, value_reg, offset, changed_len, buffer); } else @@ -895,7 +1210,15 @@ value_assign (struct value *toval, struct value *fromval) observer_notify_target_changed (¤t_target); break; } - + + case lval_computed: + { + struct lval_funcs *funcs = value_computed_funcs (toval); + + funcs->write (toval, fromval); + } + break; + default: error (_("Left operand of assignment is not an lvalue.")); } @@ -975,11 +1298,11 @@ value_repeat (struct value *arg1, int count) val = allocate_repeat_value (value_enclosing_type (arg1), count); - read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1), + read_memory (value_address (arg1), value_contents_all_raw (val), TYPE_LENGTH (value_enclosing_type (val))); VALUE_LVAL (val) = lval_memory; - VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1); + set_value_address (val, value_address (arg1)); return val; } @@ -999,7 +1322,7 @@ value_of_variable (struct symbol *var, struct block *b) frame = block_innermost_frame (b); if (!frame) { - if (BLOCK_FUNCTION (b) + if (BLOCK_FUNCTION (b) && !block_inlined_p (b) && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))) error (_("No frame is currently executing in block %s."), SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))); @@ -1029,7 +1352,7 @@ address_of_variable (struct symbol *var, struct block *b) if ((VALUE_LVAL (val) == lval_memory && value_lazy (val)) || TYPE_CODE (type) == TYPE_CODE_FUNC) { - CORE_ADDR addr = VALUE_ADDRESS (val); + CORE_ADDR addr = value_address (val); return value_from_pointer (lookup_pointer_type (type), addr); } @@ -1145,7 +1468,7 @@ value_coerce_array (struct value *arg1) error (_("Attempt to take address of value not located in memory.")); return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)), - (VALUE_ADDRESS (arg1) + value_offset (arg1))); + value_address (arg1)); } /* Given a value which is a function, return a value which is a pointer @@ -1160,7 +1483,7 @@ value_coerce_function (struct value *arg1) error (_("Attempt to take address of value not located in memory.")); retval = value_from_pointer (lookup_pointer_type (value_type (arg1)), - (VALUE_ADDRESS (arg1) + value_offset (arg1))); + value_address (arg1)); return retval; } @@ -1195,8 +1518,7 @@ value_addr (struct value *arg1) /* Get target memory address */ arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)), - (VALUE_ADDRESS (arg1) - + value_offset (arg1) + (value_address (arg1) + value_embedded_offset (arg1))); /* This may be a pointer to a base subobject; so remember the @@ -1291,7 +1613,6 @@ value_array (int lowbound, int highbound, struct value **elemvec) int idx; unsigned int typelength; struct value *val; - struct type *rangetype; struct type *arraytype; CORE_ADDR addr; @@ -1312,12 +1633,8 @@ value_array (int lowbound, int highbound, struct value **elemvec) } } - rangetype = create_range_type ((struct type *) NULL, - builtin_type_int32, - lowbound, highbound); - arraytype = create_array_type ((struct type *) NULL, - value_enclosing_type (elemvec[0]), - rangetype); + arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]), + lowbound, highbound); if (!current_language->c_style_arrays) { @@ -1342,6 +1659,20 @@ value_array (int lowbound, int highbound, struct value **elemvec) return val; } +struct value * +value_cstring (char *ptr, int len, struct type *char_type) +{ + struct value *val; + int lowbound = current_language->string_lower_bound; + int highbound = len / TYPE_LENGTH (char_type); + struct type *stringtype + = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1); + + val = allocate_value (stringtype); + memcpy (value_contents_raw (val), ptr, len); + return val; +} + /* Create a value for a string constant by allocating space in the inferior, copying the data into that space, and returning the address with type TYPE_CODE_STRING. PTR points to the string @@ -1352,45 +1683,26 @@ value_array (int lowbound, int highbound, struct value **elemvec) string may contain embedded null bytes. */ struct value * -value_string (char *ptr, int len) +value_string (char *ptr, int len, struct type *char_type) { struct value *val; int lowbound = current_language->string_lower_bound; - struct type *rangetype = create_range_type ((struct type *) NULL, - builtin_type_int32, - lowbound, - len + lowbound - 1); + int highbound = len / TYPE_LENGTH (char_type); struct type *stringtype - = create_string_type ((struct type *) NULL, rangetype); - CORE_ADDR addr; - - if (current_language->c_style_arrays == 0) - { - val = allocate_value (stringtype); - memcpy (value_contents_raw (val), ptr, len); - return val; - } - - - /* Allocate space to store the string in the inferior, and then copy - LEN bytes from PTR in gdb to that address in the inferior. */ - - addr = allocate_space_in_inferior (len); - write_memory (addr, (gdb_byte *) ptr, len); + = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1); - val = value_at_lazy (stringtype, addr); - return (val); + val = allocate_value (stringtype); + memcpy (value_contents_raw (val), ptr, len); + return val; } struct value * -value_bitstring (char *ptr, int len) +value_bitstring (char *ptr, int len, struct type *index_type) { struct value *val; - struct type *domain_type = create_range_type (NULL, - builtin_type_int32, - 0, len - 1); - struct type *type = create_set_type ((struct type *) NULL, - domain_type); + struct type *domain_type + = create_range_type (NULL, index_type, 0, len - 1); + struct type *type = create_set_type (NULL, domain_type); TYPE_CODE (type) = TYPE_CODE_BITSTRING; val = allocate_value (type); memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type)); @@ -1494,13 +1806,14 @@ typecmp (int staticp, int varargs, int nargs, fields, look for a baseclass named NAME. */ static struct value * -search_struct_field (char *name, struct value *arg1, int offset, +search_struct_field (const char *name, struct value *arg1, int offset, struct type *type, int looking_for_baseclass) { int i; - int nbases = TYPE_N_BASECLASSES (type); + int nbases; CHECK_TYPEDEF (type); + nbases = TYPE_N_BASECLASSES (type); if (!looking_for_baseclass) for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) @@ -1590,8 +1903,9 @@ search_struct_field (char *name, struct value *arg1, int offset, boffset = baseclass_offset (type, i, value_contents (arg1) + offset, - VALUE_ADDRESS (arg1) - + value_offset (arg1) + offset); + value_address (arg1) + + value_embedded_offset (arg1) + + offset); if (boffset == -1) error (_("virtual baseclass botch")); @@ -1599,35 +1913,26 @@ search_struct_field (char *name, struct value *arg1, int offset, by the user program. Make sure that it still points to a valid memory location. */ - boffset += offset; - if (boffset < 0 || boffset >= TYPE_LENGTH (type)) + boffset += value_embedded_offset (arg1) + offset; + if (boffset < 0 + || boffset >= TYPE_LENGTH (value_enclosing_type (arg1))) { CORE_ADDR base_addr; v2 = allocate_value (basetype); - base_addr = - VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset; + base_addr = value_address (arg1) + boffset; if (target_read_memory (base_addr, value_contents_raw (v2), TYPE_LENGTH (basetype)) != 0) error (_("virtual baseclass botch")); VALUE_LVAL (v2) = lval_memory; - VALUE_ADDRESS (v2) = base_addr; + set_value_address (v2, base_addr); } else { - if (VALUE_LVAL (arg1) == lval_memory && value_lazy (arg1)) - v2 = allocate_value_lazy (basetype); - else - { - v2 = allocate_value (basetype); - memcpy (value_contents_raw (v2), - value_contents_raw (arg1) + boffset, - TYPE_LENGTH (basetype)); - } - set_value_component_location (v2, arg1); - VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1); - set_value_offset (v2, value_offset (arg1) + boffset); + v2 = value_copy (arg1); + deprecated_set_value_type (v2, basetype); + set_value_embedded_offset (v2, boffset); } if (found_baseclass) @@ -1658,7 +1963,7 @@ search_struct_field (char *name, struct value *arg1, int offset, (value) -1, else return NULL. */ static struct value * -search_struct_method (char *name, struct value **arg1p, +search_struct_method (const char *name, struct value **arg1p, struct value **args, int offset, int *static_memfuncp, struct type *type) { @@ -1735,8 +2040,7 @@ search_struct_method (char *name, struct value **arg1p, if (offset < 0 || offset >= TYPE_LENGTH (type)) { gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass)); - if (target_read_memory (VALUE_ADDRESS (*arg1p) - + value_offset (*arg1p) + offset, + if (target_read_memory (value_address (*arg1p) + offset, tmp, TYPE_LENGTH (baseclass)) != 0) error (_("virtual baseclass botch")); base_valaddr = tmp; @@ -1745,8 +2049,7 @@ search_struct_method (char *name, struct value **arg1p, base_valaddr = value_contents (*arg1p) + offset; base_offset = baseclass_offset (type, i, base_valaddr, - VALUE_ADDRESS (*arg1p) - + value_offset (*arg1p) + offset); + value_address (*arg1p) + offset); if (base_offset == -1) error (_("virtual baseclass botch")); } @@ -1790,7 +2093,7 @@ search_struct_method (char *name, struct value **arg1p, struct value * value_struct_elt (struct value **argp, struct value **args, - char *name, int *static_memfuncp, char *err) + const char *name, int *static_memfuncp, const char *err) { struct type *t; struct value *v; @@ -1830,10 +2133,6 @@ value_struct_elt (struct value **argp, struct value **args, /* C++: If it was not found as a data field, then try to return it as a pointer to a method. */ - - if (destructor_name_p (name, t)) - error (_("Cannot get value of destructor")); - v = search_struct_method (name, argp, args, 0, static_memfuncp, t); @@ -1849,32 +2148,6 @@ value_struct_elt (struct value **argp, struct value **args, return v; } - if (destructor_name_p (name, t)) - { - if (!args[1]) - { - /* Destructors are a special case. */ - int m_index, f_index; - - v = NULL; - if (get_destructor_fn_field (t, &m_index, &f_index)) - { - v = value_fn_field (NULL, - TYPE_FN_FIELDLIST1 (t, m_index), - f_index, NULL, 0); - } - if (v == NULL) - error (_("could not find destructor function named %s."), - name); - else - return v; - } - else - { - error (_("destructor should not have any argument")); - } - } - else v = search_struct_method (name, argp, args, 0, static_memfuncp, t); @@ -1915,7 +2188,7 @@ value_struct_elt (struct value **argp, struct value **args, */ static struct fn_field * -find_method_list (struct value **argp, char *method, +find_method_list (struct value **argp, const char *method, int offset, struct type *type, int *num_fns, struct type **basetype, int *boffset) { @@ -1955,7 +2228,7 @@ find_method_list (struct value **argp, char *method, base_offset = value_offset (*argp) + offset; base_offset = baseclass_offset (type, i, value_contents (*argp) + base_offset, - VALUE_ADDRESS (*argp) + base_offset); + value_address (*argp) + base_offset); if (base_offset == -1) error (_("virtual baseclass botch")); } @@ -1985,7 +2258,7 @@ find_method_list (struct value **argp, char *method, */ struct fn_field * -value_find_oload_method_list (struct value **argp, char *method, +value_find_oload_method_list (struct value **argp, const char *method, int offset, int *num_fns, struct type **basetype, int *boffset) { @@ -2042,7 +2315,7 @@ value_find_oload_method_list (struct value **argp, char *method, int find_overload_match (struct type **arg_types, int nargs, - char *name, int method, int lax, + const char *name, int method, int lax, struct value **objp, struct symbol *fsym, struct value **valp, struct symbol **symp, int *staticp) @@ -2480,8 +2753,6 @@ classify_oload_match (struct badness_vector *oload_champ_bv, int destructor_name_p (const char *name, const struct type *type) { - /* Destructors are a special case. */ - if (name[0] == '~') { char *dname = type_name_no_tag (type); @@ -2510,6 +2781,9 @@ check_field (struct type *type, const char *name) { int i; + /* The type may be a stub. */ + CHECK_TYPEDEF (type); + for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) { char *t_field_name = TYPE_FIELD_NAME (type, i); @@ -2520,14 +2794,6 @@ check_field (struct type *type, const char *name) /* C++: If it was not found as a data field, then try to return it as a pointer to a method. */ - /* Destructors are a special case. */ - if (destructor_name_p (name, type)) - { - int m_index, f_index; - - return get_destructor_fn_field (type, &m_index, &f_index); - } - for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i) { if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0) @@ -2548,8 +2814,8 @@ check_field (struct type *type, const char *name) the comment before value_struct_elt_for_reference. */ struct value * -value_aggregate_elt (struct type *curtype, - char *name, int want_address, +value_aggregate_elt (struct type *curtype, char *name, + struct type *expect_type, int want_address, enum noside noside) { switch (TYPE_CODE (curtype)) @@ -2557,7 +2823,7 @@ value_aggregate_elt (struct type *curtype, case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: return value_struct_elt_for_reference (curtype, 0, curtype, - name, NULL, + name, expect_type, want_address, noside); case TYPE_CODE_NAMESPACE: return value_namespace_elt (curtype, name, @@ -2568,6 +2834,57 @@ value_aggregate_elt (struct type *curtype, } } +/* Compares the two method/function types T1 and T2 for "equality" + with respect to the the methods' parameters. If the types of the + two parameter lists are the same, returns 1; 0 otherwise. This + comparison may ignore any artificial parameters in T1 if + SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip + the first artificial parameter in T1, assumed to be a 'this' pointer. + + The type T2 is expected to have come from make_params (in eval.c). */ + +static int +compare_parameters (struct type *t1, struct type *t2, int skip_artificial) +{ + int start = 0; + + if (TYPE_FIELD_ARTIFICIAL (t1, 0)) + ++start; + + /* If skipping artificial fields, find the first real field + in T1. */ + if (skip_artificial) + { + while (start < TYPE_NFIELDS (t1) + && TYPE_FIELD_ARTIFICIAL (t1, start)) + ++start; + } + + /* Now compare parameters */ + + /* Special case: a method taking void. T1 will contain no + non-artificial fields, and T2 will contain TYPE_CODE_VOID. */ + if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1 + && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID) + return 1; + + if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2)) + { + int i; + for (i = 0; i < TYPE_NFIELDS (t2); ++i) + { + if (rank_one_type (TYPE_FIELD_TYPE (t1, start + i), + TYPE_FIELD_TYPE (t2, i)) + != 0) + return 0; + } + + return 1; + } + + return 0; +} + /* C++: Given an aggregate type CURTYPE, and a member name NAME, return the address of this member as a "pointer to member" type. If INTYPE is non-null, then it will be the type of the member we @@ -2623,12 +2940,6 @@ value_struct_elt_for_reference (struct type *domain, int offset, /* C++: If it was not found as a data field, then try to return it as a pointer to a method. */ - /* Destructors are a special case. */ - if (destructor_name_p (name, t)) - { - error (_("member pointers to destructors not implemented yet")); - } - /* Perform all necessary dereferencing. */ while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR) intype = TYPE_TARGET_TYPE (intype); @@ -2651,23 +2962,48 @@ value_struct_elt_for_reference (struct type *domain, int offset, } if (t_field_name && strcmp (t_field_name, name) == 0) { - int j = TYPE_FN_FIELDLIST_LENGTH (t, i); + int j; + int len = TYPE_FN_FIELDLIST_LENGTH (t, i); struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i); check_stub_method_group (t, i); - if (intype == 0 && j > 1) - error (_("non-unique member `%s' requires type instantiation"), name); if (intype) { - while (j--) - if (TYPE_FN_FIELD_TYPE (f, j) == intype) - break; - if (j < 0) + for (j = 0; j < len; ++j) + { + if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0) + || compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 1)) + break; + } + + if (j == len) error (_("no member function matches that type instantiation")); } else - j = 0; + { + int ii; + + j = -1; + for (ii = 0; ii < TYPE_FN_FIELDLIST_LENGTH (t, i); + ++ii) + { + /* Skip artificial methods. This is necessary if, + for example, the user wants to "print + subclass::subclass" with only one user-defined + constructor. There is no ambiguity in this + case. */ + if (TYPE_FN_FIELD_ARTIFICIAL (f, ii)) + continue; + + /* Desired method is ambiguous if more than one + method is defined. */ + if (j != -1) + error (_("non-unique member `%s' requires type instantiation"), name); + + j = ii; + } + } if (TYPE_FN_FIELD_STATIC_P (f, j)) { @@ -2715,7 +3051,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); cplus_make_method_ptr (value_type (result), value_contents_writeable (result), - VALUE_ADDRESS (v), 0); + value_address (v), 0); } } return result; @@ -2783,7 +3119,7 @@ value_maybe_namespace_elt (const struct type *curtype, sym = cp_lookup_symbol_namespace (namespace_name, name, NULL, get_selected_block (0), - VAR_DOMAIN); + VAR_DOMAIN, 1); if (sym == NULL) return NULL; @@ -2874,7 +3210,7 @@ value_full_object (struct value *argp, /* Go back by the computed top_offset from the beginning of the object, adjusting for the embedded offset of argp if that's what value_rtti_type used for its computation. */ - new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top + + new_val = value_at_lazy (real_type, value_address (argp) - top + (using_enc ? 0 : value_embedded_offset (argp))); deprecated_set_value_type (new_val, value_type (argp)); set_value_embedded_offset (new_val, (using_enc @@ -3004,7 +3340,7 @@ value_slice (struct value *array, int lowbound, int length) else if (element > 0) { int j = i % TARGET_CHAR_BIT; - if (gdbarch_bits_big_endian (current_gdbarch)) + if (gdbarch_bits_big_endian (get_type_arch (array_type))) j = TARGET_CHAR_BIT - 1 - j; value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j); }