From 2f408ecb929bd56613e94cf1e84ace4692c78257 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Tue, 8 Nov 2016 15:26:47 +0000 Subject: Use ui_file_as_string throughout more This replaces most of the remaining ui_file_xstrdup calls with ui_file_as_string calls. Whenever a call was replaced, that led to a cascade of other necessary adjustments throughout, to make the code use std::string instead of raw pointers. And then whenever I added a std::string as member of a struct, I needed to adjust allocation/destruction of said struct to use new/delete instead of xmalloc/xfree. The stopping point was once gdb built again. These doesn't seem to be a way to reasonably split this out further. Maybe-not-obvious changes: - demangle_for_lookup returns a cleanup today. To get rid of that, and avoid unnecessary string dupping/copying, this introduces a demangle_result_storage type that the caller instantiates and passes to demangle_for_lookup. - Many methods returned a "char *" to indicate that the caller owns the memory and must free it. Those are switched to return a std::string instead. Methods that return a "view" into some internal string return a "const char *" instead. I.e., we only copy/allocate when necessary. gdb/ChangeLog: 2016-11-08 Pedro Alves * ada-lang.c (ada_name_for_lookup, type_as_string): Use and return std::string. (type_as_string_and_cleanup): Delete. (ada_lookup_struct_elt_type): Use type_as_string. * ada-lang.h (ada_name_for_lookup): Now returns std::string. * ada-varobj.c (ada_varobj_scalar_image): Return a std::string. (ada_varobj_describe_child): Make 'child_name' and 'child_path_expr' parameters std::string pointers. (ada_varobj_describe_struct_child, ada_varobj_describe_ptr_child): Likewise, and use string_printf. (ada_varobj_describe_simple_array_child) (ada_varobj_describe_child): Likewise. (ada_varobj_get_name_of_child, ada_varobj_get_path_expr_of_child) (ada_varobj_get_value_image) (ada_varobj_get_value_of_array_variable) (ada_varobj_get_value_of_variable, ada_name_of_variable) (ada_name_of_child, ada_path_expr_of_child) (ada_value_of_variable): Now returns std::string. Use string_printf. (ada_value_of_child): Adjust. * break-catch-throw.c (check_status_exception_catchpoint): Adjust to use std::string. * breakpoint.c (watch_command_1): Adjust to use std::string. * c-lang.c (c_get_string): Adjust to use std::string. * c-typeprint.c (print_name_maybe_canonical): Use std::string. * c-varobj.c (varobj_is_anonymous_child): Use ==/!= std::string operators. (c_name_of_variable): Now returns a std::string. (c_describe_child): The 'cname' and 'cfull_expression' output parameters are now std::string pointers. Adjust. (c_name_of_child, c_path_expr_of_child, c_value_of_variable) (cplus_number_of_children): Adjust to use std::string and string_printf. (cplus_name_of_variable): Now returns a std::string. (cplus_describe_child): The 'cname' and 'cfull_expression' output parameters are now std::string pointers. Adjust. (cplus_name_of_child, cplus_path_expr_of_child) (cplus_value_of_variable): Now returns a std::string. * cp-abi.c (cplus_typename_from_type_info): Return std::string. * cp-abi.h (cplus_typename_from_type_info): Return std::string. (struct cp_abi_ops) : Return std::string. * cp-support.c (inspect_type): Use std::string. (cp_canonicalize_string_full, cp_canonicalize_string_no_typedefs) (cp_canonicalize_string): Return std::string and adjust. * cp-support.h (cp_canonicalize_string) (cp_canonicalize_string_no_typedefs, cp_canonicalize_string_full): Return std::string. * dbxread.c (read_dbx_symtab): Use std::string. * dwarf2read.c (dwarf2_canonicalize_name): Adjust to use std::string. * gdbcmd.h (lookup_struct_elt_type): Adjust to use std::string. * gnu-v3-abi.c (gnuv3_get_typeid): Use std::string. (gnuv3_get_typename_from_type_info): Return a std::string and adjust. (gnuv3_get_type_from_type_info): Adjust to use std::string. * guile/guile.c (gdbscm_execute_gdb_command): Adjust to use std::string. * infcmd.c (print_return_value_1): Adjust to use std::string. * linespec.c (find_linespec_symbols): Adjust to demangle_for_lookup API change. Use std::string. * mi/mi-cmd-var.c (print_varobj, mi_cmd_var_set_format) (mi_cmd_var_info_type, mi_cmd_var_info_path_expression) (mi_cmd_var_info_expression, mi_cmd_var_evaluate_expression) (mi_cmd_var_assign, varobj_update_one): Adjust to use std::string. * minsyms.c (lookup_minimal_symbol): Use std::string. * python/py-varobj.c (py_varobj_iter_next): Use new instead of XNEW. vitem->name is a std::string now, adjust. * rust-exp.y (convert_ast_to_type, convert_name): Adjust to use std::string. * stabsread.c (define_symbol): Adjust to use std::string. * symtab.c (demangle_for_lookup): Now returns 'const char *'. Add a demangle_result_storage parameter. Use it for storage. (lookup_symbol_in_language) (lookup_symbol_in_objfile_from_linkage_name): Adjust to new demangle_for_lookup API. * symtab.h (struct demangle_result_storage): New type. (demangle_for_lookup): Now returns 'const char *'. Add a demangle_result_storage parameter. * typeprint.c (type_to_string): Return std::string and use ui_file_as_string. * value.h (type_to_string): Change return type to std::string. * varobj-iter.h (struct varobj_item) : Now a std::string. (varobj_iter_delete): Use delete instead of xfree. * varobj.c (create_child): Return std::string instead of char * in output parameter. (name_of_variable, name_of_child, my_value_of_variable): Return std::string instead of char *. (varobj_create, varobj_get_handle): Constify 'objname' parameter. Adjust to std::string fields. (varobj_get_objname): Return a const char * instead of a char *. (varobj_get_expression): Return a std::string. (varobj_list_children): Adjust to use std::string. (varobj_get_type): Return a std::string. (varobj_get_path_expr): Return a const char * instead of a char *. Adjust to std::string fields. (varobj_get_formatted_value, varobj_get_value): Return a std::string. (varobj_set_value): Change type of 'expression' parameter to std::string. Use std::string. (install_new_value): Use std::string. (delete_variable_1): Adjust to use std::string. (create_child): Change the 'name' parameter to a std::string reference. Swap it into the new item's name. (create_child_with_value): Swap item's name into the new child's name. Use string_printf. (new_variable): Use new instead of XNEW. (free_variable): Don't xfree fields that are now std::string. (name_of_variable, name_of_child): Now returns std::string. (value_of_root): Adjust to use std::string. (my_value_of_variable, varobj_value_get_print_value): Return and use std::string. (varobj_value_get_print_value): Adjust to use ui_file_as_string and std::string. * varobj.h (struct varobj) : Now std::string's. : Return std::string. (varobj_create, varobj_get_handle): Constify 'objname' parameter. (varobj_get_objname): Return a const char * instead of a char *. (varobj_get_expression, varobj_get_type): Return a std::string. (varobj_get_path_expr): Return a const char * instead of a char *. (varobj_get_formatted_value, varobj_get_value): Return a std::string. (varobj_set_value): Constify 'expression' parameter. (varobj_value_get_print_value): Return a std::string. --- gdb/symtab.c | 87 ++++++++++++++++++++---------------------------------------- 1 file changed, 29 insertions(+), 58 deletions(-) (limited to 'gdb/symtab.c') diff --git a/gdb/symtab.c b/gdb/symtab.c index 4e03cb7..430bc8d 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -1770,10 +1770,10 @@ fixup_symbol_section (struct symbol *sym, struct objfile *objfile) } /* Compute the demangled form of NAME as used by the various symbol - lookup functions. The result is stored in *RESULT_NAME. Returns a - cleanup which can be used to clean up the result. + lookup functions. The result can either be the input NAME + directly, or a pointer to a buffer owned by the STORAGE object. - For Ada, this function just sets *RESULT_NAME to NAME, unmodified. + For Ada, this function just returns NAME, unmodified. Normally, Ada symbol lookups are performed using the encoded name rather than the demangled name, and so it might seem to make sense for this function to return an encoded version of NAME. @@ -1787,59 +1787,38 @@ fixup_symbol_section (struct symbol *sym, struct objfile *objfile) characters to become lowercase, and thus cause the symbol lookup to fail. */ -struct cleanup * +const char * demangle_for_lookup (const char *name, enum language lang, - const char **result_name) + demangle_result_storage &storage) { - char *demangled_name = NULL; - const char *modified_name = NULL; - struct cleanup *cleanup = make_cleanup (null_cleanup, 0); - - modified_name = name; - /* If we are using C++, D, or Go, demangle the name before doing a lookup, so we can always binary search. */ if (lang == language_cplus) { - demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS); - if (demangled_name) - { - modified_name = demangled_name; - make_cleanup (xfree, demangled_name); - } - else - { - /* If we were given a non-mangled name, canonicalize it - according to the language (so far only for C++). */ - demangled_name = cp_canonicalize_string (name); - if (demangled_name) - { - modified_name = demangled_name; - make_cleanup (xfree, demangled_name); - } - } + char *demangled_name = gdb_demangle (name, DMGL_ANSI | DMGL_PARAMS); + if (demangled_name != NULL) + return storage.set_malloc_ptr (demangled_name); + + /* If we were given a non-mangled name, canonicalize it + according to the language (so far only for C++). */ + std::string canon = cp_canonicalize_string (name); + if (!canon.empty ()) + return storage.swap_string (canon); } else if (lang == language_d) { - demangled_name = d_demangle (name, 0); - if (demangled_name) - { - modified_name = demangled_name; - make_cleanup (xfree, demangled_name); - } + char *demangled_name = d_demangle (name, 0); + if (demangled_name != NULL) + return storage.set_malloc_ptr (demangled_name); } else if (lang == language_go) { - demangled_name = go_demangle (name, 0); - if (demangled_name) - { - modified_name = demangled_name; - make_cleanup (xfree, demangled_name); - } + char *demangled_name = go_demangle (name, 0); + if (demangled_name != NULL) + return storage.set_malloc_ptr (demangled_name); } - *result_name = modified_name; - return cleanup; + return name; } /* See symtab.h. @@ -1859,15 +1838,11 @@ lookup_symbol_in_language (const char *name, const struct block *block, const domain_enum domain, enum language lang, struct field_of_this_result *is_a_field_of_this) { - const char *modified_name; - struct block_symbol returnval; - struct cleanup *cleanup = demangle_for_lookup (name, lang, &modified_name); + demangle_result_storage storage; + const char *modified_name = demangle_for_lookup (name, lang, storage); - returnval = lookup_symbol_aux (modified_name, block, domain, lang, - is_a_field_of_this); - do_cleanups (cleanup); - - return returnval; + return lookup_symbol_aux (modified_name, block, domain, lang, + is_a_field_of_this); } /* See symtab.h. */ @@ -2278,11 +2253,11 @@ lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile, domain_enum domain) { enum language lang = current_language->la_language; - const char *modified_name; - struct cleanup *cleanup = demangle_for_lookup (linkage_name, lang, - &modified_name); struct objfile *main_objfile, *cur_objfile; + demangle_result_storage storage; + const char *modified_name = demangle_for_lookup (linkage_name, lang, storage); + if (objfile->separate_debug_objfile_backlink) main_objfile = objfile->separate_debug_objfile_backlink; else @@ -2300,13 +2275,9 @@ lookup_symbol_in_objfile_from_linkage_name (struct objfile *objfile, result = lookup_symbol_in_objfile_symtabs (cur_objfile, STATIC_BLOCK, modified_name, domain); if (result.symbol != NULL) - { - do_cleanups (cleanup); - return result; - } + return result; } - do_cleanups (cleanup); return (struct block_symbol) {NULL, NULL}; } -- cgit v1.1