X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=04cf22cced138975ed58c56fd3ef58bd27ddae80;hb=08feed99cbcc75ecdd111f7a10c163b6f99c428f;hp=7fbedd77bb1175ad44caab94e105943e0eb92ed8;hpb=0891c3cc132495ad7b323896efae4f91eca87c6c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 7fbedd77bb..04cf22cced 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1,6 +1,6 @@ /* Perform non-arithmetic operations on values, for GDB. - Copyright (C) 1986-2018 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -39,9 +39,9 @@ #include "observable.h" #include "objfiles.h" #include "extension.h" -#include "byte-vector.h" +#include "gdbtypes.h" +#include "gdbsupport/byte-vector.h" -extern unsigned int overload_debug; /* Local functions. */ static int typecmp (int staticp, int varargs, int nargs, @@ -57,27 +57,28 @@ static struct value *search_struct_method (const char *, struct value **, static int find_oload_champ_namespace (gdb::array_view args, const char *, const char *, std::vector *oload_syms, - struct badness_vector **, + badness_vector *, const int no_adl); static int find_oload_champ_namespace_loop (gdb::array_view args, const char *, const char *, int, std::vector *oload_syms, - struct badness_vector **, int *, + badness_vector *, int *, const int no_adl); -static int find_oload_champ (gdb::array_view args, int, - struct fn_field *, - const std::vector *, - struct symbol **, struct badness_vector **); +static int find_oload_champ (gdb::array_view args, + size_t num_fns, + fn_field *methods, + xmethod_worker_up *xmethods, + symbol **functions, + badness_vector *oload_champ_bv); static int oload_method_static_p (struct fn_field *, int); enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE }; -static enum -oload_classification classify_oload_match (struct badness_vector *, - int, int); +static enum oload_classification classify_oload_match + (const badness_vector &, int, int); static struct value *value_struct_elt_for_reference (struct type *, int, struct type *, @@ -96,12 +97,7 @@ 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 *, - LONGEST, struct type *, struct fn_field **, int *, - std::vector *, - struct type **, LONGEST *); - -int overload_resolution = 0; +bool overload_resolution = false; static void show_overload_resolution (struct ui_file *file, int from_tty, struct cmd_list_element *c, @@ -143,7 +139,7 @@ find_function_in_inferior (const char *name, struct objfile **objf_p) if (msymbol.minsym != NULL) { struct objfile *objfile = msymbol.objfile; - struct gdbarch *gdbarch = get_objfile_arch (objfile); + struct gdbarch *gdbarch = objfile->arch (); struct type *type; CORE_ADDR maddr; @@ -179,7 +175,7 @@ value_allocate_space_in_inferior (int len) { struct objfile *objf; struct value *val = find_function_in_inferior ("malloc", &objf); - struct gdbarch *gdbarch = get_objfile_arch (objf); + struct gdbarch *gdbarch = objf->arch (); struct value *blocklen; blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len); @@ -406,12 +402,12 @@ value_cast (struct type *type, struct value *arg2) "divide object size in cast")); /* FIXME-type-allocation: need a way to free this type when we are done with it. */ - range_type = create_static_range_type ((struct type *) NULL, + range_type = create_static_range_type (NULL, TYPE_TARGET_TYPE (range_type), low_bound, new_length + low_bound - 1); deprecated_set_value_type (arg2, - create_array_type ((struct type *) NULL, + create_array_type (NULL, element_type, range_type)); return arg2; @@ -487,7 +483,7 @@ value_cast (struct type *type, struct value *arg2) if (code2 == TYPE_CODE_PTR) longest = extract_unsigned_integer (value_contents (arg2), TYPE_LENGTH (type2), - gdbarch_byte_order (get_type_arch (type2))); + type_byte_order (type2)); else longest = value_as_long (arg2); return value_from_longest (to_type, convert_to_boolean ? @@ -559,8 +555,9 @@ value_cast (struct type *type, struct value *arg2) return value_at_lazy (to_type, value_address (arg2)); else { + if (current_language->la_language == language_ada) + error (_("Invalid type conversion.")); error (_("Invalid cast.")); - return 0; } } @@ -910,7 +907,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy) /* Return a value with type TYPE located at ADDR. Call value_at only if the data needs to be fetched immediately; - if we can be 'lazy' and defer the fetch, perhaps indefinately, call + if we can be 'lazy' and defer the fetch, perhaps indefinitely, call value_at_lazy instead. value_at_lazy simply records the address of the data and sets the lazy-evaluation-required flag. The lazy flag is tested in the value_contents macro, which is used if and when @@ -1333,23 +1330,22 @@ address_of_variable (struct symbol *var, const struct block *b) error (_("Address requested for identifier " "\"%s\" which is in register $%s"), - SYMBOL_PRINT_NAME (var), regname); + var->print_name (), regname); break; } default: error (_("Can't take address of \"%s\" which isn't an lvalue."), - SYMBOL_PRINT_NAME (var)); + var->print_name ()); break; } return val; } -/* Return one if VAL does not live in target memory, but should in order - to operate on it. Otherwise return zero. */ +/* See value.h. */ -int +bool value_must_coerce_to_target (struct value *val) { struct type *valtype; @@ -1358,7 +1354,7 @@ value_must_coerce_to_target (struct value *val) if (VALUE_LVAL (val) != not_lval && VALUE_LVAL (val) != lval_internalvar && VALUE_LVAL (val) != lval_xcallable) - return 0; + return false; valtype = check_typedef (value_type (val)); @@ -1367,9 +1363,9 @@ value_must_coerce_to_target (struct value *val) case TYPE_CODE_ARRAY: return TYPE_VECTOR (valtype) ? 0 : 1; case TYPE_CODE_STRING: - return 1; + return true; default: - return 0; + return false; } } @@ -1984,23 +1980,12 @@ search_struct_method (const char *name, struct value **arg1p, int i; struct value *v; int name_matched = 0; - char dem_opname[64]; 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 (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; - else if (cplus_demangle_opname (t_field_name, dem_opname, 0)) - t_field_name = dem_opname; - } if (t_field_name && (strcmp_iw (t_field_name, name) == 0)) { int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1; @@ -2293,22 +2278,22 @@ value_union_variant (struct type *union_type, const gdb_byte *contents) } /* Search through the methods of an object (and its bases) to find a - specified method. Return the pointer to the fn_field list FN_LIST of + specified method. Return a reference to the fn_field list METHODS of overloaded instances defined in the source language. If available and matching, a vector of matching xmethods defined in extension - languages are also returned in XM_WORKER_VEC + languages are also returned in XMETHODS. Helper function for value_find_oload_list. ARGP is a pointer to a pointer to a value (the object). METHOD is a string containing the method name. OFFSET is the offset within the value. TYPE is the assumed type of the object. - FN_LIST is the pointer to matching overloaded instances defined in - source language. Since this is a recursive function, *FN_LIST - should be set to NULL when calling this function. + METHODS is a pointer to the matching overloaded instances defined + in the source language. Since this is a recursive function, + *METHODS should be set to NULL when calling this function. NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to 0 when calling this function. - XM_WORKER_VEC is the vector of matching xmethod workers. *XM_WORKER_VEC + XMETHODS is the vector of matching xmethod workers. *XMETHODS should also be set to NULL when calling this function. BASETYPE is set to the actual type of the subobject where the method is found. @@ -2317,21 +2302,21 @@ value_union_variant (struct type *union_type, const gdb_byte *contents) static void find_method_list (struct value **argp, const char *method, LONGEST offset, struct type *type, - struct fn_field **fn_list, int *num_fns, - std::vector *xm_worker_vec, + gdb::array_view *methods, + std::vector *xmethods, struct type **basetype, LONGEST *boffset) { int i; struct fn_field *f = NULL; - gdb_assert (fn_list != NULL && xm_worker_vec != NULL); + gdb_assert (methods != NULL && xmethods != NULL); type = check_typedef (type); /* First check in object itself. This function is called recursively to search through base classes. If there is a source method match found at some stage, then we need not look for source methods in consequent recursive calls. */ - if ((*fn_list) == NULL) + if (methods->empty ()) { for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--) { @@ -2342,9 +2327,8 @@ find_method_list (struct value **argp, const char *method, { int len = TYPE_FN_FIELDLIST_LENGTH (type, i); f = TYPE_FN_FIELDLIST1 (type, i); - *fn_list = f; + *methods = gdb::make_array_view (f, len); - *num_fns = len; *basetype = type; *boffset = offset; @@ -2363,7 +2347,7 @@ find_method_list (struct value **argp, const char *method, and hence there is no point restricting them with something like method hiding. Moreover, if hiding is done for xmethods as well, then we will have to provide a mechanism to un-hide (like the 'using' construct). */ - get_matching_xmethod_workers (type, method, xm_worker_vec); + get_matching_xmethod_workers (type, method, xmethods); /* If source methods are not found in current class, look for them in the base classes. We also have to go through the base classes to gather @@ -2386,23 +2370,22 @@ find_method_list (struct value **argp, const char *method, } find_method_list (argp, method, base_offset + offset, - TYPE_BASECLASS (type, i), fn_list, num_fns, - xm_worker_vec, basetype, boffset); + TYPE_BASECLASS (type, i), methods, + xmethods, basetype, boffset); } } /* Return the list of overloaded methods of a specified name. The methods could be those GDB finds in the binary, or xmethod. Methods found in - the binary are returned in FN_LIST, and xmethods are returned in - XM_WORKER_VEC. + the binary are returned in METHODS, and xmethods are returned in + XMETHODS. 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. - FN_LIST is the pointer to matching overloaded instances defined in - source language. - NUM_FNS is the number of overloaded instances. - XM_WORKER_VEC is the vector of matching xmethod workers defined in + METHODS is the list of matching overloaded instances defined in + the source language. + XMETHODS is the vector of matching xmethod workers defined in extension languages. BASETYPE is set to the type of the base subobject that defines the method. @@ -2410,9 +2393,9 @@ find_method_list (struct value **argp, const char *method, static void value_find_oload_method_list (struct value **argp, const char *method, - LONGEST offset, struct fn_field **fn_list, - int *num_fns, - std::vector *xm_worker_vec, + LONGEST offset, + gdb::array_view *methods, + std::vector *xmethods, struct type **basetype, LONGEST *boffset) { struct type *t; @@ -2434,14 +2417,13 @@ value_find_oload_method_list (struct value **argp, const char *method, error (_("Attempt to extract a component of a " "value that is not a struct or union")); - gdb_assert (fn_list != NULL && xm_worker_vec != NULL); + gdb_assert (methods != NULL && xmethods != NULL); /* Clear the lists. */ - *fn_list = NULL; - *num_fns = 0; - xm_worker_vec->clear (); + *methods = {}; + xmethods->clear (); - find_method_list (argp, method, 0, t, fn_list, num_fns, xm_worker_vec, + find_method_list (argp, method, 0, t, methods, xmethods, basetype, boffset); } @@ -2508,27 +2490,24 @@ find_overload_match (gdb::array_view args, int ext_method_oload_champ = -1; /* The measure for the current best match. */ - struct badness_vector *method_badness = NULL; - struct badness_vector *func_badness = NULL; - struct badness_vector *ext_method_badness = NULL; - struct badness_vector *src_method_badness = NULL; + badness_vector method_badness; + badness_vector func_badness; + badness_vector ext_method_badness; + badness_vector src_method_badness; struct value *temp = obj; /* For methods, the list of overloaded methods. */ - struct fn_field *fns_ptr = NULL; + gdb::array_view methods; /* For non-methods, the list of overloaded function symbols. */ - std::vector oload_syms; + std::vector functions; /* For xmethods, the vector of xmethod workers. */ - std::vector xm_worker_vec; - /* Number of overloaded instances being considered. */ - int num_fns = 0; + std::vector xmethods; struct type *basetype = NULL; LONGEST boffset; - struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL); - const char *obj_type_name = NULL; const char *func_name = NULL; + gdb::unique_xmalloc_ptr temp_func; enum oload_classification match_quality; enum oload_classification method_match_quality = INCOMPATIBLE; enum oload_classification src_method_match_quality = INCOMPATIBLE; @@ -2555,17 +2534,16 @@ find_overload_match (gdb::array_view args, if (*valp) { *staticp = 1; - do_cleanups (all_cleanups); return 0; } } /* Retrieve the list of methods with the name NAME. */ - value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns, - &xm_worker_vec, &basetype, &boffset); + value_find_oload_method_list (&temp, name, 0, &methods, + &xmethods, &basetype, &boffset); /* If this is a method only search, and no methods were found the search has failed. */ - if (method == METHOD && (!fns_ptr || !num_fns) && xm_worker_vec.empty ()) + if (method == METHOD && methods.empty () && xmethods.empty ()) error (_("Couldn't find method %s%s%s"), obj_type_name, (obj_type_name && *obj_type_name) ? "::" : "", @@ -2573,28 +2551,30 @@ find_overload_match (gdb::array_view args, /* If we are dealing with stub method types, they should have been resolved by find_method_list via value_find_oload_method_list above. */ - if (fns_ptr) + if (!methods.empty ()) { - gdb_assert (TYPE_SELF_TYPE (fns_ptr[0].type) != NULL); + gdb_assert (TYPE_SELF_TYPE (methods[0].type) != NULL); - src_method_oload_champ = find_oload_champ (args, - num_fns, fns_ptr, NULL, - NULL, &src_method_badness); + src_method_oload_champ + = find_oload_champ (args, + methods.size (), + methods.data (), NULL, NULL, + &src_method_badness); src_method_match_quality = classify_oload_match (src_method_badness, args.size (), - oload_method_static_p (fns_ptr, src_method_oload_champ)); - - make_cleanup (xfree, src_method_badness); + oload_method_static_p (methods.data (), src_method_oload_champ)); } - if (!xm_worker_vec.empty ()) + if (!xmethods.empty ()) { - ext_method_oload_champ = find_oload_champ (args, 0, NULL, &xm_worker_vec, - NULL, &ext_method_badness); + ext_method_oload_champ + = find_oload_champ (args, + xmethods.size (), + NULL, xmethods.data (), NULL, + &ext_method_badness); ext_method_match_quality = classify_oload_match (ext_method_badness, args.size (), 0); - make_cleanup (xfree, ext_method_badness); } if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0) @@ -2664,7 +2644,7 @@ find_overload_match (gdb::array_view args, if (fsym) { - qualified_name = SYMBOL_NATURAL_NAME (fsym); + qualified_name = fsym->natural_name (); /* If we have a function with a C++ name, try to extract just the function part. Do not try this for non-functions (e.g. @@ -2673,20 +2653,17 @@ find_overload_match (gdb::array_view args, && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC) { - char *temp_func; - temp_func = cp_func_name (qualified_name); /* If cp_func_name did not remove anything, the name of the symbol did not include scope or argument types - it was probably a C-style function. */ - if (temp_func) + if (temp_func != nullptr) { - make_cleanup (xfree, temp_func); - if (strcmp (temp_func, qualified_name) == 0) + if (strcmp (temp_func.get (), qualified_name) == 0) func_name = NULL; else - func_name = temp_func; + func_name = temp_func.get (); } } } @@ -2702,22 +2679,19 @@ find_overload_match (gdb::array_view args, if (func_name == NULL) { *symp = fsym; - do_cleanups (all_cleanups); return 0; } func_oload_champ = find_oload_champ_namespace (args, func_name, qualified_name, - &oload_syms, + &functions, &func_badness, no_adl); if (func_oload_champ >= 0) func_match_quality = classify_oload_match (func_badness, args.size (), 0); - - make_cleanup (xfree, func_badness); } /* Did we find a match ? */ @@ -2793,29 +2767,29 @@ find_overload_match (gdb::array_view args, } if (staticp != NULL) - *staticp = oload_method_static_p (fns_ptr, method_oload_champ); + *staticp = oload_method_static_p (methods.data (), method_oload_champ); if (method_oload_champ >= 0) { if (src_method_oload_champ >= 0) { - if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ) + if (TYPE_FN_FIELD_VIRTUAL_P (methods, method_oload_champ) && noside != EVAL_AVOID_SIDE_EFFECTS) { - *valp = value_virtual_fn_field (&temp, fns_ptr, + *valp = value_virtual_fn_field (&temp, methods.data (), method_oload_champ, basetype, boffset); } else - *valp = value_fn_field (&temp, fns_ptr, method_oload_champ, - basetype, boffset); + *valp = value_fn_field (&temp, methods.data (), + method_oload_champ, basetype, boffset); } else *valp = value_from_xmethod - (std::move (xm_worker_vec[ext_method_oload_champ])); + (std::move (xmethods[ext_method_oload_champ])); } else - *symp = oload_syms[func_oload_champ]; + *symp = functions[func_oload_champ]; if (objp) { @@ -2831,8 +2805,6 @@ find_overload_match (gdb::array_view args, *objp = temp; } - do_cleanups (all_cleanups); - switch (match_quality) { case INCOMPATIBLE: @@ -2847,17 +2819,15 @@ find_overload_match (gdb::array_view args, /* Find the best overload match, searching for FUNC_NAME in namespaces contained in QUALIFIED_NAME until it either finds a good match or runs out of namespaces. It stores the overloaded functions in - *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The - calling function is responsible for freeing *OLOAD_SYMS and - *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not - performned. */ + *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. If NO_ADL, + argument dependent lookup is not performed. */ static int find_oload_champ_namespace (gdb::array_view args, const char *func_name, const char *qualified_name, std::vector *oload_syms, - struct badness_vector **oload_champ_bv, + badness_vector *oload_champ_bv, const int no_adl) { int oload_champ; @@ -2876,10 +2846,7 @@ find_oload_champ_namespace (gdb::array_view args, how deep we've looked for namespaces, and the champ is stored in OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0 if it isn't. Other arguments are the same as in - find_oload_champ_namespace - - It is the caller's responsibility to free *OLOAD_SYMS and - *OLOAD_CHAMP_BV. */ + find_oload_champ_namespace. */ static int find_oload_champ_namespace_loop (gdb::array_view args, @@ -2887,15 +2854,13 @@ find_oload_champ_namespace_loop (gdb::array_view args, const char *qualified_name, int namespace_len, std::vector *oload_syms, - struct badness_vector **oload_champ_bv, + badness_vector *oload_champ_bv, int *oload_champ, const int no_adl) { int next_namespace_len = namespace_len; int searched_deeper = 0; - struct cleanup *old_cleanups; int new_oload_champ; - struct badness_vector *new_oload_champ_bv; char *new_namespace; if (next_namespace_len != 0) @@ -2906,9 +2871,6 @@ find_oload_champ_namespace_loop (gdb::array_view args, next_namespace_len += cp_find_first_component (qualified_name + next_namespace_len); - /* Initialize these to values that can safely be xfree'd. */ - *oload_champ_bv = NULL; - /* First, see if we have a deeper namespace we can search in. If we get a good match there, use it. */ @@ -2934,7 +2896,6 @@ find_oload_champ_namespace_loop (gdb::array_view args, because this overload mechanism only gets called if there's a function symbol to start off with.) */ - old_cleanups = make_cleanup (xfree, *oload_champ_bv); new_namespace = (char *) alloca (namespace_len + 1); strncpy (new_namespace, qualified_name, namespace_len); new_namespace[namespace_len] = '\0'; @@ -2958,7 +2919,9 @@ find_oload_champ_namespace_loop (gdb::array_view args, &new_oload_syms); } - new_oload_champ = find_oload_champ (args, new_oload_syms.size (), + badness_vector new_oload_champ_bv; + new_oload_champ = find_oload_champ (args, + new_oload_syms.size (), NULL, NULL, new_oload_syms.data (), &new_oload_champ_bv); @@ -2974,49 +2937,43 @@ find_oload_champ_namespace_loop (gdb::array_view args, { *oload_syms = std::move (new_oload_syms); *oload_champ = new_oload_champ; - *oload_champ_bv = new_oload_champ_bv; - do_cleanups (old_cleanups); + *oload_champ_bv = std::move (new_oload_champ_bv); return 1; } else if (searched_deeper) { - xfree (new_oload_champ_bv); - discard_cleanups (old_cleanups); return 0; } else { *oload_syms = std::move (new_oload_syms); *oload_champ = new_oload_champ; - *oload_champ_bv = new_oload_champ_bv; - do_cleanups (old_cleanups); + *oload_champ_bv = std::move (new_oload_champ_bv); return 0; } } /* Look for a function to take ARGS. Find the best match from among - the overloaded methods or functions given by FNS_PTR or OLOAD_SYMS - or XM_WORKER_VEC, respectively. One, and only one of FNS_PTR, - OLOAD_SYMS and XM_WORKER_VEC can be non-NULL. + the overloaded methods or functions given by METHODS or FUNCTIONS + or XMETHODS, respectively. One, and only one of METHODS, FUNCTIONS + and XMETHODS can be non-NULL. - If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR - or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS. + NUM_FNS is the length of the array pointed at by METHODS, FUNCTIONS + or XMETHODS, whichever is non-NULL. Return the index of the best match; store an indication of the - quality of the match in OLOAD_CHAMP_BV. - - It is the caller's responsibility to free *OLOAD_CHAMP_BV. */ + quality of the match in OLOAD_CHAMP_BV. */ static int find_oload_champ (gdb::array_view args, - int num_fns, struct fn_field *fns_ptr, - const std::vector *xm_worker_vec, - struct symbol **oload_syms, - struct badness_vector **oload_champ_bv) + size_t num_fns, + fn_field *methods, + xmethod_worker_up *xmethods, + symbol **functions, + badness_vector *oload_champ_bv) { - int ix; /* A measure of how good an overloaded instance is. */ - struct badness_vector *bv; + badness_vector bv; /* Index of best overloaded function. */ int oload_champ = -1; /* Current ambiguity state for overload resolution. */ @@ -3026,43 +2983,36 @@ find_oload_champ (gdb::array_view args, /* A champion can be found among methods alone, or among functions alone, or in xmethods alone, but not in more than one of these groups. */ - gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL) + gdb_assert ((methods != NULL) + (functions != NULL) + (xmethods != NULL) == 1); - *oload_champ_bv = NULL; - - int fn_count = xm_worker_vec != NULL ? xm_worker_vec->size () : num_fns; - /* Consider each candidate in turn. */ - for (ix = 0; ix < fn_count; ix++) + for (size_t ix = 0; ix < num_fns; ix++) { int jj; int static_offset = 0; std::vector parm_types; - if (xm_worker_vec != NULL) - { - xmethod_worker *worker = (*xm_worker_vec)[ix].get (); - parm_types = worker->get_arg_types (); - } + if (xmethods != NULL) + parm_types = xmethods[ix]->get_arg_types (); else { size_t nparms; - if (fns_ptr != NULL) + if (methods != NULL) { - nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix)); - static_offset = oload_method_static_p (fns_ptr, ix); + nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (methods, ix)); + static_offset = oload_method_static_p (methods, ix); } else - nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix])); + nparms = TYPE_NFIELDS (SYMBOL_TYPE (functions[ix])); parm_types.reserve (nparms); for (jj = 0; jj < nparms; jj++) { - type *t = (fns_ptr != NULL - ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type) - : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), + type *t = (methods != NULL + ? (TYPE_FN_FIELD_ARGS (methods, ix)[jj].type) + : TYPE_FIELD_TYPE (SYMBOL_TYPE (functions[ix]), jj)); parm_types.push_back (t); } @@ -3073,9 +3023,36 @@ find_oload_champ (gdb::array_view args, bv = rank_function (parm_types, args.slice (static_offset)); - if (!*oload_champ_bv) + if (overload_debug) { - *oload_champ_bv = bv; + if (methods != NULL) + fprintf_filtered (gdb_stderr, + "Overloaded method instance %s, # of parms %d\n", + methods[ix].physname, (int) parm_types.size ()); + else if (xmethods != NULL) + fprintf_filtered (gdb_stderr, + "Xmethod worker, # of parms %d\n", + (int) parm_types.size ()); + else + fprintf_filtered (gdb_stderr, + "Overloaded function instance " + "%s # of parms %d\n", + functions[ix]->demangled_name (), + (int) parm_types.size ()); + + fprintf_filtered (gdb_stderr, + "...Badness of length : {%d, %d}\n", + bv[0].rank, bv[0].subrank); + + for (jj = 1; jj < bv.size (); jj++) + fprintf_filtered (gdb_stderr, + "...Badness of arg %d : {%d, %d}\n", + jj, bv[jj].rank, bv[jj].subrank); + } + + if (oload_champ_bv->empty ()) + { + *oload_champ_bv = std::move (bv); oload_champ = 0; } else /* See whether current candidate is better or worse than @@ -3089,7 +3066,7 @@ find_oload_champ (gdb::array_view args, oload_ambiguous = 2; break; case 2: /* New champion, record details. */ - *oload_champ_bv = bv; + *oload_champ_bv = std::move (bv); oload_ambiguous = 0; oload_champ = ix; break; @@ -3098,29 +3075,9 @@ find_oload_champ (gdb::array_view args, break; } if (overload_debug) - { - if (fns_ptr != NULL) - fprintf_filtered (gdb_stderr, - "Overloaded method instance %s, # of parms %d\n", - fns_ptr[ix].physname, (int) parm_types.size ()); - else if (xm_worker_vec != NULL) - fprintf_filtered (gdb_stderr, - "Xmethod worker, # of parms %d\n", - (int) parm_types.size ()); - else - fprintf_filtered (gdb_stderr, - "Overloaded function instance " - "%s # of parms %d\n", - SYMBOL_DEMANGLED_NAME (oload_syms[ix]), - (int) parm_types.size ()); - for (jj = 0; jj < args.size () - static_offset; jj++) - fprintf_filtered (gdb_stderr, - "...Badness @ %d : %d\n", - jj, bv->rank[jj].rank); - fprintf_filtered (gdb_stderr, "Overload resolution " - "champion is %d, ambiguous? %d\n", - oload_champ, oload_ambiguous); - } + fprintf_filtered (gdb_stderr, "Overload resolution " + "champion is %d, ambiguous? %d\n", + oload_champ, oload_ambiguous); } return oload_champ; @@ -3141,7 +3098,7 @@ oload_method_static_p (struct fn_field *fns_ptr, int index) /* Check how good an overload match OLOAD_CHAMP_BV represents. */ static enum oload_classification -classify_oload_match (struct badness_vector *oload_champ_bv, +classify_oload_match (const badness_vector &oload_champ_bv, int nargs, int static_offset) { @@ -3152,12 +3109,12 @@ classify_oload_match (struct badness_vector *oload_champ_bv, { /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS or worse return INCOMPATIBLE. */ - if (compare_ranks (oload_champ_bv->rank[ix], + if (compare_ranks (oload_champ_bv[ix], INCOMPATIBLE_TYPE_BADNESS) <= 0) return INCOMPATIBLE; /* Truly mismatched types. */ /* Otherwise If this conversion is as bad as NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */ - else if (compare_ranks (oload_champ_bv->rank[ix], + else if (compare_ranks (oload_champ_bv[ix], NS_POINTER_CONVERSION_BADNESS) <= 0) worst = NON_STANDARD; /* Non-standard type conversions needed. */ @@ -3460,19 +3417,7 @@ value_struct_elt_for_reference (struct type *domain, int offset, for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i) { const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i); - char dem_opname[64]; - 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; - else if (cplus_demangle_opname (t_field_name, - dem_opname, 0)) - t_field_name = dem_opname; - } if (t_field_name && strcmp (t_field_name, name) == 0) { int j; @@ -3683,11 +3628,11 @@ value_rtti_indirect_type (struct value *v, int *full, else if (TYPE_CODE (type) == TYPE_CODE_PTR) { - TRY + try { target = value_ind (v); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { if (except.error == MEMORY_ERROR) { @@ -3696,9 +3641,8 @@ value_rtti_indirect_type (struct value *v, int *full, type. */ return NULL; } - throw_exception (except); + throw; } - END_CATCH } else return NULL; @@ -3836,14 +3780,13 @@ value_of_this_silent (const struct language_defn *lang) { struct value *ret = NULL; - TRY + try { ret = value_of_this (lang); } - CATCH (except, RETURN_MASK_ERROR) + catch (const gdb_exception_error &except) { } - END_CATCH return ret; } @@ -3865,6 +3808,11 @@ value_slice (struct value *array, int lowbound, int length) && TYPE_CODE (array_type) != TYPE_CODE_STRING) error (_("cannot take slice of non-array")); + if (type_not_allocated (array_type)) + error (_("array not allocated")); + if (type_not_associated (array_type)) + error (_("array not associated")); + range_type = TYPE_INDEX_TYPE (array_type); if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) error (_("slice from bad array or bitstring")); @@ -3875,7 +3823,7 @@ value_slice (struct value *array, int lowbound, int length) /* FIXME-type-allocation: need a way to free this type when we are done with it. */ - slice_range_type = create_static_range_type ((struct type *) NULL, + slice_range_type = create_static_range_type (NULL, TYPE_TARGET_TYPE (range_type), lowbound, lowbound + length - 1); @@ -3885,7 +3833,7 @@ value_slice (struct value *array, int lowbound, int length) LONGEST offset = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type)); - slice_type = create_array_type ((struct type *) NULL, + slice_type = create_array_type (NULL, element_type, slice_range_type); TYPE_CODE (slice_type) = TYPE_CODE (array_type); @@ -3906,14 +3854,10 @@ value_slice (struct value *array, int lowbound, int length) return slice; } -/* 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 */ +/* See value.h. */ struct value * -value_literal_complex (struct value *arg1, +value_literal_complex (struct value *arg1, struct value *arg2, struct type *type) { @@ -3931,6 +3875,31 @@ value_literal_complex (struct value *arg1, return val; } +/* See value.h. */ + +struct value * +value_real_part (struct value *value) +{ + struct type *type = check_typedef (value_type (value)); + struct type *ttype = TYPE_TARGET_TYPE (type); + + gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX); + return value_from_component (value, ttype, 0); +} + +/* See value.h. */ + +struct value * +value_imaginary_part (struct value *value) +{ + struct type *type = check_typedef (value_type (value)); + struct type *ttype = TYPE_TARGET_TYPE (type); + + gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX); + return value_from_component (value, ttype, + TYPE_LENGTH (check_typedef (ttype))); +} + /* Cast a value into the appropriate complex data type. */ static struct value * @@ -3961,8 +3930,9 @@ cast_into_complex (struct type *type, struct value *val) error (_("cannot cast non-number to complex")); } +void _initialize_valops (); void -_initialize_valops (void) +_initialize_valops () { add_setshow_boolean_cmd ("overload-resolution", class_support, &overload_resolution, _("\