diff options
Diffstat (limited to 'gdb/valops.c')
| -rw-r--r-- | gdb/valops.c | 3536 |
1 files changed, 3536 insertions, 0 deletions
diff --git a/gdb/valops.c b/gdb/valops.c new file mode 100644 index 0000000..eaf4295 --- /dev/null +++ b/gdb/valops.c @@ -0,0 +1,3536 @@ +/* Perform non-arithmetic operations on values, for GDB. + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, + 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Free Software Foundation, Inc. + + 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 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. */ + +#include "defs.h" +#include "symtab.h" +#include "gdbtypes.h" +#include "value.h" +#include "frame.h" +#include "inferior.h" +#include "gdbcore.h" +#include "target.h" +#include "demangle.h" +#include "language.h" +#include "gdbcmd.h" +#include "regcache.h" +#include "cp-abi.h" + +#include <errno.h> +#include "gdb_string.h" +#include "gdb_assert.h" + +/* 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; + +extern int overload_debug; +/* Local functions. */ + +static int typecmp (int staticp, int varargs, int nargs, + struct field t1[], struct value *t2[]); + +static CORE_ADDR find_function_addr (struct value *, struct type **); +static struct value *value_arg_coerce (struct value *, struct type *, int); + + +static CORE_ADDR value_push (CORE_ADDR, struct value *); + +static struct value *search_struct_field (char *, struct value *, int, + struct type *, int); + +static struct value *search_struct_method (char *, struct value **, + struct value **, + int, int *, struct type *); + +static int check_field_in (struct type *, const char *); + +static CORE_ADDR allocate_space_in_inferior (int); + +static struct value *cast_into_complex (struct type *, struct value *); + +static struct fn_field *find_method_list (struct value ** argp, char *method, + int offset, + struct type *type, int *num_fns, + struct type **basetype, + int *boffset); + +void _initialize_valops (void); + +/* Flag for whether we want to abandon failed expression evals by default. */ + +#if 0 +static int auto_abandon = 0; +#endif + +int overload_resolution = 0; + +/* This boolean tells what gdb should do if a signal is received while in + a function called from gdb (call dummy). If set, gdb unwinds the stack + and restore the context to what as it was before the call. + The default is to stop in the frame where the signal was received. */ + +int unwind_on_signal_p = 0; + + + +/* Find the address of function name NAME in the inferior. */ + +struct value * +find_function_in_inferior (const char *name) +{ + register struct symbol *sym; + sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); + if (sym != NULL) + { + if (SYMBOL_CLASS (sym) != LOC_BLOCK) + { + error ("\"%s\" exists in this program but is not a function.", + name); + } + return value_of_variable (sym, NULL); + } + else + { + struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL); + if (msymbol != NULL) + { + struct type *type; + CORE_ADDR maddr; + type = lookup_pointer_type (builtin_type_char); + type = lookup_function_type (type); + type = lookup_pointer_type (type); + maddr = SYMBOL_VALUE_ADDRESS (msymbol); + return value_from_pointer (type, maddr); + } + else + { + 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); + } + } +} + +/* Allocate NBYTES of space in the inferior using the inferior's malloc + and return a value that is a pointer to the allocated space. */ + +struct value * +value_allocate_space_in_inferior (int len) +{ + struct value *blocklen; + struct value *val = find_function_in_inferior (NAME_OF_MALLOC); + + blocklen = value_from_longest (builtin_type_int, (LONGEST) len); + val = call_function_by_hand (val, 1, &blocklen); + if (value_logical_not (val)) + { + 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; +} + +static CORE_ADDR +allocate_space_in_inferior (int len) +{ + return value_as_long (value_allocate_space_in_inferior (len)); +} + +/* Cast value ARG2 to type TYPE and return as a value. + More general than a C cast: accepts any two types of the same length, + and if ARG2 is an lvalue it can be cast into anything at all. */ +/* In C++, casts may change pointer or object representations. */ + +struct value * +value_cast (struct type *type, struct value *arg2) +{ + register enum type_code code1; + register enum type_code code2; + register int scalar; + struct type *type2; + + int convert_to_boolean = 0; + + if (VALUE_TYPE (arg2) == type) + return arg2; + + CHECK_TYPEDEF (type); + code1 = TYPE_CODE (type); + COERCE_REF (arg2); + type2 = check_typedef (VALUE_TYPE (arg2)); + + /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT, + is treated like a cast to (TYPE [N])OBJECT, + where N is sizeof(OBJECT)/sizeof(TYPE). */ + if (code1 == TYPE_CODE_ARRAY) + { + struct type *element_type = TYPE_TARGET_TYPE (type); + unsigned element_length = TYPE_LENGTH (check_typedef (element_type)); + if (element_length > 0 + && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED) + { + struct type *range_type = TYPE_INDEX_TYPE (type); + int val_length = TYPE_LENGTH (type2); + LONGEST low_bound, high_bound, new_length; + if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + low_bound = 0, high_bound = 0; + new_length = val_length / element_length; + if (val_length % element_length != 0) + warning ("array element type size does not divide object size in cast"); + /* FIXME-type-allocation: need a way to free this type when we are + done with it. */ + range_type = create_range_type ((struct type *) NULL, + TYPE_TARGET_TYPE (range_type), + low_bound, + new_length + low_bound - 1); + VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL, + element_type, range_type); + return arg2; + } + } + + if (current_language->c_style_arrays + && TYPE_CODE (type2) == TYPE_CODE_ARRAY) + arg2 = value_coerce_array (arg2); + + if (TYPE_CODE (type2) == TYPE_CODE_FUNC) + arg2 = value_coerce_function (arg2); + + type2 = check_typedef (VALUE_TYPE (arg2)); + COERCE_VARYING_ARRAY (arg2, type2); + code2 = TYPE_CODE (type2); + + if (code1 == TYPE_CODE_COMPLEX) + return cast_into_complex (type, arg2); + 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; + + scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT + || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE); + + if (code1 == TYPE_CODE_STRUCT + && code2 == TYPE_CODE_STRUCT + && TYPE_NAME (type) != 0) + { + /* 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 object in addition to changing its type. */ + struct value *v = search_struct_field (type_name_no_tag (type), + arg2, 0, type2, 1); + if (v) + { + VALUE_TYPE (v) = type; + return v; + } + } + if (code1 == TYPE_CODE_FLT && scalar) + return value_from_double (type, value_as_double (arg2)); + else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM + || code1 == TYPE_CODE_RANGE) + && (scalar || code2 == TYPE_CODE_PTR)) + { + LONGEST longest; + + if (hp_som_som_object_present && /* if target compiled by HP aCC */ + (code2 == TYPE_CODE_PTR)) + { + unsigned int *ptr; + struct value *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)); + /* force evaluation */ + ptr = (unsigned int *) VALUE_CONTENTS (retvalp); + *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 */ + } + } + + /* When we cast pointers to integers, we mustn't use + POINTER_TO_ADDRESS to find the address the pointer + represents, as value_as_long would. GDB should evaluate + expressions just as the compiler would --- and the compiler + sees a cast as a simple reinterpretation of the pointer's + bits. */ + if (code2 == TYPE_CODE_PTR) + longest = extract_unsigned_integer (VALUE_CONTENTS (arg2), + TYPE_LENGTH (type2)); + else + longest = value_as_long (arg2); + return value_from_longest (type, convert_to_boolean ? + (LONGEST) (longest ? 1 : 0) : longest); + } + else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || + code2 == TYPE_CODE_ENUM || + code2 == TYPE_CODE_RANGE)) + { + /* TYPE_LENGTH (type) is the length of a pointer, but we really + want the length of an address! -- we are really dealing with + addresses (i.e., gdb representations) not pointers (i.e., + target representations) here. + + This allows things like "print *(int *)0x01000234" to work + without printing a misleading message -- which would + otherwise occur when dealing with a target having two byte + pointers and four byte addresses. */ + + int addr_bit = TARGET_ADDR_BIT; + + LONGEST longest = value_as_long (arg2); + if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT) + { + if (longest >= ((LONGEST) 1 << addr_bit) + || longest <= -((LONGEST) 1 << addr_bit)) + warning ("value truncated"); + } + return value_from_longest (type, longest); + } + else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2)) + { + if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) + { + 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 + && !value_logical_not (arg2)) + { + struct value *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 = search_struct_field (type_name_no_tag (t2), + value_zero (t1, not_lval), 0, t1, 1); + if (v) + { + CORE_ADDR addr2 = value_as_address (arg2); + addr2 -= (VALUE_ADDRESS (v) + + VALUE_OFFSET (v) + + VALUE_EMBEDDED_OFFSET (v)); + return value_from_pointer (type, addr2); + } + } + } + /* No superclass found, just fall through to change ptr type. */ + } + VALUE_TYPE (arg2) = type; + arg2 = value_change_enclosing_type (arg2, type); + VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */ + return arg2; + } + /* OBSOLETE else if (chill_varying_type (type)) */ + /* OBSOLETE { */ + /* OBSOLETE struct type *range1, *range2, *eltype1, *eltype2; */ + /* OBSOLETE struct value *val; */ + /* OBSOLETE int count1, count2; */ + /* OBSOLETE LONGEST low_bound, high_bound; */ + /* OBSOLETE char *valaddr, *valaddr_data; */ + /* OBSOLETE *//* For lint warning about eltype2 possibly uninitialized: */ + /* OBSOLETE eltype2 = NULL; */ + /* OBSOLETE if (code2 == TYPE_CODE_BITSTRING) */ + /* OBSOLETE error ("not implemented: converting bitstring to varying type"); */ + /* OBSOLETE if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING) */ + /* OBSOLETE || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))), */ + /* OBSOLETE eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)), */ + /* OBSOLETE (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2) */ + /* OBSOLETE *//*|| TYPE_CODE (eltype1) != TYPE_CODE (eltype2) *//* ))) */ + /* OBSOLETE error ("Invalid conversion to varying type"); */ + /* OBSOLETE range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0); */ + /* OBSOLETE range2 = TYPE_FIELD_TYPE (type2, 0); */ + /* OBSOLETE if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0) */ + /* OBSOLETE count1 = -1; */ + /* OBSOLETE else */ + /* OBSOLETE count1 = high_bound - low_bound + 1; */ + /* OBSOLETE if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0) */ + /* OBSOLETE count1 = -1, count2 = 0; *//* To force error before */ + /* OBSOLETE else */ + /* OBSOLETE count2 = high_bound - low_bound + 1; */ + /* OBSOLETE if (count2 > count1) */ + /* OBSOLETE error ("target varying type is too small"); */ + /* OBSOLETE val = allocate_value (type); */ + /* OBSOLETE valaddr = VALUE_CONTENTS_RAW (val); */ + /* OBSOLETE valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8; */ + /* OBSOLETE *//* Set val's __var_length field to count2. */ + /* OBSOLETE store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)), */ + /* OBSOLETE count2); */ + /* OBSOLETE *//* Set the __var_data field to count2 elements copied from arg2. */ + /* OBSOLETE memcpy (valaddr_data, VALUE_CONTENTS (arg2), */ + /* OBSOLETE count2 * TYPE_LENGTH (eltype2)); */ + /* OBSOLETE *//* Zero the rest of the __var_data field of val. */ + /* OBSOLETE memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0', */ + /* OBSOLETE (count1 - count2) * TYPE_LENGTH (eltype2)); */ + /* OBSOLETE return val; */ + /* OBSOLETE } */ + else if (VALUE_LVAL (arg2) == lval_memory) + { + return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2), + VALUE_BFD_SECTION (arg2)); + } + else if (code1 == TYPE_CODE_VOID) + { + return value_zero (builtin_type_void, not_lval); + } + else + { + error ("Invalid cast."); + return 0; + } +} + +/* Create a value of type TYPE that is zero, and return it. */ + +struct value * +value_zero (struct type *type, enum lval_type lv) +{ + struct value *val = allocate_value (type); + + memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type))); + VALUE_LVAL (val) = lv; + + return val; +} + +/* Return a value with type TYPE located at ADDR. + + Call value_at only if the data needs to be fetched immediately; + if we can be 'lazy' and defer the fetch, perhaps indefinately, call + 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. + + Note: value_at does *NOT* handle embedded offsets; perform such + adjustments before or after calling it. */ + +struct value * +value_at (struct type *type, CORE_ADDR addr, asection *sect) +{ + struct value *val; + + if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) + error ("Attempt to dereference a generic pointer."); + + val = allocate_value (type); + + read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type)); + + VALUE_LVAL (val) = lval_memory; + VALUE_ADDRESS (val) = addr; + VALUE_BFD_SECTION (val) = sect; + + return val; +} + +/* Return a lazy value with type TYPE located at ADDR (cf. value_at). */ + +struct value * +value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect) +{ + struct value *val; + + if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) + error ("Attempt to dereference a generic pointer."); + + val = allocate_value (type); + + VALUE_LVAL (val) = lval_memory; + VALUE_ADDRESS (val) = addr; + VALUE_LAZY (val) = 1; + VALUE_BFD_SECTION (val) = sect; + + return val; +} + +/* 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. + + This function returns a value because it is used in the VALUE_CONTENTS + macro as part of an expression, where a void would not work. The + value is ignored. */ + +int +value_fetch_lazy (struct value *val) +{ + CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val); + int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)); + + struct type *type = VALUE_TYPE (val); + if (length) + read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length); + + VALUE_LAZY (val) = 0; + return 0; +} + + +/* Store the contents of FROMVAL into the location of TOVAL. + Return a new value with the location of TOVAL and contents of FROMVAL. */ + +struct value * +value_assign (struct value *toval, struct value *fromval) +{ + register struct type *type; + struct value *val; + char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE); + int use_buffer = 0; + + if (!toval->modifiable) + error ("Left operand of assignment is not a modifiable lvalue."); + + COERCE_REF (toval); + + type = VALUE_TYPE (toval); + if (VALUE_LVAL (toval) != lval_internalvar) + fromval = value_cast (type, fromval); + else + COERCE_ARRAY (fromval); + CHECK_TYPEDEF (type); + + /* If TOVAL is a special machine register requiring conversion + of program values to a special raw format, + convert FROMVAL's contents now, with result in `raw_buffer', + and set USE_BUFFER to the number of bytes to write. */ + + if (VALUE_REGNO (toval) >= 0) + { + int regno = VALUE_REGNO (toval); + if (CONVERT_REGISTER_P (regno)) + { + struct type *fromtype = check_typedef (VALUE_TYPE (fromval)); + VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer); + use_buffer = REGISTER_RAW_SIZE (regno); + } + } + + switch (VALUE_LVAL (toval)) + { + case lval_internalvar: + set_internalvar (VALUE_INTERNALVAR (toval), fromval); + val = value_copy (VALUE_INTERNALVAR (toval)->value); + val = value_change_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), + VALUE_OFFSET (toval), + VALUE_BITPOS (toval), + VALUE_BITSIZE (toval), + fromval); + break; + + case lval_memory: + { + char *dest_buffer; + CORE_ADDR changed_addr; + int changed_len; + + if (VALUE_BITSIZE (toval)) + { + char buffer[sizeof (LONGEST)]; + /* We assume that the argument to read_memory is in units of + host chars. FIXME: Is that correct? */ + changed_len = (VALUE_BITPOS (toval) + + VALUE_BITSIZE (toval) + + HOST_CHAR_BIT - 1) + / HOST_CHAR_BIT; + + if (changed_len > (int) sizeof (LONGEST)) + error ("Can't handle bitfields which don't fit in a %d bit word.", + (int) sizeof (LONGEST) * HOST_CHAR_BIT); + + read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + buffer, changed_len); + modify_field (buffer, value_as_long (fromval), + VALUE_BITPOS (toval), VALUE_BITSIZE (toval)); + changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval); + dest_buffer = buffer; + } + else if (use_buffer) + { + changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval); + changed_len = use_buffer; + dest_buffer = raw_buffer; + } + else + { + changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval); + changed_len = TYPE_LENGTH (type); + dest_buffer = VALUE_CONTENTS (fromval); + } + + write_memory (changed_addr, dest_buffer, changed_len); + if (memory_changed_hook) + memory_changed_hook (changed_addr, changed_len); + target_changed_event (); + } + break; + + case lval_register: + if (VALUE_BITSIZE (toval)) + { + char buffer[sizeof (LONGEST)]; + int len = + REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval); + + if (len > (int) sizeof (LONGEST)) + error ("Can't handle bitfields in registers larger than %d bits.", + (int) sizeof (LONGEST) * HOST_CHAR_BIT); + + if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval) + > len * HOST_CHAR_BIT) + /* Getting this right would involve being very careful about + byte order. */ + error ("Can't assign to bitfields that cross register " + "boundaries."); + + read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + buffer, len); + modify_field (buffer, value_as_long (fromval), + VALUE_BITPOS (toval), VALUE_BITSIZE (toval)); + write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + buffer, len); + } + else if (use_buffer) + write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + raw_buffer, use_buffer); + else + { + /* Do any conversion necessary when storing this type to more + than one register. */ +#ifdef REGISTER_CONVERT_FROM_TYPE + memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); + REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval), type, raw_buffer); + write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + raw_buffer, TYPE_LENGTH (type)); +#else + write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), + VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); +#endif + } + + target_changed_event (); + + /* Assigning to the stack pointer, frame pointer, and other + (architecture and calling convention specific) registers may + cause the frame cache to be out of date. We just do this + on all assignments to registers for simplicity; I doubt the slowdown + matters. */ + reinit_frame_cache (); + break; + + case lval_reg_frame_relative: + { + /* value is stored in a series of registers in the frame + specified by the structure. Copy that value out, modify + it, and copy it back in. */ + int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type)); + int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval)); + int byte_offset = VALUE_OFFSET (toval) % reg_size; + int reg_offset = VALUE_OFFSET (toval) / reg_size; + int amount_copied; + + /* Make the buffer large enough in all cases. */ + /* FIXME (alloca): Not safe for very large data types. */ + char *buffer = (char *) alloca (amount_to_copy + + sizeof (LONGEST) + + MAX_REGISTER_RAW_SIZE); + + int regno; + struct frame_info *frame; + + /* Figure out which frame this is in currently. */ + for (frame = get_current_frame (); + frame && FRAME_FP (frame) != VALUE_FRAME (toval); + frame = get_prev_frame (frame)) + ; + + if (!frame) + error ("Value being assigned to is no longer active."); + + amount_to_copy += (reg_size - amount_to_copy % reg_size); + + /* Copy it out. */ + for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset, + amount_copied = 0); + amount_copied < amount_to_copy; + amount_copied += reg_size, regno++) + { + get_saved_register (buffer + amount_copied, + (int *) NULL, (CORE_ADDR *) NULL, + frame, regno, (enum lval_type *) NULL); + } + + /* Modify what needs to be modified. */ + if (VALUE_BITSIZE (toval)) + modify_field (buffer + byte_offset, + value_as_long (fromval), + VALUE_BITPOS (toval), VALUE_BITSIZE (toval)); + else if (use_buffer) + memcpy (buffer + byte_offset, raw_buffer, use_buffer); + else + memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval), + TYPE_LENGTH (type)); + + /* Copy it back. */ + for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset, + amount_copied = 0); + amount_copied < amount_to_copy; + amount_copied += reg_size, regno++) + { + enum lval_type lval; + CORE_ADDR addr; + int optim; + + /* Just find out where to put it. */ + get_saved_register ((char *) NULL, + &optim, &addr, frame, regno, &lval); + + if (optim) + error ("Attempt to assign to a value that was optimized out."); + if (lval == lval_memory) + write_memory (addr, buffer + amount_copied, reg_size); + else if (lval == lval_register) + write_register_bytes (addr, buffer + amount_copied, reg_size); + else + error ("Attempt to assign to an unmodifiable value."); + } + + if (register_changed_hook) + register_changed_hook (-1); + target_changed_event (); + } + break; + + + default: + error ("Left operand of assignment is not an lvalue."); + } + + /* If the field does not entirely fill a LONGEST, then zero the sign bits. + If the field is signed, and is negative, then sign extend. */ + if ((VALUE_BITSIZE (toval) > 0) + && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST))) + { + LONGEST fieldval = value_as_long (fromval); + LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1; + + fieldval &= valmask; + if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1)))) + fieldval |= ~valmask; + + fromval = value_from_longest (type, fieldval); + } + + val = value_copy (toval); + memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval), + TYPE_LENGTH (type)); + VALUE_TYPE (val) = type; + val = value_change_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; +} + +/* Extend a value VAL to COUNT repetitions of its type. */ + +struct value * +value_repeat (struct value *arg1, int count) +{ + struct value *val; + + if (VALUE_LVAL (arg1) != lval_memory) + error ("Only values in memory can be extended with '@'."); + if (count < 1) + error ("Invalid number %d of repetitions.", count); + + val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count); + + read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1), + VALUE_CONTENTS_ALL_RAW (val), + TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))); + VALUE_LVAL (val) = lval_memory; + VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1); + + return val; +} + +struct value * +value_of_variable (struct symbol *var, struct block *b) +{ + struct value *val; + struct frame_info *frame = NULL; + + if (!b) + frame = NULL; /* Use selected frame. */ + else if (symbol_read_needs_frame (var)) + { + frame = block_innermost_frame (b); + if (!frame) + { + 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); + if (!val) + error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var)); + + return val; +} + +/* Given a value which is an array, return a value which is a pointer to its + first element, regardless of whether or not the array has a nonzero lower + bound. + + FIXME: A previous comment here indicated that this routine should be + substracting the array's lower bound. It's not clear to me that this + is correct. Given an array subscripting operation, it would certainly + work to do the adjustment here, essentially computing: + + (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0]) + + However I believe a more appropriate and logical place to account for + the lower bound is to do so in value_subscript, essentially computing: + + (&array[0] + ((index - lowerbound) * sizeof array[0])) + + As further evidence consider what would happen with operations other + than array subscripting, where the caller would get back a value that + had an address somewhere before the actual first element of the array, + and the information about the lower bound would be lost because of + the coercion to pointer type. + */ + +struct value * +value_coerce_array (struct value *arg1) +{ + register struct type *type = check_typedef (VALUE_TYPE (arg1)); + + if (VALUE_LVAL (arg1) != lval_memory) + error ("Attempt to take address of value not located in memory."); + + return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)), + (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); +} + +/* Given a value which is a function, return a value which is a pointer + to it. */ + +struct value * +value_coerce_function (struct value *arg1) +{ + struct value *retval; + + if (VALUE_LVAL (arg1) != lval_memory) + error ("Attempt to take address of value not located in memory."); + + retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)), + (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1))); + VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1); + return retval; +} + +/* Return a pointer value for the object for which ARG1 is the contents. */ + +struct value * +value_addr (struct value *arg1) +{ + struct value *arg2; + + struct type *type = check_typedef (VALUE_TYPE (arg1)); + if (TYPE_CODE (type) == TYPE_CODE_REF) + { + /* 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. */ + arg2 = value_copy (arg1); + VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type)); + return arg2; + } + if (TYPE_CODE (type) == TYPE_CODE_FUNC) + return value_coerce_function (arg1); + + if (VALUE_LVAL (arg1) != lval_memory) + error ("Attempt to take address of value not located in memory."); + + /* Get target memory address */ + arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)), + (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 ... */ + arg2 = value_change_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. */ + +struct value * +value_ind (struct value *arg1) +{ + struct type *base_type; + struct value *arg2; + + COERCE_ARRAY (arg1); + + 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 (base_type) == TYPE_CODE_INT) + return value_at_lazy (builtin_type_int, + (CORE_ADDR) value_as_long (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_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1), + VALUE_BFD_SECTION (arg1)); + /* Re-adjust type */ + VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type); + /* Add embedding info */ + arg2 = value_change_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 */ +} + +/* Pushing small parts of stack frames. */ + +/* Push one word (the size of object that a register holds). */ + +CORE_ADDR +push_word (CORE_ADDR sp, ULONGEST word) +{ + register int len = REGISTER_SIZE; + char *buffer = alloca (MAX_REGISTER_RAW_SIZE); + + store_unsigned_integer (buffer, len, word); + 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; +} + +/* Push LEN bytes with data at BUFFER. */ + +CORE_ADDR +push_bytes (CORE_ADDR sp, char *buffer, int len) +{ + 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; +} + +#ifndef PARM_BOUNDARY +#define PARM_BOUNDARY (0) +#endif + +/* Push onto the stack the specified value VALUE. Pad it correctly for + it to be an argument to a function. */ + +static CORE_ADDR +value_push (register CORE_ADDR sp, struct value *arg) +{ + register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)); + register int container_len = len; + register int offset; + + /* How big is the container we're going to put this value in? */ + if (PARM_BOUNDARY) + container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1) + & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1)); + + /* Are we going to put it at the high or low end of the container? */ + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + offset = container_len - len; + else + offset = 0; + + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= container_len; + write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len); + } + else + { + /* stack grows upward */ + write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len); + sp += container_len; + } + + return sp; +} + +CORE_ADDR +default_push_arguments (int nargs, struct value **args, CORE_ADDR sp, + int struct_return, CORE_ADDR struct_addr) +{ + /* ASSERT ( !struct_return); */ + int i; + for (i = nargs - 1; i >= 0; i--) + sp = value_push (sp, args[i]); + return sp; +} + + +/* Functions to use for the COERCE_FLOAT_TO_DOUBLE gdbarch method. + + How you should pass arguments to a function depends on whether it + was defined in K&R style or prototype style. If you define a + function using the K&R syntax that takes a `float' argument, then + callers must pass that argument as a `double'. If you define the + function using the prototype syntax, then you must pass the + argument as a `float', with no promotion. + + Unfortunately, on certain older platforms, the debug info doesn't + indicate reliably how each function was defined. A function type's + TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was + defined in prototype style. When calling a function whose + TYPE_FLAG_PROTOTYPED flag is clear, GDB consults the + COERCE_FLOAT_TO_DOUBLE gdbarch method to decide what to do. + + For modern targets, it is proper to assume that, if the prototype + flag is clear, that can be trusted: `float' arguments should be + promoted to `double'. You should register the function + `standard_coerce_float_to_double' to get this behavior. + + For some older targets, if the prototype flag is clear, that + doesn't tell us anything. So we guess that, if we don't have a + type for the formal parameter (i.e., the first argument to + COERCE_FLOAT_TO_DOUBLE is null), then we should promote it; + otherwise, we should leave it alone. The function + `default_coerce_float_to_double' provides this behavior; it is the + default value, for compatibility with older configurations. */ +int +default_coerce_float_to_double (struct type *formal, struct type *actual) +{ + return formal == NULL; +} + + +int +standard_coerce_float_to_double (struct type *formal, struct type *actual) +{ + return 1; +} + + +/* 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. + IS_PROTOTYPED is non-zero if the function declaration is prototyped. */ + +static struct value * +value_arg_coerce (struct value *arg, struct type *param_type, + int is_prototyped) +{ + register struct type *arg_type = check_typedef (VALUE_TYPE (arg)); + register struct type *type + = param_type ? check_typedef (param_type) : arg_type; + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_REF: + if (TYPE_CODE (arg_type) != TYPE_CODE_REF + && TYPE_CODE (arg_type) != TYPE_CODE_PTR) + { + arg = value_addr (arg); + VALUE_TYPE (arg) = param_type; + return arg; + } + break; + case TYPE_CODE_INT: + 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: + /* 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 (param_type, arg_type)) + { + 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; + case TYPE_CODE_ARRAY: + /* Arrays are coerced to pointers to their first element, unless + they are vectors, in which case we want to leave them alone, + because they are passed by value. */ + if (current_language->c_style_arrays) + if (!TYPE_VECTOR (type)) + type = lookup_pointer_type (TYPE_TARGET_TYPE (type)); + break; + case TYPE_CODE_UNDEF: + case TYPE_CODE_PTR: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_VOID: + case TYPE_CODE_SET: + case TYPE_CODE_RANGE: + case TYPE_CODE_STRING: + case TYPE_CODE_BITSTRING: + case TYPE_CODE_ERROR: + case TYPE_CODE_MEMBER: + case TYPE_CODE_METHOD: + case TYPE_CODE_COMPLEX: + default: + break; + } + + return value_cast (type, arg); +} + +/* Determine a function's address and its return type from its value. + Calls error() if the function is not valid for calling. */ + +static CORE_ADDR +find_function_addr (struct value *function, struct type **retval_type) +{ + register struct type *ftype = check_typedef (VALUE_TYPE (function)); + register enum type_code code = TYPE_CODE (ftype); + struct type *value_type; + CORE_ADDR funaddr; + + /* If it's a member function, just look at the function + part of it. */ + + /* Determine address to call. */ + if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD) + { + funaddr = VALUE_ADDRESS (function); + value_type = TYPE_TARGET_TYPE (ftype); + } + else if (code == TYPE_CODE_PTR) + { + funaddr = value_as_address (function); + ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); + if (TYPE_CODE (ftype) == TYPE_CODE_FUNC + || TYPE_CODE (ftype) == TYPE_CODE_METHOD) + { + funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr); + value_type = TYPE_TARGET_TYPE (ftype); + } + else + value_type = builtin_type_int; + } + else if (code == TYPE_CODE_INT) + { + /* Handle the case of functions lacking debugging info. + Their values are characters since their addresses are char */ + if (TYPE_LENGTH (ftype) == 1) + funaddr = value_as_address (value_addr (function)); + else + /* Handle integer used as address of a function. */ + funaddr = (CORE_ADDR) value_as_long (function); + + value_type = builtin_type_int; + } + else + error ("Invalid data type for function to be called."); + + *retval_type = value_type; + return funaddr; +} + +/* All this stuff with a dummy frame may seem unnecessarily complicated + (why not just save registers in GDB?). The purpose of pushing a dummy + frame which looks just like a real frame is so that if you call a + function and then hit a breakpoint (get a signal, etc), "backtrace" + will look right. Whether the backtrace needs to actually show the + stack at the time the inferior function was called is debatable, but + it certainly needs to not display garbage. So if you are contemplating + making dummy frames be different from normal frames, consider that. */ + +/* Perform a function call in the inferior. + ARGS is a vector of values of arguments (NARGS of them). + FUNCTION is a value, the function to be called. + Returns a value representing what the function returned. + May fail to return, if a breakpoint or signal is hit + during the execution of the function. + + ARGS is modified to contain coerced values. */ + +static struct value * +hand_function_call (struct value *function, int nargs, struct value **args) +{ + register CORE_ADDR sp; + register int i; + int rc; + CORE_ADDR start_sp; + /* 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. + + 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). + + NOTE: This is pretty stupid. CALL_DUMMY should be in strict + target byte order. */ + + static ULONGEST *dummy; + int sizeof_dummy1; + char *dummy1; + CORE_ADDR old_sp; + struct type *value_type; + unsigned char struct_return; + CORE_ADDR struct_addr = 0; + struct regcache *retbuf; + struct cleanup *retbuf_cleanup; + struct inferior_status *inf_status; + struct cleanup *inf_status_cleanup; + 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)); + int n_method_args = 0; + + dummy = alloca (SIZEOF_CALL_DUMMY_WORDS); + sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST); + dummy1 = alloca (sizeof_dummy1); + memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS); + + if (!target_has_execution) + noprocess (); + + /* Create a cleanup chain that contains the retbuf (buffer + containing the register values). This chain is create BEFORE the + inf_status chain so that the inferior status can cleaned up + (restored or discarded) without having the retbuf freed. */ + retbuf = regcache_xmalloc (current_gdbarch); + retbuf_cleanup = make_cleanup_regcache_xfree (retbuf); + + /* A cleanup for the inferior status. Create this AFTER the retbuf + so that this can be discarded or applied without interfering with + the regbuf. */ + inf_status = save_inferior_status (1); + inf_status_cleanup = make_cleanup_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) + they are saved on the stack in the inferior. */ + PUSH_DUMMY_FRAME; + + old_sp = read_sp (); + + /* Ensure that the initial SP is correctly aligned. */ + if (gdbarch_frame_align_p (current_gdbarch)) + { + /* NOTE: cagney/2002-09-18: + + On a RISC architecture, a void parameterless generic dummy + frame (i.e., no parameters, no result) typically does not + need to push anything the stack and hence can leave SP and + FP. Similarly, a framelss (possibly leaf) function does not + push anything on the stack and, hence, that too can leave FP + and SP unchanged. As a consequence, a sequence of void + parameterless generic dummy frame calls to frameless + functions will create a sequence of effectively identical + frames (SP, FP and TOS and PC the same). This, not + suprisingly, results in what appears to be a stack in an + infinite loop --- when GDB tries to find a generic dummy + frame on the internal dummy frame stack, it will always find + the first one. + + To avoid this problem, the code below always grows the stack. + That way, two dummy frames can never be identical. It does + burn a few bytes of stack but that is a small price to pay + :-). */ + sp = gdbarch_frame_align (current_gdbarch, old_sp); + if (sp == old_sp) + { + if (INNER_THAN (1, 2)) + /* Stack grows down. */ + sp = gdbarch_frame_align (current_gdbarch, old_sp - 1); + else + /* Stack grows up. */ + sp = gdbarch_frame_align (current_gdbarch, old_sp + 1); + } + gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp) + || (INNER_THAN (2, 1) && sp >= old_sp)); + } + else + /* FIXME: cagney/2002-09-18: Hey, you loose! Who knows how badly + aligned the SP is! Further, per comment above, if the generic + dummy frame ends up empty (because nothing is pushed) GDB won't + be able to correctly perform back traces. If a target is + having trouble with backtraces, first thing to do is add + FRAME_ALIGN() to its architecture vector. After that, try + adding SAVE_DUMMY_FRAME_TOS() and modifying FRAME_CHAIN so that + when the next outer frame is a generic dummy, it returns the + current frame's base. */ + sp = old_sp; + + if (INNER_THAN (1, 2)) + { + /* Stack grows down */ + sp -= sizeof_dummy1; + start_sp = sp; + } + else + { + /* Stack grows up */ + start_sp = sp; + sp += sizeof_dummy1; + } + + /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack + after allocating space for the call dummy. A target can specify + a SIZEOF_DUMMY1 (via SIZEOF_CALL_DUMMY_WORDS) such that all local + alignment requirements are met. */ + + funaddr = find_function_addr (function, &value_type); + CHECK_TYPEDEF (value_type); + + { + struct block *b = block_for_pc (funaddr); + /* If compiled without -g, assume GCC 2. */ + using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b)); + } + + /* Are we returning a value using a structure return or a normal + value return? */ + + struct_return = using_struct_return (function, funaddr, value_type, + using_gcc); + + /* Create a call sequence customized for this function + and the number of arguments for it. */ + for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++) + store_unsigned_integer (&dummy1[i * REGISTER_SIZE], + REGISTER_SIZE, + (ULONGEST) dummy[i]); + +#ifdef GDB_TARGET_IS_HPPA + real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, + value_type, using_gcc); +#else + FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, + value_type, using_gcc); + real_pc = start_sp; +#endif + + if (CALL_DUMMY_LOCATION == ON_STACK) + { + write_memory (start_sp, (char *) dummy1, sizeof_dummy1); + if (USE_GENERIC_DUMMY_FRAMES) + generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1); + } + + if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END) + { + /* Convex Unix prohibits executing in the stack segment. */ + /* Hope there is empty room at the top of the text segment. */ + extern CORE_ADDR text_end; + static int checked = 0; + if (!checked) + for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp) + if (read_memory_integer (start_sp, 1) != 0) + error ("text segment full -- no place to put call"); + checked = 1; + sp = old_sp; + real_pc = text_end - sizeof_dummy1; + write_memory (real_pc, (char *) dummy1, sizeof_dummy1); + if (USE_GENERIC_DUMMY_FRAMES) + generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1); + } + + if (CALL_DUMMY_LOCATION == AFTER_TEXT_END) + { + extern CORE_ADDR text_end; + int errcode; + sp = old_sp; + real_pc = text_end; + errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1); + if (errcode != 0) + error ("Cannot write text segment -- call_function failed"); + if (USE_GENERIC_DUMMY_FRAMES) + generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1); + } + + if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT) + { + real_pc = funaddr; + if (USE_GENERIC_DUMMY_FRAMES) + /* NOTE: cagney/2002-04-13: The entry point is going to be + modified with a single breakpoint. */ + generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (), + CALL_DUMMY_ADDRESS () + 1); + } + +#ifdef lint + sp = old_sp; /* It really is used, for some ifdef's... */ +#endif + + if (nargs < TYPE_NFIELDS (ftype)) + error ("too few arguments in function call"); + + for (i = nargs - 1; i >= 0; i--) + { + int prototyped; + + /* FIXME drow/2002-05-31: Should just always mark methods as + prototyped. Can we respect TYPE_VARARGS? Probably not. */ + if (TYPE_CODE (ftype) == TYPE_CODE_METHOD) + prototyped = 1; + else + prototyped = TYPE_PROTOTYPED (ftype); + + if (i < TYPE_NFIELDS (ftype)) + args[i] = value_arg_coerce (args[i], TYPE_FIELD_TYPE (ftype, i), + prototyped); + else + args[i] = value_arg_coerce (args[i], NULL, 0); + + /*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 && TYPE_CODE (ftype) != TYPE_CODE_METHOD) + /* if this parameter is a pointer to function */ + if (TYPE_CODE (param_type) == TYPE_CODE_PTR) + if (TYPE_CODE (TYPE_TARGET_TYPE (param_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 (REG_STRUCT_HAS_ADDR_P ()) + { + /* This is a machine like the sparc, where we may need to pass a + pointer to the structure, not the structure itself. */ + for (i = nargs - 1; i >= 0; i--) + { + struct type *arg_type = check_typedef (VALUE_TYPE (args[i])); + if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT + || TYPE_CODE (arg_type) == TYPE_CODE_UNION + || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY + || TYPE_CODE (arg_type) == TYPE_CODE_STRING + || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING + || TYPE_CODE (arg_type) == TYPE_CODE_SET + || (TYPE_CODE (arg_type) == TYPE_CODE_FLT + && TYPE_LENGTH (arg_type) > 8) + ) + && REG_STRUCT_HAS_ADDR (using_gcc, arg_type)) + { + CORE_ADDR addr; + int len; /* = TYPE_LENGTH (arg_type); */ + int aligned_len; + arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i])); + len = TYPE_LENGTH (arg_type); + + if (STACK_ALIGN_P ()) + /* 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. */ + aligned_len = STACK_ALIGN (len); + else + aligned_len = len; + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= aligned_len; + /* ... so the address of the thing we push is the + stack pointer after we push it. */ + addr = sp; + } + else + { + /* The stack grows up, so the address of the thing + we push is the stack pointer before we push it. */ + addr = sp; + sp += aligned_len; + } + /* Push the structure. */ + write_memory (addr, VALUE_CONTENTS_ALL (args[i]), 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), + (LONGEST) addr); */ + args[i] = value_from_pointer (lookup_pointer_type (arg_type), + addr); + } + } + } + + + /* Reserve space for the return structure to be written on the + stack, if necessary. Make certain that the value is correctly + aligned. */ + + if (struct_return) + { + int len = TYPE_LENGTH (value_type); + if (STACK_ALIGN_P ()) + /* 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. */ + len = STACK_ALIGN (len); + if (INNER_THAN (1, 2)) + { + /* Stack grows downward. Align STRUCT_ADDR and SP after + making space for the return value. */ + sp -= len; + if (gdbarch_frame_align_p (current_gdbarch)) + sp = gdbarch_frame_align (current_gdbarch, sp); + struct_addr = sp; + } + else + { + /* Stack grows upward. Align the frame, allocate space, and + then again, re-align the frame??? */ + if (gdbarch_frame_align_p (current_gdbarch)) + sp = gdbarch_frame_align (current_gdbarch, sp); + struct_addr = sp; + sp += len; + if (gdbarch_frame_align_p (current_gdbarch)) + sp = gdbarch_frame_align (current_gdbarch, sp); + } + } + + /* 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 */ + if (EXTRA_STACK_ALIGNMENT_NEEDED) + { + /* 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_ALIGN_P () && 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_ENCLOSING_TYPE (args[i])); + if (CALL_DUMMY_STACK_ADJUST_P) + len += CALL_DUMMY_STACK_ADJUST; + sp -= STACK_ALIGN (len) - len; + } + } + + sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr); + + if (PUSH_RETURN_ADDRESS_P ()) + /* for targets that use no CALL_DUMMY */ + /* There are a number of targets now which actually don't write + any CALL_DUMMY instructions into the target, but instead just + save the machine state, push the arguments, and jump directly + to the callee function. Since this doesn't actually involve + executing a JSR/BSR instruction, the return address must be set + up by hand, either by pushing onto the stack or copying into a + return-address register as appropriate. Formerly this has been + done in PUSH_ARGUMENTS, but that's overloading its + functionality a bit, so I'm making it explicit to do it here. */ + sp = PUSH_RETURN_ADDRESS (real_pc, sp); + + if (STACK_ALIGN_P () && !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! */ + if (CALL_DUMMY_STACK_ADJUST_P) + sp += CALL_DUMMY_STACK_ADJUST; + sp = STACK_ALIGN (sp); + } + +/* XXX This seems wrong. For stacks that grow down we shouldn't do + anything here! */ + /* 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 (CALL_DUMMY_STACK_ADJUST_P) + if (INNER_THAN (1, 2)) + { + /* stack grows downward */ + sp -= CALL_DUMMY_STACK_ADJUST; + } + + /* Store the address at which the structure is supposed to be + written. Note that this (and the code which reserved the space + above) assumes that gcc was used to compile this function. Since + it doesn't cost us anything but space and if the function is pcc + it will ignore this value, we will make that assumption. + + Also note that on some machines (like the sparc) pcc uses a + convention like gcc's. */ + + if (struct_return) + STORE_STRUCT_RETURN (struct_addr, sp); + + /* Write the stack pointer. This is here because the statements above + might fool with it. On SPARC, this write also stores the register + window into the right place in the new stack frame, which otherwise + wouldn't happen. (See store_inferior_registers in sparc-nat.c.) */ + write_sp (sp); + + if (SAVE_DUMMY_FRAME_TOS_P ()) + SAVE_DUMMY_FRAME_TOS (sp); + + { + char *name; + struct symbol *symbol; + + name = NULL; + symbol = find_pc_function (funaddr); + if (symbol) + { + name = SYMBOL_SOURCE_NAME (symbol); + } + else + { + /* Try the minimal symbols. */ + struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr); + + if (msymbol) + { + name = SYMBOL_SOURCE_NAME (msymbol); + } + } + if (name == NULL) + { + char format[80]; + sprintf (format, "at %s", local_hex_format ()); + name = alloca (80); + /* FIXME-32x64: assumes funaddr fits in a long. */ + sprintf (name, format, (unsigned long) funaddr); + } + + /* Execute the stack dummy routine, calling FUNCTION. + When it is done, discard the empty frame + after storing the contents of all regs into retbuf. */ + rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf); + + if (rc == 1) + { + /* We stopped inside the FUNCTION because of a random signal. + Further execution of the FUNCTION is not allowed. */ + + if (unwind_on_signal_p) + { + /* The user wants the context restored. */ + + /* We must get back to the frame we were before the dummy call. */ + POP_FRAME; + + /* FIXME: Insert a bunch of wrap_here; name can be very long if it's + a C++ name with arguments and stuff. */ + error ("\ +The program being debugged was signaled while in a function called from GDB.\n\ +GDB has restored the context to what it was before the call.\n\ +To change this behavior use \"set unwindonsignal off\"\n\ +Evaluation of the expression containing the function (%s) will be abandoned.", + name); + } + else + { + /* The user wants to stay in the frame where we stopped (default).*/ + + /* If we restored the inferior status (via the cleanup), + we would print a spurious error message (Unable to + restore previously selected frame), would write the + registers from the inf_status (which is wrong), and + would do other wrong things. */ + discard_cleanups (inf_status_cleanup); + discard_inferior_status (inf_status); + + /* FIXME: Insert a bunch of wrap_here; name can be very long if it's + a C++ name with arguments and stuff. */ + error ("\ +The program being debugged was signaled while in a function called from GDB.\n\ +GDB remains in the frame where the signal was received.\n\ +To change this behavior use \"set unwindonsignal on\"\n\ +Evaluation of the expression containing the function (%s) will be abandoned.", + name); + } + } + + if (rc == 2) + { + /* We hit a breakpoint inside the FUNCTION. */ + + /* If we restored the inferior status (via the cleanup), we + would print a spurious error message (Unable to restore + previously selected frame), would write the registers from + the inf_status (which is wrong), and would do other wrong + things. */ + discard_cleanups (inf_status_cleanup); + discard_inferior_status (inf_status); + + /* The following error message used to say "The expression + which contained the function call has been discarded." It + is a hard concept to explain in a few words. Ideally, GDB + would be able to resume evaluation of the expression when + the function finally is done executing. Perhaps someday + this will be implemented (it would not be easy). */ + + /* FIXME: Insert a bunch of wrap_here; name can be very long if it's + a C++ name with arguments and stuff. */ + error ("\ +The program being debugged stopped while in a function called from GDB.\n\ +When the function (%s) is done executing, GDB will silently\n\ +stop (instead of continuing to evaluate the expression containing\n\ +the function call).", name); + } + + /* If we get here the called FUNCTION run to completion. */ + + /* Restore the inferior status, via its cleanup. At this stage, + leave the RETBUF alone. */ + do_cleanups (inf_status_cleanup); + + /* 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) + { + do_cleanups (retbuf_cleanup); + return VALUE_RETURNED_FROM_STACK (value_type, struct_addr); + } +#endif + /* NOTE: cagney/2002-09-10: Only when the stack has been correctly + aligned (using frame_align()) do we can trust STRUCT_ADDR and + fetch the return value direct from the stack. This lack of + trust comes about because legacy targets have a nasty habit of + silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR. + For such targets, just hope that value_being_returned() can + find the adjusted value. */ + if (struct_return && gdbarch_frame_align_p (current_gdbarch)) + { + struct value *retval = value_at (value_type, struct_addr, NULL); + do_cleanups (retbuf_cleanup); + return retval; + } + else + { + struct value *retval = value_being_returned (value_type, retbuf, + struct_return); + do_cleanups (retbuf_cleanup); + return retval; + } + } +} + +struct value * +call_function_by_hand (struct value *function, int nargs, struct value **args) +{ + if (CALL_DUMMY_P) + { + return hand_function_call (function, nargs, args); + } + else + { + error ("Cannot invoke functions on this machine."); + } +} + + + +/* Create a value for an array by allocating space in the inferior, copying + the data into that space, and then setting up an array value. + + The array bounds are set from LOWBOUND and HIGHBOUND, and the array is + populated from the values passed in ELEMVEC. + + The element type of the array is inherited from the type of the + first element, and all elements must have the same size (though we + don't currently enforce any restriction on their types). */ + +struct value * +value_array (int lowbound, int highbound, struct value **elemvec) +{ + int nelem; + int idx; + unsigned int typelength; + struct value *val; + struct type *rangetype; + struct type *arraytype; + CORE_ADDR addr; + + /* Validate that the bounds are reasonable and that each of the elements + have the same size. */ + + nelem = highbound - lowbound + 1; + if (nelem <= 0) + { + error ("bad array bounds (%d, %d)", lowbound, highbound); + } + typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0])); + for (idx = 1; idx < nelem; idx++) + { + if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength) + { + error ("array elements must all be the same size"); + } + } + + rangetype = create_range_type ((struct type *) NULL, builtin_type_int, + lowbound, highbound); + arraytype = create_array_type ((struct type *) NULL, + 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_ALL_RAW (val) + (idx * typelength), + VALUE_CONTENTS_ALL (elemvec[idx]), + typelength); + } + VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]); + return val; + } + + /* Allocate space to store the array in the inferior, and then initialize + it by copying in each element. FIXME: Is it worth it to create a + local buffer in which to collect each value and then write all the + bytes in one operation? */ + + addr = allocate_space_in_inferior (nelem * typelength); + for (idx = 0; idx < nelem; idx++) + { + write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]), + typelength); + } + + /* Create the array type and set up an array value to be evaluated lazily. */ + + val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0])); + return (val); +} + +/* Create a value for a string constant by allocating space in the inferior, + copying the data into that space, and returning the address with type + TYPE_CODE_STRING. PTR points to the string constant data; LEN is number + of characters. + Note that string types are like array of char types with a lower bound of + zero and an upper bound of LEN - 1. Also note that the string may contain + embedded null bytes. */ + +struct value * +value_string (char *ptr, int len) +{ + struct value *val; + 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_string_type ((struct type *) NULL, rangetype); + CORE_ADDR addr; + + if (current_language->c_style_arrays == 0) + { + val = allocate_value (stringtype); + memcpy (VALUE_CONTENTS_RAW (val), ptr, len); + return val; + } + + + /* Allocate space to store the string in the inferior, and then + copy LEN bytes from PTR in gdb to that address in the inferior. */ + + addr = allocate_space_in_inferior (len); + write_memory (addr, ptr, len); + + val = value_at_lazy (stringtype, addr, NULL); + return (val); +} + +struct value * +value_bitstring (char *ptr, int len) +{ + struct value *val; + struct type *domain_type = create_range_type (NULL, builtin_type_int, + 0, len - 1); + struct type *type = create_set_type ((struct type *) NULL, domain_type); + TYPE_CODE (type) = TYPE_CODE_BITSTRING; + val = allocate_value (type); + memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type)); + return val; +} + +/* See if we can pass arguments in T2 to a function which takes arguments + of types T1. T1 is a list of NARGS arguments, and T2 is a NULL-terminated + vector. If some arguments need coercion of some sort, then the coerced + values are written into T2. Return value is 0 if the arguments could be + matched, or the position at which they differ if not. + + STATICP is nonzero if the T1 argument list came from a + static member function. T2 will still include the ``this'' pointer, + but it will be skipped. + + For non-static member functions, we ignore the first argument, + which is the type of the instance variable. This is because we want + to handle calls with objects from derived classes. This is not + entirely correct: we should actually check to make sure that a + requested operation is type secure, shouldn't we? FIXME. */ + +static int +typecmp (int staticp, int varargs, int nargs, + struct field t1[], struct value *t2[]) +{ + int i; + + if (t2 == 0) + internal_error (__FILE__, __LINE__, "typecmp: no argument list"); + + /* Skip ``this'' argument if applicable. T2 will always include THIS. */ + if (staticp) + t2 ++; + + for (i = 0; + (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID; + i++) + { + struct type *tt1, *tt2; + + if (!t2[i]) + return i + 1; + + tt1 = check_typedef (t1[i].type); + tt2 = check_typedef (VALUE_TYPE (t2[i])); + + if (TYPE_CODE (tt1) == TYPE_CODE_REF + /* We should be doing hairy argument matching, as below. */ + && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2))) + { + if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY) + t2[i] = value_coerce_array (t2[i]); + else + t2[i] = value_addr (t2[i]); + continue; + } + + /* djb - 20000715 - Until the new type structure is in the + place, and we can attempt things like implicit conversions, + we need to do this so you can take something like a map<const + char *>, and properly access map["hello"], because the + argument to [] will be a reference to a pointer to a char, + and the argument will be a pointer to a char. */ + while ( TYPE_CODE(tt1) == TYPE_CODE_REF || + TYPE_CODE (tt1) == TYPE_CODE_PTR) + { + tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) ); + } + while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY || + TYPE_CODE(tt2) == TYPE_CODE_PTR || + TYPE_CODE(tt2) == TYPE_CODE_REF) + { + tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) ); + } + if (TYPE_CODE (tt1) == TYPE_CODE (tt2)) + continue; + /* Array to pointer is a `trivial conversion' according to the ARM. */ + + /* We should be doing much hairier argument matching (see section 13.2 + of the ARM), but as a quick kludge, just check for the same type + code. */ + if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i]))) + return i + 1; + } + if (varargs || t2[i] == NULL) + return 0; + return i + 1; +} + +/* 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. + If found, return value, else return NULL. + + If LOOKING_FOR_BASECLASS, then instead of looking for struct fields, + look for a baseclass named NAME. */ + +static struct value * +search_struct_field (char *name, struct value *arg1, int offset, + register struct type *type, int looking_for_baseclass) +{ + int i; + int nbases = TYPE_N_BASECLASSES (type); + + CHECK_TYPEDEF (type); + + if (!looking_for_baseclass) + for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--) + { + char *t_field_name = TYPE_FIELD_NAME (type, i); + + if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) + { + struct value *v; + if (TYPE_FIELD_STATIC (type, i)) + { + v = value_static_field (type, i); + if (v == 0) + error ("field %s is nonexistent or has been optimised out", + name); + } + else + { + v = value_primitive_field (arg1, offset, i, type); + if (v == 0) + error ("there is no field named %s", name); + } + return v; + } + + if (t_field_name + && (t_field_name[0] == '\0' + || (TYPE_CODE (type) == TYPE_CODE_UNION + && (strcmp_iw (t_field_name, "else") == 0)))) + { + struct type *field_type = TYPE_FIELD_TYPE (type, i); + if (TYPE_CODE (field_type) == TYPE_CODE_UNION + || TYPE_CODE (field_type) == TYPE_CODE_STRUCT) + { + /* Look for a match through the fields of an anonymous union, + or anonymous struct. C++ provides anonymous unions. + + In the GNU Chill (OBSOLETE) implementation of + variant record types, each <alternative field> has + an (anonymous) union type, each member of the union + represents a <variant alternative>. Each <variant + alternative> is represented as a struct, with a + member for each <variant field>. */ + + struct value *v; + int new_offset = offset; + + /* This is pretty gross. In G++, the offset in an + anonymous union is relative to the beginning of the + enclosing struct. In the GNU Chill (OBSOLETE) + implementation of variant records, the bitpos is + zero in an anonymous union field, so we have to add + the offset of the union here. */ + if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT + || (TYPE_NFIELDS (field_type) > 0 + && 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; + } + } + } + + for (i = 0; i < nbases; i++) + { + struct value *v; + struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); + /* If we are looking for baseclasses, this is what we get when we + hit them. But it could happen that the base part's member name + is not yet filled in. */ + int found_baseclass = (looking_for_baseclass + && TYPE_BASECLASS_NAME (type, i) != NULL + && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0)); + + if (BASETYPE_VIA_VIRTUAL (type, i)) + { + int boffset; + struct value *v2 = allocate_value (basetype); + + boffset = baseclass_offset (type, i, + VALUE_CONTENTS (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. */ + + boffset += offset; + if (boffset < 0 || boffset >= TYPE_LENGTH (type)) + { + CORE_ADDR base_addr; + + base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset; + if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2), + TYPE_LENGTH (basetype)) != 0) + error ("virtual baseclass botch"); + VALUE_LVAL (v2) = lval_memory; + VALUE_ADDRESS (v2) = base_addr; + } + else + { + VALUE_LVAL (v2) = VALUE_LVAL (arg1); + VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1); + VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset; + if (VALUE_LAZY (arg1)) + VALUE_LAZY (v2) = 1; + else + memcpy (VALUE_CONTENTS_RAW (v2), + VALUE_CONTENTS_RAW (arg1) + boffset, + TYPE_LENGTH (basetype)); + } + + if (found_baseclass) + return v2; + v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i), + looking_for_baseclass); + } + else if (found_baseclass) + v = value_primitive_field (arg1, offset, i, type); + else + v = search_struct_field (name, arg1, + offset + TYPE_BASECLASS_BITPOS (type, i) / 8, + basetype, looking_for_baseclass); + if (v) + return v; + } + return NULL; +} + + +/* 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 (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; + + struct value *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. + If found, return value, else if name matched and args not return (value)-1, + else return NULL. */ + +static struct value * +search_struct_method (char *name, struct value **arg1p, + struct value **args, int offset, + int *static_memfuncp, register struct type *type) +{ + int i; + struct value *v; + int name_matched = 0; + char dem_opname[64]; + + CHECK_TYPEDEF (type); + for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--) + { + char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i); + /* FIXME! May need to check for ARM demangling here */ + if (strncmp (t_field_name, "__", 2) == 0 || + strncmp (t_field_name, "op", 2) == 0 || + strncmp (t_field_name, "type", 4) == 0) + { + if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI)) + t_field_name = dem_opname; + else if (cplus_demangle_opname (t_field_name, dem_opname, 0)) + t_field_name = dem_opname; + } + if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) + { + int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1; + struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); + name_matched = 1; + + check_stub_method_group (type, i); + if (j > 0 && args == 0) + error ("cannot resolve overloaded method `%s': no arguments supplied", name); + else if (j == 0 && args == 0) + { + v = value_fn_field (arg1p, f, j, type, offset); + if (v != NULL) + return v; + } + else + while (j >= 0) + { + if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j), + TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)), + TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)), + TYPE_FN_FIELD_ARGS (f, j), args)) + { + if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) + return value_virtual_fn_field (arg1p, f, j, type, offset); + if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp) + *static_memfuncp = 1; + v = value_fn_field (arg1p, f, j, type, offset); + if (v != NULL) + return v; + } + j--; + } + } + } + + 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 (*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; + } + v = search_struct_method (name, arg1p, args, base_offset + offset, + static_memfuncp, TYPE_BASECLASS (type, i)); + if (v == (struct value *) - 1) + { + name_matched = 1; + } + else if (v) + { +/* FIXME-bothner: Why is this commented out? Why is it here? */ +/* *arg1p = arg1_tmp; */ + return v; + } + } + if (name_matched) + return (struct value *) - 1; + else + return NULL; +} + +/* Given *ARGP, a value of type (pointer to a)* structure/union, + extract the component named NAME from the ultimate target structure/union + and return it as a value with its appropriate type. + ERR is used in the error message if *ARGP's type is wrong. + + C++: ARGS is a list of argument types to aid in the selection of + an appropriate method. Also, handle derived types. + + STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location + where the truthvalue of whether the function that was resolved was + a static member function or not is stored. + + ERR is an error message to be printed in case the field is not found. */ + +struct value * +value_struct_elt (struct value **argp, struct value **args, + char *name, int *static_memfuncp, char *err) +{ + register struct type *t; + struct value *v; + + COERCE_ARRAY (*argp); + + t = check_typedef (VALUE_TYPE (*argp)); + + /* Follow pointers until we get to a non-pointer. */ + + 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_struct_elt"); + + 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 %s.", err); + + /* Assume it's not, unless we see that it is. */ + if (static_memfuncp) + *static_memfuncp = 0; + + if (!args) + { + /* if there are no arguments ...do this... */ + + /* Try as a field first, because if we succeed, there + is less work to be done. */ + v = search_struct_field (name, *argp, 0, t, 0); + if (v) + return v; + + /* C++: If it was not found as a data field, then try to + return it as a pointer to a method. */ + + if (destructor_name_p (name, t)) + error ("Cannot get value of destructor"); + + v = search_struct_method (name, argp, args, 0, static_memfuncp, t); + + if (v == (struct value *) - 1) + error ("Cannot take address of a method"); + else if (v == 0) + { + if (TYPE_NFN_FIELDS (t)) + error ("There is no member or method named %s.", name); + else + error ("There is no member named %s.", name); + } + return v; + } + + if (destructor_name_p (name, t)) + { + if (!args[1]) + { + /* Destructors are a special case. */ + int m_index, f_index; + + v = NULL; + if (get_destructor_fn_field (t, &m_index, &f_index)) + { + v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index), + f_index, NULL, 0); + } + if (v == NULL) + error ("could not find destructor function named %s.", name); + else + return v; + } + else + { + error ("destructor should not have any argument"); + } + } + else + v = search_struct_method (name, argp, args, 0, static_memfuncp, t); + + if (v == (struct value *) - 1) + { + error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name); + } + else if (v == 0) + { + /* See if user tried to invoke data as function. If so, + hand it back. If it's not callable (i.e., a pointer to function), + gdb should give an error. */ + v = search_struct_field (name, *argp, 0, t, 0); + } + + if (!v) + error ("Structure has no component named %s.", name); + 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 + * 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 */ + +static struct fn_field * +find_method_list (struct value **argp, char *method, int offset, + 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 && (strcmp_iw (fn_field_name, method) == 0)) + { + int len = TYPE_FN_FIELDLIST_LENGTH (type, i); + struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); + + *num_fns = len; + *basetype = type; + *boffset = offset; + + /* Resolve any stub methods. */ + check_stub_method_group (type, i); + + return f; + } + } + + /* 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, + 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 + * 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 (struct value **argp, char *method, int offset, + int *num_fns, struct type **basetype, + int *boffset) +{ + struct type *t; + + 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"); + + return find_method_list (argp, method, 0, t, num_fns, basetype, boffset); +} + +/* Given an array of argument types (ARGTYPES) (which includes an + entry for "this" in the case of C++ methods), the number of + arguments NARGS, the NAME of a function whether it's a method or + not (METHOD), and the degree of laxness (LAX) in conforming to + overload resolution rules in ANSI C++, find the best function that + matches on the argument types according to the overload resolution + rules. + + In the case of class methods, the parameter OBJ is an object value + in which to search for overloaded methods. + + In the case of non-method functions, the parameter FSYM is a symbol + corresponding to one of the overloaded functions. + + Return value is an integer: 0 -> good match, 10 -> debugger applied + non-standard coercions, 100 -> incompatible. + + If a method is being searched for, VALP will hold the value. + If a non-method is being searched for, SYMP will hold the symbol for it. + + If a method is being searched for, and it is a static method, + then STATICP will point to a non-zero value. + + Note: This function does *not* check the value of + overload_resolution. Caller must check it to see whether overload + resolution is permitted. + */ + +int +find_overload_match (struct type **arg_types, int nargs, char *name, int method, + int lax, struct value **objp, struct symbol *fsym, + struct value **valp, struct symbol **symp, int *staticp) +{ + int nparms; + struct type **parm_types; + int champ_nparms = 0; + struct value *obj = (objp ? *objp : NULL); + + short oload_champ = -1; /* Index of best overloaded function */ + short oload_ambiguous = 0; /* Current ambiguity state for overload resolution */ + /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */ + short oload_ambig_champ = -1; /* 2nd contender for best match */ + short oload_non_standard = 0; /* did we have to use non-standard conversions? */ + short oload_incompatible = 0; /* are args supplied incompatible with any function? */ + + struct badness_vector *bv; /* A measure of how good an overloaded instance is */ + struct badness_vector *oload_champ_bv = NULL; /* The measure for the current best match */ + + struct value *temp = obj; + struct fn_field *fns_ptr = NULL; /* For methods, the list of overloaded methods */ + struct symbol **oload_syms = NULL; /* For non-methods, the list of overloaded function symbols */ + int num_fns = 0; /* Number of overloaded instances being considered */ + struct type *basetype = NULL; + int boffset; + register int jj; + register int ix; + int static_offset; + struct cleanup *cleanups = NULL; + + char *obj_type_name = NULL; + char *func_name = NULL; + + /* Get the list of overloaded methods or functions */ + if (method) + { + obj_type_name = TYPE_NAME (VALUE_TYPE (obj)); + /* Hack: evaluate_subexp_standard often passes in a pointer + value rather than the object itself, so try again */ + if ((!obj_type_name || !*obj_type_name) && + (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR)) + obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj))); + + fns_ptr = value_find_oload_method_list (&temp, name, 0, + &num_fns, + &basetype, &boffset); + if (!fns_ptr || !num_fns) + error ("Couldn't find method %s%s%s", + obj_type_name, + (obj_type_name && *obj_type_name) ? "::" : "", + name); + /* If we are dealing with stub method types, they should have + been resolved by find_method_list via value_find_oload_method_list + above. */ + gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL); + } + else + { + int i = -1; + func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS); + + /* If the name is NULL this must be a C-style function. + Just return the same symbol. */ + if (!func_name) + { + *symp = fsym; + return 0; + } + + oload_syms = make_symbol_overload_list (fsym); + cleanups = make_cleanup (xfree, oload_syms); + while (oload_syms[++i]) + num_fns++; + if (!num_fns) + error ("Couldn't find function %s", func_name); + } + + oload_champ_bv = NULL; + + /* Consider each candidate in turn */ + for (ix = 0; ix < num_fns; ix++) + { + static_offset = 0; + if (method) + { + if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix)) + static_offset = 1; + nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix)); + } + else + { + /* If it's not a method, this is the proper place */ + nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix])); + } + + /* Prepare array of parameter types */ + parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *))); + for (jj = 0; jj < nparms; jj++) + parm_types[jj] = (method + ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type) + : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj)); + + /* Compare parameter types to supplied argument types. Skip THIS for + static methods. */ + bv = rank_function (parm_types, nparms, arg_types + static_offset, + nargs - static_offset); + + if (!oload_champ_bv) + { + oload_champ_bv = bv; + oload_champ = 0; + champ_nparms = nparms; + } + else + /* See whether current candidate is better or worse than previous best */ + switch (compare_badness (bv, oload_champ_bv)) + { + case 0: + oload_ambiguous = 1; /* top two contenders are equally good */ + oload_ambig_champ = ix; + break; + case 1: + oload_ambiguous = 2; /* incomparable top contenders */ + oload_ambig_champ = ix; + break; + case 2: + oload_champ_bv = bv; /* new champion, record details */ + oload_ambiguous = 0; + oload_champ = ix; + oload_ambig_champ = -1; + champ_nparms = nparms; + break; + case 3: + default: + break; + } + xfree (parm_types); + if (overload_debug) + { + if (method) + fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms); + else + fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms); + for (jj = 0; jj < nargs - static_offset; jj++) + fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]); + fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous); + } + } /* end loop over all candidates */ + /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one + if they have the exact same goodness. This is because there is no + way to differentiate based on return type, which we need to in + cases like overloads of .begin() <It's both const and non-const> */ +#if 0 + if (oload_ambiguous) + { + if (method) + error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature", + obj_type_name, + (obj_type_name && *obj_type_name) ? "::" : "", + name); + else + error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature", + func_name); + } +#endif + + /* Check how bad the best match is. */ + static_offset = 0; + if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ)) + static_offset = 1; + for (ix = 1; ix <= nargs - static_offset; ix++) + { + if (oload_champ_bv->rank[ix] >= 100) + oload_incompatible = 1; /* truly mismatched types */ + + else if (oload_champ_bv->rank[ix] >= 10) + oload_non_standard = 1; /* non-standard type conversions needed */ + } + if (oload_incompatible) + { + if (method) + error ("Cannot resolve method %s%s%s to any overloaded instance", + obj_type_name, + (obj_type_name && *obj_type_name) ? "::" : "", + name); + else + error ("Cannot resolve function %s to any overloaded instance", + func_name); + } + else if (oload_non_standard) + { + if (method) + warning ("Using non-standard conversion to match method %s%s%s to supplied arguments", + obj_type_name, + (obj_type_name && *obj_type_name) ? "::" : "", + name); + else + warning ("Using non-standard conversion to match function %s to supplied arguments", + func_name); + } + + if (method) + { + if (staticp && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ)) + *staticp = 1; + else if (staticp) + *staticp = 0; + if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ)) + *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset); + else + *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset); + } + else + { + *symp = oload_syms[oload_champ]; + xfree (func_name); + } + + if (objp) + { + if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR + && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR) + { + temp = value_addr (temp); + } + *objp = temp; + } + if (cleanups != NULL) + do_cleanups (cleanups); + + return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0); +} + +/* 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. */ +int +destructor_name_p (const char *name, const struct type *type) +{ + /* destructors are a special case. */ + + if (name[0] == '~') + { + char *dname = type_name_no_tag (type); + char *cp = strchr (dname, '<'); + unsigned int len; + + /* Do not compare the template part for template classes. */ + if (cp == NULL) + len = strlen (dname); + else + len = cp - dname; + if (strlen (name + 1) != len || !STREQN (dname, name + 1, len)) + error ("name of destructor must equal name of class"); + else + return 1; + } + return 0; +} + +/* Helper function for check_field: Given TYPE, a structure/union, + return 1 if the component named NAME from the ultimate + target structure/union is defined, otherwise, return 0. */ + +static int +check_field_in (register struct type *type, const char *name) +{ + register int i; + + for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--) + { + char *t_field_name = TYPE_FIELD_NAME (type, i); + if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) + return 1; + } + + /* C++: If it was not found as a data field, then try to + return it as a pointer to a method. */ + + /* Destructors are a special case. */ + if (destructor_name_p (name, type)) + { + int m_index, f_index; + + return get_destructor_fn_field (type, &m_index, &f_index); + } + + for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i) + { + if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0) + return 1; + } + + for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) + if (check_field_in (TYPE_BASECLASS (type, i), name)) + return 1; + + return 0; +} + + +/* C++: Given ARG1, a value of type (pointer to a)* structure/union, + return 1 if the component named NAME from the ultimate + target structure/union is defined, otherwise, return 0. */ + +int +check_field (struct value *arg1, const char *name) +{ + register struct type *t; + + COERCE_ARRAY (arg1); + + t = VALUE_TYPE (arg1); + + /* Follow pointers until we get to a non-pointer. */ + + for (;;) + { + CHECK_TYPEDEF (t); + if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF) + break; + t = TYPE_TARGET_TYPE (t); + } + + if (TYPE_CODE (t) == TYPE_CODE_MEMBER) + error ("not implemented: member type in check_field"); + + if (TYPE_CODE (t) != TYPE_CODE_STRUCT + && TYPE_CODE (t) != TYPE_CODE_UNION) + error ("Internal error: `this' is not an aggregate"); + + return check_field_in (t, name); +} + +/* C++: Given an aggregate type CURTYPE, and a member name NAME, + return the address of this member as a "pointer to member" + type. If INTYPE is non-null, then it will be the type + of the member we are looking for. This will help us resolve + "pointers to member functions". This function is used + to resolve user expressions of the form "DOMAIN::NAME". */ + +struct value * +value_struct_elt_for_reference (struct type *domain, int offset, + struct type *curtype, char *name, + struct type *intype) +{ + register struct type *t = curtype; + register int i; + struct value *v; + + if (TYPE_CODE (t) != TYPE_CODE_STRUCT + && TYPE_CODE (t) != TYPE_CODE_UNION) + error ("Internal error: non-aggregate type to value_struct_elt_for_reference"); + + for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--) + { + char *t_field_name = TYPE_FIELD_NAME (t, i); + + if (t_field_name && STREQ (t_field_name, name)) + { + if (TYPE_FIELD_STATIC (t, i)) + { + v = value_static_field (t, i); + if (v == NULL) + error ("static field %s has been optimized out", + name); + return v; + } + if (TYPE_FIELD_PACKED (t, i)) + error ("pointers to bitfield members not allowed"); + + return value_from_longest + (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i), + domain)), + offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3)); + } + } + + /* C++: If it was not found as a data field, then try to + return it as a pointer to a method. */ + + /* Destructors are a special case. */ + if (destructor_name_p (name, t)) + { + error ("member pointers to destructors not implemented yet"); + } + + /* Perform all necessary dereferencing. */ + while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR) + intype = TYPE_TARGET_TYPE (intype); + + for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i) + { + char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i); + char dem_opname[64]; + + if (strncmp (t_field_name, "__", 2) == 0 || + strncmp (t_field_name, "op", 2) == 0 || + strncmp (t_field_name, "type", 4) == 0) + { + if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI)) + t_field_name = dem_opname; + else if (cplus_demangle_opname (t_field_name, dem_opname, 0)) + t_field_name = dem_opname; + } + if (t_field_name && STREQ (t_field_name, name)) + { + int j = TYPE_FN_FIELDLIST_LENGTH (t, i); + struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i); + + check_stub_method_group (t, i); + + if (intype == 0 && j > 1) + error ("non-unique member `%s' requires type instantiation", name); + if (intype) + { + while (j--) + if (TYPE_FN_FIELD_TYPE (f, j) == intype) + break; + if (j < 0) + error ("no member function matches that type instantiation"); + } + else + j = 0; + + if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) + { + return value_from_longest + (lookup_reference_type + (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j), + domain)), + (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j))); + } + else + { + struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), + 0, VAR_NAMESPACE, 0, NULL); + if (s == NULL) + { + v = 0; + } + else + { + v = read_var_value (s, 0); +#if 0 + VALUE_TYPE (v) = lookup_reference_type + (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j), + domain)); +#endif + } + return v; + } + } + } + for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--) + { + struct value *v; + int base_offset; + + if (BASETYPE_VIA_VIRTUAL (t, i)) + base_offset = 0; + else + base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8; + v = value_struct_elt_for_reference (domain, + offset + base_offset, + TYPE_BASECLASS (t, i), + name, + intype); + if (v) + return v; + } + return 0; +} + + +/* 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 (struct value *v, int *full, int *top, int *using_enc) +{ + struct value *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 */ + +struct value * +value_full_object (struct value *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; + struct value *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) + { + argp = value_change_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. */ + +struct value * +value_of_this (int complain) +{ + struct symbol *func, *sym; + struct block *b; + int i; + static const char funny_this[] = "this"; + struct value *this; + + if (selected_frame == 0) + { + if (complain) + error ("no frame selected"); + else + return 0; + } + + func = get_frame_function (selected_frame); + if (!func) + { + if (complain) + error ("no `this' in nameless context"); + else + return 0; + } + + b = SYMBOL_BLOCK_VALUE (func); + i = BLOCK_NSYMS (b); + if (i <= 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). */ + sym = lookup_block_symbol (b, funny_this, NULL, VAR_NAMESPACE); + if (sym == NULL) + { + if (complain) + error ("current stack frame not in method"); + else + return NULL; + } + + this = read_var_value (sym, selected_frame); + if (this == 0 && complain) + error ("`this' argument at unknown address"); + return this; +} + +/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements + long, starting at LOWBOUND. The result has the same lower bound as + the original ARRAY. */ + +struct value * +value_slice (struct value *array, int lowbound, int length) +{ + struct type *slice_range_type, *slice_type, *range_type; + LONGEST lowerbound, upperbound, offset; + struct value *slice; + struct type *array_type; + array_type = check_typedef (VALUE_TYPE (array)); + COERCE_VARYING_ARRAY (array, array_type); + if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY + && TYPE_CODE (array_type) != TYPE_CODE_STRING + && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING) + error ("cannot take slice of non-array"); + range_type = TYPE_INDEX_TYPE (array_type); + if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) + error ("slice from bad array or bitstring"); + if (lowbound < lowerbound || length < 0 + || lowbound + length - 1 > upperbound) + /* OBSOLETE Chill allows zero-length strings but not arrays. */ + /* OBSOLETE || (current_language->la_language == language_chill */ + /* OBSOLETE && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY)) */ + error ("slice out of range"); + /* FIXME-type-allocation: need a way to free this type when we are + done with it. */ + slice_range_type = create_range_type ((struct type *) NULL, + TYPE_TARGET_TYPE (range_type), + lowbound, lowbound + length - 1); + if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING) + { + int i; + slice_type = create_set_type ((struct type *) NULL, slice_range_type); + TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING; + slice = value_zero (slice_type, not_lval); + for (i = 0; i < length; i++) + { + int element = value_bit_index (array_type, + VALUE_CONTENTS (array), + lowbound + i); + if (element < 0) + error ("internal error accessing bitstring"); + else if (element > 0) + { + int j = i % TARGET_CHAR_BIT; + if (BITS_BIG_ENDIAN) + j = TARGET_CHAR_BIT - 1 - j; + VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j); + } + } + /* We should set the address, bitssize, and bitspos, so the clice + can be used on the LHS, but that may require extensions to + value_assign. For now, just leave as a non_lval. FIXME. */ + } + else + { + struct type *element_type = TYPE_TARGET_TYPE (array_type); + offset + = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type)); + slice_type = create_array_type ((struct type *) NULL, element_type, + slice_range_type); + TYPE_CODE (slice_type) = TYPE_CODE (array_type); + slice = allocate_value (slice_type); + if (VALUE_LAZY (array)) + VALUE_LAZY (slice) = 1; + else + memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset, + TYPE_LENGTH (slice_type)); + if (VALUE_LVAL (array) == lval_internalvar) + VALUE_LVAL (slice) = lval_internalvar_component; + else + VALUE_LVAL (slice) = VALUE_LVAL (array); + VALUE_ADDRESS (slice) = VALUE_ADDRESS (array); + VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset; + } + return slice; +} + +/* Assuming OBSOLETE chill_varying_type (VARRAY) is true, return an + equivalent value as a fixed-length array. */ + +struct value * +varying_to_slice (struct value *varray) +{ + struct type *vtype = check_typedef (VALUE_TYPE (varray)); + LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0), + VALUE_CONTENTS (varray) + + TYPE_FIELD_BITPOS (vtype, 0) / 8); + return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length); +} + +/* Create a value for a FORTRAN complex number. Currently most of + the time values are coerced to COMPLEX*16 (i.e. a complex number + composed of 2 doubles. This really should be a smarter routine + that figures out precision inteligently as opposed to assuming + doubles. FIXME: fmb */ + +struct value * +value_literal_complex (struct value *arg1, struct value *arg2, struct type *type) +{ + struct value *val; + struct type *real_type = TYPE_TARGET_TYPE (type); + + val = allocate_value (type); + arg1 = value_cast (real_type, arg1); + arg2 = value_cast (real_type, arg2); + + memcpy (VALUE_CONTENTS_RAW (val), + VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type)); + memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type), + VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type)); + return val; +} + +/* Cast a value into the appropriate complex data type. */ + +static struct value * +cast_into_complex (struct type *type, struct value *val) +{ + struct type *real_type = TYPE_TARGET_TYPE (type); + if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX) + { + struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val)); + struct value *re_val = allocate_value (val_real_type); + struct value *im_val = allocate_value (val_real_type); + + memcpy (VALUE_CONTENTS_RAW (re_val), + VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type)); + memcpy (VALUE_CONTENTS_RAW (im_val), + VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type), + TYPE_LENGTH (val_real_type)); + + return value_literal_complex (re_val, im_val, type); + } + else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT + || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT) + return value_literal_complex (val, value_zero (real_type, not_lval), type); + else + error ("cannot cast non-number to complex"); +} + +void +_initialize_valops (void) +{ +#if 0 + add_show_from_set + (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon, + "Set automatic abandonment of expressions upon failure.", + &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; + + add_show_from_set ( + add_set_cmd ("unwindonsignal", no_class, var_boolean, + (char *) &unwind_on_signal_p, +"Set unwinding of stack if a signal is received while in a call dummy.\n\ +The unwindonsignal lets the user determine what gdb should do if a signal\n\ +is received while in a function called from gdb (call dummy). If set, gdb\n\ +unwinds the stack and restore the context to what as it was before the call.\n\ +The default is to stop in the frame where the signal was received.", &setlist), + &showlist); +} |