X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalues.c;h=760d2f894cd585dd2aa17c275540b0b625f0050c;hb=44f457706379d963e1a18c99a2d13c5636dd011d;hp=3f9e7bbb808eb30c736b4e8360f3bd7aa35e3886;hpb=119dfbb7c16c594e26b4745e5efaf836b48d8c1b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/values.c b/gdb/values.c index 3f9e7bbb80..760d2f894c 100644 --- a/gdb/values.c +++ b/gdb/values.c @@ -1,22 +1,23 @@ /* Low level packing and unpacking of values for GDB, the GNU Debugger. - Copyright 1986, 1987, 1989, 1991, 1993, 1994, 1995, 1996 + Copyright 1986, 87, 89, 91, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" #include "gdb_string.h" @@ -32,7 +33,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "scm-lang.h" #include "demangle.h" -/* Local function prototypes. */ +/* Prototypes for exported functions. */ + +void _initialize_values PARAMS ((void)); + +/* Prototypes for local functions. */ static value_ptr value_headof PARAMS ((value_ptr, struct type *, struct type *)); @@ -52,10 +57,10 @@ static int vb_match PARAMS ((struct type *, int, struct type *)); #define VALUE_HISTORY_CHUNK 60 struct value_history_chunk -{ - struct value_history_chunk *next; - value_ptr values[VALUE_HISTORY_CHUNK]; -}; + { + struct value_history_chunk *next; + value_ptr values[VALUE_HISTORY_CHUNK]; + }; /* Chain of chunks now in use. */ @@ -82,6 +87,7 @@ allocate_value (type) VALUE_NEXT (val) = all_values; all_values = val; VALUE_TYPE (val) = type; + VALUE_ENCLOSING_TYPE (val) = type; VALUE_LVAL (val) = not_lval; VALUE_ADDRESS (val) = 0; VALUE_FRAME (val) = 0; @@ -91,6 +97,9 @@ allocate_value (type) VALUE_REGNO (val) = -1; VALUE_LAZY (val) = 0; VALUE_OPTIMIZED_OUT (val) = 0; + VALUE_BFD_SECTION (val) = NULL; + VALUE_EMBEDDED_OFFSET (val) = 0; + VALUE_POINTED_TO_OFFSET (val) = 0; val->modifiable = 1; return val; } @@ -103,12 +112,12 @@ allocate_repeat_value (type, count) struct type *type; int count; { - int low_bound = current_language->string_lower_bound; /* ??? */ + int low_bound = current_language->string_lower_bound; /* ??? */ /* FIXME-type-allocation: need a way to free this type when we are done with it. */ struct type *range_type - = create_range_type ((struct type *) NULL, builtin_type_int, - low_bound, count + low_bound - 1); + = create_range_type ((struct type *) NULL, builtin_type_int, + low_bound, count + low_bound - 1); /* FIXME-type-allocation: need a way to free this type when we are done with it. */ return allocate_value (create_array_type ((struct type *) NULL, @@ -208,8 +217,9 @@ value_ptr value_copy (arg) value_ptr arg; { - register struct type *type = VALUE_TYPE (arg); - register value_ptr val = allocate_value (type); + register struct type *encl_type = VALUE_ENCLOSING_TYPE (arg); + register value_ptr val = allocate_value (encl_type); + VALUE_TYPE (val) = VALUE_TYPE (arg); VALUE_LVAL (val) = VALUE_LVAL (arg); VALUE_ADDRESS (val) = VALUE_ADDRESS (arg); VALUE_OFFSET (val) = VALUE_OFFSET (arg); @@ -219,11 +229,15 @@ value_copy (arg) VALUE_REGNO (val) = VALUE_REGNO (arg); VALUE_LAZY (val) = VALUE_LAZY (arg); VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg); + VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg); + VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg); + VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (arg); val->modifiable = arg->modifiable; if (!VALUE_LAZY (val)) { - memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS_RAW (arg), - TYPE_LENGTH (VALUE_TYPE (arg))); + memcpy (VALUE_CONTENTS_ALL_RAW (val), VALUE_CONTENTS_ALL_RAW (arg), + TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg))); + } return val; } @@ -260,8 +274,8 @@ record_latest_value (val) if (i == 0) { register struct value_history_chunk *new - = (struct value_history_chunk *) - xmalloc (sizeof (struct value_history_chunk)); + = (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; @@ -327,9 +341,9 @@ clear_value_history () { for (i = 0; i < VALUE_HISTORY_CHUNK; i++) if ((val = value_history_chain->values[i]) != NULL) - free ((PTR)val); + free ((PTR) val); next = value_history_chain->next; - free ((PTR)value_history_chain); + free ((PTR) value_history_chain); value_history_chain = next; } value_history_count = 0; @@ -346,8 +360,8 @@ show_values (num_exp, from_tty) if (num_exp) { - /* "info history +" should print from the stored position. - "info history " should print around value number . */ + /* "info history +" should print from the stored position. + "info history " should print around value number . */ if (num_exp[0] != '+' || num_exp[1] != '\0') num = parse_and_eval_address (num_exp) - 5; } @@ -422,7 +436,7 @@ value_of_internalvar (var) #ifdef IS_TRAPPED_INTERNALVAR if (IS_TRAPPED_INTERNALVAR (var->name)) return VALUE_OF_TRAPPED_INTERNALVAR (var); -#endif +#endif val = value_copy (var->value); if (VALUE_LAZY (val)) @@ -479,7 +493,7 @@ set_internalvar (var, val) something in the value chain (i.e., before release_value is called), because after the error free_all_values will get called before long. */ - free ((PTR)var->value); + free ((PTR) var->value); var->value = newval; release_value (newval); /* End code which must not call error(). */ @@ -504,9 +518,9 @@ clear_internalvars () { var = internalvars; internalvars = var->next; - free ((PTR)var->name); - free ((PTR)var->value); - free ((PTR)var); + free ((PTR) var->name); + free ((PTR) var->value); + free ((PTR) var); } } @@ -560,7 +574,7 @@ value_as_double (val) { DOUBLEST foo; int inv; - + foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv); if (inv) error ("Invalid floating value found in program."); @@ -578,7 +592,7 @@ value_as_pointer (val) /* ADDR_BITS_REMOVE is wrong if we are being called for a non-address (e.g. argument to "signal", "info break", etc.), or for pointers to char, in which the low bits *are* significant. */ - return ADDR_BITS_REMOVE(value_as_long (val)); + return ADDR_BITS_REMOVE (value_as_long (val)); #else return value_as_long (val); #endif @@ -631,7 +645,10 @@ unpack_long (type, valaddr) case TYPE_CODE_PTR: case TYPE_CODE_REF: /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure - whether we want this to be true eventually. */ + whether we want this to be true eventually. */ + if (GDB_TARGET_IS_D10V + && len == 2) + return D10V_MAKE_DADDR (extract_address (valaddr, len)); return extract_address (valaddr, len); case TYPE_CODE_MEMBER: @@ -640,7 +657,7 @@ unpack_long (type, valaddr) default: error ("Value can't be converted to integer."); } - return 0; /* Placate lint. */ + return 0; /* Placate lint. */ } /* Return a double value from the specified type and address. @@ -655,12 +672,15 @@ unpack_double (type, valaddr, invp) char *valaddr; int *invp; { - register enum type_code code = TYPE_CODE (type); - register int len = TYPE_LENGTH (type); - register int nosign = TYPE_UNSIGNED (type); + enum type_code code; + int len; + int nosign; *invp = 0; /* Assume valid. */ CHECK_TYPEDEF (type); + code = TYPE_CODE (type); + len = TYPE_LENGTH (type); + nosign = TYPE_UNSIGNED (type); if (code == TYPE_CODE_FLT) { #ifdef INVALID_FLOAT @@ -675,15 +695,11 @@ unpack_double (type, valaddr, invp) else if (nosign) { /* Unsigned -- be sure we compensate for signed LONGEST. */ -#ifndef _MSC_VER - return (ULONGEST) unpack_long (type, valaddr); -#else -#if (_MSC_VER > 800) +#if !defined (_MSC_VER) || (_MSC_VER > 900) return (ULONGEST) unpack_long (type, valaddr); #else /* FIXME!!! msvc22 doesn't support unsigned __int64 -> double */ return (LONGEST) unpack_long (type, valaddr); -#endif #endif /* _MSC_VER */ } else @@ -716,12 +732,51 @@ unpack_pointer (type, valaddr) return unpack_long (type, valaddr); } +/* Get the value of the FIELDN'th field (which must be static) of TYPE. */ + +value_ptr +value_static_field (type, fieldno) + struct type *type; + int fieldno; +{ + CORE_ADDR addr; + asection *sect; + if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno)) + { + addr = TYPE_FIELD_STATIC_PHYSADDR (type, fieldno); + sect = NULL; + } + else + { + char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); + struct symbol *sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL); + if (sym == NULL) + { + /* 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); + if (!msym) + return NULL; + else + { + addr = SYMBOL_VALUE_ADDRESS (msym); + sect = SYMBOL_BFD_SECTION (msym); + } + } + else + { + addr = SYMBOL_VALUE_ADDRESS (sym); + sect = SYMBOL_BFD_SECTION (sym); + } + SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), addr); + } + return value_at (TYPE_FIELD_TYPE (type, fieldno), addr, sect); +} + /* Given a value ARG1 (offset by OFFSET bytes) of a struct or union type ARG_TYPE, - extract and return the value of one of its fields. - FIELDNO says which field. - - For C++, must also be able to return values from static fields */ + extract and return the value of one of its (non-static) fields. + FIELDNO says which field. */ value_ptr value_primitive_field (arg1, offset, fieldno, arg_type) @@ -738,38 +793,61 @@ value_primitive_field (arg1, offset, fieldno, arg_type) /* Handle packed fields */ - offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; if (TYPE_FIELD_BITSIZE (arg_type, fieldno)) { v = value_from_longest (type, - unpack_field_as_long (arg_type, - VALUE_CONTENTS (arg1), - fieldno)); + unpack_field_as_long (arg_type, + VALUE_CONTENTS (arg1) + + offset, + fieldno)); VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8; VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno); + VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset + + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; + } + else if (fieldno < TYPE_N_BASECLASSES (arg_type)) + { + /* This field is actually a base subobject, so preserve the + entire object's contents for later references to virtual + bases, etc. */ + v = allocate_value (VALUE_ENCLOSING_TYPE (arg1)); + VALUE_TYPE (v) = arg_type; + if (VALUE_LAZY (arg1)) + VALUE_LAZY (v) = 1; + else + memcpy (VALUE_CONTENTS_ALL_RAW (v), VALUE_CONTENTS_ALL_RAW (arg1), + TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1))); + VALUE_OFFSET (v) = VALUE_OFFSET (arg1); + VALUE_EMBEDDED_OFFSET (v) + = offset + + VALUE_EMBEDDED_OFFSET (arg1) + + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; } else { + /* Plain old data member */ + offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; v = allocate_value (type); if (VALUE_LAZY (arg1)) VALUE_LAZY (v) = 1; else - memcpy (VALUE_CONTENTS_RAW (v), VALUE_CONTENTS_RAW (arg1) + offset, + memcpy (VALUE_CONTENTS_RAW (v), + VALUE_CONTENTS_RAW (arg1) + offset, TYPE_LENGTH (type)); + VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset; } VALUE_LVAL (v) = VALUE_LVAL (arg1); if (VALUE_LVAL (arg1) == lval_internalvar) VALUE_LVAL (v) = lval_internalvar_component; VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1); - VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1); +/* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset + + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */ return v; } /* Given a value ARG1 of a struct or union type, - extract and return the value of one of its fields. - FIELDNO says which field. - - For C++, must also be able to return values from static fields */ + extract and return the value of one of its (non-static) fields. + FIELDNO says which field. */ value_ptr value_field (arg1, fieldno) @@ -797,26 +875,26 @@ value_fn_field (arg1p, f, j, type, offset) sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), 0, VAR_NAMESPACE, 0, NULL); - if (! sym) - return NULL; + if (!sym) + return NULL; /* - error ("Internal error: could not find physical method named %s", - TYPE_FN_FIELD_PHYSNAME (f, j)); -*/ - + error ("Internal error: could not find physical method named %s", + TYPE_FN_FIELD_PHYSNAME (f, j)); + */ + v = allocate_value (ftype); VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); VALUE_TYPE (v) = ftype; if (arg1p) - { - if (type != VALUE_TYPE (*arg1p)) - *arg1p = value_ind (value_cast (lookup_pointer_type (type), - value_addr (*arg1p))); - - /* Move the `this' pointer according to the offset. - VALUE_OFFSET (*arg1p) += offset; - */ + { + if (type != VALUE_TYPE (*arg1p)) + *arg1p = value_ind (value_cast (lookup_pointer_type (type), + value_addr (*arg1p))); + + /* Move the `this' pointer according to the offset. + VALUE_OFFSET (*arg1p) += offset; + */ } return v; @@ -840,74 +918,181 @@ value_virtual_fn_field (arg1p, f, j, type, offset) { value_ptr arg1 = *arg1p; struct type *type1 = check_typedef (VALUE_TYPE (arg1)); - struct type *entry_type; - /* First, get the virtual function table pointer. That comes - with a strange type, so cast it to type `pointer to long' (which - should serve just fine as a function type). Then, index into - the table, and convert final value to appropriate function type. */ - value_ptr entry, vfn, vtbl; - value_ptr vi = value_from_longest (builtin_type_int, - (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j)); - struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j); - struct type *context; - if (fcontext == NULL) - /* We don't have an fcontext (e.g. the program was compiled with - g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE. - This won't work right for multiple inheritance, but at least we - should do as well as GDB 3.x did. */ - fcontext = TYPE_VPTR_BASETYPE (type); - context = lookup_pointer_type (fcontext); - /* Now context is a pointer to the basetype containing the vtbl. */ - if (TYPE_TARGET_TYPE (context) != type1) - { - arg1 = value_ind (value_cast (context, value_addr (arg1))); - type1 = check_typedef (VALUE_TYPE (arg1)); - } - context = type1; - /* Now context is the basetype containing the vtbl. */ - - /* This type may have been defined before its virtual function table - was. If so, fill in the virtual function table entry for the - type now. */ - if (TYPE_VPTR_FIELDNO (context) < 0) - fill_in_vptr_fieldno (context); - - /* The virtual function table is now an array of structures - which have the form { int16 offset, delta; void *pfn; }. */ - vtbl = value_ind (value_primitive_field (arg1, 0, - TYPE_VPTR_FIELDNO (context), - TYPE_VPTR_BASETYPE (context))); - - /* Index into the virtual function table. This is hard-coded because - looking up a field is not cheap, and it may be important to save - time, e.g. if the user has set a conditional breakpoint calling - a virtual function. */ - entry = value_subscript (vtbl, vi); - entry_type = check_typedef (VALUE_TYPE (entry)); - - if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT) + if (TYPE_HAS_VTABLE (type)) { - /* Move the `this' pointer according to the virtual function table. */ - VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0)); - - if (! VALUE_LAZY (arg1)) + /* Deal with HP/Taligent runtime model for virtual functions */ + value_ptr vp; + value_ptr argp; /* arg1 cast to base */ + CORE_ADDR coreptr; /* pointer to target address */ + int class_index; /* which class segment pointer to use */ + struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); /* method type */ + + argp = value_cast (type, *arg1p); + + if (VALUE_ADDRESS (argp) == 0) + error ("Address of object is null; object may not have been created."); + + /* pai: FIXME -- 32x64 possible problem? */ + /* First word (4 bytes) in object layout is the vtable pointer */ + coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (argp)); /* pai: (temp) */ + /* + offset + VALUE_EMBEDDED_OFFSET (argp)); */ + + if (!coreptr) + error ("Virtual table pointer is null for object; object may not have been created."); + + /* pai/1997-05-09 + * FIXME: The code here currently handles only + * the non-RRBC case of the Taligent/HP runtime spec; when RRBC + * is introduced, the condition for the "if" below will have to + * be changed to be a test for the RRBC case. */ + + if (1) { - VALUE_LAZY (arg1) = 1; - value_fetch_lazy (arg1); + /* Non-RRBC case; the virtual function pointers are stored at fixed + * offsets in the virtual table. */ + + /* Retrieve the offset in the virtual table from the debug + * info. The offset of the vfunc's entry is in words from + * the beginning of the vtable; but first we have to adjust + * by HP_ACC_VFUNC_START to account for other entries */ + + /* pai: FIXME: 32x64 problem here, a word may be 8 bytes in + * which case the multiplier should be 8 and values should be long */ + vp = value_at (builtin_type_int, + coreptr + 4 * (TYPE_FN_FIELD_VOFFSET (f, j) + HP_ACC_VFUNC_START), NULL); + + coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp)); + /* coreptr now contains the address of the virtual function */ + /* (Actually, it contains the pointer to the plabel for the function. */ + } + else + { + /* RRBC case; the virtual function pointers are found by double + * indirection through the class segment tables. */ + + /* Choose class segment depending on type we were passed */ + class_index = class_index_in_primary_list (type); + + /* Find class segment pointer. These are in the vtable slots after + * some other entries, so adjust by HP_ACC_VFUNC_START for that. */ + /* pai: FIXME 32x64 problem here, if words are 8 bytes long + * the multiplier below has to be 8 and value should be long. */ + vp = value_at (builtin_type_int, + coreptr + 4 * (HP_ACC_VFUNC_START + class_index), NULL); + /* Indirect once more, offset by function index */ + /* pai: FIXME 32x64 problem here, again multiplier could be 8 and value long */ + coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp) + 4 * TYPE_FN_FIELD_VOFFSET (f, j)); + vp = value_at (builtin_type_int, coreptr, NULL); + coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp)); + + /* coreptr now contains the address of the virtual function */ + /* (Actually, it contains the pointer to the plabel for the function.) */ + } - vfn = value_field (entry, 2); + if (!coreptr) + error ("Address of virtual function is null; error in virtual table?"); + + /* Wrap this addr in a value and return pointer */ + vp = allocate_value (ftype); + VALUE_TYPE (vp) = ftype; + VALUE_ADDRESS (vp) = coreptr; + + /* pai: (temp) do we need the value_ind stuff in value_fn_field? */ + return vp; } - else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR) - vfn = entry; else - error ("I'm confused: virtual function table has bad type"); - /* Reinstantiate the function pointer with the correct type. */ - VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)); + { /* Not using HP/Taligent runtime conventions; so try to + * use g++ conventions for virtual table */ + + struct type *entry_type; + /* First, get the virtual function table pointer. That comes + with a strange type, so cast it to type `pointer to long' (which + should serve just fine as a function type). Then, index into + the table, and convert final value to appropriate function type. */ + value_ptr entry, vfn, vtbl; + value_ptr vi = value_from_longest (builtin_type_int, + (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j)); + struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j); + struct type *context; + if (fcontext == NULL) + /* We don't have an fcontext (e.g. the program was compiled with + g++ version 1). Try to get the vtbl from the TYPE_VPTR_BASETYPE. + This won't work right for multiple inheritance, but at least we + should do as well as GDB 3.x did. */ + fcontext = TYPE_VPTR_BASETYPE (type); + context = lookup_pointer_type (fcontext); + /* Now context is a pointer to the basetype containing the vtbl. */ + if (TYPE_TARGET_TYPE (context) != type1) + { + value_ptr tmp = value_cast (context, value_addr (arg1)); + VALUE_POINTED_TO_OFFSET (tmp) = 0; + arg1 = value_ind (tmp); + type1 = check_typedef (VALUE_TYPE (arg1)); + } + + context = type1; + /* Now context is the basetype containing the vtbl. */ + + /* This type may have been defined before its virtual function table + was. If so, fill in the virtual function table entry for the + type now. */ + if (TYPE_VPTR_FIELDNO (context) < 0) + fill_in_vptr_fieldno (context); - *arg1p = arg1; - return vfn; + /* The virtual function table is now an array of structures + which have the form { int16 offset, delta; void *pfn; }. */ + vtbl = value_primitive_field (arg1, 0, TYPE_VPTR_FIELDNO (context), + TYPE_VPTR_BASETYPE (context)); + + /* With older versions of g++, the vtbl field pointed to an array + of structures. Nowadays it points directly to the structure. */ + if (TYPE_CODE (VALUE_TYPE (vtbl)) == TYPE_CODE_PTR + && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (vtbl))) == TYPE_CODE_ARRAY) + { + /* Handle the case where the vtbl field points to an + array of structures. */ + vtbl = value_ind (vtbl); + + /* Index into the virtual function table. This is hard-coded because + looking up a field is not cheap, and it may be important to save + time, e.g. if the user has set a conditional breakpoint calling + a virtual function. */ + entry = value_subscript (vtbl, vi); + } + else + { + /* Handle the case where the vtbl field points directly to a structure. */ + vtbl = value_add (vtbl, vi); + entry = value_ind (vtbl); + } + + entry_type = check_typedef (VALUE_TYPE (entry)); + + if (TYPE_CODE (entry_type) == TYPE_CODE_STRUCT) + { + /* Move the `this' pointer according to the virtual function table. */ + VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0)); + + if (!VALUE_LAZY (arg1)) + { + VALUE_LAZY (arg1) = 1; + value_fetch_lazy (arg1); + } + + vfn = value_field (entry, 2); + } + else if (TYPE_CODE (entry_type) == TYPE_CODE_PTR) + vfn = entry; + else + error ("I'm confused: virtual function table has bad type"); + /* Reinstantiate the function pointer with the correct type. */ + VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)); + + *arg1p = arg1; + return vfn; + } } /* ARG is a pointer to an object we know to be at least @@ -948,9 +1133,9 @@ value_headof (in_arg, btype, dtype) || !VTBL_PREFIX_P (demangled_name)) { /* If we expected to find a vtable, but did not, let the user - know that we aren't happy, but don't throw an error. - FIXME: there has to be a better way to do this. */ - struct type *error_type = (struct type *)xmalloc (sizeof (struct type)); + know that we aren't happy, but don't throw an error. + FIXME: there has to be a better way to do this. */ + struct type *error_type = (struct type *) xmalloc (sizeof (struct type)); memcpy (error_type, VALUE_TYPE (in_arg), sizeof (struct type)); TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *")); VALUE_TYPE (in_arg) = error_type; @@ -962,8 +1147,8 @@ value_headof (in_arg, btype, dtype) nelems = longest_to_int (value_as_long (value_field (entry, 2))); for (i = 1; i <= nelems; i++) { - entry = value_subscript (vtbl, value_from_longest (builtin_type_int, - (LONGEST) i)); + entry = value_subscript (vtbl, value_from_longest (builtin_type_int, + (LONGEST) i)); /* This won't work if we're using thunks. */ if (TYPE_CODE (check_typedef (VALUE_TYPE (entry))) != TYPE_CODE_STRUCT) break; @@ -984,7 +1169,7 @@ value_headof (in_arg, btype, dtype) * But we leave it in for future use, when we will hopefully * have optimizes the vtable to use thunks instead of offsets. */ /* Use the name of vtable itself to extract a base type. */ - demangled_name += 4; /* Skip _vt$ prefix. */ + demangled_name += 4; /* Skip _vt$ prefix. */ } else { @@ -1002,7 +1187,8 @@ value_headof (in_arg, btype, dtype) arg = value_add (value_cast (builtin_type_int, arg), value_field (best_entry, 0)); } - else arg = in_arg; + else + arg = in_arg; VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym)); return arg; } @@ -1099,23 +1285,23 @@ baseclass_offset (type, index, valaddr, address) register int n_baseclasses = TYPE_N_BASECLASSES (type); /* First look for the virtual baseclass pointer - in the fields. */ + in the fields. */ for (i = n_baseclasses; i < len; i++) { if (vb_match (type, i, basetype)) { CORE_ADDR addr - = unpack_pointer (TYPE_FIELD_TYPE (type, i), - valaddr + (TYPE_FIELD_BITPOS (type, i) / 8)); + = unpack_pointer (TYPE_FIELD_TYPE (type, i), + valaddr + (TYPE_FIELD_BITPOS (type, i) / 8)); return addr - (LONGEST) address; } } /* Not in the fields, so try looking through the baseclasses. */ - for (i = index+1; i < n_baseclasses; i++) + for (i = index + 1; i < n_baseclasses; i++) { int boffset = - baseclass_offset (type, i, valaddr, address); + baseclass_offset (type, i, valaddr, address); if (boffset) return boffset; } @@ -1152,8 +1338,11 @@ unpack_field_as_long (type, valaddr, fieldno) int bitpos = TYPE_FIELD_BITPOS (type, fieldno); int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); int lsbcount; + struct type *field_type; val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val)); + field_type = TYPE_FIELD_TYPE (type, fieldno); + CHECK_TYPEDEF (field_type); /* Extract bits. See comment above. */ @@ -1170,7 +1359,7 @@ unpack_field_as_long (type, valaddr, fieldno) { valmask = (((ULONGEST) 1) << bitsize) - 1; val &= valmask; - if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type, fieldno))) + if (!TYPE_UNSIGNED (field_type)) { if (val & (valmask ^ (valmask >> 1))) { @@ -1202,10 +1391,10 @@ modify_field (addr, fieldval, bitpos, bitsize) /* Warn if value is too big to fit in the field in question. */ if (bitsize < (8 * (int) sizeof (fieldval)) - && 0 != (fieldval & ~((1<= size of oword */ if (bitsize < 8 * (int) sizeof (oword)) - oword &= ~(((((ULONGEST)1) << bitsize) - 1) << bitpos); + oword &= ~(((((ULONGEST) 1) << bitsize) - 1) << bitpos); else - oword &= ~((~(ULONGEST)0) << bitpos); + oword &= ~((~(ULONGEST) 0) << bitpos); oword |= fieldval << bitpos; store_signed_integer (addr, sizeof oword, oword); @@ -1238,7 +1427,7 @@ value_from_longest (type, num) register value_ptr val = allocate_value (type); register enum type_code code; register int len; - retry: +retry: code = TYPE_CODE (type); len = TYPE_LENGTH (type); @@ -1254,20 +1443,46 @@ value_from_longest (type, num) case TYPE_CODE_RANGE: store_signed_integer (VALUE_CONTENTS_RAW (val), len, num); break; - + case TYPE_CODE_REF: case TYPE_CODE_PTR: /* This assumes that all pointers of a given length - have the same form. */ + have the same form. */ store_address (VALUE_CONTENTS_RAW (val), len, (CORE_ADDR) num); break; default: - error ("Unexpected type encountered for integer constant."); + error ("Unexpected type (%d) encountered for integer constant.", code); } return val; } +/* Create a value for a string constant to be stored locally + (not in the inferior's memory space, but in GDB memory). + This is analogous to value_from_longest, which also does not + use inferior memory. String shall NOT contain embedded nulls. */ + +value_ptr +value_from_string (ptr) + char *ptr; +{ + value_ptr val; + int len = strlen (ptr); + int lowbound = current_language->string_lower_bound; + struct type *rangetype = + create_range_type ((struct type *) NULL, + builtin_type_int, + lowbound, len + lowbound - 1); + struct type *stringtype = + create_array_type ((struct type *) NULL, + *current_language->string_char_type, + rangetype); + + val = allocate_value (stringtype); + memcpy (VALUE_CONTENTS_RAW (val), ptr, len); + return val; +} + value_ptr value_from_double (type, num) struct type *type; @@ -1305,22 +1520,22 @@ value_from_double (type, num) value_ptr value_being_returned (valtype, retbuf, struct_return) register struct type *valtype; - char retbuf[REGISTER_BYTES]; + char *retbuf; int struct_return; - /*ARGSUSED*/ + /*ARGSUSED */ { register value_ptr val; CORE_ADDR addr; -#if defined (EXTRACT_STRUCT_VALUE_ADDRESS) /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */ - if (struct_return) { - addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf); - if (!addr) - error ("Function return value unknown"); - return value_at (valtype, addr); - } -#endif + if (EXTRACT_STRUCT_VALUE_ADDRESS_P) + if (struct_return) + { + addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf); + if (!addr) + error ("Function return value unknown"); + return value_at (valtype, addr, NULL); + } val = allocate_value (valtype); CHECK_TYPEDEF (valtype); @@ -1343,14 +1558,21 @@ value_being_returned (valtype, retbuf, struct_return) 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled would cause more chaos than dealing with some struct returns being handled wrong. */ -#if !defined (USE_STRUCT_CONVENTION) -#define USE_STRUCT_CONVENTION(gcc_p, type)\ - (!((gcc_p == 1) && (TYPE_LENGTH (value_type) == 1 \ - || TYPE_LENGTH (value_type) == 2 \ - || TYPE_LENGTH (value_type) == 4 \ - || TYPE_LENGTH (value_type) == 8 \ - ) \ - )) + +int +generic_use_struct_convention (gcc_p, value_type) + int gcc_p; + struct type *value_type; +{ + return !((gcc_p == 1) + && (TYPE_LENGTH (value_type) == 1 + || TYPE_LENGTH (value_type) == 2 + || TYPE_LENGTH (value_type) == 4 + || TYPE_LENGTH (value_type) == 8)); +} + +#ifndef USE_STRUCT_CONVENTION +#define USE_STRUCT_CONVENTION(gcc_p,type) generic_use_struct_convention (gcc_p, type) #endif /* Some fundamental types (such as long double) are returned on the stack for @@ -1374,7 +1596,7 @@ using_struct_return (function, funcaddr, value_type, gcc_p) CORE_ADDR funcaddr; struct type *value_type; int gcc_p; - /*ARGSUSED*/ + /*ARGSUSED */ { register enum type_code code = TYPE_CODE (value_type); @@ -1404,7 +1626,7 @@ set_return_value (val) if (code == TYPE_CODE_ERROR) error ("Function return type unknown."); - if ( code == TYPE_CODE_STRUCT + if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION) /* FIXME, implement struct return. */ error ("GDB does not support specifying a struct or union return value."); @@ -1415,7 +1637,7 @@ void _initialize_values () { add_cmd ("convenience", no_class, show_convenience, - "Debugger convenience (\"$foo\") variables.\n\ + "Debugger convenience (\"$foo\") variables.\n\ These variables are created when you assign them values;\n\ thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\ A few convenience variables are given values automatically:\n\