X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=276763086d949b376c3ac9bf4d8785a29e5ad965;hb=b64296285dff79d58ce7b9dad578d5f3438a6cd4;hp=711392f9b626dab570e5212a347bf4fc6dc097b2;hpb=802db21b617808df4dd4a47aec3ccbe828f694f5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 711392f9b6..276763086d 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1,5 +1,6 @@ /* Perform non-arithmetic operations on values, for GDB. - Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998 + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, + 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GDB. @@ -30,9 +31,16 @@ #include "demangle.h" #include "language.h" #include "gdbcmd.h" +#include "regcache.h" +#include "cp-abi.h" +#include "block.h" +#include "infcall.h" +#include "dictionary.h" +#include "cp-support.h" #include #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. */ @@ -41,37 +49,32 @@ extern int hp_som_som_object_present; extern int overload_debug; /* Local functions. */ -static int typecmp (int staticp, struct type *t1[], value_ptr t2[]); +static int typecmp (int staticp, int varargs, int nargs, + struct field t1[], struct value *t2[]); -static CORE_ADDR find_function_addr (value_ptr, struct type **); -static value_ptr value_arg_coerce (value_ptr, struct type *, int); +static CORE_ADDR value_push (CORE_ADDR, struct value *); - -static CORE_ADDR value_push (CORE_ADDR, value_ptr); - -static value_ptr search_struct_field (char *, value_ptr, int, +static struct value *search_struct_field (char *, struct value *, int, struct type *, int); -static value_ptr search_struct_method (char *, value_ptr *, - value_ptr *, +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 value_ptr cast_into_complex (struct type *, value_ptr); +static struct value *cast_into_complex (struct type *, struct value *); -static struct fn_field *find_method_list (value_ptr * argp, char *method, - int offset, int *static_memfuncp, +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); -#define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL) - /* Flag for whether we want to abandon failed expression evals by default. */ #if 0 @@ -80,23 +83,13 @@ static int auto_abandon = 0; 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. */ -value_ptr -find_function_in_inferior (name) - char *name; +struct value * +find_function_in_inferior (const char *name) { register struct symbol *sym; - sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); + sym = lookup_symbol (name, 0, VAR_DOMAIN, 0, NULL); if (sym != NULL) { if (SYMBOL_CLASS (sym) != LOC_BLOCK) @@ -132,12 +125,11 @@ find_function_in_inferior (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. */ -value_ptr -value_allocate_space_in_inferior (len) - int len; +struct value * +value_allocate_space_in_inferior (int len) { - value_ptr blocklen; - register value_ptr val = find_function_in_inferior ("malloc"); + 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); @@ -152,8 +144,7 @@ value_allocate_space_in_inferior (len) } static CORE_ADDR -allocate_space_in_inferior (len) - int len; +allocate_space_in_inferior (int len) { return value_as_long (value_allocate_space_in_inferior (len)); } @@ -163,10 +154,8 @@ allocate_space_in_inferior (len) and if ARG2 is an lvalue it can be cast into anything at all. */ /* In C++, casts may change pointer or object representations. */ -value_ptr -value_cast (type, arg2) - struct type *type; - register value_ptr arg2; +struct value * +value_cast (struct type *type, struct value *arg2) { register enum type_code code1; register enum type_code code2; @@ -246,7 +235,7 @@ value_cast (type, arg2) /* 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. */ - value_ptr v = search_struct_field (type_name_no_tag (type), + struct value *v = search_struct_field (type_name_no_tag (type), arg2, 0, type2, 1); if (v) { @@ -266,7 +255,7 @@ value_cast (type, arg2) (code2 == TYPE_CODE_PTR)) { unsigned int *ptr; - value_ptr retvalp; + struct value *retvalp; switch (TYPE_CODE (TYPE_TARGET_TYPE (type2))) { @@ -286,20 +275,42 @@ value_cast (type, arg2) break; /* fall out and go to normal handling */ } } - longest = value_as_long (arg2); + + /* 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)) + code2 == TYPE_CODE_ENUM || + code2 == TYPE_CODE_RANGE)) { - int ptr_bit = HOST_CHAR_BIT * TYPE_LENGTH (type); + /* 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 (ptr_bit < sizeof (LONGEST) * HOST_CHAR_BIT) + if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT) { - if (longest >= ((LONGEST) 1 << ptr_bit) - || longest <= -((LONGEST) 1 << ptr_bit)) + if (longest >= ((LONGEST) 1 << addr_bit) + || longest <= -((LONGEST) 1 << addr_bit)) warning ("value truncated"); } return value_from_longest (type, longest); @@ -314,7 +325,7 @@ value_cast (type, arg2) && TYPE_CODE (t2) == TYPE_CODE_STRUCT && !value_logical_not (arg2)) { - value_ptr v; + 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 @@ -341,71 +352,21 @@ value_cast (type, arg2) value_zero (t1, not_lval), 0, t1, 1); if (v) { - value_ptr v2 = value_ind (arg2); - VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v) - + VALUE_OFFSET (v); - - /* JYG: adjust the new pointer value and - embedded offset. */ - v2->aligner.contents[0] -= VALUE_EMBEDDED_OFFSET (v); - VALUE_EMBEDDED_OFFSET (v2) = 0; - - v2 = value_addr (v2); - VALUE_TYPE (v2) = type; - return v2; + 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; - VALUE_ENCLOSING_TYPE (arg2) = type; /* pai: chk_val */ + arg2 = value_change_enclosing_type (arg2, type); VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */ return arg2; } - else if (chill_varying_type (type)) - { - struct type *range1, *range2, *eltype1, *eltype2; - value_ptr val; - int count1, count2; - LONGEST low_bound, high_bound; - char *valaddr, *valaddr_data; - /* For lint warning about eltype2 possibly uninitialized: */ - eltype2 = NULL; - if (code2 == TYPE_CODE_BITSTRING) - error ("not implemented: converting bitstring to varying type"); - if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING) - || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))), - eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)), - (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2) - /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ ))) - error ("Invalid conversion to varying type"); - range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0); - range2 = TYPE_FIELD_TYPE (type2, 0); - if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0) - count1 = -1; - else - count1 = high_bound - low_bound + 1; - if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0) - count1 = -1, count2 = 0; /* To force error before */ - else - count2 = high_bound - low_bound + 1; - if (count2 > count1) - error ("target varying type is too small"); - val = allocate_value (type); - valaddr = VALUE_CONTENTS_RAW (val); - valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8; - /* Set val's __var_length field to count2. */ - store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)), - count2); - /* Set the __var_data field to count2 elements copied from arg2. */ - memcpy (valaddr_data, VALUE_CONTENTS (arg2), - count2 * TYPE_LENGTH (eltype2)); - /* Zero the rest of the __var_data field of val. */ - memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0', - (count1 - count2) * TYPE_LENGTH (eltype2)); - return val; - } else if (VALUE_LVAL (arg2) == lval_memory) { return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2), @@ -424,12 +385,10 @@ value_cast (type, arg2) /* Create a value of type TYPE that is zero, and return it. */ -value_ptr -value_zero (type, lv) - struct type *type; - enum lval_type lv; +struct value * +value_zero (struct type *type, enum lval_type lv) { - register value_ptr val = allocate_value (type); + struct value *val = allocate_value (type); memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type))); VALUE_LVAL (val) = lv; @@ -449,43 +408,17 @@ value_zero (type, lv) Note: value_at does *NOT* handle embedded offsets; perform such adjustments before or after calling it. */ -value_ptr -value_at (type, addr, sect) - struct type *type; - CORE_ADDR addr; - asection *sect; +struct value * +value_at (struct type *type, CORE_ADDR addr, asection *sect) { - register value_ptr val; + struct value *val; if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) error ("Attempt to dereference a generic pointer."); val = allocate_value (type); - if (GDB_TARGET_IS_D10V - && TYPE_CODE (type) == TYPE_CODE_PTR - && TYPE_TARGET_TYPE (type) - && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)) - { - /* pointer to function */ - unsigned long num; - unsigned short snum; - snum = read_memory_unsigned_integer (addr, 2); - num = D10V_MAKE_IADDR (snum); - store_address (VALUE_CONTENTS_RAW (val), 4, num); - } - else if (GDB_TARGET_IS_D10V - && TYPE_CODE (type) == TYPE_CODE_PTR) - { - /* pointer to data */ - unsigned long num; - unsigned short snum; - snum = read_memory_unsigned_integer (addr, 2); - num = D10V_MAKE_DADDR (snum); - store_address (VALUE_CONTENTS_RAW (val), 4, num); - } - else - read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type)); + read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type)); VALUE_LVAL (val) = lval_memory; VALUE_ADDRESS (val) = addr; @@ -496,13 +429,10 @@ value_at (type, addr, sect) /* Return a lazy value with type TYPE located at ADDR (cf. value_at). */ -value_ptr -value_at_lazy (type, addr, sect) - struct type *type; - CORE_ADDR addr; - asection *sect; +struct value * +value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect) { - register value_ptr val; + struct value *val; if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) error ("Attempt to dereference a generic pointer."); @@ -530,36 +460,13 @@ value_at_lazy (type, addr, sect) value is ignored. */ int -value_fetch_lazy (val) - register value_ptr val; +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 (GDB_TARGET_IS_D10V - && TYPE_CODE (type) == TYPE_CODE_PTR - && TYPE_TARGET_TYPE (type) - && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)) - { - /* pointer to function */ - unsigned long num; - unsigned short snum; - snum = read_memory_unsigned_integer (addr, 2); - num = D10V_MAKE_IADDR (snum); - store_address (VALUE_CONTENTS_RAW (val), 4, num); - } - else if (GDB_TARGET_IS_D10V - && TYPE_CODE (type) == TYPE_CODE_PTR) - { - /* pointer to data */ - unsigned long num; - unsigned short snum; - snum = read_memory_unsigned_integer (addr, 2); - num = D10V_MAKE_DADDR (snum); - store_address (VALUE_CONTENTS_RAW (val), 4, num); - } - else if (length) + if (length) read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length); VALUE_LAZY (val) = 0; @@ -570,14 +477,14 @@ value_fetch_lazy (val) /* Store the contents of FROMVAL into the location of TOVAL. Return a new value with the location of TOVAL and contents of FROMVAL. */ -value_ptr -value_assign (toval, fromval) - register value_ptr toval, fromval; +struct value * +value_assign (struct value *toval, struct value *fromval) { register struct type *type; - register value_ptr val; - char raw_buffer[MAX_REGISTER_RAW_SIZE]; + struct value *val; + char raw_buffer[MAX_REGISTER_SIZE]; int use_buffer = 0; + struct frame_id old_frame; if (!toval->modifiable) error ("Left operand of assignment is not a modifiable lvalue."); @@ -599,21 +506,25 @@ value_assign (toval, fromval) if (VALUE_REGNO (toval) >= 0) { int regno = VALUE_REGNO (toval); - if (REGISTER_CONVERTIBLE (regno)) + if (CONVERT_REGISTER_P (regno)) { struct type *fromtype = check_typedef (VALUE_TYPE (fromval)); - REGISTER_CONVERT_TO_RAW (fromtype, regno, - VALUE_CONTENTS (fromval), raw_buffer); + VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer); use_buffer = REGISTER_RAW_SIZE (regno); } } + /* Since modifying a register can trash the frame chain, and modifying memory + can trash the frame cache, we save the old frame and then restore the new + frame afterwards. */ + old_frame = get_frame_id (deprecated_selected_frame); + switch (VALUE_LVAL (toval)) { case lval_internalvar: set_internalvar (VALUE_INTERNALVAR (toval), fromval); val = value_copy (VALUE_INTERNALVAR (toval)->value); - VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval); + 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; @@ -644,7 +555,7 @@ value_assign (toval, fromval) if (changed_len > (int) sizeof (LONGEST)) error ("Can't handle bitfields which don't fit in a %d bit word.", - sizeof (LONGEST) * HOST_CHAR_BIT); + (int) sizeof (LONGEST) * HOST_CHAR_BIT); read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval), buffer, changed_len); @@ -669,145 +580,162 @@ value_assign (toval, 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.", - 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 - } - /* 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: + case lval_register: { /* 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. */ - char *buffer = (char *) alloca (amount_to_copy - + sizeof (LONGEST) - + MAX_REGISTER_RAW_SIZE); - + int amount_to_copy; + char *buffer; + int value_reg; + int reg_offset; + int byte_offset; 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 (VALUE_LVAL (toval) == lval_register) + { + frame = get_current_frame (); + value_reg = VALUE_REGNO (toval); + } + else + { + frame = frame_find_by_id (VALUE_FRAME_ID (toval)); + value_reg = VALUE_FRAME_REGNUM (toval); + } if (!frame) error ("Value being assigned to is no longer active."); - amount_to_copy += (reg_size - amount_to_copy % reg_size); + /* Locate the first register that falls in the value that + needs to be transfered. Compute the offset of the value in + that register. */ + { + int offset; + for (reg_offset = value_reg, offset = 0; + offset + REGISTER_RAW_SIZE (reg_offset) <= VALUE_OFFSET (toval); + reg_offset++); + byte_offset = VALUE_OFFSET (toval) - offset; + } - /* Copy it out. */ - for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset, - amount_copied = 0); + /* Compute the number of register aligned values that need to + be copied. */ + if (VALUE_BITSIZE (toval)) + amount_to_copy = byte_offset + 1; + else + amount_to_copy = byte_offset + TYPE_LENGTH (type); + + /* And a bounce buffer. Be slightly over generous. */ + buffer = (char *) alloca (amount_to_copy + MAX_REGISTER_SIZE); + + /* Copy it in. */ + for (regno = reg_offset, amount_copied = 0; amount_copied < amount_to_copy; - amount_copied += reg_size, regno++) + amount_copied += REGISTER_RAW_SIZE (regno), regno++) { - get_saved_register (buffer + amount_copied, - (int *) NULL, (CORE_ADDR *) NULL, - frame, regno, (enum lval_type *) NULL); + frame_register_read (frame, regno, buffer + amount_copied); } - + /* 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)); + { + 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); + { + memcpy (buffer + VALUE_OFFSET (toval), raw_buffer, use_buffer); + } else - memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval), - TYPE_LENGTH (type)); + { + memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval), + TYPE_LENGTH (type)); + /* Do any conversion necessary when storing this type to + more than one register. */ +#ifdef REGISTER_CONVERT_FROM_TYPE + REGISTER_CONVERT_FROM_TYPE (value_reg, type, + (buffer + byte_offset)); +#endif + } - /* Copy it back. */ - for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset, - amount_copied = 0); + /* Copy it out. */ + for (regno = reg_offset, amount_copied = 0; amount_copied < amount_to_copy; - amount_copied += reg_size, regno++) + amount_copied += REGISTER_RAW_SIZE (regno), regno++) { enum lval_type lval; CORE_ADDR addr; int optim; - + int realnum; + /* Just find out where to put it. */ - get_saved_register ((char *) NULL, - &optim, &addr, frame, regno, &lval); - + frame_register (frame, regno, &optim, &lval, &addr, &realnum, + NULL); + 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); + write_memory (addr, buffer + amount_copied, + REGISTER_RAW_SIZE (regno)); else if (lval == lval_register) - write_register_bytes (addr, buffer + amount_copied, reg_size); + regcache_cooked_write (current_regcache, realnum, + (buffer + amount_copied)); 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."); } + /* 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. Assigning to memory + also can. We just do this on all assignments to registers or + memory, for simplicity's sake; I doubt the slowdown matters. */ + switch (VALUE_LVAL (toval)) + { + case lval_memory: + case lval_register: + case lval_reg_frame_relative: + + reinit_frame_cache (); + + /* Having destoroyed the frame cache, restore the selected frame. */ + + /* FIXME: cagney/2002-11-02: There has to be a better way of + doing this. Instead of constantly saving/restoring the + frame. Why not create a get_selected_frame() function that, + having saved the selected frame's ID can automatically + re-find the previously selected frame automatically. */ + + { + struct frame_info *fi = frame_find_by_id (old_frame); + if (fi != NULL) + select_frame (fi); + } + + break; + default: + break; + } + /* 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) @@ -827,7 +755,7 @@ value_assign (toval, fromval) memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval), TYPE_LENGTH (type)); VALUE_TYPE (val) = type; - VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval); + 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); @@ -836,12 +764,10 @@ value_assign (toval, fromval) /* Extend a value VAL to COUNT repetitions of its type. */ -value_ptr -value_repeat (arg1, count) - value_ptr arg1; - int count; +struct value * +value_repeat (struct value *arg1, int count) { - register value_ptr val; + struct value *val; if (VALUE_LVAL (arg1) != lval_memory) error ("Only values in memory can be extended with '@'."); @@ -859,12 +785,10 @@ value_repeat (arg1, count) return val; } -value_ptr -value_of_variable (var, b) - struct symbol *var; - struct block *b; +struct value * +value_of_variable (struct symbol *var, struct block *b) { - value_ptr val; + struct value *val; struct frame_info *frame = NULL; if (!b) @@ -875,9 +799,9 @@ value_of_variable (var, b) if (!frame) { if (BLOCK_FUNCTION (b) - && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b))) + && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))) error ("No frame is currently executing in block %s.", - SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b))); + SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))); else error ("No frame is currently executing in specified block"); } @@ -885,7 +809,7 @@ value_of_variable (var, b) val = read_var_value (var, frame); if (!val) - error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var)); + error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var)); return val; } @@ -913,9 +837,8 @@ value_of_variable (var, b) the coercion to pointer type. */ -value_ptr -value_coerce_array (arg1) - value_ptr arg1; +struct value * +value_coerce_array (struct value *arg1) { register struct type *type = check_typedef (VALUE_TYPE (arg1)); @@ -929,11 +852,10 @@ value_coerce_array (arg1) /* Given a value which is a function, return a value which is a pointer to it. */ -value_ptr -value_coerce_function (arg1) - value_ptr arg1; +struct value * +value_coerce_function (struct value *arg1) { - value_ptr retval; + struct value *retval; if (VALUE_LVAL (arg1) != lval_memory) error ("Attempt to take address of value not located in memory."); @@ -946,11 +868,10 @@ value_coerce_function (arg1) /* Return a pointer value for the object for which ARG1 is the contents. */ -value_ptr -value_addr (arg1) - value_ptr arg1; +struct value * +value_addr (struct value *arg1) { - value_ptr arg2; + struct value *arg2; struct type *type = check_typedef (VALUE_TYPE (arg1)); if (TYPE_CODE (type) == TYPE_CODE_REF) @@ -976,7 +897,7 @@ value_addr (arg1) /* This may be a pointer to a base subobject; so remember the full derived object's type ... */ - VALUE_ENCLOSING_TYPE (arg2) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)); + 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); @@ -985,12 +906,11 @@ value_addr (arg1) /* Given a value of a pointer type, apply the C unary * operator to it. */ -value_ptr -value_ind (arg1) - value_ptr arg1; +struct value * +value_ind (struct value *arg1) { struct type *base_type; - value_ptr arg2; + struct value *arg2; COERCE_ARRAY (arg1); @@ -1004,9 +924,9 @@ value_ind (arg1) 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 (builtin_type_int, - (CORE_ADDR) value_as_long (arg1), - VALUE_BFD_SECTION (arg1)); + 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; @@ -1016,12 +936,12 @@ value_ind (arg1) enc_type = TYPE_TARGET_TYPE (enc_type); /* Retrieve the enclosing object pointed to */ arg2 = value_at_lazy (enc_type, - value_as_pointer (arg1) - VALUE_POINTED_TO_OFFSET (arg1), + value_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 */ - VALUE_ENCLOSING_TYPE (arg2) = enc_type; + 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 */ @@ -1038,12 +958,10 @@ value_ind (arg1) /* Push one word (the size of object that a register holds). */ CORE_ADDR -push_word (sp, word) - CORE_ADDR sp; - ULONGEST word; +push_word (CORE_ADDR sp, ULONGEST word) { - register int len = REGISTER_SIZE; - char buffer[MAX_REGISTER_RAW_SIZE]; + register int len = DEPRECATED_REGISTER_SIZE; + char buffer[MAX_REGISTER_SIZE]; store_unsigned_integer (buffer, len, word); if (INNER_THAN (1, 2)) @@ -1065,10 +983,7 @@ push_word (sp, word) /* Push LEN bytes with data at BUFFER. */ CORE_ADDR -push_bytes (sp, buffer, len) - CORE_ADDR sp; - char *buffer; - int len; +push_bytes (CORE_ADDR sp, char *buffer, int len) { if (INNER_THAN (1, 2)) { @@ -1094,9 +1009,7 @@ push_bytes (sp, buffer, len) it to be an argument to a function. */ static CORE_ADDR -value_push (sp, arg) - register CORE_ADDR sp; - value_ptr arg; +value_push (register CORE_ADDR sp, struct value *arg) { register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg)); register int container_len = len; @@ -1108,7 +1021,7 @@ value_push (sp, arg) & ~(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 == BIG_ENDIAN) + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) offset = container_len - len; else offset = 0; @@ -1129,17 +1042,9 @@ value_push (sp, arg) return sp; } -#ifndef PUSH_ARGUMENTS -#define PUSH_ARGUMENTS default_push_arguments -#endif - CORE_ADDR -default_push_arguments (nargs, args, sp, struct_return, struct_addr) - int nargs; - value_ptr *args; - CORE_ADDR sp; - int struct_return; - CORE_ADDR struct_addr; +legacy_push_arguments (int nargs, struct value **args, CORE_ADDR sp, + int struct_return, CORE_ADDR struct_addr) { /* ASSERT ( !struct_return); */ int i; @@ -1148,704 +1053,6 @@ default_push_arguments (nargs, args, sp, struct_return, struct_addr) return sp; } - -/* A default function for COERCE_FLOAT_TO_DOUBLE: do the coercion only - when we don't have any type for the argument at hand. This occurs - when we have no debug info, or when passing varargs. - - This is an annoying default: the rule the compiler follows is to do - the standard promotions whenever there is no prototype in scope, - and almost all targets want this behavior. But there are some old - architectures which want this odd behavior. If you want to go - through them all and fix them, please do. Modern gdbarch-style - targets may find it convenient to use standard_coerce_float_to_double. */ -int -default_coerce_float_to_double (struct type *formal, struct type *actual) -{ - return formal == NULL; -} - - -/* Always coerce floats to doubles when there is no prototype in scope. - If your architecture follows the standard type promotion rules for - calling unprototyped functions, your gdbarch init function can pass - this function to set_gdbarch_coerce_float_to_double to use its logic. */ -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 value_ptr -value_arg_coerce (arg, param_type, is_prototyped) - value_ptr arg; - struct type *param_type; - int is_prototyped; -{ - register struct type *arg_type = check_typedef (VALUE_TYPE (arg)); - register struct type *type - = param_type ? check_typedef (param_type) : arg_type; - - switch (TYPE_CODE (type)) - { - case TYPE_CODE_REF: - if (TYPE_CODE (arg_type) != TYPE_CODE_REF) - { - 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: - if (current_language->c_style_arrays) - 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 (function, retval_type) - value_ptr 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_pointer (function); - ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); - if (TYPE_CODE (ftype) == TYPE_CODE_FUNC - || TYPE_CODE (ftype) == TYPE_CODE_METHOD) - { -#ifdef CONVERT_FROM_FUNC_PTR_ADDR - /* FIXME: This is a workaround for the unusual function - pointer representation on the RS/6000, see comment - in config/rs6000/tm-rs6000.h */ - funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr); -#endif - 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_pointer (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 value_ptr hand_function_call (value_ptr function, int nargs, - value_ptr * args); -static value_ptr -hand_function_call (function, nargs, args) - value_ptr function; - int nargs; - value_ptr *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 inferior_status *inf_status; - struct cleanup *old_chain; - 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)); - - 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 (); - - inf_status = save_inferior_status (1); - old_chain = 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 = sp = read_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; - } - - 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 (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 (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 (CALL_DUMMY_LOCATION == AT_ENTRY_POINT) - { - real_pc = funaddr; - } - -#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--) - { - /* If we're off the end of the known arguments, do the standard - promotions. FIXME: if we had a prototype, this should only - be allowed if ... were present. */ - if (i >= TYPE_NFIELDS (ftype)) - args[i] = value_arg_coerce (args[i], NULL, 0); - - else - { - int is_prototyped = TYPE_FLAGS (ftype) & TYPE_FLAG_PROTOTYPED; - param_type = TYPE_FIELD_TYPE (ftype, i); - - args[i] = value_arg_coerce (args[i], param_type, is_prototyped); - } - - /*elz: this code is to handle the case in which the function to be called - has a pointer to function as parameter and the corresponding actual argument - is the address of a function and not a pointer to function variable. - In aCC compiled code, the calls through pointers to functions (in the body - of the function called by hand) are made via $$dyncall_external which - requires some registers setting, this is taken care of if we call - via a function pointer variable, but not via a function address. - In cc this is not a problem. */ - - if (using_gcc == 0) - if (param_type) - /* if this parameter is a pointer to function */ - if (TYPE_CODE (param_type) == TYPE_CODE_PTR) - if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC) - /* elz: FIXME here should go the test about the compiler used - to compile the target. We want to issue the error - message only if the compiler used was HP's aCC. - If we used HP's cc, then there is no problem and no need - to return at this point */ - if (using_gcc == 0) /* && compiler == aCC */ - /* go see if the actual parameter is a variable of type - pointer to function or just a function */ - if (args[i]->lval == not_lval) - { - char *arg_name; - if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL)) - error ("\ -You cannot use function <%s> as argument. \n\ -You must use a pointer to function type variable. Command ignored.", arg_name); - } - } - - if (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; - } - else - { - /* The stack grows up, so the address of the thing - we push is the stack pointer before we push it. */ - addr = sp; - } - /* Push the structure. */ - write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len); - if (INNER_THAN (1, 2)) - { - /* The stack grows down, so the address of the thing - we push is the stack pointer after we push it. */ - addr = sp; - } - else - { - /* stack grows upward */ - sp += aligned_len; - } - /* The value we're going to pass is the address of the - thing we just pushed. */ - /*args[i] = value_from_longest (lookup_pointer_type (value_type), - (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 */ - - 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 */ - sp -= len; - struct_addr = sp; - } - else - { - /* stack grows upward */ - struct_addr = sp; - sp += len; - } - } - -/* elz: on HPPA no need for this extra alignment, maybe it is needed - on other architectures. This is because all the alignment is taken care - of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in - hppa_push_arguments */ -#ifndef NO_EXTRA_ALIGNMENT_NEEDED - - /* 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; - } -#endif /* NO_EXTRA_ALIGNMENT_NEEDED */ - - sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr); - -#ifdef PUSH_RETURN_ADDRESS /* 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); -#endif /* PUSH_RETURN_ADDRESS */ - - 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 retbuf[REGISTER_BYTES]; - 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 did the cleanups, 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 (old_chain); - 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 did the cleanups, 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 (old_chain); - 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. */ - do_cleanups (old_chain); - - /* Figure out the value returned by the function. */ -/* elz: I defined this new macro for the hppa architecture only. - this gives us a way to get the value returned by the function from the stack, - at the same address we told the function to put it. - We cannot assume on the pa that r28 still contains the address of the returned - structure. Usually this will be overwritten by the callee. - I don't know about other architectures, so I defined this macro - */ - -#ifdef VALUE_RETURNED_FROM_STACK - if (struct_return) - return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr); -#endif - - return value_being_returned (value_type, retbuf, struct_return); - } -} - -value_ptr -call_function_by_hand (function, nargs, args) - value_ptr function; - int nargs; - value_ptr *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. @@ -1856,16 +1063,13 @@ call_function_by_hand (function, nargs, args) first element, and all elements must have the same size (though we don't currently enforce any restriction on their types). */ -value_ptr -value_array (lowbound, highbound, elemvec) - int lowbound; - int highbound; - value_ptr *elemvec; +struct value * +value_array (int lowbound, int highbound, struct value **elemvec) { int nelem; int idx; unsigned int typelength; - value_ptr val; + struct value *val; struct type *rangetype; struct type *arraytype; CORE_ADDR addr; @@ -1931,12 +1135,10 @@ value_array (lowbound, highbound, elemvec) zero and an upper bound of LEN - 1. Also note that the string may contain embedded null bytes. */ -value_ptr -value_string (ptr, len) - char *ptr; - int len; +struct value * +value_string (char *ptr, int len) { - value_ptr val; + struct value *val; int lowbound = current_language->string_lower_bound; struct type *rangetype = create_range_type ((struct type *) NULL, builtin_type_int, @@ -1963,12 +1165,10 @@ value_string (ptr, len) return (val); } -value_ptr -value_bitstring (ptr, len) - char *ptr; - int len; +struct value * +value_bitstring (char *ptr, int len) { - value_ptr val; + 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); @@ -1979,13 +1179,14 @@ value_bitstring (ptr, len) } /* See if we can pass arguments in T2 to a function which takes arguments - of types T1. Both t1 and t2 are NULL-terminated vectors. 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. + 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. + 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 @@ -1994,30 +1195,30 @@ value_bitstring (ptr, len) requested operation is type secure, shouldn't we? FIXME. */ static int -typecmp (staticp, t1, t2) - int staticp; - struct type *t1[]; - value_ptr t2[]; +typecmp (int staticp, int varargs, int nargs, + struct field t1[], struct value *t2[]) { int i; if (t2 == 0) - return 1; - if (staticp && t1 == 0) - return t2[1] != 0; - if (t1 == 0) - return 1; - if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) - return 0; - if (t1[!staticp] == 0) - return 0; - for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++) + 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]); + + 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))) @@ -2034,7 +1235,7 @@ typecmp (staticp, t1, t2) we need to do this so you can take something like a map, and properly access map["hello"], because the argument to [] will be a reference to a pointer to a char, - and the arrgument will be 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) { @@ -2053,12 +1254,12 @@ typecmp (staticp, t1, t2) /* 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_CODE (VALUE_TYPE (t2[i]))) + if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i]))) return i + 1; } - if (!t1[i]) + if (varargs || t2[i] == NULL) return 0; - return t2[i] ? i + 1 : 0; + return i + 1; } /* Helper function used by value_struct_elt to recurse through baseclasses. @@ -2069,13 +1270,9 @@ typecmp (staticp, t1, t2) If LOOKING_FOR_BASECLASS, then instead of looking for struct fields, look for a baseclass named NAME. */ -static value_ptr -search_struct_field (name, arg1, offset, type, looking_for_baseclass) - char *name; - register value_ptr arg1; - int offset; - register struct type *type; - int looking_for_baseclass; +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); @@ -2089,13 +1286,20 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) { - value_ptr v; + struct value *v; if (TYPE_FIELD_STATIC (type, i)) - v = value_static_field (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); + { + v = value_primitive_field (arg1, offset, i, type); + if (v == 0) + error ("there is no field named %s", name); + } return v; } @@ -2111,19 +1315,22 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) /* Look for a match through the fields of an anonymous union, or anonymous struct. C++ provides anonymous unions. - In the GNU Chill implementation of variant record types, - each has an (anonymous) union type, - each member of the union represents a . - Each is represented as a struct, - with a member for each . */ + In the GNU Chill (now deleted from GDB) + implementation of variant record types, each + has an (anonymous) union type, + each member of the union represents a . Each is + represented as a struct, with a member for each + . */ - value_ptr v; + 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 implementation of variant records, - the bitpos is zero in an anonymous union field, so we + /* 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 (now deleted + from GDB) 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 @@ -2140,7 +1347,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) for (i = 0; i < nbases; i++) { - value_ptr v; + 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 @@ -2152,7 +1359,7 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) if (BASETYPE_VIA_VIRTUAL (type, i)) { int boffset; - value_ptr v2 = allocate_value (basetype); + struct value *v2 = allocate_value (basetype); boffset = baseclass_offset (type, i, VALUE_CONTENTS (arg1) + offset, @@ -2227,19 +1434,14 @@ search_struct_field (name, arg1, offset, type, looking_for_baseclass) * conventions. */ void -find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p) - struct type *type; - struct type *basetype; - char *valaddr; - int offset; - int *boffset_p; - int *skip_p; +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; - value_ptr vp; + struct value *vp; CORE_ADDR vtbl; /* the virtual table pointer */ struct type *pbc; /* the primary base class */ @@ -2307,15 +1509,13 @@ find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p) If found, return value, else if name matched and args not return (value)-1, else return NULL. */ -static value_ptr -search_struct_method (name, arg1p, args, offset, static_memfuncp, type) - char *name; - register value_ptr *arg1p, *args; - int offset, *static_memfuncp; - register struct type *type; +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; - value_ptr v; + struct value *v; int name_matched = 0; char dem_opname[64]; @@ -2339,25 +1539,33 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) 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); - while (j >= 0) + else if (j == 0 && args == 0) { - if (TYPE_FN_FIELD_STUB (f, j)) - check_stub_method (type, i, j); - if (!typecmp (TYPE_FN_FIELD_STATIC_P (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--; + 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--; + } } } @@ -2414,7 +1622,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) } v = search_struct_method (name, arg1p, args, base_offset + offset, static_memfuncp, TYPE_BASECLASS (type, i)); - if (v == (value_ptr) - 1) + if (v == (struct value *) - 1) { name_matched = 1; } @@ -2426,7 +1634,7 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) } } if (name_matched) - return (value_ptr) - 1; + return (struct value *) - 1; else return NULL; } @@ -2445,15 +1653,12 @@ search_struct_method (name, arg1p, args, offset, static_memfuncp, type) ERR is an error message to be printed in case the field is not found. */ -value_ptr -value_struct_elt (argp, args, name, static_memfuncp, err) - register value_ptr *argp, *args; - char *name; - int *static_memfuncp; - char *err; +struct value * +value_struct_elt (struct value **argp, struct value **args, + char *name, int *static_memfuncp, char *err) { register struct type *t; - value_ptr v; + struct value *v; COERCE_ARRAY (*argp); @@ -2499,7 +1704,7 @@ value_struct_elt (argp, args, name, static_memfuncp, err) v = search_struct_method (name, argp, args, 0, static_memfuncp, t); - if (v == (value_ptr) - 1) + if (v == (struct value *) - 1) error ("Cannot take address of a method"); else if (v == 0) { @@ -2536,10 +1741,10 @@ value_struct_elt (argp, args, name, static_memfuncp, err) } else v = search_struct_method (name, argp, args, 0, static_memfuncp, t); - - if (v == (value_ptr) - 1) + + if (v == (struct value *) - 1) { - error ("Argument list of %s mismatch with component in the structure.", name); + 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) { @@ -2561,22 +1766,15 @@ value_struct_elt (argp, args, name, static_memfuncp, err) * ARGP is a pointer to a pointer to a value (the object) * METHOD is a string containing the method name * OFFSET is the offset within the value - * STATIC_MEMFUNCP is set if the method is static * TYPE is the assumed type of the object * NUM_FNS is the number of overloaded instances * BASETYPE is set to the actual type of the subobject where the method is found * BOFFSET is the offset of the base subobject where the method is found */ static struct fn_field * -find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset) - value_ptr *argp; - char *method; - int offset; - int *static_memfuncp; - struct type *type; - int *num_fns; - struct type **basetype; - int *boffset; +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; @@ -2591,10 +1789,17 @@ find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i); if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0)) { - *num_fns = TYPE_FN_FIELDLIST_LENGTH (type, i); + int len = TYPE_FN_FIELDLIST_LENGTH (type, i); + struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); + + *num_fns = len; *basetype = type; *boffset = offset; - return TYPE_FN_FIELDLIST1 (type, i); + + /* Resolve any stub methods. */ + check_stub_method_group (type, i); + + return f; } } @@ -2634,7 +1839,8 @@ find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8; } f = find_method_list (argp, method, base_offset + offset, - static_memfuncp, TYPE_BASECLASS (type, i), num_fns, basetype, boffset); + TYPE_BASECLASS (type, i), num_fns, basetype, + boffset); if (f) return f; } @@ -2645,20 +1851,14 @@ find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype * ARGP is a pointer to a pointer to a value (the object) * METHOD is the method name * OFFSET is the offset within the value contents - * STATIC_MEMFUNCP is set if the method is static * NUM_FNS is the number of overloaded instances * BASETYPE is set to the type of the base subobject that defines the method * BOFFSET is the offset of the base subobject which defines the method */ struct fn_field * -value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset) - value_ptr *argp; - char *method; - int offset; - int *static_memfuncp; - int *num_fns; - struct type **basetype; - int *boffset; +value_find_oload_method_list (struct value **argp, char *method, int offset, + int *num_fns, struct type **basetype, + int *boffset) { struct type *t; @@ -2681,12 +1881,7 @@ value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, ba && TYPE_CODE (t) != TYPE_CODE_UNION) error ("Attempt to extract a component of a value that is not a struct or union"); - /* Assume it's not static, unless we see that it is. */ - if (static_memfuncp) - *static_memfuncp = 0; - - return find_method_list (argp, method, 0, static_memfuncp, t, num_fns, basetype, boffset); - + return find_method_list (argp, method, 0, t, num_fns, basetype, boffset); } /* Given an array of argument types (ARGTYPES) (which includes an @@ -2718,21 +1913,14 @@ value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, ba */ int -find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp) - struct type **arg_types; - int nargs; - char *name; - int method; - int lax; - value_ptr obj; - struct symbol *fsym; - value_ptr *valp; - struct symbol **symp; - int *staticp; +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 */ @@ -2744,7 +1932,7 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, 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 */ - value_ptr temp = obj; + 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 */ @@ -2752,6 +1940,8 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, int boffset; register int jj; register int ix; + int static_offset; + struct cleanup *cleanups = NULL; char *obj_type_name = NULL; char *func_name = NULL; @@ -2759,9 +1949,6 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, /* Get the list of overloaded methods or functions */ if (method) { - int i; - int len; - struct type *domain; 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 */ @@ -2770,7 +1957,6 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj))); fns_ptr = value_find_oload_method_list (&temp, name, 0, - staticp, &num_fns, &basetype, &boffset); if (!fns_ptr || !num_fns) @@ -2778,31 +1964,15 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, obj_type_name, (obj_type_name && *obj_type_name) ? "::" : "", name); - domain = TYPE_DOMAIN_TYPE (fns_ptr[0].type); - len = TYPE_NFN_FIELDS (domain); - /* NOTE: dan/2000-03-10: This stuff is for STABS, which won't - give us the info we need directly in the types. We have to - use the method stub conversion to get it. Be aware that this - is by no means perfect, and if you use STABS, please move to - DWARF-2, or something like it, because trying to improve - overloading using STABS is really a waste of time. */ - for (i = 0; i < len; i++) - { - int j; - struct fn_field *f = TYPE_FN_FIELDLIST1 (domain, i); - int len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i); - - for (j = 0; j < len2; j++) - { - if (TYPE_FN_FIELD_STUB (f, j) && (!strcmp_iw (TYPE_FN_FIELDLIST_NAME (domain,i),name))) - check_stub_method (domain, i, j); - } - } + /* 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); + func_name = cplus_demangle (DEPRECATED_SYMBOL_NAME (fsym), DMGL_NO_OPTS); /* If the name is NULL this must be a C-style function. Just return the same symbol. */ @@ -2813,6 +1983,7 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, } oload_syms = make_symbol_overload_list (fsym); + cleanups = make_cleanup (xfree, oload_syms); while (oload_syms[++i]) num_fns++; if (!num_fns) @@ -2824,17 +1995,12 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, /* Consider each candidate in turn */ for (ix = 0; ix < num_fns; ix++) { + static_offset = 0; if (method) { - /* For static member functions, we won't have a this pointer, but nothing - else seems to handle them right now, so we just pretend ourselves */ - nparms=0; - - if (TYPE_FN_FIELD_ARGS(fns_ptr,ix)) - { - while (TYPE_CODE(TYPE_FN_FIELD_ARGS(fns_ptr,ix)[nparms]) != TYPE_CODE_VOID) - nparms++; - } + if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix)) + static_offset = 1; + nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix)); } else { @@ -2846,11 +2012,13 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, 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_FN_FIELD_ARGS (fns_ptr, ix)[jj].type) : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj)); - /* Compare parameter types to supplied argument types */ - bv = rank_function (parm_types, nparms, arg_types, nargs); + /* 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) { @@ -2881,14 +2049,14 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, default: break; } - free (parm_types); + 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; jj++) + 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); } @@ -2911,8 +2079,11 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, } #endif - /* Check how bad the best match is */ - for (ix = 1; ix <= nargs; ix++) + /* 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 */ @@ -2945,6 +2116,10 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, 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 @@ -2953,9 +2128,21 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, else { *symp = oload_syms[oload_champ]; - free (func_name); + 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); } @@ -2963,9 +2150,7 @@ find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, 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 (name, type) - const char *name; - const struct type *type; +destructor_name_p (const char *name, const struct type *type) { /* destructors are a special case. */ @@ -2993,9 +2178,7 @@ destructor_name_p (name, type) target structure/union is defined, otherwise, return 0. */ static int -check_field_in (type, name) - register struct type *type; - const char *name; +check_field_in (register struct type *type, const char *name) { register int i; @@ -3036,9 +2219,7 @@ check_field_in (type, name) target structure/union is defined, otherwise, return 0. */ int -check_field (arg1, name) - register value_ptr arg1; - const char *name; +check_field (struct value *arg1, const char *name) { register struct type *t; @@ -3073,15 +2254,14 @@ check_field (arg1, name) "pointers to member functions". This function is used to resolve user expressions of the form "DOMAIN::NAME". */ -value_ptr -value_struct_elt_for_reference (domain, offset, curtype, name, intype) - struct type *domain, *curtype, *intype; - int offset; - char *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; - value_ptr v; + struct value *v; if (TYPE_CODE (t) != TYPE_CODE_STRUCT && TYPE_CODE (t) != TYPE_CODE_UNION) @@ -3097,7 +2277,7 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) { v = value_static_field (t, i); if (v == NULL) - error ("Internal error: could not find static variable %s", + error ("static field %s has been optimized out", name); return v; } @@ -3143,6 +2323,8 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) 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) @@ -3156,8 +2338,6 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) else j = 0; - if (TYPE_FN_FIELD_STUB (f, j)) - check_stub_method (t, i, j); if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) { return value_from_longest @@ -3169,7 +2349,7 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) else { struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), - 0, VAR_NAMESPACE, 0, NULL); + 0, VAR_DOMAIN, 0, NULL); if (s == NULL) { v = 0; @@ -3189,7 +2369,7 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) } for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--) { - value_ptr v; + struct value *v; int base_offset; if (BASETYPE_VIA_VIRTUAL (t, i)) @@ -3208,243 +2388,15 @@ value_struct_elt_for_reference (domain, offset, curtype, name, intype) } -/* Find the real run-time type of a value using RTTI. - * V is a pointer to the value. - * A pointer to the struct type entry of the run-time type - * is returneed. - * FULL is a flag that is set only if the value V includes - * the entire contents of an object of the RTTI type. - * TOP is the offset to the top of the enclosing object of - * the real run-time type. This offset may be for the embedded - * object, or for the enclosing object of V. - * USING_ENC is the flag that distinguishes the two cases. - * If it is 1, then the offset is for the enclosing object, - * otherwise for the embedded object. - * - */ - -struct type * -value_rtti_type (v, full, top, using_enc) - value_ptr v; - int *full; - int *top; - int *using_enc; -{ - struct type *known_type; - struct type *rtti_type; - CORE_ADDR coreptr; - value_ptr vp; - int using_enclosing = 0; - long top_offset = 0; - char rtti_type_name[256]; - - if (full) - *full = 0; - if (top) - *top = -1; - if (using_enc) - *using_enc = 0; - - /* Get declared type */ - known_type = VALUE_TYPE (v); - CHECK_TYPEDEF (known_type); - /* RTTI works only or class objects */ - if (TYPE_CODE (known_type) != TYPE_CODE_CLASS) - return NULL; - if (TYPE_HAS_VTABLE(known_type)) - { - /* If neither the declared type nor the enclosing type of the - * value structure has a HP ANSI C++ style virtual table, - * we can't do anything. */ - if (!TYPE_HAS_VTABLE (known_type)) - { - known_type = VALUE_ENCLOSING_TYPE (v); - CHECK_TYPEDEF (known_type); - if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) || - !TYPE_HAS_VTABLE (known_type)) - return NULL; /* No RTTI, or not HP-compiled types */ - CHECK_TYPEDEF (known_type); - using_enclosing = 1; - } - - if (using_enclosing && using_enc) - *using_enc = 1; - - /* First get the virtual table address */ - coreptr = *(CORE_ADDR *) ((VALUE_CONTENTS_ALL (v)) - + VALUE_OFFSET (v) - + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v))); - if (coreptr == 0) - return NULL; /* return silently -- maybe called on gdb-generated value */ - - /* Fetch the top offset of the object */ - /* FIXME possible 32x64 problem with pointer size & arithmetic */ - vp = value_at (builtin_type_int, - coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET, - VALUE_BFD_SECTION (v)); - top_offset = value_as_long (vp); - if (top) - *top = top_offset; - - /* Fetch the typeinfo pointer */ - /* FIXME possible 32x64 problem with pointer size & arithmetic */ - vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v)); - /* Indirect through the typeinfo pointer and retrieve the pointer - * to the string name */ - coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp)); - if (!coreptr) - error ("Retrieved null typeinfo pointer in trying to determine run-time type"); - vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v)); /* 4 -> offset of name field */ - /* FIXME possible 32x64 problem */ - - coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp)); - - read_memory_string (coreptr, rtti_type_name, 256); - - if (strlen (rtti_type_name) == 0) - error ("Retrieved null type name from typeinfo"); - - /* search for type */ - rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1); - - if (!rtti_type) - error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name); - CHECK_TYPEDEF (rtti_type); -#if 0 - printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1); -#endif - /* Check whether we have the entire object */ - if (full /* Non-null pointer passed */ - && - /* Either we checked on the whole object in hand and found the - top offset to be zero */ - (((top_offset == 0) && - using_enclosing && - TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type)) - || - /* Or we checked on the embedded object and top offset was the - same as the embedded offset */ - ((top_offset == VALUE_EMBEDDED_OFFSET (v)) && - !using_enclosing && - TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type)))) - - *full = 1; - } - else - /* - Right now this is G++ RTTI. Plan on this changing in the - future as i get around to setting the vtables properly for G++ - compiled stuff. Also, i'll be using the type info functions, - which are always right. Deal with it until then. - */ - { - CORE_ADDR vtbl; - struct minimal_symbol *minsym; - struct symbol *sym; - char *demangled_name; - struct type *btype; - /* If the type has no vptr fieldno, try to get it filled in */ - if (TYPE_VPTR_FIELDNO(known_type) < 0) - fill_in_vptr_fieldno(known_type); - - /* If we still can't find one, give up */ - if (TYPE_VPTR_FIELDNO(known_type) < 0) - return NULL; - - /* Make sure our basetype and known type match, otherwise, cast - so we can get at the vtable properly. - */ - btype = TYPE_VPTR_BASETYPE (known_type); - CHECK_TYPEDEF (btype); - if (btype != known_type ) - { - v = value_cast (btype, v); - if (using_enc) - *using_enc=1; - } - /* - We can't use value_ind here, because it would want to use RTTI, and - we'd waste a bunch of time figuring out we already know the type. - Besides, we don't care about the type, just the actual pointer - */ - if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0) - return NULL; - - /* - If we are enclosed by something that isn't us, adjust the - address properly and set using_enclosing. - */ - if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v)) - { - value_ptr tempval; - tempval=value_field(v,TYPE_VPTR_FIELDNO(known_type)); - VALUE_ADDRESS(tempval)+=(TYPE_BASECLASS_BITPOS(known_type,TYPE_VPTR_FIELDNO(known_type))/8); - vtbl=value_as_pointer(tempval); - using_enclosing=1; - } - else - { - vtbl=value_as_pointer(value_field(v,TYPE_VPTR_FIELDNO(known_type))); - using_enclosing=0; - } - - /* Try to find a symbol that is the vtable */ - minsym=lookup_minimal_symbol_by_pc(vtbl); - if (minsym==NULL || (demangled_name=SYMBOL_NAME(minsym))==NULL || !VTBL_PREFIX_P(demangled_name)) - return NULL; - - /* If we just skip the prefix, we get screwed by namespaces */ - demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI); - *(strchr(demangled_name,' '))=0; - - /* Lookup the type for the name */ - rtti_type=lookup_typename(demangled_name, (struct block *)0,1); - - if (rtti_type==NULL) - return NULL; - - if (TYPE_N_BASECLASSES(rtti_type) > 1 && full && (*full) != 1) - { - if (top) - *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8; - if (top && ((*top) >0)) - { - if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type)) - { - if (full) - *full=0; - } - else - { - if (full) - *full=1; - } - } - } - else - { - if (full) - *full=1; - } - if (using_enc) - *using_enc=using_enclosing; - } - return rtti_type; -} - /* Given a pointer value V, find the real (RTTI) type of the object it points to. Other parameters FULL, TOP, USING_ENC as with value_rtti_type() and refer to the values computed for the object pointed to. */ struct type * -value_rtti_target_type (v, full, top, using_enc) - value_ptr v; - int *full; - int *top; - int *using_enc; +value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc) { - value_ptr target; + struct value *target; target = value_ind (v); @@ -3461,20 +2413,15 @@ value_rtti_target_type (v, full, top, using_enc) they can be supplied and a second call to value_rtti_type() is avoided. (Pass RTYPE == NULL if they're not available */ -value_ptr -value_full_object (argp, rtype, xfull, xtop, xusing_enc) - value_ptr argp; - struct type *rtype; - int xfull; - int xtop; - int xusing_enc; - +struct 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; - value_ptr new_val; + struct value *new_val; if (rtype) { @@ -3494,7 +2441,7 @@ value_full_object (argp, rtype, xfull, xtop, xusing_enc) type is wrong, set it *//* pai: FIXME -- sounds iffy */ if (full) { - VALUE_ENCLOSING_TYPE (argp) = real_type; + argp = value_change_enclosing_type (argp, real_type); return argp; } @@ -3521,21 +2468,18 @@ value_full_object (argp, rtype, xfull, xtop, xusing_enc) -/* C++: return the value of the class instance variable, if one exists. +/* Return the value of the local variable, if one exists. Flag COMPLAIN signals an error if the request is made in an inappropriate context. */ -value_ptr -value_of_this (complain) - int complain; +struct value * +value_of_local (const char *name, int complain) { struct symbol *func, *sym; struct block *b; - int i; - static const char funny_this[] = "this"; - value_ptr this; + struct value * ret; - if (selected_frame == 0) + if (deprecated_selected_frame == 0) { if (complain) error ("no frame selected"); @@ -3543,54 +2487,64 @@ value_of_this (complain) return 0; } - func = get_frame_function (selected_frame); + func = get_frame_function (deprecated_selected_frame); if (!func) { if (complain) - error ("no `this' in nameless context"); + error ("no `%s' in nameless context", name); else return 0; } b = SYMBOL_BLOCK_VALUE (func); - i = BLOCK_NSYMS (b); - if (i <= 0) + if (dict_empty (BLOCK_DICT (b))) { if (complain) - error ("no args, no `this'"); + error ("no args, no `%s'", name); 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, VAR_NAMESPACE); + sym = lookup_block_symbol (b, name, NULL, VAR_DOMAIN); if (sym == NULL) { if (complain) - error ("current stack frame not in method"); + error ("current stack frame does not contain a variable named `%s'", name); else return NULL; } - this = read_var_value (sym, selected_frame); - if (this == 0 && complain) - error ("`this' argument at unknown address"); - return this; + ret = read_var_value (sym, deprecated_selected_frame); + if (ret == 0 && complain) + error ("`%s' argument unreadable", name); + return ret; +} + +/* C++/Objective-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) +{ + if (current_language->la_language == language_objc) + return value_of_local ("self", complain); + else + return value_of_local ("this", complain); } /* 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. */ -value_ptr -value_slice (array, lowbound, length) - value_ptr array; - int lowbound, length; +struct value * +value_slice (struct value *array, int lowbound, int length) { struct type *slice_range_type, *slice_type, *range_type; - LONGEST lowerbound, upperbound, offset; - value_ptr slice; + LONGEST lowerbound, upperbound; + struct value *slice; struct type *array_type; array_type = check_typedef (VALUE_TYPE (array)); COERCE_VARYING_ARRAY (array, array_type); @@ -3602,10 +2556,7 @@ value_slice (array, lowbound, length) 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 - /* Chill allows zero-length strings but not arrays. */ - || (current_language->la_language == language_chill - && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY)) + || lowbound + length - 1 > upperbound) error ("slice out of range"); /* FIXME-type-allocation: need a way to free this type when we are done with it. */ @@ -3640,7 +2591,7 @@ value_slice (array, lowbound, length) else { struct type *element_type = TYPE_TARGET_TYPE (array_type); - offset + LONGEST offset = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type)); slice_type = create_array_type ((struct type *) NULL, element_type, slice_range_type); @@ -3661,33 +2612,16 @@ value_slice (array, lowbound, length) return slice; } -/* Assuming chill_varying_type (VARRAY) is true, return an equivalent - value as a fixed-length array. */ - -value_ptr -varying_to_slice (varray) - value_ptr 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 */ -value_ptr -value_literal_complex (arg1, arg2, type) - value_ptr arg1; - value_ptr arg2; - struct type *type; +struct value * +value_literal_complex (struct value *arg1, struct value *arg2, struct type *type) { - register value_ptr val; + struct value *val; struct type *real_type = TYPE_TARGET_TYPE (type); val = allocate_value (type); @@ -3703,17 +2637,15 @@ value_literal_complex (arg1, arg2, type) /* Cast a value into the appropriate complex data type. */ -static value_ptr -cast_into_complex (type, val) - struct type *type; - register value_ptr val; +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)); - value_ptr re_val = allocate_value (val_real_type); - value_ptr im_val = allocate_value (val_real_type); + 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)); @@ -3731,7 +2663,7 @@ cast_into_complex (type, val) } void -_initialize_valops () +_initialize_valops (void) { #if 0 add_show_from_set @@ -3747,14 +2679,4 @@ _initialize_valops () &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); }