/* Convert symbols from GDB to GCC Copyright (C) 2014-2017 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include "defs.h" #include "compile-internal.h" #include "compile-cplus.h" #include "gdb_assert.h" #include "symtab.h" #include "parser-defs.h" #include "block.h" #include "objfiles.h" #include "compile.h" #include "value.h" #include "exceptions.h" #include "gdbtypes.h" #include "dwarf2loc.h" #include "cp-support.h" #include "gdbcmd.h" #include "compile-c.h" /* !!keiths FIXME for c_get_range_decl_name */ using namespace compile; /* See description in compile-internal.h. */ int debug_compile_oracle = 0; /* Convert a given symbol, SYM, to the compiler's representation. CONTEXT is the compiler instance. IS_GLOBAL is true if the symbol came from the global scope. IS_LOCAL is true if the symbol came from a local scope. (Note that the two are not strictly inverses because the symbol might have come from the static scope.) */ static void convert_one_symbol (compile_cplus_instance *instance, struct block_symbol sym, bool is_global, bool is_local) { /* Squash compiler warning. */ gcc_type sym_type = 0; const char *filename = symbol_symtab (sym.symbol)->filename; unsigned short line = SYMBOL_LINE (sym.symbol); instance->error_symbol_once (sym.symbol); if (SYMBOL_CLASS (sym.symbol) == LOC_LABEL) sym_type = 0; else if (!SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (sym.symbol)) sym_type = instance->convert_type (SYMBOL_TYPE (sym.symbol)); if (SYMBOL_DOMAIN (sym.symbol) == STRUCT_DOMAIN) { /* Nothing to do. */ } else { /* Squash compiler warning. */ gcc_cp_symbol_kind_flags kind = GCC_CP_FLAG_BASE; CORE_ADDR addr = 0; std::string name; char *symbol_name = NULL; /* Add a null cleanup for templates. !!keiths: remove! */ struct cleanup *back_to = make_cleanup (free_current_contents, &symbol_name); switch (SYMBOL_CLASS (sym.symbol)) { case LOC_TYPEDEF: if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_TYPEDEF) kind = GCC_CP_SYMBOL_TYPEDEF; else if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_NAMESPACE) { do_cleanups (back_to); return; } break; case LOC_LABEL: kind = GCC_CP_SYMBOL_LABEL; addr = SYMBOL_VALUE_ADDRESS (sym.symbol); break; case LOC_BLOCK: { bool ignore; char *special_name; const char *func_name; kind = GCC_CP_SYMBOL_FUNCTION; addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol)); if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym.symbol))) addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr); special_name = NULL; func_name = maybe_canonicalize_special_function (SYMBOL_LINKAGE_NAME (sym.symbol), NULL, SYMBOL_TYPE (sym.symbol), &special_name, &ignore); if (special_name != NULL) { kind |= GCC_CP_FLAG_SPECIAL_FUNCTION; name = special_name; xfree (special_name); } else if (func_name != SYMBOL_NATURAL_NAME (sym.symbol)) { kind |= GCC_CP_FLAG_SPECIAL_FUNCTION; name = func_name; } else if (ignore) { /* !!keiths: I don't think we can get here, can we? */ gdb_assert_not_reached ("told to ignore method!"); } } break; case LOC_CONST: if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_ENUM) { /* Already handled by convert_enum. */ do_cleanups (back_to); return; } instance->build_constant (sym_type, SYMBOL_NATURAL_NAME (sym.symbol), SYMBOL_VALUE (sym.symbol), filename, line); do_cleanups (back_to); return; case LOC_CONST_BYTES: error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."), SYMBOL_PRINT_NAME (sym.symbol)); case LOC_UNDEF: internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."), SYMBOL_PRINT_NAME (sym.symbol)); case LOC_COMMON_BLOCK: error (_("Fortran common block is unsupported for compilation " "evaluaton of symbol \"%s\"."), SYMBOL_PRINT_NAME (sym.symbol)); case LOC_OPTIMIZED_OUT: error (_("Symbol \"%s\" cannot be used for compilation evaluation " "as it is optimized out."), SYMBOL_PRINT_NAME (sym.symbol)); case LOC_COMPUTED: if (is_local) goto substitution; /* Probably TLS here. */ warning (_("Symbol \"%s\" is thread-local and currently can only " "be referenced from the current thread in " "compiled code."), SYMBOL_PRINT_NAME (sym.symbol)); /* FALLTHROUGH */ case LOC_UNRESOLVED: /* 'symbol_name' cannot be used here as that one is used only for local variables from compile_dwarf_expr_to_c. Global variables can be accessed by GCC only by their address, not by their name. */ { struct value *val; struct frame_info *frame = NULL; if (symbol_read_needs_frame (sym.symbol)) { frame = get_selected_frame (NULL); if (frame == NULL) error (_("Symbol \"%s\" cannot be used because " "there is no selected frame"), SYMBOL_PRINT_NAME (sym.symbol)); } val = read_var_value (sym.symbol, sym.block, frame); if (VALUE_LVAL (val) != lval_memory) error (_("Symbol \"%s\" cannot be used for compilation " "evaluation as its address has not been found."), SYMBOL_PRINT_NAME (sym.symbol)); kind = GCC_CP_SYMBOL_VARIABLE; addr = value_address (val); } break; case LOC_REGISTER: case LOC_ARG: case LOC_REF_ARG: case LOC_REGPARM_ADDR: case LOC_LOCAL: substitution: kind = GCC_CP_SYMBOL_VARIABLE; symbol_name = c_symbol_substitution_name (sym.symbol); break; case LOC_STATIC: kind = GCC_CP_SYMBOL_VARIABLE; addr = SYMBOL_VALUE_ADDRESS (sym.symbol); break; case LOC_FINAL_VALUE: default: gdb_assert_not_reached ("Unreachable case in convert_one_symbol."); } /* Don't emit local variable decls for a raw expression. */ if (instance->scope () != COMPILE_I_RAW_SCOPE || symbol_name == NULL) { compile_scope scope; /* For non-local symbols, create/push a new scope so that the symbol is properly scoped to the plug-in. */ if (!is_local) { scope = instance->new_scope (SYMBOL_NATURAL_NAME (sym.symbol), SYMBOL_TYPE (sym.symbol)); if (scope.nested_type () != GCC_TYPE_NONE) { /* We found a symbol for this type that was defined inside some other symbol, e.g., a class tyepdef defined. Don't return anything in that case because that really confuses users. */ do_cleanups (back_to); return; } instance->enter_scope (scope); } /* Get the `raw' name of the symbol. */ if (name.empty () && SYMBOL_NATURAL_NAME (sym.symbol) != NULL) { char *str = cp_func_name (SYMBOL_NATURAL_NAME (sym.symbol)); name = str; xfree (str); } /* Define the decl. */ if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (sym.symbol)) { struct template_symbol *tsymbol = (struct template_symbol *) sym.symbol; instance->build_function_template_specialization (tsymbol, addr, filename, line); } else { instance->build_decl ("variable", name.c_str (), kind, sym_type, symbol_name, addr, filename, line); } /* Pop scope for non-local symbols. */ if (!is_local) instance->leave_scope (); } /* Free any allocated memory. */ do_cleanups (back_to); } } /* Convert a full symbol to its gcc form. CONTEXT is the compiler to use, IDENTIFIER is the name of the symbol, SYM is the symbol itself, and DOMAIN is the domain which was searched. */ static void convert_symbol_sym (compile_cplus_instance *instance, const char *identifier, struct block_symbol sym, domain_enum domain) { /* If we found a symbol and it is not in the static or global scope, then we should first convert any static or global scope symbol of the same name. This lets this unusual case work: int x; // Global. int func(void) { int x; // At this spot, evaluate "extern int x; x" } */ const struct block *static_block = block_static_block (sym.block); /* STATIC_BLOCK is NULL if FOUND_BLOCK is the global block. */ bool is_local_symbol = (sym.block != static_block && static_block != NULL); if (is_local_symbol) { struct block_symbol global_sym; global_sym = lookup_symbol (identifier, NULL, domain, NULL); /* If the outer symbol is in the static block, we ignore it, as it cannot be referenced. */ if (global_sym.symbol != NULL && global_sym.block != block_static_block (global_sym.block)) { if (compile_debug) fprintf_unfiltered (gdb_stdout, "gcc_convert_symbol \"%s\": global symbol\n", identifier); convert_one_symbol (instance, global_sym, true, false); } } if (compile_debug) fprintf_unfiltered (gdb_stdout, "gcc_convert_symbol \"%s\": local symbol\n", identifier); convert_one_symbol (instance, sym, false, is_local_symbol); } /* Convert a minimal symbol to its gcc form. CONTEXT is the compiler to use and BMSYM is the minimal symbol to convert. */ static void convert_symbol_bmsym (compile_cplus_instance *instance, struct bound_minimal_symbol bmsym) { struct minimal_symbol *msym = bmsym.minsym; struct objfile *objfile = bmsym.objfile; struct type *type; gcc_cp_symbol_kind_flags kind; gcc_type sym_type; CORE_ADDR addr; addr = MSYMBOL_VALUE_ADDRESS (objfile, msym); /* Conversion copied from write_exp_msymbol. */ switch (MSYMBOL_TYPE (msym)) { case mst_text: case mst_file_text: case mst_solib_trampoline: type = objfile_type (objfile)->nodebug_text_symbol; kind = GCC_CP_SYMBOL_FUNCTION; break; case mst_text_gnu_ifunc: /* nodebug_text_gnu_ifunc_symbol would cause: function return type cannot be function */ type = objfile_type (objfile)->nodebug_text_symbol; kind = GCC_CP_SYMBOL_FUNCTION; addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr); break; case mst_data: case mst_file_data: case mst_bss: case mst_file_bss: type = objfile_type (objfile)->nodebug_data_symbol; kind = GCC_CP_SYMBOL_VARIABLE; break; case mst_slot_got_plt: type = objfile_type (objfile)->nodebug_got_plt_symbol; kind = GCC_CP_SYMBOL_FUNCTION; break; default: type = objfile_type (objfile)->nodebug_unknown_symbol; kind = GCC_CP_SYMBOL_VARIABLE; break; } sym_type = instance->convert_type (type); instance->push_namespace (""); /* FIXME: push (and, after the call, pop) any other namespaces, if any, and drop the above when defining a class member. drop any namespace and class names from before the symbol name, and any function signatures from after it. -lxo */ /* !!keiths: I don't see how we could do this. We have NO debug information for the symbol. While we have access to the demangled name, we still don't know what A::B::C::D::E::F means without debug info, no? */ instance->build_decl ("minsym", MSYMBOL_NATURAL_NAME (msym), kind, sym_type, NULL, addr, NULL, 0); instance->pop_binding_level (""); } /* Do a regular expression search of the symbol table for any symbol named NAME in the given DOMAIN. Warning: This is INCREDIBLY slow. */ static int regexp_search_symbols (compile_cplus_instance *instance, const char *name, domain_enum domain) { char *regexp; enum search_domain search_domain; struct symbol_search *symbols, *p; struct cleanup *cleanup; int found = 0; switch (domain) { case STRUCT_DOMAIN: search_domain = TYPES_DOMAIN; break; case VAR_DOMAIN: /* !!keiths: We really don't want to search functions. The search will return all kinds of stuff that we don't really want, such as every operator+ defined in every class. */ return 0; /* !!keiths; fscked up. We need to search through functions when GCC_CP_ORACLE_SYMBOL (= VAR_DOMAIN). */ /* !!keiths; I hope we don't have to search even more domains! */ search_domain = FUNCTIONS_DOMAIN; break; default: /* This will cause search_symbols to assert. */ search_domain = ALL_DOMAIN; break; } symbols = NULL; cleanup = make_cleanup_free_search_symbols (&symbols); regexp = xstrprintf ("\\(\\(::\\)\\|^\\)%s\\($\\|<\\)", name); make_cleanup (xfree, regexp); search_symbols (regexp, search_domain, 0, NULL, &symbols); for (p = symbols; p != NULL; p = p->next) { if (p->symbol != NULL) { struct block_symbol sym; sym.symbol = p->symbol; sym.block = SYMBOL_BLOCK_VALUE (p->symbol); convert_symbol_sym (instance, name, sym, domain); found = 1; } /* !!keiths: Ignore minsyms? */ } do_cleanups (cleanup); return found; } /* See compile-cplus.h. */ void gcc_cplus_convert_symbol (void *datum, struct gcc_cp_context *gcc_context, enum gcc_cp_oracle_request request, const char *identifier) { compile_cplus_instance *instance = (compile_cplus_instance *) datum; int found = 0; struct search_multiple_result search_result; struct cleanup *cleanups; /* !!keiths create htab for template definitions */ switch (request) { case GCC_CP_ORACLE_IDENTIFIER: /* FIXME: This used to be separate SYMBOL and TAG. Check for simplification opportunities below. -lxo */ break; default: gdb_assert_not_reached ("Unrecognized oracle request."); } /* We can't allow exceptions to escape out of this callback. Safest is to simply emit a gcc error. */ if (debug_compile_oracle) { printf ("got oracle request for \"%s\"\n", identifier); } memset (&search_result, 0, sizeof (search_result)); cleanups = make_cleanup (search_multiple_result_cleanup, &search_result); TRY { int ix; /* !!keiths: Symbol lookup is out of control. Here's the current process, screaming for a custom symbol table search: 1. If looking up a symbol in VAR_DOMAIN (basically anything but a type), use linespec.c's (new) multi-symbol search. This will allow overloads of functions (not methods) to be converted. 2. If a symbol is not found, do a "standard" lookup. This will find variables in the current scope. 3. If a symbol is still not found, try a regexp search. This allows namespace-y stuff to work (cp-simple-ns.exp). This is currently only used for STRUCT_DOMAIN lookups. 4. Finally, if all else fails, fall back to minsyms. */ if (1) { search_result = search_symbols_multiple (identifier, current_language, VAR_DOMAIN, NULL, NULL); if (!VEC_empty (block_symbol_d, search_result.symbols)) { struct block_symbol *elt; /* Define any template generics from the found symbols. */ define_templates (instance, search_result.symbols); /* Convert each found symbol. */ for (ix = 0; VEC_iterate (block_symbol_d, search_result.symbols, ix, elt); ++ix) { convert_symbol_sym (instance, identifier, *elt, VAR_DOMAIN); } found = 1; } } if (!found) { struct block_symbol sym = lookup_symbol (identifier, instance->block (), VAR_DOMAIN, NULL); if (sym.symbol != NULL) { convert_symbol_sym (instance, identifier, sym, VAR_DOMAIN); found = 1; } } if (1) { struct block_symbol sym = lookup_symbol (identifier, instance->block (), STRUCT_DOMAIN, NULL); if (sym.symbol != NULL) { convert_symbol_sym (instance, identifier, sym, STRUCT_DOMAIN); found = 1; } } if (!found) { /* Try a regexp search of the program's symbols. */ found = regexp_search_symbols (instance, identifier, VAR_DOMAIN) + regexp_search_symbols (instance, identifier, STRUCT_DOMAIN); /* One last attempt: fall back to minsyms. */ if (!found && !VEC_empty (bound_minimal_symbol_d, search_result.minimal_symbols)) { struct bound_minimal_symbol *elt; for (ix = 0; VEC_iterate (bound_minimal_symbol_d, search_result.minimal_symbols, ix, elt); ++ix) { convert_symbol_bmsym (instance, *elt); } found = 1; } } } CATCH (e, RETURN_MASK_ALL) { instance->error (e.message); } END_CATCH if (compile_debug && !found) fprintf_unfiltered (gdb_stdout, "gcc_convert_symbol \"%s\": lookup_symbol failed\n", identifier); if (debug_compile_oracle) { if (found) printf_unfiltered ("found type for %s!\n", identifier); else printf_unfiltered ("did not find type for %s\n", identifier); } do_cleanups (cleanups); return; } /* See compile-cplus.h. */ gcc_address gcc_cplus_symbol_address (void *datum, struct gcc_cp_context *gcc_context, const char *identifier) { compile_cplus_instance *instance = (compile_cplus_instance *) datum; gcc_address result = 0; int found = 0; if (debug_compile_oracle) printf_unfiltered ("got oracle request for address of %s\n", identifier); /* We can't allow exceptions to escape out of this callback. Safest is to simply emit a gcc error. */ TRY { struct symbol *sym; /* FIXME: We used to only need global functions here, but we may now be asked for other symbols. IDENTIFIER is a mangled name. -lxo */ sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL).symbol; if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK) { if (compile_debug) fprintf_unfiltered (gdb_stdout, "gcc_symbol_address \"%s\": full symbol\n", identifier); result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); if (TYPE_GNU_IFUNC (SYMBOL_TYPE (sym))) result = gnu_ifunc_resolve_addr (target_gdbarch (), result); found = 1; } else { struct bound_minimal_symbol msym; msym = lookup_bound_minimal_symbol (identifier); if (msym.minsym != NULL) { if (compile_debug) fprintf_unfiltered (gdb_stdout, "gcc_symbol_address \"%s\": minimal " "symbol\n", identifier); result = BMSYMBOL_VALUE_ADDRESS (msym); if (MSYMBOL_TYPE (msym.minsym) == mst_text_gnu_ifunc) result = gnu_ifunc_resolve_addr (target_gdbarch (), result); found = 1; } } } CATCH (e, RETURN_MASK_ERROR) { instance->error (e.message); } END_CATCH if (compile_debug && !found) fprintf_unfiltered (gdb_stdout, "gcc_symbol_address \"%s\": failed\n", identifier); if (debug_compile_oracle) { if (found) printf_unfiltered ("found address for %s!\n", identifier); else printf_unfiltered ("did not find address for %s\n", identifier); } return result; } void _initialize_compile_cplus_symbols (void); void _initialize_compile_cplus_symbols (void) { add_setshow_boolean_cmd ("compile-oracle", no_class, &debug_compile_oracle, _("\ Set debugging of compiler plug-in oracle requests."), _("\ Show debugging of compiler plug-in oracle requests."), _("\ When enabled debugging messages are printed for compiler plug-in\n\ oracle requests."), NULL, NULL, &setdebuglist, &showdebuglist); }