diff options
Diffstat (limited to 'gdb/valops.c')
| -rw-r--r-- | gdb/valops.c | 1420 |
1 files changed, 1192 insertions, 228 deletions
diff --git a/gdb/valops.c b/gdb/valops.c index f902304..076b3ea 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1,5 +1,5 @@ /* Perform non-arithmetic operations on values, for GDB. - Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996 + Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc. This file is part of GDB. @@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "target.h" #include "demangle.h" #include "language.h" +#include "gdbcmd.h" #include <errno.h> #include "gdb_string.h" @@ -41,13 +42,18 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL) #endif +/* Flag indicating HP compilers were used; needed to correctly handle some + value operations with HP aCC code/runtime. */ +extern int hp_som_som_object_present; + + /* Local functions. */ static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[])); #ifdef CALL_DUMMY static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **)); -static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *)); +static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int)); #endif @@ -58,6 +64,10 @@ static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr)); static value_ptr search_struct_field PARAMS ((char *, value_ptr, int, struct type *, int)); +static value_ptr search_struct_field_aux PARAMS ((char *, value_ptr, int, + struct type *, int, int *, char *, + struct type **)); + static value_ptr search_struct_method PARAMS ((char *, value_ptr *, value_ptr *, int, int *, struct type *)); @@ -68,6 +78,8 @@ static CORE_ADDR allocate_space_in_inferior PARAMS ((int)); static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr)); +void _initialize_valops PARAMS ((void)); + #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL) /* Flag for whether we want to abandon failed expression evals by default. */ @@ -76,6 +88,9 @@ static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr)); static int auto_abandon = 0; #endif +int overload_resolution = 0; + + /* Find the address of function name NAME in the inferior. */ @@ -109,7 +124,10 @@ find_function_in_inferior (name) } else { - error ("evaluation of this expression requires the program to have a function \"%s\".", name); + if (!target_has_execution) + error ("evaluation of this expression requires the target program to be active"); + else + error ("evaluation of this expression requires the program to have a function \"%s\".", name); } } } @@ -128,7 +146,10 @@ value_allocate_space_in_inferior (len) val = call_function_by_hand (val, 1, &blocklen); if (value_logical_not (val)) { - error ("No memory available to program."); + if (!target_has_execution) + error ("No memory available to program now: you need to start the target first"); + else + error ("No memory available to program: call to malloc failed"); } return val; } @@ -155,6 +176,8 @@ value_cast (type, arg2) register int scalar; struct type *type2; + int convert_to_boolean = 0; + if (VALUE_TYPE (arg2) == type) return arg2; @@ -206,8 +229,13 @@ value_cast (type, arg2) if (code1 == TYPE_CODE_COMPLEX) return cast_into_complex (type, arg2); - if (code1 == TYPE_CODE_BOOL || code1 == TYPE_CODE_CHAR) - code1 = TYPE_CODE_INT; + if (code1 == TYPE_CODE_BOOL) + { + code1 = TYPE_CODE_INT; + convert_to_boolean = 1; + } + if (code1 == TYPE_CODE_CHAR) + code1 = TYPE_CODE_INT; if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR) code2 = TYPE_CODE_INT; @@ -234,32 +262,86 @@ value_cast (type, arg2) else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM || code1 == TYPE_CODE_RANGE) && (scalar || code2 == TYPE_CODE_PTR)) - return value_from_longest (type, value_as_long (arg2)); + { + LONGEST longest; + + if (hp_som_som_object_present && /* if target compiled by HP aCC */ + (code2 == TYPE_CODE_PTR)) + { + unsigned int * ptr; + value_ptr retvalp; + + switch (TYPE_CODE (TYPE_TARGET_TYPE (type2))) + { + /* With HP aCC, pointers to data members have a bias */ + case TYPE_CODE_MEMBER: + retvalp = value_from_longest (type, value_as_long (arg2)); + ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* force evaluation */ + *ptr &= ~0x20000000; /* zap 29th bit to remove bias */ + return retvalp; + + /* While pointers to methods don't really point to a function */ + case TYPE_CODE_METHOD: + error ("Pointers to methods not supported with HP aCC"); + + default: + break; /* fall out and go to normal handling */ + } + } + longest = value_as_long (arg2); + return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest); + } else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2)) { if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) { - /* 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. */ struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type)); struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2)); if ( TYPE_CODE (t1) == TYPE_CODE_STRUCT && TYPE_CODE (t2) == TYPE_CODE_STRUCT - && TYPE_NAME (t1) != 0) /* if name unknown, can't have supercl */ + && !value_logical_not (arg2)) { - value_ptr v = search_struct_field (type_name_no_tag (t1), - value_ind (arg2), 0, t2, 1); - if (v) + value_ptr v; + + /* 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. */ + if (TYPE_NAME (t1) != NULL) + { + v = search_struct_field (type_name_no_tag (t1), + value_ind (arg2), 0, t2, 1); + if (v) + { + v = value_addr (v); + VALUE_TYPE (v) = type; + return v; + } + } + + /* 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. */ + if (TYPE_NAME (t2) != NULL) { - v = value_addr (v); - VALUE_TYPE (v) = type; - return v; + v = search_struct_field (type_name_no_tag (t2), + value_zero (t1, not_lval), 0, t1, 1); + if (v) + { + value_ptr v2 = value_ind (arg2); + VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v) + + VALUE_OFFSET (v); + v2 = value_addr (v2); + VALUE_TYPE (v2) = type; + return v2; + } } } /* No superclass found, just fall through to change ptr type. */ } VALUE_TYPE (arg2) = type; + VALUE_ENCLOSING_TYPE (arg2) = type; /* pai: chk_val */ + VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */ return arg2; } else if (chill_varying_type (type)) @@ -269,6 +351,8 @@ value_cast (type, arg2) int count1, count2; LONGEST low_bound, high_bound; char *valaddr, *valaddr_data; + /* For lint warning about eltype2 possibly uninitialized: */ + eltype2 = NULL; if (code2 == TYPE_CODE_BITSTRING) error ("not implemented: converting bitstring to varying type"); if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING) @@ -341,7 +425,10 @@ value_zero (type, lv) value_at_lazy instead. value_at_lazy simply records the address of the data and sets the lazy-evaluation-required flag. The lazy flag is tested in the VALUE_CONTENTS macro, which is used if and when - the contents are actually required. */ + the contents are actually required. + + Note: value_at does *NOT* handle embedded offsets; perform such + adjustments before or after calling it. */ value_ptr value_at (type, addr, sect) @@ -357,18 +444,29 @@ value_at (type, addr, sect) val = allocate_value (type); #ifdef GDB_TARGET_IS_D10V - if (TYPE_TARGET_TYPE(type) && TYPE_CODE(TYPE_TARGET_TYPE(type)) == TYPE_CODE_FUNC) + if (TYPE_CODE (type) == TYPE_CODE_PTR + && TYPE_TARGET_TYPE (type) + && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)) { - int num; - short snum; - read_memory (addr, (char *)&snum, 2); + /* pointer to function */ + unsigned long num; + unsigned short snum; + snum = read_memory_unsigned_integer (addr, 2); num = D10V_MAKE_IADDR(snum); - memcpy( VALUE_CONTENTS_RAW (val), &num, 4); + store_address ( VALUE_CONTENTS_RAW (val), 4, num); + } + else if (TYPE_CODE(type) == TYPE_CODE_PTR) + { + /* pointer to data */ + unsigned long num; + unsigned short snum; + snum = read_memory_unsigned_integer (addr, 2); + num = D10V_MAKE_DADDR(snum); + store_address ( VALUE_CONTENTS_RAW (val), 4, num); } else #endif - - read_memory_section (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (type), sect); + read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect); VALUE_LVAL (val) = lval_memory; VALUE_ADDRESS (val) = addr; @@ -400,10 +498,10 @@ value_at_lazy (type, addr, sect) return val; } -/* Called only from the VALUE_CONTENTS macro, if the current data for - a variable needs to be loaded into VALUE_CONTENTS(VAL). Fetches the - data from the user's process, and clears the lazy flag to indicate - that the data in the buffer is valid. +/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros, + if the current data for a variable needs to be loaded into + VALUE_CONTENTS(VAL). Fetches the data from the user's process, and + clears the lazy flag to indicate that the data in the buffer is valid. If the value is zero-length, we avoid calling read_memory, which would abort. We mark the value as fetched anyway -- all 0 bytes of it. @@ -417,23 +515,35 @@ value_fetch_lazy (val) register value_ptr val; { CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val); - int length = TYPE_LENGTH (VALUE_TYPE (val)); + int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)); #ifdef GDB_TARGET_IS_D10V struct type *type = VALUE_TYPE(val); - if (TYPE_TARGET_TYPE(type) && TYPE_CODE(TYPE_TARGET_TYPE(type)) == TYPE_CODE_FUNC) + if (TYPE_CODE (type) == TYPE_CODE_PTR + && TYPE_TARGET_TYPE (type) + && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)) { - int num; - short snum; - read_memory (addr, (char *)&snum, 2); + /* pointer to function */ + unsigned long num; + unsigned short snum; + snum = read_memory_unsigned_integer (addr, 2); num = D10V_MAKE_IADDR(snum); - memcpy( VALUE_CONTENTS_RAW (val), &num, 4); + store_address ( VALUE_CONTENTS_RAW (val), 4, num); + } + else if (TYPE_CODE(type) == TYPE_CODE_PTR) + { + /* pointer to data */ + unsigned long num; + unsigned short snum; + snum = read_memory_unsigned_integer (addr, 2); + num = D10V_MAKE_DADDR(snum); + store_address ( VALUE_CONTENTS_RAW (val), 4, num); } else #endif if (length) - read_memory_section (addr, VALUE_CONTENTS_RAW (val), length, + read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length, VALUE_BFD_SECTION (val)); VALUE_LAZY (val) = 0; return 0; @@ -488,7 +598,11 @@ value_assign (toval, fromval) { case lval_internalvar: set_internalvar (VALUE_INTERNALVAR (toval), fromval); - return value_copy (VALUE_INTERNALVAR (toval)->value); + val = value_copy (VALUE_INTERNALVAR (toval)->value); + VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval); + VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval); + VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval); + return val; case lval_internalvar_component: set_internalvar_component (VALUE_INTERNALVAR (toval), @@ -679,6 +793,9 @@ Can't handle bitfield which doesn't fit in a single register."); memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); VALUE_TYPE (val) = type; + VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval); + VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval); + VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval); return val; } @@ -697,11 +814,11 @@ value_repeat (arg1, count) if (count < 1) error ("Invalid number %d of repetitions.", count); - val = allocate_repeat_value (VALUE_TYPE (arg1), count); + val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count); read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1), - VALUE_CONTENTS_RAW (val), - TYPE_LENGTH (VALUE_TYPE (val))); + 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); @@ -722,12 +839,14 @@ value_of_variable (var, b) { frame = block_innermost_frame (b); if (!frame) - if (BLOCK_FUNCTION (b) - && SYMBOL_NAME (BLOCK_FUNCTION (b))) - error ("No frame is currently executing in block %s.", - SYMBOL_NAME (BLOCK_FUNCTION (b))); - else - error ("No frame is currently executing in specified block"); + { + if (BLOCK_FUNCTION (b) + && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b))) + error ("No frame is currently executing in block %s.", + SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b))); + else + error ("No frame is currently executing in specified block"); + } } val = read_var_value (var, frame); @@ -797,7 +916,7 @@ value_ptr value_addr (arg1) value_ptr arg1; { - value_ptr retval; + value_ptr arg2; struct type *type = check_typedef (VALUE_TYPE (arg1)); if (TYPE_CODE (type) == TYPE_CODE_REF) @@ -805,7 +924,7 @@ value_addr (arg1) /* Copy the value, but change the type from (T&) to (T*). We keep the same location information, which is efficient, and allows &(&X) to get the location containing the reference. */ - value_ptr arg2 = value_copy (arg1); + arg2 = value_copy (arg1); VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type)); return arg2; } @@ -815,10 +934,19 @@ value_addr (arg1) if (VALUE_LVAL (arg1) != lval_memory) error ("Attempt to take address of value not located in memory."); - retval = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)), - (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); - VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1); - return retval; + /* Get target memory address */ + arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)), + (LONGEST) (VALUE_ADDRESS (arg1) + + VALUE_OFFSET (arg1) + + VALUE_EMBEDDED_OFFSET (arg1))); + + /* This may be a pointer to a base subobject; so remember the + full derived object's type ... */ + VALUE_ENCLOSING_TYPE (arg2) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)); + /* ... and also the relative position of the subobject in the full object */ + VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1); + VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1); + return arg2; } /* Given a value of a pointer type, apply the C unary * operator to it. */ @@ -827,24 +955,47 @@ value_ptr value_ind (arg1) value_ptr arg1; { - struct type *type1; + struct type *base_type; + value_ptr arg2; + value_ptr real_val; + COERCE_ARRAY (arg1); - type1 = check_typedef (VALUE_TYPE (arg1)); - if (TYPE_CODE (type1) == TYPE_CODE_MEMBER) + base_type = check_typedef (VALUE_TYPE (arg1)); + + if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER) error ("not implemented: member types in value_ind"); /* Allow * on an integer so we can cast it to whatever we want. This returns an int, which seems like the most C-like thing to do. "long long" variables are rare enough that BUILTIN_TYPE_LONGEST would seem to be a mistake. */ - if (TYPE_CODE (type1) == TYPE_CODE_INT) + if (TYPE_CODE (base_type) == TYPE_CODE_INT) return value_at (builtin_type_int, (CORE_ADDR) value_as_long (arg1), VALUE_BFD_SECTION (arg1)); - else if (TYPE_CODE (type1) == TYPE_CODE_PTR) - return value_at_lazy (TYPE_TARGET_TYPE (type1), value_as_pointer (arg1), - VALUE_BFD_SECTION (arg1)); + else if (TYPE_CODE (base_type) == TYPE_CODE_PTR) + { + struct type *enc_type; + /* We may be pointing to something embedded in a larger object */ + /* Get the real type of the enclosing object */ + enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1)); + enc_type = TYPE_TARGET_TYPE (enc_type); + /* Retrieve the enclosing object pointed to */ + arg2 = value_at_lazy (enc_type, + value_as_pointer (arg1) - VALUE_POINTED_TO_OFFSET (arg1), + VALUE_BFD_SECTION (arg1)); + /* Re-adjust type */ + VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type); + /* Add embedding info */ + VALUE_ENCLOSING_TYPE (arg2) = enc_type; + VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1); + + /* We may be pointing to an object of some derived type */ + arg2 = value_full_object (arg2, NULL, 0, 0, 0); + return arg2; + } + error ("Attempt to take contents of a non-pointer value."); return 0; /* For lint -- never reached */ } @@ -862,13 +1013,18 @@ push_word (sp, word) char buffer[MAX_REGISTER_RAW_SIZE]; store_unsigned_integer (buffer, len, word); -#if 1 INNER_THAN 2 - sp -= len; - write_memory (sp, buffer, len); -#else /* stack grows upward */ - write_memory (sp, buffer, len); - sp += len; -#endif /* stack grows upward */ + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= len; + write_memory (sp, buffer, len); + } + else + { + /* stack grows upward */ + write_memory (sp, buffer, len); + sp += len; + } return sp; } @@ -881,13 +1037,18 @@ push_bytes (sp, buffer, len) char *buffer; int len; { -#if 1 INNER_THAN 2 - sp -= len; - write_memory (sp, buffer, len); -#else /* stack grows upward */ - write_memory (sp, buffer, len); - sp += len; -#endif /* stack grows upward */ + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= len; + write_memory (sp, buffer, len); + } + else + { + /* stack grows upward */ + write_memory (sp, buffer, len); + sp += len; + } return sp; } @@ -901,15 +1062,20 @@ value_push (sp, arg) register CORE_ADDR sp; value_ptr arg; { - register int len = TYPE_LENGTH (VALUE_TYPE (arg)); + register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)); -#if 1 INNER_THAN 2 - sp -= len; - write_memory (sp, VALUE_CONTENTS (arg), len); -#else /* stack grows upward */ - write_memory (sp, VALUE_CONTENTS (arg), len); - sp += len; -#endif /* stack grows upward */ + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= len; + write_memory (sp, VALUE_CONTENTS_ALL (arg), len); + } + else + { + /* stack grows upward */ + write_memory (sp, VALUE_CONTENTS_ALL (arg), len); + sp += len; + } return sp; } @@ -920,12 +1086,14 @@ value_push (sp, arg) /* Perform the standard coercions that are specified for arguments to be passed to C functions. - If PARAM_TYPE is non-NULL, it is the expected parameter type. */ + If PARAM_TYPE is non-NULL, it is the expected parameter type. + IS_PROTOTYPED is non-zero if the function declaration is prototyped. */ static value_ptr -value_arg_coerce (arg, param_type) +value_arg_coerce (arg, param_type, is_prototyped) value_ptr arg; struct type *param_type; + int is_prototyped; { register struct type *arg_type = check_typedef (VALUE_TYPE (arg)); register struct type *type @@ -945,19 +1113,31 @@ value_arg_coerce (arg, param_type) case TYPE_CODE_CHAR: case TYPE_CODE_BOOL: case TYPE_CODE_ENUM: + /* If we don't have a prototype, coerce to integer type if necessary. */ + if (!is_prototyped) + { + if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) + type = builtin_type_int; + } + /* Currently all target ABIs require at least the width of an integer + type for an argument. We may have to conditionalize the following + type coercion for future targets. */ if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int)) type = builtin_type_int; break; - case TYPE_CODE_FLT: - /* coerce float to double, unless the function prototype specifies float */ - if (COERCE_FLOAT_TO_DOUBLE) - { - if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double)) - type = builtin_type_double; - else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double)) - type = builtin_type_long_double; - } - break; + case TYPE_CODE_FLT: + /* FIXME: We should always convert floats to doubles in the + non-prototyped case. As many debugging formats include + no information about prototyping, we have to live with + COERCE_FLOAT_TO_DOUBLE for now. */ + if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE) + { + if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double)) + type = builtin_type_double; + else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double)) + type = builtin_type_long_double; + } + break; case TYPE_CODE_FUNC: type = lookup_pointer_type (type); break; @@ -1074,7 +1254,14 @@ call_function_by_hand (function, nargs, args) /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it and remove any extra bytes which might exist because ULONGEST is - bigger than REGISTER_SIZE. */ + bigger than REGISTER_SIZE. + + NOTE: This is pretty wierd, as the call dummy is actually a + sequence of instructions. But CISC machines will have + to pack the instructions into REGISTER_SIZE units (and + so will RISC machines for which INSTRUCTION_SIZE is not + REGISTER_SIZE). */ + static ULONGEST dummy[] = CALL_DUMMY; char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (ULONGEST)]; CORE_ADDR old_sp; @@ -1086,13 +1273,15 @@ call_function_by_hand (function, nargs, args) CORE_ADDR funaddr; int using_gcc; /* Set to version of gcc in use, or zero if not gcc */ CORE_ADDR real_pc; + struct type *param_type = NULL; struct type *ftype = check_typedef (SYMBOL_TYPE (function)); if (!target_has_execution) noprocess(); save_inferior_status (&inf_status, 1); - old_chain = make_cleanup (restore_inferior_status, &inf_status); + old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status, + &inf_status); /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers (and POP_FRAME for restoring them). (At least on most machines) @@ -1101,13 +1290,18 @@ call_function_by_hand (function, nargs, args) old_sp = sp = read_sp (); -#if 1 INNER_THAN 2 /* Stack grows down */ - sp -= sizeof dummy1; - start_sp = sp; -#else /* Stack grows up */ - start_sp = sp; - sp += sizeof dummy1; -#endif + if (INNER_THAN (1, 2)) + { + /* Stack grows down */ + sp -= sizeof dummy1; + start_sp = sp; + } + else + { + /* Stack grows up */ + start_sp = sp; + sp += sizeof dummy1; + } funaddr = find_function_addr (function, &value_type); CHECK_TYPEDEF (value_type); @@ -1186,12 +1380,50 @@ call_function_by_hand (function, nargs, args) for (i = nargs - 1; i >= 0; i--) { - struct type *param_type; - if (TYPE_NFIELDS (ftype) > i) - param_type = TYPE_FIELD_TYPE (ftype, i); - else - param_type = 0; - args[i] = value_arg_coerce (args[i], param_type); + /* If we're off the end of the known arguments, do the standard + promotions. FIXME: if we had a prototype, this should only + be allowed if ... were present. */ + if (i >= TYPE_NFIELDS (ftype)) + args[i] = value_arg_coerce (args[i], NULL, 0); + + else + { + int is_prototyped = TYPE_FLAGS (ftype) & TYPE_FLAG_PROTOTYPED; + param_type = TYPE_FIELD_TYPE (ftype, i); + + args[i] = value_arg_coerce (args[i], param_type, is_prototyped); + } + + /*elz: this code is to handle the case in which the function to be called + has a pointer to function as parameter and the corresponding actual argument + is the address of a function and not a pointer to function variable. + In aCC compiled code, the calls through pointers to functions (in the body + of the function called by hand) are made via $$dyncall_external which + requires some registers setting, this is taken care of if we call + via a function pointer variable, but not via a function address. + In cc this is not a problem. */ + + if (using_gcc == 0) + if (param_type) + /* if this parameter is a pointer to function*/ + if (TYPE_CODE (param_type) == TYPE_CODE_PTR) + if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC) + /* elz: FIXME here should go the test about the compiler used + to compile the target. We want to issue the error + message only if the compiler used was HP's aCC. + If we used HP's cc, then there is no problem and no need + to return at this point */ + if (using_gcc == 0) /* && compiler == aCC*/ + /* go see if the actual parameter is a variable of type + pointer to function or just a function */ + if (args[i]->lval == not_lval) + { + char *arg_name; + if (find_pc_partial_function((CORE_ADDR)args[i]->aligner.contents[0], &arg_name, NULL, NULL)) + error("\ +You cannot use function <%s> as argument. \n\ +You must use a pointer to function type variable. Command ignored.", arg_name); + } } #if defined (REG_STRUCT_HAS_ADDR) @@ -1213,34 +1445,48 @@ call_function_by_hand (function, nargs, args) && REG_STRUCT_HAS_ADDR (using_gcc, arg_type)) { CORE_ADDR addr; - int len = TYPE_LENGTH (arg_type); + int len; /* = TYPE_LENGTH (arg_type); */ + int aligned_len; + arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i])); + len = TYPE_LENGTH (arg_type); + #ifdef STACK_ALIGN /* MVS 11/22/96: I think at least some of this stack_align code is really broken. Better to let PUSH_ARGUMENTS adjust the stack in a target-defined manner. */ - int aligned_len = STACK_ALIGN (len); -#else - int aligned_len = len; -#endif -#if !(1 INNER_THAN 2) - /* The stack grows up, so the address of the thing we push - is the stack pointer before we push it. */ - addr = sp; + aligned_len = STACK_ALIGN (len); #else - sp -= aligned_len; + aligned_len = len; #endif + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= aligned_len; + } + else + { + /* The stack grows up, so the address of the thing we push + is the stack pointer before we push it. */ + addr = sp; + } /* Push the structure. */ - write_memory (sp, VALUE_CONTENTS (args[i]), len); -#if 1 INNER_THAN 2 - /* The stack grows down, so the address of the thing we push - is the stack pointer after we push it. */ - addr = sp; -#else - sp += aligned_len; -#endif + write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len); + if (INNER_THAN (1, 2)) + { + /* The stack grows down, so the address of the thing we push + is the stack pointer after we push it. */ + addr = sp; + } + else + { + /* stack grows upward */ + sp += aligned_len; + } /* The value we're going to pass is the address of the thing we just pushed. */ - args[i] = value_from_longest (lookup_pointer_type (value_type), + /*args[i] = value_from_longest (lookup_pointer_type (value_type), + (LONGEST) addr);*/ + args[i] = value_from_longest (lookup_pointer_type (arg_type), (LONGEST) addr); } } @@ -1259,31 +1505,44 @@ call_function_by_hand (function, nargs, args) a target-defined manner. */ len = STACK_ALIGN (len); #endif -#if 1 INNER_THAN 2 - sp -= len; - struct_addr = sp; -#else - struct_addr = sp; - sp += len; -#endif + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= len; + struct_addr = sp; + } + else + { + /* stack grows upward */ + struct_addr = sp; + sp += len; + } } -#if defined(STACK_ALIGN) && (1 INNER_THAN 2) +/* elz: on HPPA no need for this extra alignment, maybe it is needed + on other architectures. This is because all the alignment is taken care + of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in + hppa_push_arguments*/ +#ifndef NO_EXTRA_ALIGNMENT_NEEDED + +#if defined(STACK_ALIGN) /* MVS 11/22/96: I think at least some of this stack_align code is really broken. Better to let PUSH_ARGUMENTS adjust the stack in a target-defined manner. */ - { - /* If stack grows down, we must leave a hole at the top. */ - int len = 0; + if (INNER_THAN (1, 2)) + { + /* If stack grows down, we must leave a hole at the top. */ + int len = 0; - for (i = nargs - 1; i >= 0; i--) - len += TYPE_LENGTH (VALUE_TYPE (args[i])); + for (i = nargs - 1; i >= 0; i--) + len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); #ifdef CALL_DUMMY_STACK_ADJUST - len += CALL_DUMMY_STACK_ADJUST; + len += CALL_DUMMY_STACK_ADJUST; #endif - sp -= STACK_ALIGN (len) - len; - } + sp -= STACK_ALIGN (len) - len; + } #endif /* STACK_ALIGN */ +#endif /* NO_EXTRA_ALIGNMENT_NEEDED */ #ifdef PUSH_ARGUMENTS PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr); @@ -1305,15 +1564,16 @@ call_function_by_hand (function, nargs, args) sp = PUSH_RETURN_ADDRESS(real_pc, sp); #endif /* PUSH_RETURN_ADDRESS */ -#if defined(STACK_ALIGN) && !(1 INNER_THAN 2) - { - /* If stack grows up, we must leave a hole at the bottom, note - that sp already has been advanced for the arguments! */ +#if defined(STACK_ALIGN) + if (! INNER_THAN (1, 2)) + { + /* If stack grows up, we must leave a hole at the bottom, note + that sp already has been advanced for the arguments! */ #ifdef CALL_DUMMY_STACK_ADJUST - sp += CALL_DUMMY_STACK_ADJUST; + sp += CALL_DUMMY_STACK_ADJUST; #endif - sp = STACK_ALIGN (sp); - } + sp = STACK_ALIGN (sp); + } #endif /* STACK_ALIGN */ /* XXX This seems wrong. For stacks that grow down we shouldn't do @@ -1322,9 +1582,11 @@ call_function_by_hand (function, nargs, args) really broken. Better to let PUSH_ARGUMENTS adjust the stack in a target-defined manner. */ #ifdef CALL_DUMMY_STACK_ADJUST -#if 1 INNER_THAN 2 - sp -= CALL_DUMMY_STACK_ADJUST; -#endif + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= CALL_DUMMY_STACK_ADJUST; + } #endif /* CALL_DUMMY_STACK_ADJUST */ /* Store the address at which the structure is supposed to be @@ -1409,6 +1671,19 @@ the function call).", name); do_cleanups (old_chain); /* Figure out the value returned by the function. */ +/* elz: I defined this new macro for the hppa architecture only. + this gives us a way to get the value returned by the function from the stack, + at the same address we told the function to put it. + We cannot assume on the pa that r28 still contains the address of the returned + structure. Usually this will be overwritten by the callee. + I don't know about other architectures, so I defined this macro +*/ + +#ifdef VALUE_RETURNED_FROM_STACK + if (struct_return) + return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr); +#endif + return value_being_returned (value_type, retbuf, struct_return); } } @@ -1456,10 +1731,10 @@ value_array (lowbound, highbound, elemvec) { error ("bad array bounds (%d, %d)", lowbound, highbound); } - typelength = TYPE_LENGTH (VALUE_TYPE (elemvec[0])); + typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0])); for (idx = 1; idx < nelem; idx++) { - if (TYPE_LENGTH (VALUE_TYPE (elemvec[idx])) != typelength) + if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength) { error ("array elements must all be the same size"); } @@ -1468,15 +1743,15 @@ value_array (lowbound, highbound, elemvec) rangetype = create_range_type ((struct type *) NULL, builtin_type_int, lowbound, highbound); arraytype = create_array_type ((struct type *) NULL, - VALUE_TYPE (elemvec[0]), rangetype); + VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype); if (!current_language->c_style_arrays) { val = allocate_value (arraytype); for (idx = 0; idx < nelem; idx++) { - memcpy (VALUE_CONTENTS_RAW (val) + (idx * typelength), - VALUE_CONTENTS (elemvec[idx]), + memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength), + VALUE_CONTENTS_ALL (elemvec[idx]), typelength); } VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]); @@ -1491,7 +1766,7 @@ value_array (lowbound, highbound, elemvec) addr = allocate_space_in_inferior (nelem * typelength); for (idx = 0; idx < nelem; idx++) { - write_memory (addr + (idx * typelength), VALUE_CONTENTS (elemvec[idx]), + write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]), typelength); } @@ -1641,34 +1916,91 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) register struct type *type; int looking_for_baseclass; { + int found = 0; + char found_class[1024]; + value_ptr v; + struct type *vbase = NULL; + + found_class[0] = '\000'; + + v = search_struct_field_aux (name, arg1, offset, type, looking_for_baseclass, &found, found_class, &vbase); + if (found > 1) + warning ("%s ambiguous; using %s::%s. Use a cast to disambiguate.", + name, found_class, name); + + return v; +} + + +static value_ptr +search_struct_field_aux (name, arg1, offset, type, looking_for_baseclass, found, found_class_name, vbase) + char *name; + register value_ptr arg1; + int offset; + register struct type *type; + int looking_for_baseclass; + int * found; + char * found_class_name; + struct type ** vbase; +{ int i; + value_ptr retval = NULL; + char tmp_class_name[1024]; + int tmp_found = 0; + int assigned = 0; + int nbases = TYPE_N_BASECLASSES (type); + + tmp_class_name[0] = '\000'; CHECK_TYPEDEF (type); if (! looking_for_baseclass) - for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) + for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) { char *t_field_name = TYPE_FIELD_NAME (type, i); if (t_field_name && STREQ (t_field_name, name)) { - value_ptr v; + value_ptr v = NULL; if (TYPE_FIELD_STATIC (type, i)) + v = value_static_field (type, i); + if (v != NULL) { - char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, i); - struct symbol *sym = - lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL); - if (sym == NULL) - error ("Internal error: could not find physical static variable named %s", - phys_name); - v = value_at (TYPE_FIELD_TYPE (type, i), - SYMBOL_VALUE_ADDRESS (sym), SYMBOL_BFD_SECTION (sym)); + if (!*found) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + char *class_name = TYPE_TAG_NAME (type); + retval = v; + if (class_name) + strcpy (found_class_name, class_name); + else + found_class_name = NULL; + } + (*found)++; } else - v = value_primitive_field (arg1, offset, i, type); + { + v = value_primitive_field (arg1, offset, i, type); + if (v != NULL) + { + if (!*found) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + char *class_name = TYPE_TAG_NAME (type); + retval = v; + if (class_name) + strcpy (found_class_name, class_name); + else + found_class_name = NULL; + } + (*found)++; + } + } + if (v == 0) - error("there is no field named %s", name); - return v; + error("Couldn't retrieve field named %s", name); } if (t_field_name @@ -1702,15 +2034,29 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) && TYPE_FIELD_BITPOS (field_type, 0) == 0)) new_offset += TYPE_FIELD_BITPOS (type, i) / 8; - v = search_struct_field (name, arg1, new_offset, field_type, - looking_for_baseclass); - if (v) - return v; + v = search_struct_field_aux (name, arg1, new_offset, field_type, + looking_for_baseclass, &tmp_found, + tmp_class_name, vbase); + if (!*found && v) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + retval = v; + /* TYPE_TAG_NAME can be null in case of an anonymous union */ + if (TYPE_TAG_NAME (type)) + strcpy (found_class_name, TYPE_TAG_NAME (type)); + else + strcpy (found_class_name, " "); + strcat (found_class_name, "::"); + strcat (found_class_name, tmp_class_name); + } + *found += tmp_found; + tmp_found = 0; } } } - for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) + for (i = 0; i < nbases; i++) { value_ptr v; struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); @@ -1723,41 +2069,262 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) if (BASETYPE_VIA_VIRTUAL (type, i)) { - int boffset = VALUE_OFFSET (arg1) + offset; - boffset = baseclass_offset (type, i, - VALUE_CONTENTS (arg1) + boffset, - VALUE_ADDRESS (arg1) + boffset); - if (boffset == -1) - error ("virtual baseclass botch"); + int boffset; + value_ptr v2 = allocate_value (VALUE_ENCLOSING_TYPE (arg1)); + + if (TYPE_HAS_VTABLE (type)) + { + /* HP aCC compiled type, use Taligent/HP runtime model */ + int skip; + find_rt_vbase_offset (type, TYPE_BASECLASS (type, i), + VALUE_CONTENTS_ALL (arg1), + offset + VALUE_EMBEDDED_OFFSET (arg1), + &boffset, &skip); + if (skip >= 0) + error ("Virtual base class offset not found from vtable"); + } + + else + { + + boffset = baseclass_offset (type, i, + VALUE_CONTENTS_ALL (arg1) + offset, + VALUE_ADDRESS (arg1) + + VALUE_OFFSET (arg1) + offset); + if (boffset == -1) + error ("virtual baseclass botch"); + + /* The virtual base class pointer might have been clobbered by the + user program. Make sure that it still points to a valid memory + location. */ + + if ((boffset + offset) < 0 || + (boffset + offset) >= TYPE_LENGTH (type)) + { + CORE_ADDR base_addr; + + base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + + boffset + offset; + 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; + assigned = 1; + } + } + + if (!assigned) + { + VALUE_LVAL (v2) = VALUE_LVAL (arg1); + VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1); + } + + /* Earlier, this code used to allocate a value of type + basetype and copy the contents of arg1 at the + appropriate offset into the new value. This doesn't + work because there is important stuff (virtual bases, + for example) that could be anywhere in the contents + of arg1, and not just within the length of a basetype + object. In particular the boffset below could be + negative, with the HP/Taligent C++ runtime system. + So, the only way to ensure that required information + is not lost is to always allocate a value of the same + type as arg1 and to fill it with the _entire_ + contents of arg1. It sounds wasteful, but there is + really no way around it if later member lookup, + casts, etc. have to work correctly with the returned + value. */ + + + VALUE_TYPE (v2) = basetype; + VALUE_OFFSET (v2) = VALUE_OFFSET (arg1); + VALUE_EMBEDDED_OFFSET(v2) + = VALUE_EMBEDDED_OFFSET(arg1) + offset + boffset; + if (VALUE_LAZY (arg1)) + VALUE_LAZY (v2) = 1; + else + memcpy ((char *) (v2)->aligner.contents, + (char *) (arg1)->aligner.contents, + TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1))); + if (found_baseclass) - { - value_ptr v2 = allocate_value (basetype); - VALUE_LVAL (v2) = VALUE_LVAL (arg1); - VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1); - VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + offset + boffset; - if (VALUE_LAZY (arg1)) - VALUE_LAZY (v2) = 1; - else - memcpy (VALUE_CONTENTS_RAW (v2), - VALUE_CONTENTS_RAW (arg1) + offset + boffset, - TYPE_LENGTH (basetype)); - return v2; + { + /*return v2;*/ + + if (!*found) /* not yet found anything */ + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + retval = v2; + strcpy (found_class_name, TYPE_TAG_NAME (type)); + } + /* Don't count virtual bases twice when deciding ambiguity */ + if (*vbase != basetype) /* works for null *vbase */ + (*found)++; + /* Is this the first virtual base where we "found" something? */ + if (!*vbase) + *vbase = basetype; } - v = search_struct_field (name, arg1, offset + boffset, - TYPE_BASECLASS (type, i), - looking_for_baseclass); + else /* base not found, or looking for member */ + { + v = search_struct_field_aux (name, arg1, offset + boffset, + TYPE_BASECLASS (type, i), + looking_for_baseclass, &tmp_found, + tmp_class_name, vbase); + if (!*found && v) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + retval = v; + /* TYPE_TAG_NAME can be null in case of an anonymous union */ + if (TYPE_TAG_NAME (type)) + strcpy (found_class_name, TYPE_TAG_NAME (type)); + else + strcpy (found_class_name, " "); + strcat (found_class_name, "::"); + strcat (found_class_name, tmp_class_name); + } + /* Don't count virtual bases twice when deciding ambiguity */ + if (*vbase != basetype) /* works for null *vbase */ + *found += tmp_found; + /* Is this the first virtual base where we "found" something? */ + if (!*vbase) + *vbase = basetype; + tmp_found = 0; + } } else if (found_baseclass) - v = value_primitive_field (arg1, offset, i, type); + { + v = value_primitive_field (arg1, offset, i, type); + if (!*found) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + retval = v; + strcpy (found_class_name, TYPE_TAG_NAME (type)); + } + (*found)++; + } else - v = search_struct_field (name, arg1, - offset + TYPE_BASECLASS_BITPOS (type, i) / 8, - basetype, looking_for_baseclass); - if (v) return v; + { + v = search_struct_field_aux (name, arg1, + offset + TYPE_BASECLASS_BITPOS (type, i) / 8, + basetype, looking_for_baseclass, &tmp_found, + tmp_class_name, vbase); + if (!*found && v) + { + /* Record return value and class name, and continue + looking for possible ambiguous members */ + retval = v; + /* TYPE_TAG_NAME can be null in case of an anonymous union */ + if (TYPE_TAG_NAME (type)) + strcpy (found_class_name, TYPE_TAG_NAME (type)); + else + strcpy (found_class_name, " "); + strcat (found_class_name, "::"); + strcat (found_class_name, tmp_class_name); + } + *found += tmp_found; + tmp_found = 0; + } } - return NULL; + return retval; } + +/* Return the offset (in bytes) of the virtual base of type BASETYPE + * in an object pointed to by VALADDR (on the host), assumed to be of + * type TYPE. OFFSET is number of bytes beyond start of ARG to start + * looking (in case VALADDR is the contents of an enclosing object). + * + * This routine recurses on the primary base of the derived class because + * the virtual base entries of the primary base appear before the other + * virtual base entries. + * + * If the virtual base is not found, a negative integer is returned. + * The magnitude of the negative integer is the number of entries in + * the virtual table to skip over (entries corresponding to various + * ancestral classes in the chain of primary bases). + * + * Important: This assumes the HP / Taligent C++ runtime + * conventions. Use baseclass_offset() instead to deal with g++ + * conventions. */ + +void +find_rt_vbase_offset(type, basetype, valaddr, offset, boffset_p, skip_p) + struct type * type; + struct type * basetype; + char * valaddr; + int offset; + int * boffset_p; + int * skip_p; +{ + int boffset; /* offset of virtual base */ + int index; /* displacement to use in virtual table */ + int skip; + + value_ptr vp; + CORE_ADDR vtbl; /* the virtual table pointer */ + struct type * pbc; /* the primary base class */ + + /* Look for the virtual base recursively in the primary base, first. + * This is because the derived class object and its primary base + * subobject share the primary virtual table. */ + + boffset = 0; + pbc = TYPE_PRIMARY_BASE(type); + if (pbc) + { + find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip); + if (skip < 0) + { + *boffset_p = boffset; + *skip_p = -1; + return; + } + } + else + skip = 0; + + + /* Find the index of the virtual base according to HP/Taligent + runtime spec. (Depth-first, left-to-right.) */ + index = virtual_base_index_skip_primaries (basetype, type); + + if (index < 0) { + *skip_p = skip + virtual_base_list_length_skip_primaries (type); + *boffset_p = 0; + return; + } + + /* pai: FIXME -- 32x64 possible problem */ + /* First word (4 bytes) in object layout is the vtable pointer */ + vtbl = * (CORE_ADDR *) (valaddr + offset); + + /* Before the constructor is invoked, things are usually zero'd out. */ + if (vtbl == 0) + error ("Couldn't find virtual table -- object may not be constructed yet."); + + + /* Find virtual base's offset -- jump over entries for primary base + * ancestors, then use the index computed above. But also adjust by + * HP_ACC_VBASE_START for the vtable slots before the start of the + * virtual base entries. Offset is negative -- virtual base entries + * appear _before_ the address point of the virtual table. */ + + /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier + & use long type */ + + /* epstein : FIXME -- added param for overlay section. May not be correct */ + vp = value_at (builtin_type_int, vtbl + 4 * (- skip - index - HP_ACC_VBASE_START), NULL); + boffset = value_as_long (vp); + *skip_p = -1; + *boffset_p = boffset; + return; +} + + /* Helper function used by value_struct_elt to recurse through baseclasses. Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes, and search in it assuming it has (class) type TYPE. @@ -1797,7 +2364,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) name_matched = 1; if (j > 0 && args == 0) - error ("cannot resolve overloaded method `%s'", name); + error ("cannot resolve overloaded method `%s': no arguments supplied", name); while (j >= 0) { if (TYPE_FN_FIELD_STUB (f, j)) @@ -1823,14 +2390,47 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) if (BASETYPE_VIA_VIRTUAL (type, i)) { - base_offset = VALUE_OFFSET (*arg1p) + offset; - base_offset = - baseclass_offset (type, i, - VALUE_CONTENTS (*arg1p) + base_offset, - VALUE_ADDRESS (*arg1p) + base_offset); - if (base_offset == -1) - error ("virtual baseclass botch"); - } + if (TYPE_HAS_VTABLE (type)) + { + /* HP aCC compiled type, search for virtual base offset + according to HP/Taligent runtime spec. */ + int skip; + find_rt_vbase_offset (type, TYPE_BASECLASS (type, i), + VALUE_CONTENTS_ALL (*arg1p), + offset + VALUE_EMBEDDED_OFFSET (*arg1p), + &base_offset, &skip); + if (skip >= 0) + error ("Virtual base class offset not found in vtable"); + } + else + { + struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); + char *base_valaddr; + + /* The virtual base class pointer might have been clobbered by the + user program. Make sure that it still points to a valid memory + location. */ + + if (offset < 0 || offset >= TYPE_LENGTH (type)) + { + base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass)); + if (target_read_memory (VALUE_ADDRESS (*arg1p) + + VALUE_OFFSET (*arg1p) + offset, + base_valaddr, + TYPE_LENGTH (baseclass)) != 0) + error ("virtual baseclass botch"); + } + else + base_valaddr = VALUE_CONTENTS (*arg1p) + offset; + + base_offset = + baseclass_offset (type, i, base_valaddr, + VALUE_ADDRESS (*arg1p) + + VALUE_OFFSET (*arg1p) + offset); + if (base_offset == -1) + error ("virtual baseclass botch"); + } + } else { base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8; @@ -1975,6 +2575,142 @@ value_struct_elt (argp, args, name, static_memfuncp, err) return v; } + +/* Search through the methods of an object (and its bases) + * to find a specified method. Return the pointer to the + * fn_field list of overloaded instances. + * Helper function for value_find_oload_list. + * ARGP is a pointer to a pointer to a value (the object) + * METHOD is a string containing the method name + * OFFSET is the offset within the value + * STATIC_MEMFUNCP is set if the method is static + * TYPE is the assumed type of the object + * NUM_FNS is the number of overloaded instances + * BASETYPE is set to the actual type of the subobject where the method is found + * BOFFSET is the offset of the base subobject where the method is found */ + +struct fn_field * +find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset) + value_ptr *argp; + char * method; + int offset; + int * static_memfuncp; + struct type * type; + int * num_fns; + struct type ** basetype; + int * boffset; +{ + int i; + struct fn_field * f; + CHECK_TYPEDEF (type); + + *num_fns = 0; + + /* First check in object itself */ + for (i = TYPE_NFN_FIELDS (type) -1; i >= 0; i--) + { + /* pai: FIXME What about operators and type conversions? */ + char * fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i); + if (fn_field_name && STREQ (fn_field_name, method)) + { + *num_fns = TYPE_FN_FIELDLIST_LENGTH (type, i); + *basetype = type; + *boffset = offset; + return TYPE_FN_FIELDLIST1 (type, i); + } + } + + /* Not found in object, check in base subobjects */ + for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) + { + int base_offset; + if (BASETYPE_VIA_VIRTUAL (type, i)) + { + if (TYPE_HAS_VTABLE (type)) + { + /* HP aCC compiled type, search for virtual base offset + * according to HP/Taligent runtime spec. */ + int skip; + find_rt_vbase_offset (type, TYPE_BASECLASS (type, i), + VALUE_CONTENTS_ALL (*argp), + offset + VALUE_EMBEDDED_OFFSET (*argp), + &base_offset, &skip); + if (skip >= 0) + error ("Virtual base class offset not found in vtable"); + } + else + { + /* probably g++ runtime model */ + base_offset = VALUE_OFFSET (*argp) + offset; + base_offset = + baseclass_offset (type, i, + VALUE_CONTENTS (*argp) + base_offset, + VALUE_ADDRESS (*argp) + base_offset); + if (base_offset == -1) + error ("virtual baseclass botch"); + } + } + else /* non-virtual base, simply use bit position from debug info */ + { + base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8; + } + f = find_method_list (argp, method, base_offset + offset, + static_memfuncp, TYPE_BASECLASS (type, i), num_fns, basetype, boffset); + if (f) + return f; + } + return NULL; +} + +/* Return the list of overloaded methods of a specified name. + * ARGP is a pointer to a pointer to a value (the object) + * METHOD is the method name + * OFFSET is the offset within the value contents + * STATIC_MEMFUNCP is set if the method is static + * NUM_FNS is the number of overloaded instances + * BASETYPE is set to the type of the base subobject that defines the method + * BOFFSET is the offset of the base subobject which defines the method */ + +struct fn_field * +value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset) + value_ptr *argp; + char * method; + int offset; + int * static_memfuncp; + int * num_fns; + struct type ** basetype; + int * boffset; +{ + struct type * t; + value_ptr v; + + t = check_typedef (VALUE_TYPE (*argp)); + + /* code snarfed from value_struct_elt */ + while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF) + { + *argp = value_ind (*argp); + /* Don't coerce fn pointer to fn and then back again! */ + if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC) + COERCE_ARRAY (*argp); + t = check_typedef (VALUE_TYPE (*argp)); + } + + if (TYPE_CODE (t) == TYPE_CODE_MEMBER) + error ("Not implemented: member type in value_find_oload_lis"); + + if ( TYPE_CODE (t) != TYPE_CODE_STRUCT + && TYPE_CODE (t) != TYPE_CODE_UNION) + error ("Attempt to extract a component of a value that is not a struct or union"); + + /* Assume it's not static, unless we see that it is. */ + if (static_memfuncp) + *static_memfuncp =0; + + return find_method_list (argp, method, 0, static_memfuncp, t, num_fns, basetype, boffset); + +} + /* C++: return 1 is NAME is a legitimate name for the destructor of type TYPE. If TYPE does not have a destructor, or if NAME is inappropriate for TYPE, an error is signaled. */ @@ -2111,15 +2847,11 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) { if (TYPE_FIELD_STATIC (t, i)) { - char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (t, i); - struct symbol *sym = - lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL); - if (sym == NULL) - error ("Internal error: could not find physical static variable named %s", - phys_name); - return value_at (SYMBOL_TYPE (sym), - SYMBOL_VALUE_ADDRESS (sym), - SYMBOL_BFD_SECTION (sym)); + v = value_static_field (t, i); + if (v == NULL) + error ("Internal error: could not find static variable %s", + name); + return v; } if (TYPE_FIELD_PACKED (t, i)) error ("pointers to bitfield members not allowed"); @@ -2227,6 +2959,226 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) return 0; } + +/* Find the real run-time type of a value using RTTI. + * V is a pointer to the value. + * A pointer to the struct type entry of the run-time type + * is returneed. + * FULL is a flag that is set only if the value V includes + * the entire contents of an object of the RTTI type. + * TOP is the offset to the top of the enclosing object of + * the real run-time type. This offset may be for the embedded + * object, or for the enclosing object of V. + * USING_ENC is the flag that distinguishes the two cases. + * If it is 1, then the offset is for the enclosing object, + * otherwise for the embedded object. + * + * This currently works only for RTTI information generated + * by the HP ANSI C++ compiler (aCC). g++ today (1997-06-10) + * does not appear to support RTTI. This function returns a + * NULL value for objects in the g++ runtime model. */ + +struct type * +value_rtti_type (v, full, top, using_enc) + value_ptr v; + int * full; + int * top; + int * using_enc; +{ + struct type * known_type; + struct type * rtti_type; + CORE_ADDR coreptr; + value_ptr vp; + int using_enclosing = 0; + long top_offset = 0; + char rtti_type_name[256]; + + if (full) + *full = 0; + if (top) + *top = -1; + if (using_enc) + *using_enc = 0; + + /* Get declared type */ + known_type = VALUE_TYPE (v); + CHECK_TYPEDEF (known_type); + /* RTTI works only or class objects */ + if (TYPE_CODE (known_type) != TYPE_CODE_CLASS) + return NULL; + + /* If neither the declared type nor the enclosing type of the + * value structure has a HP ANSI C++ style virtual table, + * we can't do anything. */ + if (!TYPE_HAS_VTABLE (known_type)) + { + known_type = VALUE_ENCLOSING_TYPE (v); + CHECK_TYPEDEF (known_type); + if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) || + !TYPE_HAS_VTABLE (known_type)) + return NULL; /* No RTTI, or not HP-compiled types */ + CHECK_TYPEDEF (known_type); + using_enclosing = 1; + } + + if (using_enclosing && using_enc) + *using_enc = 1; + + /* First get the virtual table address */ + coreptr = * (CORE_ADDR *) ((VALUE_CONTENTS_ALL (v)) + + VALUE_OFFSET (v) + + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v))); + if (coreptr == 0) + return NULL; /* return silently -- maybe called on gdb-generated value */ + + /* Fetch the top offset of the object */ + /* FIXME possible 32x64 problem with pointer size & arithmetic */ + vp = value_at (builtin_type_int, + coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET, + VALUE_BFD_SECTION (v)); + top_offset = value_as_long (vp); + if (top) + *top = top_offset; + + /* Fetch the typeinfo pointer */ + /* FIXME possible 32x64 problem with pointer size & arithmetic */ + vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v)); + /* Indirect through the typeinfo pointer and retrieve the pointer + * to the string name */ + coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp)); + if (!coreptr) + error ("Retrieved null typeinfo pointer in trying to determine run-time type"); + vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v)); /* 4 -> offset of name field */ + /* FIXME possible 32x64 problem */ + + coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp)); + + read_memory_string (coreptr, rtti_type_name, 256); + + if (strlen (rtti_type_name) == 0) + error ("Retrieved null type name from typeinfo"); + + /* search for type */ + rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1); + + if (!rtti_type) + error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name); + CHECK_TYPEDEF (rtti_type); + +#if 0 /* debugging*/ + printf("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1); +#endif + + /* Check whether we have the entire object */ + if (full /* Non-null pointer passed */ + + && + /* Either we checked on the whole object in hand and found the + top offset to be zero */ + (((top_offset == 0) && + using_enclosing && + TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type)) + || + /* Or we checked on the embedded object and top offset was the + same as the embedded offset */ + ((top_offset == VALUE_EMBEDDED_OFFSET (v)) && + !using_enclosing && + TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type)))) + + *full = 1; + + return rtti_type; +} + +/* Given a pointer value V, find the real (RTTI) type + of the object it points to. + Other parameters FULL, TOP, USING_ENC as with value_rtti_type() + and refer to the values computed for the object pointed to. */ + +struct type * +value_rtti_target_type (v, full, top, using_enc) + value_ptr v; + int * full; + int * top; + int * using_enc; +{ + value_ptr target; + + target = value_ind (v); + + return value_rtti_type (target, full, top, using_enc); +} + +/* Given a value pointed to by ARGP, check its real run-time type, and + if that is different from the enclosing type, create a new value + using the real run-time type as the enclosing type (and of the same + type as ARGP) and return it, with the embedded offset adjusted to + be the correct offset to the enclosed object + RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other + parameters, computed by value_rtti_type(). If these are available, + they can be supplied and a second call to value_rtti_type() is avoided. + (Pass RTYPE == NULL if they're not available */ + +value_ptr +value_full_object (argp, rtype, xfull, xtop, xusing_enc) + value_ptr argp; + struct type * rtype; + int xfull; + int xtop; + int xusing_enc; + +{ + struct type * real_type; + int full = 0; + int top = -1; + int using_enc = 0; + value_ptr new_val; + + if (rtype) + { + real_type = rtype; + full = xfull; + top = xtop; + using_enc = xusing_enc; + } + else + real_type = value_rtti_type (argp, &full, &top, &using_enc); + + /* If no RTTI data, or if object is already complete, do nothing */ + if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp)) + return argp; + + /* If we have the full object, but for some reason the enclosing + type is wrong, set it */ /* pai: FIXME -- sounds iffy */ + if (full) + { + VALUE_ENCLOSING_TYPE (argp) = real_type; + return argp; + } + + /* Check if object is in memory */ + if (VALUE_LVAL (argp) != lval_memory) + { + warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type)); + + return argp; + } + + /* All other cases -- retrieve the complete object */ + /* 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 + + (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)), + VALUE_BFD_SECTION (argp)); + VALUE_TYPE (new_val) = VALUE_TYPE (argp); + VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top; + return new_val; +} + + + + /* C++: return the value of the class instance variable, if one exists. Flag COMPLAIN signals an error if the request is made in an inappropriate context. */ @@ -2242,9 +3194,11 @@ value_of_this (complain) value_ptr this; if (selected_frame == 0) - if (complain) - error ("no frame selected"); - else return 0; + { + if (complain) + error ("no frame selected"); + else return 0; + } func = get_frame_function (selected_frame); if (!func) @@ -2257,9 +3211,11 @@ value_of_this (complain) b = SYMBOL_BLOCK_VALUE (func); i = BLOCK_NSYMS (b); if (i <= 0) - if (complain) - error ("no args, no `this'"); - else return 0; + { + if (complain) + error ("no args, no `this'"); + else return 0; + } /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER symbol instead of the LOC_ARG one (if both exist). */ @@ -2439,4 +3395,12 @@ _initialize_valops () &setlist), &showlist); #endif + + add_show_from_set + (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *)&overload_resolution, + "Set overload resolution in evaluating C++ functions.", + &setlist), + &showlist); + overload_resolution = 1; + } |