X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=8a456413a09c1faea2a7dd306d2b947aa9ee549a;hb=41b56feb5063aee4fefb4a991eb796d1e8a7475e;hp=e0c8873fb892bcb997b25dd791fad199a51575bf;hpb=233e8b28cf7b548ca197a7a6d9bf5f9ce80053ac;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index e0c8873fb8..8a456413a0 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1,6 +1,6 @@ /* Perform non-arithmetic operations on values, for GDB. - Copyright (C) 1986-2014 Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -36,12 +36,8 @@ #include "cp-support.h" #include "dfp.h" #include "tracepoint.h" -#include -#include -#include "gdb_assert.h" #include "observer.h" #include "objfiles.h" -#include "exceptions.h" #include "extension.h" extern unsigned int overload_debug; @@ -51,11 +47,11 @@ static int typecmp (int staticp, int varargs, int nargs, struct field t1[], struct value *t2[]); static struct value *search_struct_field (const char *, struct value *, - int, struct type *, int); + struct type *, int); static struct value *search_struct_method (const char *, struct value **, struct value **, - int, int *, struct type *); + LONGEST, int *, struct type *); static int find_oload_champ_namespace (struct value **, int, const char *, const char *, @@ -100,9 +96,9 @@ static CORE_ADDR allocate_space_in_inferior (int); static struct value *cast_into_complex (struct type *, struct value *); static void find_method_list (struct value **, const char *, - int, struct type *, struct fn_field **, int *, + LONGEST, struct type *, struct fn_field **, int *, VEC (xmethod_worker_ptr) **, - struct type **, int *); + struct type **, LONGEST *); void _initialize_valops (void); @@ -131,21 +127,21 @@ show_overload_resolution (struct ui_file *file, int from_tty, struct value * find_function_in_inferior (const char *name, struct objfile **objf_p) { - struct symbol *sym; + struct block_symbol sym; sym = lookup_symbol (name, 0, VAR_DOMAIN, 0); - if (sym != NULL) + if (sym.symbol != NULL) { - if (SYMBOL_CLASS (sym) != LOC_BLOCK) + if (SYMBOL_CLASS (sym.symbol) != LOC_BLOCK) { error (_("\"%s\" exists in this program but is not a function."), name); } if (objf_p) - *objf_p = SYMBOL_SYMTAB (sym)->objfile; + *objf_p = symbol_objfile (sym.symbol); - return value_of_variable (sym, NULL); + return value_of_variable (sym.symbol, sym.block); } else { @@ -249,7 +245,7 @@ value_cast_structs (struct type *type, struct value *v2) if (TYPE_NAME (t1) != NULL) { v = search_struct_field (type_name_no_tag (t1), - v2, 0, t2, 1); + v2, t2, 1); if (v) return v; } @@ -260,7 +256,8 @@ value_cast_structs (struct type *type, struct value *v2) if (TYPE_NAME (t2) != NULL) { /* Try downcasting using the run-time type of the value. */ - int full, top, using_enc; + int full, using_enc; + LONGEST top; struct type *real_type; real_type = value_rtti_type (v2, &full, &top, &using_enc); @@ -276,7 +273,7 @@ value_cast_structs (struct type *type, struct value *v2) && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1))) return v; - v = search_struct_field (type_name_no_tag (t2), v, 0, real_type, 1); + v = search_struct_field (type_name_no_tag (t2), v, real_type, 1); if (v) return v; } @@ -285,7 +282,7 @@ value_cast_structs (struct type *type, struct value *v2) T2. This wouldn't work properly for classes with virtual bases, but those were handled above. */ v = search_struct_field (type_name_no_tag (t2), - value_zero (t1, not_lval), 0, t1, 1); + value_zero (t1, not_lval), t1, 1); if (v) { /* Downcasting is possible (t1 is superclass of v2). */ @@ -336,7 +333,7 @@ value_cast_pointers (struct type *type, struct value *arg2, deprecated_set_value_type (v, type); return v; } - } + } /* No superclass found, just change the pointer type. */ arg2 = value_copy (arg2); @@ -385,7 +382,7 @@ value_cast (struct type *type, struct value *arg2) /* We deref the value and then do the cast. */ return value_cast (type, coerce_ref (arg2)); - CHECK_TYPEDEF (type); + type = check_typedef (type); code1 = TYPE_CODE (type); arg2 = coerce_ref (arg2); type2 = check_typedef (value_type (arg2)); @@ -639,7 +636,7 @@ value_reinterpret_cast (struct type *type, struct value *arg) static int dynamic_cast_check_1 (struct type *desired_type, const gdb_byte *valaddr, - int embedded_offset, + LONGEST embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, @@ -651,8 +648,9 @@ dynamic_cast_check_1 (struct type *desired_type, for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) { - int offset = baseclass_offset (search_type, i, valaddr, embedded_offset, - address, val); + LONGEST offset = baseclass_offset (search_type, i, valaddr, + embedded_offset, + address, val); if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i))) { @@ -686,7 +684,7 @@ dynamic_cast_check_1 (struct type *desired_type, static int dynamic_cast_check_2 (struct type *desired_type, const gdb_byte *valaddr, - int embedded_offset, + LONGEST embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, @@ -696,7 +694,7 @@ dynamic_cast_check_2 (struct type *desired_type, for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i) { - int offset; + LONGEST offset; if (! BASETYPE_VIA_PUBLIC (search_type, i)) continue; @@ -727,7 +725,8 @@ dynamic_cast_check_2 (struct type *desired_type, struct value * value_dynamic_cast (struct type *type, struct value *arg) { - int full, top, using_enc; + int full, using_enc; + LONGEST top; struct type *resolved_type = check_typedef (type); struct type *arg_type = check_typedef (value_type (arg)); struct type *class_type, *rtti_type; @@ -739,7 +738,7 @@ value_dynamic_cast (struct type *type, struct value *arg) && TYPE_CODE (resolved_type) != TYPE_CODE_REF) error (_("Argument to dynamic_cast must be a pointer or reference type")); if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID - && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_CLASS) + && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast must be pointer to class or `void *'")); class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type)); @@ -752,7 +751,7 @@ value_dynamic_cast (struct type *type, struct value *arg) if (TYPE_CODE (arg_type) == TYPE_CODE_PTR) { arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type)); - if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS) + if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast does " "not have pointer to class type")); } @@ -765,7 +764,7 @@ value_dynamic_cast (struct type *type, struct value *arg) } else { - if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS) + if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT) error (_("Argument to dynamic_cast does not have class type")); } @@ -958,34 +957,40 @@ value_at_lazy (struct type *type, CORE_ADDR addr) } void -read_value_memory (struct value *val, int embedded_offset, +read_value_memory (struct value *val, LONGEST embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length) { - ULONGEST xfered = 0; + ULONGEST xfered_total = 0; + struct gdbarch *arch = get_value_arch (val); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + enum target_object object; + + object = stack ? TARGET_OBJECT_STACK_MEMORY : TARGET_OBJECT_MEMORY; - while (xfered < length) + while (xfered_total < length) { enum target_xfer_status status; - ULONGEST xfered_len; + ULONGEST xfered_partial; status = target_xfer_partial (current_target.beneath, - TARGET_OBJECT_MEMORY, NULL, - buffer + xfered, NULL, - memaddr + xfered, length - xfered, - &xfered_len); + object, NULL, + buffer + xfered_total * unit_size, NULL, + memaddr + xfered_total, + length - xfered_total, + &xfered_partial); if (status == TARGET_XFER_OK) /* nothing */; else if (status == TARGET_XFER_UNAVAILABLE) - mark_value_bytes_unavailable (val, embedded_offset + xfered, - xfered_len); + mark_value_bytes_unavailable (val, embedded_offset + xfered_total, + xfered_partial); else if (status == TARGET_XFER_EOF) - memory_error (TARGET_XFER_E_IO, memaddr + xfered); + memory_error (TARGET_XFER_E_IO, memaddr + xfered_total); else - memory_error (status, memaddr + xfered); + memory_error (status, memaddr + xfered_total); - xfered += xfered_len; + xfered_total += xfered_partial; QUIT; } } @@ -1016,7 +1021,7 @@ value_assign (struct value *toval, struct value *fromval) fromval = coerce_array (fromval); } - CHECK_TYPEDEF (type); + type = check_typedef (type); /* Since modifying a register can trash the frame chain, and modifying memory can trash the frame cache, we save the old frame @@ -1032,7 +1037,7 @@ value_assign (struct value *toval, struct value *fromval) case lval_internalvar_component: { - int offset = value_offset (toval); + LONGEST offset = value_offset (toval); /* Are we dealing with a bitfield? @@ -1093,7 +1098,7 @@ value_assign (struct value *toval, struct value *fromval) else { changed_addr = value_address (toval); - changed_len = TYPE_LENGTH (type); + changed_len = type_length_units (type); dest_buffer = value_contents (fromval); } @@ -1107,60 +1112,69 @@ value_assign (struct value *toval, struct value *fromval) struct gdbarch *gdbarch; int value_reg; - /* Figure out which frame this is in currently. */ + /* Figure out which frame this is in currently. + + We use VALUE_FRAME_ID for obtaining the value's frame id instead of + VALUE_NEXT_FRAME_ID due to requiring a frame which may be passed to + put_frame_register_bytes() below. That function will (eventually) + perform the necessary unwind operation by first obtaining the next + frame. */ frame = frame_find_by_id (VALUE_FRAME_ID (toval)); + value_reg = VALUE_REGNUM (toval); if (!frame) error (_("Value being assigned to is no longer active.")); gdbarch = get_frame_arch (frame); - if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), type)) + + if (value_bitsize (toval)) { - /* If TOVAL is a special machine register requiring - conversion of program values to a special raw - format. */ - gdbarch_value_to_register (gdbarch, frame, - VALUE_REGNUM (toval), type, - value_contents (fromval)); + struct value *parent = value_parent (toval); + LONGEST offset = value_offset (parent) + value_offset (toval); + int changed_len; + gdb_byte buffer[sizeof (LONGEST)]; + int optim, unavail; + + 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); + + if (!get_frame_register_bytes (frame, value_reg, offset, + changed_len, buffer, + &optim, &unavail)) + { + if (optim) + throw_error (OPTIMIZED_OUT_ERROR, + _("value has been optimized out")); + if (unavail) + throw_error (NOT_AVAILABLE_ERROR, + _("value is not available")); + } + + modify_field (type, buffer, value_as_long (fromval), + value_bitpos (toval), value_bitsize (toval)); + + put_frame_register_bytes (frame, value_reg, offset, + changed_len, buffer); } else { - if (value_bitsize (toval)) + if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), + type)) { - struct value *parent = value_parent (toval); - int offset = value_offset (parent) + value_offset (toval); - int changed_len; - gdb_byte buffer[sizeof (LONGEST)]; - int optim, unavail; - - 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); - - if (!get_frame_register_bytes (frame, value_reg, offset, - changed_len, buffer, - &optim, &unavail)) - { - if (optim) - throw_error (OPTIMIZED_OUT_ERROR, - _("value has been optimized out")); - if (unavail) - throw_error (NOT_AVAILABLE_ERROR, - _("value is not available")); - } - - modify_field (type, buffer, value_as_long (fromval), - value_bitpos (toval), value_bitsize (toval)); - - put_frame_register_bytes (frame, value_reg, offset, - changed_len, buffer); + /* If TOVAL is a special machine register requiring + conversion of program values to a special raw + format. */ + gdbarch_value_to_register (gdbarch, frame, + VALUE_REGNUM (toval), type, + value_contents (fromval)); } else { @@ -1171,8 +1185,7 @@ value_assign (struct value *toval, struct value *fromval) } } - if (deprecated_register_changed_hook) - deprecated_register_changed_hook (-1); + observer_notify_register_changed (frame, value_reg); break; } @@ -1283,7 +1296,7 @@ value_repeat (struct value *arg1, int count) read_value_memory (val, 0, value_stack (val), value_address (val), value_contents_all_raw (val), - TYPE_LENGTH (value_enclosing_type (val))); + type_length_units (value_enclosing_type (val))); return val; } @@ -1291,27 +1304,12 @@ value_repeat (struct value *arg1, int count) struct value * value_of_variable (struct symbol *var, const struct block *b) { - struct frame_info *frame; + struct frame_info *frame = NULL; - if (!symbol_read_needs_frame (var)) - frame = NULL; - else if (!b) + if (symbol_read_needs_frame (var)) frame = get_selected_frame (_("No frame selected.")); - else - { - frame = block_innermost_frame (b); - if (!frame) - { - if (BLOCK_FUNCTION (b) && !block_inlined_p (b) - && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))) - error (_("No frame is currently executing in block %s."), - SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b))); - else - error (_("No frame is currently executing in specified block")); - } - } - return read_var_value (var, frame); + return read_var_value (var, b, frame); } struct value * @@ -1342,7 +1340,7 @@ address_of_variable (struct symbol *var, const struct block *b) struct frame_info *frame; const char *regname; - frame = frame_find_by_id (VALUE_FRAME_ID (val)); + frame = frame_find_by_id (VALUE_NEXT_FRAME_ID (val)); gdb_assert (frame); regname = gdbarch_register_name (get_frame_arch (frame), @@ -1477,13 +1475,28 @@ value_addr (struct value *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); - deprecated_set_value_type (arg2, - lookup_pointer_type (TYPE_TARGET_TYPE (type))); - return arg2; + if (value_bits_synthetic_pointer (arg1, value_embedded_offset (arg1), + TARGET_CHAR_BIT * TYPE_LENGTH (type))) + arg1 = coerce_ref (arg1); + else + { + /* 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. + Do the same to its enclosing type for consistency. */ + struct type *type_ptr + = lookup_pointer_type (TYPE_TARGET_TYPE (type)); + struct type *enclosing_type + = check_typedef (value_enclosing_type (arg1)); + struct type *enclosing_type_ptr + = lookup_pointer_type (TYPE_TARGET_TYPE (enclosing_type)); + + arg2 = value_copy (arg1); + deprecated_set_value_type (arg2, type_ptr); + set_value_enclosing_type (arg2, enclosing_type_ptr); + + return arg2; + } } if (TYPE_CODE (type) == TYPE_CODE_FUNC) return value_coerce_function (arg1); @@ -1597,7 +1610,7 @@ value_array (int lowbound, int highbound, struct value **elemvec) { int nelem; int idx; - unsigned int typelength; + ULONGEST typelength; struct value *val; struct type *arraytype; @@ -1609,10 +1622,11 @@ value_array (int lowbound, int highbound, struct value **elemvec) { error (_("bad array bounds (%d, %d)"), lowbound, highbound); } - typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0])); + typelength = type_length_units (value_enclosing_type (elemvec[0])); for (idx = 1; idx < nelem; idx++) { - if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength) + if (type_length_units (value_enclosing_type (elemvec[idx])) + != typelength) { error (_("array elements must all be the same size")); } @@ -1640,7 +1654,7 @@ value_array (int lowbound, int highbound, struct value **elemvec) } struct value * -value_cstring (char *ptr, ssize_t len, struct type *char_type) +value_cstring (const char *ptr, ssize_t len, struct type *char_type) { struct value *val; int lowbound = current_language->string_lower_bound; @@ -1663,7 +1677,7 @@ value_cstring (char *ptr, ssize_t len, struct type *char_type) string may contain embedded null bytes. */ struct value * -value_string (char *ptr, ssize_t len, struct type *char_type) +value_string (const char *ptr, ssize_t len, struct type *char_type) { struct value *val; int lowbound = current_language->string_lower_bound; @@ -1722,7 +1736,7 @@ typecmp (int staticp, int varargs, int nargs, tt2 = check_typedef (value_type (t2[i])); if (TYPE_CODE (tt1) == TYPE_CODE_REF - /* We should be doing hairy argument matching, as below. */ + /* We should be doing hairy argument matching, as below. */ && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2))) { @@ -1772,7 +1786,7 @@ typecmp (int staticp, int varargs, int nargs, static void update_search_result (struct value **result_ptr, struct value *v, - int *last_boffset, int boffset, + LONGEST *last_boffset, LONGEST boffset, const char *name, struct type *type) { if (v != NULL) @@ -1796,16 +1810,16 @@ update_search_result (struct value **result_ptr, struct value *v, lookup is ambiguous. */ static void -do_search_struct_field (const char *name, struct value *arg1, int offset, +do_search_struct_field (const char *name, struct value *arg1, LONGEST offset, struct type *type, int looking_for_baseclass, struct value **result_ptr, - int *last_boffset, + LONGEST *last_boffset, struct type *outermost_type) { int i; int nbases; - CHECK_TYPEDEF (type); + type = check_typedef (type); nbases = TYPE_N_BASECLASSES (type); if (!looking_for_baseclass) @@ -1826,9 +1840,7 @@ do_search_struct_field (const char *name, struct value *arg1, int offset, } if (t_field_name - && (t_field_name[0] == '\0' - || (TYPE_CODE (type) == TYPE_CODE_UNION - && (strcmp_iw (t_field_name, "else") == 0)))) + && t_field_name[0] == '\0') { struct type *field_type = TYPE_FIELD_TYPE (type, i); @@ -1848,7 +1860,7 @@ do_search_struct_field (const char *name, struct value *arg1, int offset, . */ struct value *v = NULL; - int new_offset = offset; + LONGEST new_offset = offset; /* This is pretty gross. In G++, the offset in an anonymous union is relative to the beginning of the @@ -1887,7 +1899,7 @@ do_search_struct_field (const char *name, struct value *arg1, int offset, && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0)); - int boffset = value_embedded_offset (arg1) + offset; + LONGEST boffset = value_embedded_offset (arg1) + offset; if (BASETYPE_VIA_VIRTUAL (type, i)) { @@ -1952,21 +1964,20 @@ do_search_struct_field (const char *name, struct value *arg1, int offset, } /* 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. + baseclasses. Look for a field NAME in ARG1. 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 (const char *name, struct value *arg1, int offset, +search_struct_field (const char *name, struct value *arg1, struct type *type, int looking_for_baseclass) { struct value *result = NULL; - int boffset = 0; + LONGEST boffset = 0; - do_search_struct_field (name, arg1, offset, type, looking_for_baseclass, + do_search_struct_field (name, arg1, 0, type, looking_for_baseclass, &result, &boffset, type); return result; } @@ -1981,7 +1992,7 @@ search_struct_field (const char *name, struct value *arg1, int offset, static struct value * search_struct_method (const char *name, struct value **arg1p, - struct value **args, int offset, + struct value **args, LONGEST offset, int *static_memfuncp, struct type *type) { int i; @@ -1989,15 +2000,15 @@ search_struct_method (const char *name, struct value **arg1p, int name_matched = 0; char dem_opname[64]; - CHECK_TYPEDEF (type); + type = check_typedef (type); for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--) { const 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 (startswith (t_field_name, "__") || + startswith (t_field_name, "op") || + startswith (t_field_name, "type")) { if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI)) t_field_name = dem_opname; @@ -2045,8 +2056,8 @@ search_struct_method (const char *name, struct value **arg1p, for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) { - int base_offset; - int this_offset; + LONGEST base_offset; + LONGEST this_offset; if (BASETYPE_VIA_VIRTUAL (type, i)) { @@ -2056,7 +2067,7 @@ search_struct_method (const char *name, struct value **arg1p, /* The virtual base class pointer might have been clobbered by the user program. Make sure that it - still points to a valid memory location. */ + still points to a valid memory location. */ if (offset < 0 || offset >= TYPE_LENGTH (type)) { @@ -2064,7 +2075,7 @@ search_struct_method (const char *name, struct value **arg1p, struct cleanup *back_to; CORE_ADDR address; - tmp = xmalloc (TYPE_LENGTH (baseclass)); + tmp = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass)); back_to = make_cleanup (xfree, tmp); address = value_address (*arg1p); @@ -2165,7 +2176,7 @@ value_struct_elt (struct value **argp, struct value **args, /* 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); + v = search_struct_field (name, *argp, t, 0); if (v) return v; @@ -2186,8 +2197,8 @@ value_struct_elt (struct value **argp, struct value **args, return v; } - v = search_struct_method (name, argp, args, 0, - static_memfuncp, t); + v = search_struct_method (name, argp, args, 0, + static_memfuncp, t); if (v == (struct value *) - 1) { @@ -2199,7 +2210,7 @@ value_struct_elt (struct value **argp, struct value **args, /* 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); + v = search_struct_field (name, *argp, t, 0); /* If we found an ordinary field, then it is not a method call. So, treat it as if it were a static member function. */ if (v && static_memfuncp) @@ -2222,9 +2233,7 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, const char *err) { struct type *t; - struct value *v; int i; - int nbases; *argp = coerce_array (*argp); @@ -2281,17 +2290,17 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype, static void find_method_list (struct value **argp, const char *method, - int offset, struct type *type, + LONGEST offset, struct type *type, struct fn_field **fn_list, int *num_fns, VEC (xmethod_worker_ptr) **xm_worker_vec, - struct type **basetype, int *boffset) + struct type **basetype, LONGEST *boffset) { int i; struct fn_field *f = NULL; VEC (xmethod_worker_ptr) *worker_vec = NULL, *new_vec = NULL; gdb_assert (fn_list != NULL && xm_worker_vec != NULL); - CHECK_TYPEDEF (type); + type = check_typedef (type); /* First check in object itself. This function is called recursively to search through base classes. @@ -2341,7 +2350,7 @@ find_method_list (struct value **argp, const char *method, extension methods. */ for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--) { - int base_offset; + LONGEST base_offset; if (BASETYPE_VIA_VIRTUAL (type, i)) { @@ -2381,10 +2390,10 @@ find_method_list (struct value **argp, const char *method, static void value_find_oload_method_list (struct value **argp, const char *method, - int offset, struct fn_field **fn_list, + LONGEST offset, struct fn_field **fn_list, int *num_fns, VEC (xmethod_worker_ptr) **xm_worker_vec, - struct type **basetype, int *boffset) + struct type **basetype, LONGEST *boffset) { struct type *t; @@ -2452,6 +2461,12 @@ value_find_oload_method_list (struct value **argp, const char *method, ADL overload candidates when performing overload resolution for a fully qualified name. + If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be + read while picking the best overload match (it may be all zeroes and thus + not have a vtable pointer), in which case skip virtual function lookup. + This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine + the result type. + Note: This function does *not* check the value of overload_resolution. Caller must check it to see whether overload resolution is permitted. */ @@ -2461,7 +2476,8 @@ find_overload_match (struct value **args, int nargs, const char *name, enum oload_search_type method, struct value **objp, struct symbol *fsym, struct value **valp, struct symbol **symp, - int *staticp, const int no_adl) + int *staticp, const int no_adl, + const enum noside noside) { struct value *obj = (objp ? *objp : NULL); struct type *obj_type = obj ? value_type (obj) : NULL; @@ -2470,7 +2486,6 @@ find_overload_match (struct value **args, int nargs, int method_oload_champ = -1; int src_method_oload_champ = -1; int ext_method_oload_champ = -1; - int src_and_ext_equal = 0; /* The measure for the current best match. */ struct badness_vector *method_badness = NULL; @@ -2488,7 +2503,7 @@ find_overload_match (struct value **args, int nargs, /* Number of overloaded instances being considered. */ int num_fns = 0; struct type *basetype = NULL; - int boffset; + LONGEST boffset; struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL); @@ -2515,7 +2530,7 @@ find_overload_match (struct value **args, int nargs, a function. */ if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT) { - *valp = search_struct_field (name, obj, 0, + *valp = search_struct_field (name, obj, check_typedef (value_type (obj)), 0); if (*valp) { @@ -2540,7 +2555,7 @@ find_overload_match (struct value **args, int nargs, value_find_oload_method_list above. */ if (fns_ptr) { - gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL); + gdb_assert (TYPE_SELF_TYPE (fns_ptr[0].type) != NULL); src_method_oload_champ = find_oload_champ (args, nargs, num_fns, fns_ptr, NULL, @@ -2569,7 +2584,6 @@ find_overload_match (struct value **args, int nargs, switch (compare_badness (ext_method_badness, src_method_badness)) { case 0: /* Src method and xmethod are equally good. */ - src_and_ext_equal = 1; /* If src method and xmethod are equally good, then xmethod should be the winner. Hence, fall through to the case where a xmethod is better than the source @@ -2767,9 +2781,13 @@ find_overload_match (struct value **args, int nargs, { if (src_method_oload_champ >= 0) { - if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ)) - *valp = value_virtual_fn_field (&temp, fns_ptr, method_oload_champ, - basetype, boffset); + if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ) + && noside != EVAL_AVOID_SIDE_EFFECTS) + { + *valp = value_virtual_fn_field (&temp, fns_ptr, + method_oload_champ, basetype, + boffset); + } else *valp = value_fn_field (&temp, fns_ptr, method_oload_champ, basetype, boffset); @@ -2906,7 +2924,7 @@ find_oload_champ_namespace_loop (struct value **args, int nargs, old_cleanups = make_cleanup (xfree, *oload_syms); make_cleanup (xfree, *oload_champ_bv); - new_namespace = alloca (namespace_len + 1); + new_namespace = (char *) alloca (namespace_len + 1); strncpy (new_namespace, qualified_name, namespace_len); new_namespace[namespace_len] = '\0'; new_oload_syms = make_symbol_overload_list (func_name, @@ -2990,7 +3008,6 @@ find_oload_champ (struct value **args, int nargs, { int ix; int fn_count; - int xm_worker_vec_n = VEC_length (xmethod_worker_ptr, xm_worker_vec); /* A measure of how good an overloaded instance is. */ struct badness_vector *bv; /* Index of best overloaded function. */ @@ -3034,13 +3051,12 @@ find_oload_champ (struct value **args, int nargs, else nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix])); - parm_types = (struct type **) - xmalloc (nparms * (sizeof (struct type *))); + parm_types = XNEWVEC (struct type *, nparms); for (jj = 0; jj < nparms; jj++) parm_types[jj] = (fns_ptr != NULL ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type) : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), - jj)); + jj)); } /* Compare parameter types to supplied argument types. Skip @@ -3352,7 +3368,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, type = check_typedef (value_type (ptr)); gdb_assert (type != NULL && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR); - tmp = lookup_pointer_type (TYPE_DOMAIN_TYPE (type)); + tmp = lookup_pointer_type (TYPE_SELF_TYPE (type)); v = value_cast_pointers (tmp, v, 1); mem_offset = value_as_long (ptr); tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type)); @@ -3378,9 +3394,9 @@ value_struct_elt_for_reference (struct type *domain, int offset, const 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 (startswith (t_field_name, "__") + || startswith (t_field_name, "op") + || startswith (t_field_name, "type")) { if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI)) @@ -3448,15 +3464,15 @@ value_struct_elt_for_reference (struct type *domain, int offset, { struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), - 0, VAR_DOMAIN, 0); + 0, VAR_DOMAIN, 0).symbol; if (s == NULL) return NULL; if (want_address) - return value_addr (read_var_value (s, 0)); + return value_addr (read_var_value (s, 0, 0)); else - return read_var_value (s, 0); + return read_var_value (s, 0, 0); } if (TYPE_FN_FIELD_VIRTUAL_P (f, j)) @@ -3479,12 +3495,12 @@ value_struct_elt_for_reference (struct type *domain, int offset, { struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j), - 0, VAR_DOMAIN, 0); + 0, VAR_DOMAIN, 0).symbol; if (s == NULL) return NULL; - v = read_var_value (s, 0); + v = read_var_value (s, 0, 0); if (!want_address) result = v; else @@ -3555,30 +3571,21 @@ value_maybe_namespace_elt (const struct type *curtype, enum noside noside) { const char *namespace_name = TYPE_TAG_NAME (curtype); - struct symbol *sym; + struct block_symbol sym; struct value *result; sym = cp_lookup_symbol_namespace (namespace_name, name, get_selected_block (0), VAR_DOMAIN); - if (sym == NULL) - { - char *concatenated_name = alloca (strlen (namespace_name) + 2 - + strlen (name) + 1); - - sprintf (concatenated_name, "%s::%s", namespace_name, name); - sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN); - } - - if (sym == NULL) + if (sym.symbol == NULL) return NULL; else if ((noside == EVAL_AVOID_SIDE_EFFECTS) - && (SYMBOL_CLASS (sym) == LOC_TYPEDEF)) - result = allocate_value (SYMBOL_TYPE (sym)); + && (SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF)) + result = allocate_value (SYMBOL_TYPE (sym.symbol)); else - result = value_of_variable (sym, get_selected_block (0)); + result = value_of_variable (sym.symbol, sym.block); - if (result && want_address) + if (want_address) result = value_addr (result); return result; @@ -3591,9 +3598,9 @@ value_maybe_namespace_elt (const struct type *curtype, struct type * value_rtti_indirect_type (struct value *v, int *full, - int *top, int *using_enc) + LONGEST *top, int *using_enc) { - struct value *target; + struct value *target = NULL; struct type *type, *real_type, *target_type; type = value_type (v); @@ -3601,7 +3608,25 @@ value_rtti_indirect_type (struct value *v, int *full, if (TYPE_CODE (type) == TYPE_CODE_REF) target = coerce_ref (v); else if (TYPE_CODE (type) == TYPE_CODE_PTR) - target = value_ind (v); + { + + TRY + { + target = value_ind (v); + } + CATCH (except, RETURN_MASK_ERROR) + { + if (except.error == MEMORY_ERROR) + { + /* value_ind threw a memory error. The pointer is NULL or + contains an uninitialized value: we can't determine any + type. */ + return NULL; + } + throw_exception (except); + } + END_CATCH + } else return NULL; @@ -3646,7 +3671,7 @@ value_full_object (struct value *argp, { struct type *real_type; int full = 0; - int top = -1; + LONGEST top = -1; int using_enc = 0; struct value *new_val; @@ -3711,8 +3736,8 @@ value_full_object (struct value *argp, struct value * value_of_this (const struct language_defn *lang) { - struct symbol *sym; - struct block *b; + struct block_symbol sym; + const struct block *b; struct frame_info *frame; if (!lang->la_name_of_this) @@ -3723,11 +3748,11 @@ value_of_this (const struct language_defn *lang) b = get_frame_block (frame, NULL); sym = lookup_language_this (lang, b); - if (sym == NULL) + if (sym.symbol == NULL) error (_("current stack frame does not contain a variable named `%s'"), lang->la_name_of_this); - return read_var_value (sym, frame); + return read_var_value (sym.symbol, sym.block, frame); } /* Return the value of the local variable, if one exists. Return NULL @@ -3737,12 +3762,15 @@ struct value * value_of_this_silent (const struct language_defn *lang) { struct value *ret = NULL; - volatile struct gdb_exception except; - TRY_CATCH (except, RETURN_MASK_ERROR) + TRY { ret = value_of_this (lang); } + CATCH (except, RETURN_MASK_ERROR) + { + } + END_CATCH return ret; } @@ -3795,11 +3823,11 @@ value_slice (struct value *array, int lowbound, int length) { slice = allocate_value (slice_type); value_contents_copy (slice, 0, array, offset, - TYPE_LENGTH (slice_type)); + type_length_units (slice_type)); } set_value_component_location (slice, array); - VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array); + VALUE_NEXT_FRAME_ID (slice) = VALUE_NEXT_FRAME_ID (array); set_value_offset (slice, value_offset (array) + offset); }