diff options
-rw-r--r-- | gdb/ChangeLog | 34 | ||||
-rw-r--r-- | gdb/c-valprint.c | 4 | ||||
-rw-r--r-- | gdb/cp-abi.c | 9 | ||||
-rw-r--r-- | gdb/cp-abi.h | 21 | ||||
-rw-r--r-- | gdb/cp-valprint.c | 6 | ||||
-rw-r--r-- | gdb/gdbtypes.c | 2 | ||||
-rw-r--r-- | gdb/gnu-v3-abi.c | 143 | ||||
-rw-r--r-- | gdb/valops.c | 8 |
8 files changed, 152 insertions, 75 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d39d45b9254..ebe69986e96 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,39 @@ 2008-09-11 Ulrich Weigand <uweigand@de.ibm.com> + * cp-abi.h (cplus_method_ptr_size): Add TO_TYPE parameter. + (cplus_make_method_ptr): Add TYPE parameter. + * cp-abi.c (cplus_method_ptr_size): Add TO_TYPE parameter. Pass it + on to current_cp_abi.method_ptr_size callback. + (cplus_make_method_ptr): Add TYPE parameter. Pass it on to + current_cp_abi.make_method_ptr callback. + + * gdbtypes.c (lookup_methodptr_type): Pass target type + argument to cplus_method_ptr_size. + * valops.c (value_cast): Pass type argument to cplus_make_method_ptr. + (value_struct_elt_for_reference): Likewise. + + * gnu-v3-abi.c (get_class_arch): New function. + (vtable_address_point_offset): Add GDBARCH parameter. Use it + instead of current_gdbarch. Update all callers. + (gnuv3_get_vtable): Likewise. + (gnuv3_get_virtual_fn): Likewise. + (gnuv3_decode_method_ptr): Likewise. + (gnuv3_rtti_type): Call get_class_arch to determine architecture. + Use it instead of current_gdbarch. + (gnuv3_virtual_fn_field): Likewise. + (gnuv3_baseclass_offset): Likewise. + (gnuv3_print_method_ptr): Likewise. + (gnuv3_method_ptr_to_value): Likewise. + (gnuv3_method_ptr_size): Add TYPE parameter. Use it to determine + class architecture. Use architecture types instead of builtin types. + (gnuv3_make_method_ptr): Likewise. + + * cp-valprint.c (cp_print_class_member): Expect pointer type + instead of class type. Use its length when extracting value. + * c-valprint.c (c_val_print): Update call to cp_print_class_member. + +2008-09-11 Ulrich Weigand <uweigand@de.ibm.com> + * stack.c (return_command): Use frame architecture to determine default integer return type. diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index 9d8b439065d..1dff6cbcf14 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -189,9 +189,7 @@ c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream); break; } - cp_print_class_member (valaddr + embedded_offset, - TYPE_DOMAIN_TYPE (type), - stream, "&"); + cp_print_class_member (valaddr + embedded_offset, type, stream, "&"); break; case TYPE_CODE_METHODPTR: diff --git a/gdb/cp-abi.c b/gdb/cp-abi.c index 250f64b35e4..b87072ac74f 100644 --- a/gdb/cp-abi.c +++ b/gdb/cp-abi.c @@ -113,19 +113,20 @@ cplus_print_method_ptr (const gdb_byte *contents, struct type *type, } int -cplus_method_ptr_size (void) +cplus_method_ptr_size (struct type *to_type) { if (current_cp_abi.method_ptr_size == NULL) error (_("GDB does not support pointers to methods on this target")); - return (*current_cp_abi.method_ptr_size) (); + return (*current_cp_abi.method_ptr_size) (to_type); } void -cplus_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual) +cplus_make_method_ptr (struct type *type, gdb_byte *contents, + CORE_ADDR value, int is_virtual) { if (current_cp_abi.make_method_ptr == NULL) error (_("GDB does not support pointers to methods on this target")); - (*current_cp_abi.make_method_ptr) (contents, value, is_virtual); + (*current_cp_abi.make_method_ptr) (type, contents, value, is_virtual); } CORE_ADDR diff --git a/gdb/cp-abi.h b/gdb/cp-abi.h index 18b5201645f..47d6dc841e4 100644 --- a/gdb/cp-abi.h +++ b/gdb/cp-abi.h @@ -151,21 +151,20 @@ extern int baseclass_offset (struct type *type, int index, void cplus_print_method_ptr (const gdb_byte *contents, struct type *type, struct ui_file *stream); -/* Return the size of a pointer to member function for the current - architecture. */ -int cplus_method_ptr_size (void); +/* Return the size of a pointer to member function of type TO_TYPE. */ +int cplus_method_ptr_size (struct type *to_type); /* Return the method which should be called by applying METHOD_PTR to *THIS_P, and adjust *THIS_P if necessary. */ struct value *cplus_method_ptr_to_value (struct value **this_p, struct value *method_ptr); -/* Create the byte pattern in CONTENTS representing a pointer to - member function at ADDRESS (if IS_VIRTUAL is 0) or with virtual - table offset ADDRESS (if IS_VIRTUAL is 1). This is the opposite - of cplus_method_ptr_to_value. */ -void cplus_make_method_ptr (gdb_byte *CONTENTS, CORE_ADDR address, - int is_virtual); +/* Create the byte pattern in CONTENTS representing a pointer of + type TYPE to member function at ADDRESS (if IS_VIRTUAL is 0) + or with virtual table offset ADDRESS (if IS_VIRTUAL is 1). + This is the opposite of cplus_method_ptr_to_value. */ +void cplus_make_method_ptr (struct type *type, gdb_byte *CONTENTS, + CORE_ADDR address, int is_virtual); /* Determine if we are currently in a C++ thunk. If so, get the address of the routine we are thunking to and continue to there instead. */ @@ -195,8 +194,8 @@ struct cp_abi_ops const bfd_byte *valaddr, CORE_ADDR address); void (*print_method_ptr) (const gdb_byte *contents, struct type *type, struct ui_file *stream); - int (*method_ptr_size) (void); - void (*make_method_ptr) (gdb_byte *, CORE_ADDR, int); + int (*method_ptr_size) (struct type *); + void (*make_method_ptr) (struct type *, gdb_byte *, CORE_ADDR, int); struct value * (*method_ptr_to_value) (struct value **, struct value *); CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR); int (*pass_by_reference) (struct type *type); diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c index 85f673dc808..4d9131921ad 100644 --- a/gdb/cp-valprint.c +++ b/gdb/cp-valprint.c @@ -538,16 +538,16 @@ cp_find_class_member (struct type **domain_p, int *fieldno, } void -cp_print_class_member (const gdb_byte *valaddr, struct type *domain, +cp_print_class_member (const gdb_byte *valaddr, struct type *type, struct ui_file *stream, char *prefix) { /* VAL is a byte offset into the structure type DOMAIN. Find the name of the field for that offset and print it. */ + struct type *domain = TYPE_DOMAIN_TYPE (type); + LONGEST val = extract_signed_integer (valaddr, TYPE_LENGTH (type)); unsigned int fieldno; - LONGEST val = unpack_long (builtin_type_long, valaddr); - /* Pointers to data members are usually byte offsets into an object. Because a data member can have offset zero, and a NULL pointer to member must be distinct from any valid non-NULL pointer to diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index c21d9030049..c1bb76528b6 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -663,7 +663,7 @@ lookup_methodptr_type (struct type *to_type) mtype = alloc_type (TYPE_OBJFILE (to_type)); TYPE_TARGET_TYPE (mtype) = to_type; TYPE_DOMAIN_TYPE (mtype) = TYPE_DOMAIN_TYPE (to_type); - TYPE_LENGTH (mtype) = cplus_method_ptr_size (); + TYPE_LENGTH (mtype) = cplus_method_ptr_size (to_type); TYPE_CODE (mtype) = TYPE_CODE_METHODPTR; return mtype; } diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c index 1ae6d9a079e..c2c348a6103 100644 --- a/gdb/gnu-v3-abi.c +++ b/gdb/gnu-v3-abi.c @@ -45,6 +45,21 @@ gnuv3_is_operator_name (const char *name) } +/* Determine architecture of class DOMAIN. This architecture is used + to query C++ ABI details (types, method pointer layout, etc.). + + Note that we assume DOMAIN must have been allocated with an OBJFILE; + GDB does not provide any built-in class types. Thus we use the + architecture of that OBJFILE to define the C++ ABI. */ + +static struct gdbarch * +get_class_arch (struct type *domain) +{ + gdb_assert (TYPE_CODE (domain) == TYPE_CODE_CLASS); + gdb_assert (TYPE_OBJFILE (domain) != NULL); + return get_objfile_arch (TYPE_OBJFILE (domain)); +} + /* To help us find the components of a vtable, we build ourselves a GDB type object representing the vtable structure. Following the V3 ABI, it goes something like this: @@ -176,10 +191,9 @@ build_gdb_vtable_type (struct gdbarch *arch) gdb_gnu_v3_abi_vtable' object to the vtable's "address point" (i.e., where objects' virtual table pointers point). */ static int -vtable_address_point_offset (void) +vtable_address_point_offset (struct gdbarch *gdbarch) { - struct type *vtable_type = gdbarch_data (current_gdbarch, - vtable_type_gdbarch_data); + struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions) / TARGET_CHAR_BIT); @@ -190,8 +204,8 @@ static struct type * gnuv3_rtti_type (struct value *value, int *full_p, int *top_p, int *using_enc_p) { - struct type *vtable_type = gdbarch_data (current_gdbarch, - vtable_type_gdbarch_data); + struct gdbarch *gdbarch; + struct type *vtable_type; struct type *values_type = check_typedef (value_type (value)); CORE_ADDR vtable_address; struct value *vtable; @@ -208,6 +222,16 @@ gnuv3_rtti_type (struct value *value, if (TYPE_CODE (values_type) != TYPE_CODE_CLASS) return NULL; + /* This routine may be called for Java types that do not have + a proper objfile. Just return NULL for those. */ + if (!TYPE_OBJFILE (values_type) + || !TYPE_OBJFILE (values_type)->obfd) + return NULL; + + /* Determine architecture. */ + gdbarch = get_class_arch (values_type); + vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); + /* If we can't find the virtual table pointer for values_type, we can't find the RTTI. */ values_type_vptr_fieldno = get_vptr_fieldno (values_type, @@ -229,8 +253,9 @@ gnuv3_rtti_type (struct value *value, } vtable_address = value_as_address (value_field (value, values_type_vptr_fieldno)); - vtable = value_at_lazy (vtable_type, - vtable_address - vtable_address_point_offset ()); + vtable + = value_at_lazy (vtable_type, + vtable_address - vtable_address_point_offset (gdbarch)); /* Find the linker symbol for this vtable. */ vtable_symbol @@ -282,10 +307,9 @@ gnuv3_rtti_type (struct value *value, vtable type for this architecture. */ static struct value * -gnuv3_get_vtable (struct value *container) +gnuv3_get_vtable (struct gdbarch *gdbarch, struct value *container) { - struct type *vtable_type = gdbarch_data (current_gdbarch, - vtable_type_gdbarch_data); + struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); struct type *vtable_pointer_type; struct value *vtable_pointer; CORE_ADDR vtable_pointer_address, vtable_address; @@ -311,17 +335,17 @@ gnuv3_get_vtable (struct value *container) /* Correct it to point at the start of the virtual table, rather than the address point. */ return value_at_lazy (vtable_type, - vtable_address - vtable_address_point_offset ()); + vtable_address - vtable_address_point_offset (gdbarch)); } /* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual function, of type FNTYPE. */ static struct value * -gnuv3_get_virtual_fn (struct value *container, struct type *fntype, - int vtable_index) +gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container, + struct type *fntype, int vtable_index) { - struct value *vtable = gnuv3_get_vtable (container); + struct value *vtable = gnuv3_get_vtable (gdbarch, container); struct value *vfn; /* Fetch the appropriate function pointer from the vtable. */ @@ -333,7 +357,7 @@ gnuv3_get_virtual_fn (struct value *container, struct type *fntype, (i.e. points to the descriptor). We don't need to scale the index by the size of a function descriptor; GCC does that before outputing debug information. */ - if (gdbarch_vtable_function_descriptors (current_gdbarch)) + if (gdbarch_vtable_function_descriptors (gdbarch)) vfn = value_addr (vfn); /* Cast the function pointer to the appropriate type. */ @@ -351,18 +375,22 @@ gnuv3_virtual_fn_field (struct value **value_p, struct type *vfn_base, int offset) { struct type *values_type = check_typedef (value_type (*value_p)); + struct gdbarch *gdbarch; /* Some simple sanity checks. */ if (TYPE_CODE (values_type) != TYPE_CODE_CLASS) error (_("Only classes can have virtual functions.")); + /* Determine architecture. */ + gdbarch = get_class_arch (values_type); + /* Cast our value to the base class which defines this virtual function. This takes care of any necessary `this' adjustments. */ if (vfn_base != values_type) *value_p = value_cast (vfn_base, *value_p); - return gnuv3_get_virtual_fn (*value_p, TYPE_FN_FIELD_TYPE (f, j), + return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j), TYPE_FN_FIELD_VOFFSET (f, j)); } @@ -377,8 +405,9 @@ static int gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr, CORE_ADDR address) { - struct type *vtable_type = gdbarch_data (current_gdbarch, - vtable_type_gdbarch_data); + struct gdbarch *gdbarch; + struct type *vtable_type; + struct type *ptr_type; struct value *vtable; struct type *vbasetype; struct value *offset_val, *vbase_array; @@ -386,6 +415,11 @@ gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr, long int cur_base_offset, base_offset; int vbasetype_vptr_fieldno; + /* Determine architecture. */ + gdbarch = get_class_arch (type); + vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data); + ptr_type = builtin_type (gdbarch)->builtin_data_ptr; + /* If it isn't a virtual base, this is easy. The offset is in the type definition. */ if (!BASETYPE_VIA_VIRTUAL (type, index)) @@ -397,14 +431,13 @@ gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr, complete inheritance graph based on the debug info. Neither is worthwhile. */ cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8; - if (cur_base_offset >= - vtable_address_point_offset ()) + if (cur_base_offset >= - vtable_address_point_offset (gdbarch)) error (_("Expected a negative vbase offset (old compiler?)")); - cur_base_offset = cur_base_offset + vtable_address_point_offset (); - if ((- cur_base_offset) % TYPE_LENGTH (builtin_type_void_data_ptr) != 0) + cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch); + if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0) error (_("Misaligned vbase offset.")); - cur_base_offset = cur_base_offset - / ((int) TYPE_LENGTH (builtin_type_void_data_ptr)); + cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type)); /* We're now looking for the cur_base_offset'th entry (negative index) in the vcall_and_vbase_offsets array. We used to cast the object to @@ -425,11 +458,11 @@ gnuv3_baseclass_offset (struct type *type, int index, const bfd_byte *valaddr, error (_("Illegal vptr offset in class %s"), TYPE_NAME (vbasetype) ? TYPE_NAME (vbasetype) : "<unknown>"); - vtable_address = value_as_address (value_at_lazy (builtin_type_void_data_ptr, - address)); - vtable = value_at_lazy (vtable_type, - vtable_address - vtable_address_point_offset ()); - offset_val = value_from_longest(builtin_type_int32, cur_base_offset); + vtable_address = value_as_address (value_at_lazy (ptr_type, address)); + vtable + = value_at_lazy (vtable_type, + vtable_address - vtable_address_point_offset (gdbarch)); + offset_val = value_from_longest (builtin_type_int32, cur_base_offset); vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets); base_offset = value_as_long (value_subscript (vbase_array, offset_val)); return base_offset; @@ -492,12 +525,13 @@ gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset, /* Decode GNU v3 method pointer. */ static int -gnuv3_decode_method_ptr (const gdb_byte *contents, +gnuv3_decode_method_ptr (struct gdbarch *gdbarch, + const gdb_byte *contents, CORE_ADDR *value_p, LONGEST *adjustment_p) { - struct type *funcptr_type = builtin_type_void_func_ptr; - struct type *offset_type = builtin_type_long; + struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr; + struct type *offset_type = builtin_type (gdbarch)->builtin_long; CORE_ADDR ptr_value; LONGEST voffset, adjustment; int vbit; @@ -513,7 +547,7 @@ gnuv3_decode_method_ptr (const gdb_byte *contents, contents += TYPE_LENGTH (funcptr_type); adjustment = extract_signed_integer (contents, TYPE_LENGTH (offset_type)); - if (!gdbarch_vbit_in_delta (current_gdbarch)) + if (!gdbarch_vbit_in_delta (gdbarch)) { vbit = voffset & 1; voffset = voffset ^ vbit; @@ -536,15 +570,14 @@ gnuv3_print_method_ptr (const gdb_byte *contents, struct type *type, struct ui_file *stream) { + struct type *domain = TYPE_DOMAIN_TYPE (type); + struct gdbarch *gdbarch = get_class_arch (domain); CORE_ADDR ptr_value; LONGEST adjustment; - struct type *domain; int vbit; - domain = TYPE_DOMAIN_TYPE (type); - /* Extract the pointer to member. */ - vbit = gnuv3_decode_method_ptr (contents, &ptr_value, &adjustment); + vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment); /* Check for NULL. */ if (ptr_value == 0 && vbit == 0) @@ -562,7 +595,7 @@ gnuv3_print_method_ptr (const gdb_byte *contents, /* It's a virtual table offset, maybe in this class. Search for a field with the correct vtable offset. First convert it to an index, as used in TYPE_FN_FIELD_VOFFSET. */ - voffset = ptr_value / TYPE_LENGTH (builtin_type_long); + voffset = ptr_value / TYPE_LENGTH (builtin_type (gdbarch)->builtin_long); physname = gnuv3_find_method_in (domain, voffset, adjustment); @@ -601,17 +634,22 @@ gnuv3_print_method_ptr (const gdb_byte *contents, /* GNU v3 implementation of cplus_method_ptr_size. */ static int -gnuv3_method_ptr_size (void) +gnuv3_method_ptr_size (struct type *type) { - return 2 * TYPE_LENGTH (builtin_type_void_data_ptr); + struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type)); + struct gdbarch *gdbarch = get_class_arch (domain_type); + return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr); } /* GNU v3 implementation of cplus_make_method_ptr. */ static void -gnuv3_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual) +gnuv3_make_method_ptr (struct type *type, gdb_byte *contents, + CORE_ADDR value, int is_virtual) { - int size = TYPE_LENGTH (builtin_type_void_data_ptr); + struct type *domain_type = check_typedef (TYPE_DOMAIN_TYPE (type)); + struct gdbarch *gdbarch = get_class_arch (domain_type); + int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr); /* FIXME drow/2006-12-24: The adjustment of "this" is currently always zero, since the method pointer is of the correct type. @@ -622,7 +660,7 @@ gnuv3_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual) support for adjusting pointers to members when casting them - not currently supported by GDB. */ - if (!gdbarch_vbit_in_delta (current_gdbarch)) + if (!gdbarch_vbit_in_delta (gdbarch)) { store_unsigned_integer (contents, size, value | is_virtual); store_unsigned_integer (contents + size, size, 0); @@ -639,20 +677,22 @@ gnuv3_make_method_ptr (gdb_byte *contents, CORE_ADDR value, int is_virtual) static struct value * gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr) { + struct gdbarch *gdbarch; const gdb_byte *contents = value_contents (method_ptr); CORE_ADDR ptr_value; - struct type *final_type, *method_type; + struct type *domain_type, *final_type, *method_type; LONGEST adjustment; struct value *adjval; int vbit; - final_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr))); - final_type = lookup_pointer_type (final_type); + domain_type = TYPE_DOMAIN_TYPE (check_typedef (value_type (method_ptr))); + final_type = lookup_pointer_type (domain_type); method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr))); /* Extract the pointer to member. */ - vbit = gnuv3_decode_method_ptr (contents, &ptr_value, &adjustment); + gdbarch = get_class_arch (domain_type); + vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment); /* First convert THIS to match the containing type of the pointer to member. This cast may adjust the value of THIS. */ @@ -673,15 +713,18 @@ gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr) You can provoke this case by casting a Base::* to a Derived::*, for instance. */ - *this_p = value_cast (builtin_type_void_data_ptr, *this_p); - adjval = value_from_longest (builtin_type_long, adjustment); + *this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p); + adjval = value_from_longest (builtin_type (gdbarch)->builtin_long, + adjustment); *this_p = value_ptradd (*this_p, adjval); *this_p = value_cast (final_type, *this_p); if (vbit) { - LONGEST voffset = ptr_value / TYPE_LENGTH (builtin_type_long); - return gnuv3_get_virtual_fn (value_ind (*this_p), method_type, voffset); + LONGEST voffset; + voffset = ptr_value / TYPE_LENGTH (builtin_type (gdbarch)->builtin_long); + return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p), + method_type, voffset); } else return value_from_pointer (lookup_pointer_type (method_type), ptr_value); diff --git a/gdb/valops.c b/gdb/valops.c index 48c24456305..1ab88ba57ad 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -473,7 +473,7 @@ value_cast (struct type *type, struct value *arg2) && value_as_long (arg2) == 0) { struct value *result = allocate_value (type); - cplus_make_method_ptr (value_contents_writeable (result), 0, 0); + cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0); return result; } else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT @@ -2618,7 +2618,8 @@ 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_contents_writeable (result), + cplus_make_method_ptr (value_type (result), + value_contents_writeable (result), TYPE_FN_FIELD_VOFFSET (f, j), 1); } else if (noside == EVAL_AVOID_SIDE_EFFECTS) @@ -2641,7 +2642,8 @@ value_struct_elt_for_reference (struct type *domain, int offset, else { result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); - cplus_make_method_ptr (value_contents_writeable (result), + cplus_make_method_ptr (value_type (result), + value_contents_writeable (result), VALUE_ADDRESS (v), 0); } } |