X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalops.c;h=2f5a4c815f23ef98eef98a98914965b692c5b679;hb=be6d4f74c77c6f521afc873d226480e001cb99c2;hp=7fbedd77bb1175ad44caab94e105943e0eb92ed8;hpb=0891c3cc132495ad7b323896efae4f91eca87c6c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/valops.c b/gdb/valops.c index 7fbedd77bb..2f5a4c815f 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-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -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,11 +97,6 @@ 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; static void show_overload_resolution (struct ui_file *file, int from_tty, @@ -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) @@ -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 performned. */ 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,9 @@ find_oload_champ (gdb::array_view args, bv = rank_function (parm_types, args.slice (static_offset)); - if (!*oload_champ_bv) + if (oload_champ_bv->empty ()) { - *oload_champ_bv = bv; + *oload_champ_bv = std::move (bv); oload_champ = 0; } else /* See whether current candidate is better or worse than @@ -3089,7 +3039,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; @@ -3099,11 +3049,11 @@ find_oload_champ (gdb::array_view args, } if (overload_debug) { - if (fns_ptr != NULL) + if (methods != 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) + 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 ()); @@ -3111,12 +3061,12 @@ find_oload_champ (gdb::array_view args, fprintf_filtered (gdb_stderr, "Overloaded function instance " "%s # of parms %d\n", - SYMBOL_DEMANGLED_NAME (oload_syms[ix]), + SYMBOL_DEMANGLED_NAME (functions[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); + jj, bv[jj].rank); fprintf_filtered (gdb_stderr, "Overload resolution " "champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous); @@ -3141,7 +3091,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 +3102,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 +3410,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;