6c2659886f
I'd like to enable the -Wmissing-declarations warning. However, it
warns for every _initialize function, for example:
CXX dcache.o
/home/smarchi/src/binutils-gdb/gdb/dcache.c: In function ‘void _initialize_dcache()’:
/home/smarchi/src/binutils-gdb/gdb/dcache.c:688:1: error: no previous declaration for ‘void _initialize_dcache()’ [-Werror=missing-declarations]
_initialize_dcache (void)
^~~~~~~~~~~~~~~~~~
The only practical way forward I found is to add back the declarations,
which were removed by this commit:
commit 481695ed5f
Author: John Baldwin <jhb@FreeBSD.org>
Date: Sat Sep 9 11:02:37 2017 -0700
Remove unnecessary function prototypes.
I don't think it's a big problem to have the declarations for these
functions, but if anybody has a better solution for this, I'll be happy
to use it.
gdb/ChangeLog:
* aarch64-fbsd-nat.c (_initialize_aarch64_fbsd_nat): Add declaration.
* aarch64-fbsd-tdep.c (_initialize_aarch64_fbsd_tdep): Add declaration.
* aarch64-linux-nat.c (_initialize_aarch64_linux_nat): Add declaration.
* aarch64-linux-tdep.c (_initialize_aarch64_linux_tdep): Add declaration.
* aarch64-newlib-tdep.c (_initialize_aarch64_newlib_tdep): Add declaration.
* aarch64-tdep.c (_initialize_aarch64_tdep): Add declaration.
* ada-exp.y (_initialize_ada_exp): Add declaration.
* ada-lang.c (_initialize_ada_language): Add declaration.
* ada-tasks.c (_initialize_tasks): Add declaration.
* agent.c (_initialize_agent): Add declaration.
* aix-thread.c (_initialize_aix_thread): Add declaration.
* alpha-bsd-nat.c (_initialize_alphabsd_nat): Add declaration.
* alpha-linux-nat.c (_initialize_alpha_linux_nat): Add declaration.
* alpha-linux-tdep.c (_initialize_alpha_linux_tdep): Add declaration.
* alpha-nbsd-tdep.c (_initialize_alphanbsd_tdep): Add declaration.
* alpha-obsd-tdep.c (_initialize_alphaobsd_tdep): Add declaration.
* alpha-tdep.c (_initialize_alpha_tdep): Add declaration.
* amd64-darwin-tdep.c (_initialize_amd64_darwin_tdep): Add declaration.
* amd64-dicos-tdep.c (_initialize_amd64_dicos_tdep): Add declaration.
* amd64-fbsd-nat.c (_initialize_amd64fbsd_nat): Add declaration.
* amd64-fbsd-tdep.c (_initialize_amd64fbsd_tdep): Add declaration.
* amd64-linux-nat.c (_initialize_amd64_linux_nat): Add declaration.
* amd64-linux-tdep.c (_initialize_amd64_linux_tdep): Add declaration.
* amd64-nbsd-nat.c (_initialize_amd64nbsd_nat): Add declaration.
* amd64-nbsd-tdep.c (_initialize_amd64nbsd_tdep): Add declaration.
* amd64-obsd-nat.c (_initialize_amd64obsd_nat): Add declaration.
* amd64-obsd-tdep.c (_initialize_amd64obsd_tdep): Add declaration.
* amd64-sol2-tdep.c (_initialize_amd64_sol2_tdep): Add declaration.
* amd64-tdep.c (_initialize_amd64_tdep): Add declaration.
* amd64-windows-nat.c (_initialize_amd64_windows_nat): Add declaration.
* amd64-windows-tdep.c (_initialize_amd64_windows_tdep): Add declaration.
* annotate.c (_initialize_annotate): Add declaration.
* arc-newlib-tdep.c (_initialize_arc_newlib_tdep): Add declaration.
* arc-tdep.c (_initialize_arc_tdep): Add declaration.
* arch-utils.c (_initialize_gdbarch_utils): Add declaration.
* arm-fbsd-nat.c (_initialize_arm_fbsd_nat): Add declaration.
* arm-fbsd-tdep.c (_initialize_arm_fbsd_tdep): Add declaration.
* arm-linux-nat.c (_initialize_arm_linux_nat): Add declaration.
* arm-linux-tdep.c (_initialize_arm_linux_tdep): Add declaration.
* arm-nbsd-nat.c (_initialize_arm_netbsd_nat): Add declaration.
* arm-nbsd-tdep.c (_initialize_arm_netbsd_tdep): Add declaration.
* arm-obsd-tdep.c (_initialize_armobsd_tdep): Add declaration.
* arm-pikeos-tdep.c (_initialize_arm_pikeos_tdep): Add declaration.
* arm-symbian-tdep.c (_initialize_arm_symbian_tdep): Add declaration.
* arm-tdep.c (_initialize_arm_tdep): Add declaration.
* arm-wince-tdep.c (_initialize_arm_wince_tdep): Add declaration.
* auto-load.c (_initialize_auto_load): Add declaration.
* auxv.c (_initialize_auxv): Add declaration.
* avr-tdep.c (_initialize_avr_tdep): Add declaration.
* ax-gdb.c (_initialize_ax_gdb): Add declaration.
* bfin-linux-tdep.c (_initialize_bfin_linux_tdep): Add declaration.
* bfin-tdep.c (_initialize_bfin_tdep): Add declaration.
* break-catch-sig.c (_initialize_break_catch_sig): Add declaration.
* break-catch-syscall.c (_initialize_break_catch_syscall): Add declaration.
* break-catch-throw.c (_initialize_break_catch_throw): Add declaration.
* breakpoint.c (_initialize_breakpoint): Add declaration.
* bsd-uthread.c (_initialize_bsd_uthread): Add declaration.
* btrace.c (_initialize_btrace): Add declaration.
* charset.c (_initialize_charset): Add declaration.
* cli/cli-cmds.c (_initialize_cli_cmds): Add declaration.
* cli/cli-dump.c (_initialize_cli_dump): Add declaration.
* cli/cli-interp.c (_initialize_cli_interp): Add declaration.
* cli/cli-logging.c (_initialize_cli_logging): Add declaration.
* cli/cli-script.c (_initialize_cli_script): Add declaration.
* cli/cli-style.c (_initialize_cli_style): Add declaration.
* coff-pe-read.c (_initialize_coff_pe_read): Add declaration.
* coffread.c (_initialize_coffread): Add declaration.
* compile/compile-cplus-types.c (_initialize_compile_cplus_types): Add declaration.
* compile/compile.c (_initialize_compile): Add declaration.
* complaints.c (_initialize_complaints): Add declaration.
* completer.c (_initialize_completer): Add declaration.
* copying.c (_initialize_copying): Add declaration.
* corefile.c (_initialize_core): Add declaration.
* corelow.c (_initialize_corelow): Add declaration.
* cp-abi.c (_initialize_cp_abi): Add declaration.
* cp-namespace.c (_initialize_cp_namespace): Add declaration.
* cp-support.c (_initialize_cp_support): Add declaration.
* cp-valprint.c (_initialize_cp_valprint): Add declaration.
* cris-linux-tdep.c (_initialize_cris_linux_tdep): Add declaration.
* cris-tdep.c (_initialize_cris_tdep): Add declaration.
* csky-linux-tdep.c (_initialize_csky_linux_tdep): Add declaration.
* csky-tdep.c (_initialize_csky_tdep): Add declaration.
* ctfread.c (_initialize_ctfread): Add declaration.
* d-lang.c (_initialize_d_language): Add declaration.
* darwin-nat-info.c (_initialize_darwin_info_commands): Add declaration.
* darwin-nat.c (_initialize_darwin_nat): Add declaration.
* dbxread.c (_initialize_dbxread): Add declaration.
* dcache.c (_initialize_dcache): Add declaration.
* disasm-selftests.c (_initialize_disasm_selftests): Add declaration.
* disasm.c (_initialize_disasm): Add declaration.
* dtrace-probe.c (_initialize_dtrace_probe): Add declaration.
* dummy-frame.c (_initialize_dummy_frame): Add declaration.
* dwarf-index-cache.c (_initialize_index_cache): Add declaration.
* dwarf-index-write.c (_initialize_dwarf_index_write): Add declaration.
* dwarf2-frame-tailcall.c (_initialize_tailcall_frame): Add declaration.
* dwarf2-frame.c (_initialize_dwarf2_frame): Add declaration.
* dwarf2expr.c (_initialize_dwarf2expr): Add declaration.
* dwarf2loc.c (_initialize_dwarf2loc): Add declaration.
* dwarf2read.c (_initialize_dwarf2_read): Add declaration.
* elfread.c (_initialize_elfread): Add declaration.
* exec.c (_initialize_exec): Add declaration.
* extension.c (_initialize_extension): Add declaration.
* f-lang.c (_initialize_f_language): Add declaration.
* f-valprint.c (_initialize_f_valprint): Add declaration.
* fbsd-nat.c (_initialize_fbsd_nat): Add declaration.
* fbsd-tdep.c (_initialize_fbsd_tdep): Add declaration.
* filesystem.c (_initialize_filesystem): Add declaration.
* findcmd.c (_initialize_mem_search): Add declaration.
* findvar.c (_initialize_findvar): Add declaration.
* fork-child.c (_initialize_fork_child): Add declaration.
* frame-base.c (_initialize_frame_base): Add declaration.
* frame-unwind.c (_initialize_frame_unwind): Add declaration.
* frame.c (_initialize_frame): Add declaration.
* frv-linux-tdep.c (_initialize_frv_linux_tdep): Add declaration.
* frv-tdep.c (_initialize_frv_tdep): Add declaration.
* ft32-tdep.c (_initialize_ft32_tdep): Add declaration.
* gcore.c (_initialize_gcore): Add declaration.
* gdb-demangle.c (_initialize_gdb_demangle): Add declaration.
* gdb_bfd.c (_initialize_gdb_bfd): Add declaration.
* gdbarch-selftests.c (_initialize_gdbarch_selftests): Add declaration.
* gdbarch.c (_initialize_gdbarch): Add declaration.
* gdbtypes.c (_initialize_gdbtypes): Add declaration.
* gnu-nat.c (_initialize_gnu_nat): Add declaration.
* gnu-v2-abi.c (_initialize_gnu_v2_abi): Add declaration.
* gnu-v3-abi.c (_initialize_gnu_v3_abi): Add declaration.
* go-lang.c (_initialize_go_language): Add declaration.
* go32-nat.c (_initialize_go32_nat): Add declaration.
* guile/guile.c (_initialize_guile): Add declaration.
* h8300-tdep.c (_initialize_h8300_tdep): Add declaration.
* hppa-linux-nat.c (_initialize_hppa_linux_nat): Add declaration.
* hppa-linux-tdep.c (_initialize_hppa_linux_tdep): Add declaration.
* hppa-nbsd-nat.c (_initialize_hppanbsd_nat): Add declaration.
* hppa-nbsd-tdep.c (_initialize_hppanbsd_tdep): Add declaration.
* hppa-obsd-nat.c (_initialize_hppaobsd_nat): Add declaration.
* hppa-obsd-tdep.c (_initialize_hppabsd_tdep): Add declaration.
* hppa-tdep.c (_initialize_hppa_tdep): Add declaration.
* i386-bsd-nat.c (_initialize_i386bsd_nat): Add declaration.
* i386-cygwin-tdep.c (_initialize_i386_cygwin_tdep): Add declaration.
* i386-darwin-nat.c (_initialize_i386_darwin_nat): Add declaration.
* i386-darwin-tdep.c (_initialize_i386_darwin_tdep): Add declaration.
* i386-dicos-tdep.c (_initialize_i386_dicos_tdep): Add declaration.
* i386-fbsd-nat.c (_initialize_i386fbsd_nat): Add declaration.
* i386-fbsd-tdep.c (_initialize_i386fbsd_tdep): Add declaration.
* i386-gnu-nat.c (_initialize_i386gnu_nat): Add declaration.
* i386-gnu-tdep.c (_initialize_i386gnu_tdep): Add declaration.
* i386-go32-tdep.c (_initialize_i386_go32_tdep): Add declaration.
* i386-linux-nat.c (_initialize_i386_linux_nat): Add declaration.
* i386-linux-tdep.c (_initialize_i386_linux_tdep): Add declaration.
* i386-nbsd-nat.c (_initialize_i386nbsd_nat): Add declaration.
* i386-nbsd-tdep.c (_initialize_i386nbsd_tdep): Add declaration.
* i386-nto-tdep.c (_initialize_i386nto_tdep): Add declaration.
* i386-obsd-nat.c (_initialize_i386obsd_nat): Add declaration.
* i386-obsd-tdep.c (_initialize_i386obsd_tdep): Add declaration.
* i386-sol2-nat.c (_initialize_amd64_sol2_nat): Add declaration.
* i386-sol2-tdep.c (_initialize_i386_sol2_tdep): Add declaration.
* i386-tdep.c (_initialize_i386_tdep): Add declaration.
* i386-windows-nat.c (_initialize_i386_windows_nat): Add declaration.
* ia64-libunwind-tdep.c (_initialize_libunwind_frame): Add declaration.
* ia64-linux-nat.c (_initialize_ia64_linux_nat): Add declaration.
* ia64-linux-tdep.c (_initialize_ia64_linux_tdep): Add declaration.
* ia64-tdep.c (_initialize_ia64_tdep): Add declaration.
* ia64-vms-tdep.c (_initialize_ia64_vms_tdep): Add declaration.
* infcall.c (_initialize_infcall): Add declaration.
* infcmd.c (_initialize_infcmd): Add declaration.
* inflow.c (_initialize_inflow): Add declaration.
* infrun.c (_initialize_infrun): Add declaration.
* interps.c (_initialize_interpreter): Add declaration.
* iq2000-tdep.c (_initialize_iq2000_tdep): Add declaration.
* jit.c (_initialize_jit): Add declaration.
* language.c (_initialize_language): Add declaration.
* linux-fork.c (_initialize_linux_fork): Add declaration.
* linux-nat.c (_initialize_linux_nat): Add declaration.
* linux-tdep.c (_initialize_linux_tdep): Add declaration.
* linux-thread-db.c (_initialize_thread_db): Add declaration.
* lm32-tdep.c (_initialize_lm32_tdep): Add declaration.
* m2-lang.c (_initialize_m2_language): Add declaration.
* m32c-tdep.c (_initialize_m32c_tdep): Add declaration.
* m32r-linux-nat.c (_initialize_m32r_linux_nat): Add declaration.
* m32r-linux-tdep.c (_initialize_m32r_linux_tdep): Add declaration.
* m32r-tdep.c (_initialize_m32r_tdep): Add declaration.
* m68hc11-tdep.c (_initialize_m68hc11_tdep): Add declaration.
* m68k-bsd-nat.c (_initialize_m68kbsd_nat): Add declaration.
* m68k-bsd-tdep.c (_initialize_m68kbsd_tdep): Add declaration.
* m68k-linux-nat.c (_initialize_m68k_linux_nat): Add declaration.
* m68k-linux-tdep.c (_initialize_m68k_linux_tdep): Add declaration.
* m68k-tdep.c (_initialize_m68k_tdep): Add declaration.
* machoread.c (_initialize_machoread): Add declaration.
* macrocmd.c (_initialize_macrocmd): Add declaration.
* macroscope.c (_initialize_macroscope): Add declaration.
* maint-test-options.c (_initialize_maint_test_options): Add declaration.
* maint-test-settings.c (_initialize_maint_test_settings): Add declaration.
* maint.c (_initialize_maint_cmds): Add declaration.
* mdebugread.c (_initialize_mdebugread): Add declaration.
* memattr.c (_initialize_mem): Add declaration.
* mep-tdep.c (_initialize_mep_tdep): Add declaration.
* mi/mi-cmd-env.c (_initialize_mi_cmd_env): Add declaration.
* mi/mi-cmds.c (_initialize_mi_cmds): Add declaration.
* mi/mi-interp.c (_initialize_mi_interp): Add declaration.
* mi/mi-main.c (_initialize_mi_main): Add declaration.
* microblaze-linux-tdep.c (_initialize_microblaze_linux_tdep): Add declaration.
* microblaze-tdep.c (_initialize_microblaze_tdep): Add declaration.
* mips-fbsd-nat.c (_initialize_mips_fbsd_nat): Add declaration.
* mips-fbsd-tdep.c (_initialize_mips_fbsd_tdep): Add declaration.
* mips-linux-nat.c (_initialize_mips_linux_nat): Add declaration.
* mips-linux-tdep.c (_initialize_mips_linux_tdep): Add declaration.
* mips-nbsd-nat.c (_initialize_mipsnbsd_nat): Add declaration.
* mips-nbsd-tdep.c (_initialize_mipsnbsd_tdep): Add declaration.
* mips-sde-tdep.c (_initialize_mips_sde_tdep): Add declaration.
* mips-tdep.c (_initialize_mips_tdep): Add declaration.
* mips64-obsd-nat.c (_initialize_mips64obsd_nat): Add declaration.
* mips64-obsd-tdep.c (_initialize_mips64obsd_tdep): Add declaration.
* mipsread.c (_initialize_mipsread): Add declaration.
* mn10300-linux-tdep.c (_initialize_mn10300_linux_tdep): Add declaration.
* mn10300-tdep.c (_initialize_mn10300_tdep): Add declaration.
* moxie-tdep.c (_initialize_moxie_tdep): Add declaration.
* msp430-tdep.c (_initialize_msp430_tdep): Add declaration.
* nds32-tdep.c (_initialize_nds32_tdep): Add declaration.
* nios2-linux-tdep.c (_initialize_nios2_linux_tdep): Add declaration.
* nios2-tdep.c (_initialize_nios2_tdep): Add declaration.
* nto-procfs.c (_initialize_procfs): Add declaration.
* objc-lang.c (_initialize_objc_language): Add declaration.
* observable.c (_initialize_observer): Add declaration.
* opencl-lang.c (_initialize_opencl_language): Add declaration.
* or1k-linux-tdep.c (_initialize_or1k_linux_tdep): Add declaration.
* or1k-tdep.c (_initialize_or1k_tdep): Add declaration.
* osabi.c (_initialize_gdb_osabi): Add declaration.
* osdata.c (_initialize_osdata): Add declaration.
* p-valprint.c (_initialize_pascal_valprint): Add declaration.
* parse.c (_initialize_parse): Add declaration.
* ppc-fbsd-nat.c (_initialize_ppcfbsd_nat): Add declaration.
* ppc-fbsd-tdep.c (_initialize_ppcfbsd_tdep): Add declaration.
* ppc-linux-nat.c (_initialize_ppc_linux_nat): Add declaration.
* ppc-linux-tdep.c (_initialize_ppc_linux_tdep): Add declaration.
* ppc-nbsd-nat.c (_initialize_ppcnbsd_nat): Add declaration.
* ppc-nbsd-tdep.c (_initialize_ppcnbsd_tdep): Add declaration.
* ppc-obsd-nat.c (_initialize_ppcobsd_nat): Add declaration.
* ppc-obsd-tdep.c (_initialize_ppcobsd_tdep): Add declaration.
* printcmd.c (_initialize_printcmd): Add declaration.
* probe.c (_initialize_probe): Add declaration.
* proc-api.c (_initialize_proc_api): Add declaration.
* proc-events.c (_initialize_proc_events): Add declaration.
* proc-service.c (_initialize_proc_service): Add declaration.
* procfs.c (_initialize_procfs): Add declaration.
* producer.c (_initialize_producer): Add declaration.
* psymtab.c (_initialize_psymtab): Add declaration.
* python/python.c (_initialize_python): Add declaration.
* ravenscar-thread.c (_initialize_ravenscar): Add declaration.
* record-btrace.c (_initialize_record_btrace): Add declaration.
* record-full.c (_initialize_record_full): Add declaration.
* record.c (_initialize_record): Add declaration.
* regcache-dump.c (_initialize_regcache_dump): Add declaration.
* regcache.c (_initialize_regcache): Add declaration.
* reggroups.c (_initialize_reggroup): Add declaration.
* remote-notif.c (_initialize_notif): Add declaration.
* remote-sim.c (_initialize_remote_sim): Add declaration.
* remote.c (_initialize_remote): Add declaration.
* reverse.c (_initialize_reverse): Add declaration.
* riscv-fbsd-nat.c (_initialize_riscv_fbsd_nat): Add declaration.
* riscv-fbsd-tdep.c (_initialize_riscv_fbsd_tdep): Add declaration.
* riscv-linux-nat.c (_initialize_riscv_linux_nat): Add declaration.
* riscv-linux-tdep.c (_initialize_riscv_linux_tdep): Add declaration.
* riscv-tdep.c (_initialize_riscv_tdep): Add declaration.
* rl78-tdep.c (_initialize_rl78_tdep): Add declaration.
* rs6000-aix-tdep.c (_initialize_rs6000_aix_tdep): Add declaration.
* rs6000-lynx178-tdep.c (_initialize_rs6000_lynx178_tdep):
Add declaration.
* rs6000-nat.c (_initialize_rs6000_nat): Add declaration.
* rs6000-tdep.c (_initialize_rs6000_tdep): Add declaration.
* run-on-main-thread.c (_initialize_run_on_main_thread): Add declaration.
* rust-exp.y (_initialize_rust_exp): Add declaration.
* rx-tdep.c (_initialize_rx_tdep): Add declaration.
* s12z-tdep.c (_initialize_s12z_tdep): Add declaration.
* s390-linux-nat.c (_initialize_s390_nat): Add declaration.
* s390-linux-tdep.c (_initialize_s390_linux_tdep): Add declaration.
* s390-tdep.c (_initialize_s390_tdep): Add declaration.
* score-tdep.c (_initialize_score_tdep): Add declaration.
* ser-go32.c (_initialize_ser_dos): Add declaration.
* ser-mingw.c (_initialize_ser_windows): Add declaration.
* ser-pipe.c (_initialize_ser_pipe): Add declaration.
* ser-tcp.c (_initialize_ser_tcp): Add declaration.
* ser-uds.c (_initialize_ser_socket): Add declaration.
* ser-unix.c (_initialize_ser_hardwire): Add declaration.
* serial.c (_initialize_serial): Add declaration.
* sh-linux-tdep.c (_initialize_sh_linux_tdep): Add declaration.
* sh-nbsd-nat.c (_initialize_shnbsd_nat): Add declaration.
* sh-nbsd-tdep.c (_initialize_shnbsd_tdep): Add declaration.
* sh-tdep.c (_initialize_sh_tdep): Add declaration.
* skip.c (_initialize_step_skip): Add declaration.
* sol-thread.c (_initialize_sol_thread): Add declaration.
* solib-aix.c (_initialize_solib_aix): Add declaration.
* solib-darwin.c (_initialize_darwin_solib): Add declaration.
* solib-dsbt.c (_initialize_dsbt_solib): Add declaration.
* solib-frv.c (_initialize_frv_solib): Add declaration.
* solib-svr4.c (_initialize_svr4_solib): Add declaration.
* solib-target.c (_initialize_solib_target): Add declaration.
* solib.c (_initialize_solib): Add declaration.
* source-cache.c (_initialize_source_cache): Add declaration.
* source.c (_initialize_source): Add declaration.
* sparc-linux-nat.c (_initialize_sparc_linux_nat): Add declaration.
* sparc-linux-tdep.c (_initialize_sparc_linux_tdep): Add declaration.
* sparc-nat.c (_initialize_sparc_nat): Add declaration.
* sparc-nbsd-nat.c (_initialize_sparcnbsd_nat): Add declaration.
* sparc-nbsd-tdep.c (_initialize_sparcnbsd_tdep): Add declaration.
* sparc-obsd-tdep.c (_initialize_sparc32obsd_tdep): Add declaration.
* sparc-sol2-tdep.c (_initialize_sparc_sol2_tdep): Add declaration.
* sparc-tdep.c (_initialize_sparc_tdep): Add declaration.
* sparc64-fbsd-nat.c (_initialize_sparc64fbsd_nat): Add declaration.
* sparc64-fbsd-tdep.c (_initialize_sparc64fbsd_tdep): Add declaration.
* sparc64-linux-nat.c (_initialize_sparc64_linux_nat): Add declaration.
* sparc64-linux-tdep.c (_initialize_sparc64_linux_tdep): Add declaration.
* sparc64-nat.c (_initialize_sparc64_nat): Add declaration.
* sparc64-nbsd-nat.c (_initialize_sparc64nbsd_nat): Add declaration.
* sparc64-nbsd-tdep.c (_initialize_sparc64nbsd_tdep): Add declaration.
* sparc64-obsd-nat.c (_initialize_sparc64obsd_nat): Add declaration.
* sparc64-obsd-tdep.c (_initialize_sparc64obsd_tdep): Add declaration.
* sparc64-sol2-tdep.c (_initialize_sparc64_sol2_tdep): Add declaration.
* sparc64-tdep.c (_initialize_sparc64_adi_tdep): Add declaration.
* stabsread.c (_initialize_stabsread): Add declaration.
* stack.c (_initialize_stack): Add declaration.
* stap-probe.c (_initialize_stap_probe): Add declaration.
* std-regs.c (_initialize_frame_reg): Add declaration.
* symfile-debug.c (_initialize_symfile_debug): Add declaration.
* symfile-mem.c (_initialize_symfile_mem): Add declaration.
* symfile.c (_initialize_symfile): Add declaration.
* symmisc.c (_initialize_symmisc): Add declaration.
* symtab.c (_initialize_symtab): Add declaration.
* target.c (_initialize_target): Add declaration.
* target-connection.c (_initialize_target_connection): Add
declaration.
* target-dcache.c (_initialize_target_dcache): Add declaration.
* target-descriptions.c (_initialize_target_descriptions): Add declaration.
* thread.c (_initialize_thread): Add declaration.
* tic6x-linux-tdep.c (_initialize_tic6x_linux_tdep): Add declaration.
* tic6x-tdep.c (_initialize_tic6x_tdep): Add declaration.
* tilegx-linux-nat.c (_initialize_tile_linux_nat): Add declaration.
* tilegx-linux-tdep.c (_initialize_tilegx_linux_tdep): Add declaration.
* tilegx-tdep.c (_initialize_tilegx_tdep): Add declaration.
* tracectf.c (_initialize_ctf): Add declaration.
* tracefile-tfile.c (_initialize_tracefile_tfile): Add declaration.
* tracefile.c (_initialize_tracefile): Add declaration.
* tracepoint.c (_initialize_tracepoint): Add declaration.
* tui/tui-hooks.c (_initialize_tui_hooks): Add declaration.
* tui/tui-interp.c (_initialize_tui_interp): Add declaration.
* tui/tui-layout.c (_initialize_tui_layout): Add declaration.
* tui/tui-regs.c (_initialize_tui_regs): Add declaration.
* tui/tui-stack.c (_initialize_tui_stack): Add declaration.
* tui/tui-win.c (_initialize_tui_win): Add declaration.
* tui/tui.c (_initialize_tui): Add declaration.
* typeprint.c (_initialize_typeprint): Add declaration.
* ui-style.c (_initialize_ui_style): Add declaration.
* unittests/array-view-selftests.c (_initialize_array_view_selftests): Add declaration.
* unittests/child-path-selftests.c (_initialize_child_path_selftests): Add declaration.
* unittests/cli-utils-selftests.c (_initialize_cli_utils_selftests): Add declaration.
* unittests/common-utils-selftests.c (_initialize_common_utils_selftests): Add declaration.
* unittests/copy_bitwise-selftests.c (_initialize_copy_bitwise_utils_selftests): Add declaration.
* unittests/environ-selftests.c (_initialize_environ_selftests): Add declaration.
* unittests/filtered_iterator-selftests.c
(_initialize_filtered_iterator_selftests): Add declaration.
* unittests/format_pieces-selftests.c (_initialize_format_pieces_selftests): Add declaration.
* unittests/function-view-selftests.c (_initialize_function_view_selftests): Add declaration.
* unittests/help-doc-selftests.c (_initialize_help_doc_selftests): Add declaration.
* unittests/lookup_name_info-selftests.c (_initialize_lookup_name_info_selftests): Add declaration.
* unittests/main-thread-selftests.c
(_initialize_main_thread_selftests): Add declaration.
* unittests/memory-map-selftests.c (_initialize_memory_map_selftests): Add declaration.
* unittests/memrange-selftests.c (_initialize_memrange_selftests): Add declaration.
* unittests/mkdir-recursive-selftests.c (_initialize_mkdir_recursive_selftests): Add declaration.
* unittests/observable-selftests.c (_initialize_observer_selftest): Add declaration.
* unittests/offset-type-selftests.c (_initialize_offset_type_selftests): Add declaration.
* unittests/optional-selftests.c (_initialize_optional_selftests): Add declaration.
* unittests/parse-connection-spec-selftests.c (_initialize_parse_connection_spec_selftests): Add declaration.
* unittests/rsp-low-selftests.c (_initialize_rsp_low_selftests): Add declaration.
* unittests/scoped_fd-selftests.c (_initialize_scoped_fd_selftests): Add declaration.
* unittests/scoped_mmap-selftests.c (_initialize_scoped_mmap_selftests): Add declaration.
* unittests/scoped_restore-selftests.c (_initialize_scoped_restore_selftests): Add declaration.
* unittests/string_view-selftests.c (_initialize_string_view_selftests): Add declaration.
* unittests/style-selftests.c (_initialize_style_selftest): Add declaration.
* unittests/tracepoint-selftests.c (_initialize_tracepoint_selftests): Add declaration.
* unittests/tui-selftests.c (_initialize_tui_selftest): Add
declaration.
* unittests/unpack-selftests.c (_initialize_unpack_selftests): Add declaration.
* unittests/utils-selftests.c (_initialize_utils_selftests): Add declaration.
* unittests/vec-utils-selftests.c (_initialize_vec_utils_selftests): Add declaration.
* unittests/xml-utils-selftests.c (_initialize_xml_utils): Add declaration.
* user-regs.c (_initialize_user_regs): Add declaration.
* utils.c (_initialize_utils): Add declaration.
* v850-tdep.c (_initialize_v850_tdep): Add declaration.
* valops.c (_initialize_valops): Add declaration.
* valprint.c (_initialize_valprint): Add declaration.
* value.c (_initialize_values): Add declaration.
* varobj.c (_initialize_varobj): Add declaration.
* vax-bsd-nat.c (_initialize_vaxbsd_nat): Add declaration.
* vax-nbsd-tdep.c (_initialize_vaxnbsd_tdep): Add declaration.
* vax-tdep.c (_initialize_vax_tdep): Add declaration.
* windows-nat.c (_initialize_windows_nat): Add declaration.
(_initialize_check_for_gdb_ini): Add declaration.
(_initialize_loadable): Add declaration.
* windows-tdep.c (_initialize_windows_tdep): Add declaration.
* x86-bsd-nat.c (_initialize_x86_bsd_nat): Add declaration.
* x86-linux-nat.c (_initialize_x86_linux_nat): Add declaration.
* xcoffread.c (_initialize_xcoffread): Add declaration.
* xml-support.c (_initialize_xml_support): Add declaration.
* xstormy16-tdep.c (_initialize_xstormy16_tdep): Add declaration.
* xtensa-linux-nat.c (_initialize_xtensa_linux_nat): Add declaration.
* xtensa-linux-tdep.c (_initialize_xtensa_linux_tdep): Add declaration.
* xtensa-tdep.c (_initialize_xtensa_tdep): Add declaration.
Change-Id: I13eec7e0ed2b3c427377a7bdb055cf46da64def9
1448 lines
41 KiB
C
1448 lines
41 KiB
C
/* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
|
|
|
|
Copyright (C) 2009-2020 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 <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
|
|
#include "jit.h"
|
|
#include "jit-reader.h"
|
|
#include "block.h"
|
|
#include "breakpoint.h"
|
|
#include "command.h"
|
|
#include "dictionary.h"
|
|
#include "filenames.h"
|
|
#include "frame-unwind.h"
|
|
#include "gdbcmd.h"
|
|
#include "gdbcore.h"
|
|
#include "inferior.h"
|
|
#include "observable.h"
|
|
#include "objfiles.h"
|
|
#include "regcache.h"
|
|
#include "symfile.h"
|
|
#include "symtab.h"
|
|
#include "target.h"
|
|
#include "gdbsupport/gdb-dlfcn.h"
|
|
#include <sys/stat.h>
|
|
#include "gdb_bfd.h"
|
|
#include "readline/tilde.h"
|
|
#include "completer.h"
|
|
#include <forward_list>
|
|
|
|
static std::string jit_reader_dir;
|
|
|
|
static const struct objfile_data *jit_objfile_data;
|
|
|
|
static const char *const jit_break_name = "__jit_debug_register_code";
|
|
|
|
static const char *const jit_descriptor_name = "__jit_debug_descriptor";
|
|
|
|
static void jit_inferior_init (struct gdbarch *gdbarch);
|
|
static void jit_inferior_exit_hook (struct inferior *inf);
|
|
|
|
/* An unwinder is registered for every gdbarch. This key is used to
|
|
remember if the unwinder has been registered for a particular
|
|
gdbarch. */
|
|
|
|
static struct gdbarch_data *jit_gdbarch_data;
|
|
|
|
/* Non-zero if we want to see trace of jit level stuff. */
|
|
|
|
static unsigned int jit_debug = 0;
|
|
|
|
static void
|
|
show_jit_debug (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c, const char *value)
|
|
{
|
|
fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
|
|
}
|
|
|
|
struct target_buffer
|
|
{
|
|
CORE_ADDR base;
|
|
ULONGEST size;
|
|
};
|
|
|
|
/* Opening the file is a no-op. */
|
|
|
|
static void *
|
|
mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
|
|
{
|
|
return open_closure;
|
|
}
|
|
|
|
/* Closing the file is just freeing the base/size pair on our side. */
|
|
|
|
static int
|
|
mem_bfd_iovec_close (struct bfd *abfd, void *stream)
|
|
{
|
|
xfree (stream);
|
|
|
|
/* Zero means success. */
|
|
return 0;
|
|
}
|
|
|
|
/* For reading the file, we just need to pass through to target_read_memory and
|
|
fix up the arguments and return values. */
|
|
|
|
static file_ptr
|
|
mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
|
|
file_ptr nbytes, file_ptr offset)
|
|
{
|
|
int err;
|
|
struct target_buffer *buffer = (struct target_buffer *) stream;
|
|
|
|
/* If this read will read all of the file, limit it to just the rest. */
|
|
if (offset + nbytes > buffer->size)
|
|
nbytes = buffer->size - offset;
|
|
|
|
/* If there are no more bytes left, we've reached EOF. */
|
|
if (nbytes == 0)
|
|
return 0;
|
|
|
|
err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
|
|
if (err)
|
|
return -1;
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
/* For statting the file, we only support the st_size attribute. */
|
|
|
|
static int
|
|
mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
|
|
{
|
|
struct target_buffer *buffer = (struct target_buffer*) stream;
|
|
|
|
memset (sb, 0, sizeof (struct stat));
|
|
sb->st_size = buffer->size;
|
|
return 0;
|
|
}
|
|
|
|
/* Open a BFD from the target's memory. */
|
|
|
|
static gdb_bfd_ref_ptr
|
|
bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
|
|
{
|
|
struct target_buffer *buffer = XNEW (struct target_buffer);
|
|
|
|
buffer->base = addr;
|
|
buffer->size = size;
|
|
return gdb_bfd_openr_iovec ("<in-memory>", target,
|
|
mem_bfd_iovec_open,
|
|
buffer,
|
|
mem_bfd_iovec_pread,
|
|
mem_bfd_iovec_close,
|
|
mem_bfd_iovec_stat);
|
|
}
|
|
|
|
struct jit_reader
|
|
{
|
|
jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
|
|
: functions (f), handle (std::move (h))
|
|
{
|
|
}
|
|
|
|
~jit_reader ()
|
|
{
|
|
functions->destroy (functions);
|
|
}
|
|
|
|
DISABLE_COPY_AND_ASSIGN (jit_reader);
|
|
|
|
struct gdb_reader_funcs *functions;
|
|
gdb_dlhandle_up handle;
|
|
};
|
|
|
|
/* One reader that has been loaded successfully, and can potentially be used to
|
|
parse debug info. */
|
|
|
|
static struct jit_reader *loaded_jit_reader = NULL;
|
|
|
|
typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
|
|
static const char *reader_init_fn_sym = "gdb_init_reader";
|
|
|
|
/* Try to load FILE_NAME as a JIT debug info reader. */
|
|
|
|
static struct jit_reader *
|
|
jit_reader_load (const char *file_name)
|
|
{
|
|
reader_init_fn_type *init_fn;
|
|
struct gdb_reader_funcs *funcs = NULL;
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
|
|
file_name);
|
|
gdb_dlhandle_up so = gdb_dlopen (file_name);
|
|
|
|
init_fn = (reader_init_fn_type *) gdb_dlsym (so, reader_init_fn_sym);
|
|
if (!init_fn)
|
|
error (_("Could not locate initialization function: %s."),
|
|
reader_init_fn_sym);
|
|
|
|
if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
|
|
error (_("Reader not GPL compatible."));
|
|
|
|
funcs = init_fn ();
|
|
if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
|
|
error (_("Reader version does not match GDB version."));
|
|
|
|
return new jit_reader (funcs, std::move (so));
|
|
}
|
|
|
|
/* Provides the jit-reader-load command. */
|
|
|
|
static void
|
|
jit_reader_load_command (const char *args, int from_tty)
|
|
{
|
|
if (args == NULL)
|
|
error (_("No reader name provided."));
|
|
gdb::unique_xmalloc_ptr<char> file (tilde_expand (args));
|
|
|
|
if (loaded_jit_reader != NULL)
|
|
error (_("JIT reader already loaded. Run jit-reader-unload first."));
|
|
|
|
if (!IS_ABSOLUTE_PATH (file.get ()))
|
|
file.reset (xstrprintf ("%s%s%s", jit_reader_dir.c_str (), SLASH_STRING,
|
|
file.get ()));
|
|
|
|
loaded_jit_reader = jit_reader_load (file.get ());
|
|
reinit_frame_cache ();
|
|
jit_inferior_created_hook ();
|
|
}
|
|
|
|
/* Provides the jit-reader-unload command. */
|
|
|
|
static void
|
|
jit_reader_unload_command (const char *args, int from_tty)
|
|
{
|
|
if (!loaded_jit_reader)
|
|
error (_("No JIT reader loaded."));
|
|
|
|
reinit_frame_cache ();
|
|
jit_inferior_exit_hook (current_inferior ());
|
|
|
|
delete loaded_jit_reader;
|
|
loaded_jit_reader = NULL;
|
|
}
|
|
|
|
/* Per-program space structure recording which objfile has the JIT
|
|
symbols. */
|
|
|
|
struct jit_program_space_data
|
|
{
|
|
/* The objfile. This is NULL if no objfile holds the JIT
|
|
symbols. */
|
|
|
|
struct objfile *objfile = nullptr;
|
|
|
|
/* If this program space has __jit_debug_register_code, this is the
|
|
cached address from the minimal symbol. This is used to detect
|
|
relocations requiring the breakpoint to be re-created. */
|
|
|
|
CORE_ADDR cached_code_address = 0;
|
|
|
|
/* This is the JIT event breakpoint, or NULL if it has not been
|
|
set. */
|
|
|
|
struct breakpoint *jit_breakpoint = nullptr;
|
|
};
|
|
|
|
static program_space_key<jit_program_space_data> jit_program_space_key;
|
|
|
|
/* Per-objfile structure recording the addresses in the program space.
|
|
This object serves two purposes: for ordinary objfiles, it may
|
|
cache some symbols related to the JIT interface; and for
|
|
JIT-created objfiles, it holds some information about the
|
|
jit_code_entry. */
|
|
|
|
struct jit_objfile_data
|
|
{
|
|
/* Symbol for __jit_debug_register_code. */
|
|
struct minimal_symbol *register_code;
|
|
|
|
/* Symbol for __jit_debug_descriptor. */
|
|
struct minimal_symbol *descriptor;
|
|
|
|
/* Address of struct jit_code_entry in this objfile. This is only
|
|
non-zero for objfiles that represent code created by the JIT. */
|
|
CORE_ADDR addr;
|
|
};
|
|
|
|
/* Fetch the jit_objfile_data associated with OBJF. If no data exists
|
|
yet, make a new structure and attach it. */
|
|
|
|
static struct jit_objfile_data *
|
|
get_jit_objfile_data (struct objfile *objf)
|
|
{
|
|
struct jit_objfile_data *objf_data;
|
|
|
|
objf_data = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
|
|
if (objf_data == NULL)
|
|
{
|
|
objf_data = XCNEW (struct jit_objfile_data);
|
|
set_objfile_data (objf, jit_objfile_data, objf_data);
|
|
}
|
|
|
|
return objf_data;
|
|
}
|
|
|
|
/* Remember OBJFILE has been created for struct jit_code_entry located
|
|
at inferior address ENTRY. */
|
|
|
|
static void
|
|
add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
|
|
{
|
|
struct jit_objfile_data *objf_data;
|
|
|
|
objf_data = get_jit_objfile_data (objfile);
|
|
objf_data->addr = entry;
|
|
}
|
|
|
|
/* Return jit_program_space_data for current program space. Allocate
|
|
if not already present. */
|
|
|
|
static struct jit_program_space_data *
|
|
get_jit_program_space_data ()
|
|
{
|
|
struct jit_program_space_data *ps_data;
|
|
|
|
ps_data = jit_program_space_key.get (current_program_space);
|
|
if (ps_data == NULL)
|
|
ps_data = jit_program_space_key.emplace (current_program_space);
|
|
return ps_data;
|
|
}
|
|
|
|
/* Helper function for reading the global JIT descriptor from remote
|
|
memory. Returns 1 if all went well, 0 otherwise. */
|
|
|
|
static int
|
|
jit_read_descriptor (struct gdbarch *gdbarch,
|
|
struct jit_descriptor *descriptor,
|
|
struct jit_program_space_data *ps_data)
|
|
{
|
|
int err;
|
|
struct type *ptr_type;
|
|
int ptr_size;
|
|
int desc_size;
|
|
gdb_byte *desc_buf;
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
struct jit_objfile_data *objf_data;
|
|
|
|
if (ps_data->objfile == NULL)
|
|
return 0;
|
|
objf_data = get_jit_objfile_data (ps_data->objfile);
|
|
if (objf_data->descriptor == NULL)
|
|
return 0;
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
"jit_read_descriptor, descriptor_addr = %s\n",
|
|
paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
|
|
objf_data->descriptor)));
|
|
|
|
/* Figure out how big the descriptor is on the remote and how to read it. */
|
|
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
|
ptr_size = TYPE_LENGTH (ptr_type);
|
|
desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
|
|
desc_buf = (gdb_byte *) alloca (desc_size);
|
|
|
|
/* Read the descriptor. */
|
|
err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
|
|
objf_data->descriptor),
|
|
desc_buf, desc_size);
|
|
if (err)
|
|
{
|
|
printf_unfiltered (_("Unable to read JIT descriptor from "
|
|
"remote memory\n"));
|
|
return 0;
|
|
}
|
|
|
|
/* Fix the endianness to match the host. */
|
|
descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
|
|
descriptor->action_flag =
|
|
extract_unsigned_integer (&desc_buf[4], 4, byte_order);
|
|
descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
|
|
descriptor->first_entry =
|
|
extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Helper function for reading a JITed code entry from remote memory. */
|
|
|
|
static void
|
|
jit_read_code_entry (struct gdbarch *gdbarch,
|
|
CORE_ADDR code_addr, struct jit_code_entry *code_entry)
|
|
{
|
|
int err, off;
|
|
struct type *ptr_type;
|
|
int ptr_size;
|
|
int entry_size;
|
|
int align_bytes;
|
|
gdb_byte *entry_buf;
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
/* Figure out how big the entry is on the remote and how to read it. */
|
|
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
|
ptr_size = TYPE_LENGTH (ptr_type);
|
|
|
|
/* Figure out where the uint64_t value will be. */
|
|
align_bytes = type_align (builtin_type (gdbarch)->builtin_uint64);
|
|
off = 3 * ptr_size;
|
|
off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
|
|
|
|
entry_size = off + 8; /* Three pointers and one 64-bit int. */
|
|
entry_buf = (gdb_byte *) alloca (entry_size);
|
|
|
|
/* Read the entry. */
|
|
err = target_read_memory (code_addr, entry_buf, entry_size);
|
|
if (err)
|
|
error (_("Unable to read JIT code entry from remote memory!"));
|
|
|
|
/* Fix the endianness to match the host. */
|
|
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
|
code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
|
|
code_entry->prev_entry =
|
|
extract_typed_address (&entry_buf[ptr_size], ptr_type);
|
|
code_entry->symfile_addr =
|
|
extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
|
|
code_entry->symfile_size =
|
|
extract_unsigned_integer (&entry_buf[off], 8, byte_order);
|
|
}
|
|
|
|
/* Proxy object for building a block. */
|
|
|
|
struct gdb_block
|
|
{
|
|
gdb_block (gdb_block *parent, CORE_ADDR begin, CORE_ADDR end,
|
|
const char *name)
|
|
: parent (parent),
|
|
begin (begin),
|
|
end (end),
|
|
name (name != nullptr ? xstrdup (name) : nullptr)
|
|
{}
|
|
|
|
/* The parent of this block. */
|
|
struct gdb_block *parent;
|
|
|
|
/* Points to the "real" block that is being built out of this
|
|
instance. This block will be added to a blockvector, which will
|
|
then be added to a symtab. */
|
|
struct block *real_block = nullptr;
|
|
|
|
/* The first and last code address corresponding to this block. */
|
|
CORE_ADDR begin, end;
|
|
|
|
/* The name of this block (if any). If this is non-NULL, the
|
|
FUNCTION symbol symbol is set to this value. */
|
|
gdb::unique_xmalloc_ptr<char> name;
|
|
};
|
|
|
|
/* Proxy object for building a symtab. */
|
|
|
|
struct gdb_symtab
|
|
{
|
|
explicit gdb_symtab (const char *file_name)
|
|
: file_name (file_name != nullptr ? file_name : "")
|
|
{}
|
|
|
|
/* The list of blocks in this symtab. These will eventually be
|
|
converted to real blocks.
|
|
|
|
This is specifically a linked list, instead of, for example, a vector,
|
|
because the pointers are returned to the user's debug info reader. So
|
|
it's important that the objects don't change location during their
|
|
lifetime (which would happen with a vector of objects getting resized). */
|
|
std::forward_list<gdb_block> blocks;
|
|
|
|
/* The number of blocks inserted. */
|
|
int nblocks = 0;
|
|
|
|
/* A mapping between line numbers to PC. */
|
|
gdb::unique_xmalloc_ptr<struct linetable> linetable;
|
|
|
|
/* The source file for this symtab. */
|
|
std::string file_name;
|
|
};
|
|
|
|
/* Proxy object for building an object. */
|
|
|
|
struct gdb_object
|
|
{
|
|
/* Symtabs of this object.
|
|
|
|
This is specifically a linked list, instead of, for example, a vector,
|
|
because the pointers are returned to the user's debug info reader. So
|
|
it's important that the objects don't change location during their
|
|
lifetime (which would happen with a vector of objects getting resized). */
|
|
std::forward_list<gdb_symtab> symtabs;
|
|
};
|
|
|
|
/* The type of the `private' data passed around by the callback
|
|
functions. */
|
|
|
|
typedef CORE_ADDR jit_dbg_reader_data;
|
|
|
|
/* The reader calls into this function to read data off the targets
|
|
address space. */
|
|
|
|
static enum gdb_status
|
|
jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
|
|
{
|
|
int result = target_read_memory ((CORE_ADDR) target_mem,
|
|
(gdb_byte *) gdb_buf, len);
|
|
if (result == 0)
|
|
return GDB_SUCCESS;
|
|
else
|
|
return GDB_FAIL;
|
|
}
|
|
|
|
/* The reader calls into this function to create a new gdb_object
|
|
which it can then pass around to the other callbacks. Right now,
|
|
all that is required is allocating the memory. */
|
|
|
|
static struct gdb_object *
|
|
jit_object_open_impl (struct gdb_symbol_callbacks *cb)
|
|
{
|
|
/* CB is not required right now, but sometime in the future we might
|
|
need a handle to it, and we'd like to do that without breaking
|
|
the ABI. */
|
|
return new gdb_object;
|
|
}
|
|
|
|
/* Readers call into this function to open a new gdb_symtab, which,
|
|
again, is passed around to other callbacks. */
|
|
|
|
static struct gdb_symtab *
|
|
jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
|
|
struct gdb_object *object,
|
|
const char *file_name)
|
|
{
|
|
/* CB stays unused. See comment in jit_object_open_impl. */
|
|
|
|
object->symtabs.emplace_front (file_name);
|
|
return &object->symtabs.front ();
|
|
}
|
|
|
|
/* Called by readers to open a new gdb_block. This function also
|
|
inserts the new gdb_block in the correct place in the corresponding
|
|
gdb_symtab. */
|
|
|
|
static struct gdb_block *
|
|
jit_block_open_impl (struct gdb_symbol_callbacks *cb,
|
|
struct gdb_symtab *symtab, struct gdb_block *parent,
|
|
GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
|
|
{
|
|
/* Place the block at the beginning of the list, it will be sorted when the
|
|
symtab is finalized. */
|
|
symtab->blocks.emplace_front (parent, begin, end, name);
|
|
symtab->nblocks++;
|
|
|
|
return &symtab->blocks.front ();
|
|
}
|
|
|
|
/* Readers call this to add a line mapping (from PC to line number) to
|
|
a gdb_symtab. */
|
|
|
|
static void
|
|
jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
|
|
struct gdb_symtab *stab, int nlines,
|
|
struct gdb_line_mapping *map)
|
|
{
|
|
int i;
|
|
int alloc_len;
|
|
|
|
if (nlines < 1)
|
|
return;
|
|
|
|
alloc_len = sizeof (struct linetable)
|
|
+ (nlines - 1) * sizeof (struct linetable_entry);
|
|
stab->linetable.reset (XNEWVAR (struct linetable, alloc_len));
|
|
stab->linetable->nitems = nlines;
|
|
for (i = 0; i < nlines; i++)
|
|
{
|
|
stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
|
|
stab->linetable->item[i].line = map[i].line;
|
|
}
|
|
}
|
|
|
|
/* Called by readers to close a gdb_symtab. Does not need to do
|
|
anything as of now. */
|
|
|
|
static void
|
|
jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
|
|
struct gdb_symtab *stab)
|
|
{
|
|
/* Right now nothing needs to be done here. We may need to do some
|
|
cleanup here in the future (again, without breaking the plugin
|
|
ABI). */
|
|
}
|
|
|
|
/* Transform STAB to a proper symtab, and add it it OBJFILE. */
|
|
|
|
static void
|
|
finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
|
|
{
|
|
struct compunit_symtab *cust;
|
|
size_t blockvector_size;
|
|
CORE_ADDR begin, end;
|
|
struct blockvector *bv;
|
|
|
|
int actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
|
|
|
|
/* Sort the blocks in the order they should appear in the blockvector. */
|
|
stab->blocks.sort([] (const gdb_block &a, const gdb_block &b)
|
|
{
|
|
if (a.begin != b.begin)
|
|
return a.begin < b.begin;
|
|
|
|
return a.end > b.end;
|
|
});
|
|
|
|
cust = allocate_compunit_symtab (objfile, stab->file_name.c_str ());
|
|
allocate_symtab (cust, stab->file_name.c_str ());
|
|
add_compunit_symtab_to_objfile (cust);
|
|
|
|
/* JIT compilers compile in memory. */
|
|
COMPUNIT_DIRNAME (cust) = NULL;
|
|
|
|
/* Copy over the linetable entry if one was provided. */
|
|
if (stab->linetable)
|
|
{
|
|
size_t size = ((stab->linetable->nitems - 1)
|
|
* sizeof (struct linetable_entry)
|
|
+ sizeof (struct linetable));
|
|
SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
|
|
= (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);
|
|
memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)),
|
|
stab->linetable.get (), size);
|
|
}
|
|
|
|
blockvector_size = (sizeof (struct blockvector)
|
|
+ (actual_nblocks - 1) * sizeof (struct block *));
|
|
bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
|
|
blockvector_size);
|
|
COMPUNIT_BLOCKVECTOR (cust) = bv;
|
|
|
|
/* At the end of this function, (begin, end) will contain the PC range this
|
|
entire blockvector spans. */
|
|
BLOCKVECTOR_MAP (bv) = NULL;
|
|
begin = stab->blocks.front ().begin;
|
|
end = stab->blocks.front ().end;
|
|
BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
|
|
|
|
/* First run over all the gdb_block objects, creating a real block
|
|
object for each. Simultaneously, keep setting the real_block
|
|
fields. */
|
|
int block_idx = FIRST_LOCAL_BLOCK;
|
|
for (gdb_block &gdb_block_iter : stab->blocks)
|
|
{
|
|
struct block *new_block = allocate_block (&objfile->objfile_obstack);
|
|
struct symbol *block_name = allocate_symbol (objfile);
|
|
struct type *block_type = arch_type (get_objfile_arch (objfile),
|
|
TYPE_CODE_VOID,
|
|
TARGET_CHAR_BIT,
|
|
"void");
|
|
|
|
BLOCK_MULTIDICT (new_block)
|
|
= mdict_create_linear (&objfile->objfile_obstack, NULL);
|
|
/* The address range. */
|
|
BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter.begin;
|
|
BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter.end;
|
|
|
|
/* The name. */
|
|
SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
|
|
SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
|
|
symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
|
|
SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
|
|
SYMBOL_BLOCK_VALUE (block_name) = new_block;
|
|
|
|
block_name->m_name = obstack_strdup (&objfile->objfile_obstack,
|
|
gdb_block_iter.name.get ());
|
|
|
|
BLOCK_FUNCTION (new_block) = block_name;
|
|
|
|
BLOCKVECTOR_BLOCK (bv, block_idx) = new_block;
|
|
if (begin > BLOCK_START (new_block))
|
|
begin = BLOCK_START (new_block);
|
|
if (end < BLOCK_END (new_block))
|
|
end = BLOCK_END (new_block);
|
|
|
|
gdb_block_iter.real_block = new_block;
|
|
|
|
block_idx++;
|
|
}
|
|
|
|
/* Now add the special blocks. */
|
|
struct block *block_iter = NULL;
|
|
for (enum block_enum i : { GLOBAL_BLOCK, STATIC_BLOCK })
|
|
{
|
|
struct block *new_block;
|
|
|
|
new_block = (i == GLOBAL_BLOCK
|
|
? allocate_global_block (&objfile->objfile_obstack)
|
|
: allocate_block (&objfile->objfile_obstack));
|
|
BLOCK_MULTIDICT (new_block)
|
|
= mdict_create_linear (&objfile->objfile_obstack, NULL);
|
|
BLOCK_SUPERBLOCK (new_block) = block_iter;
|
|
block_iter = new_block;
|
|
|
|
BLOCK_START (new_block) = (CORE_ADDR) begin;
|
|
BLOCK_END (new_block) = (CORE_ADDR) end;
|
|
|
|
BLOCKVECTOR_BLOCK (bv, i) = new_block;
|
|
|
|
if (i == GLOBAL_BLOCK)
|
|
set_block_compunit_symtab (new_block, cust);
|
|
}
|
|
|
|
/* Fill up the superblock fields for the real blocks, using the
|
|
real_block fields populated earlier. */
|
|
for (gdb_block &gdb_block_iter : stab->blocks)
|
|
{
|
|
if (gdb_block_iter.parent != NULL)
|
|
{
|
|
/* If the plugin specifically mentioned a parent block, we
|
|
use that. */
|
|
BLOCK_SUPERBLOCK (gdb_block_iter.real_block) =
|
|
gdb_block_iter.parent->real_block;
|
|
}
|
|
else
|
|
{
|
|
/* And if not, we set a default parent block. */
|
|
BLOCK_SUPERBLOCK (gdb_block_iter.real_block) =
|
|
BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Called when closing a gdb_objfile. Converts OBJ to a proper
|
|
objfile. */
|
|
|
|
static void
|
|
jit_object_close_impl (struct gdb_symbol_callbacks *cb,
|
|
struct gdb_object *obj)
|
|
{
|
|
struct objfile *objfile;
|
|
jit_dbg_reader_data *priv_data;
|
|
|
|
priv_data = (jit_dbg_reader_data *) cb->priv_data;
|
|
|
|
objfile = objfile::make (nullptr, "<< JIT compiled code >>",
|
|
OBJF_NOT_FILENAME);
|
|
objfile->per_bfd->gdbarch = target_gdbarch ();
|
|
|
|
for (gdb_symtab &symtab : obj->symtabs)
|
|
finalize_symtab (&symtab, objfile);
|
|
|
|
add_objfile_entry (objfile, *priv_data);
|
|
|
|
delete obj;
|
|
}
|
|
|
|
/* Try to read CODE_ENTRY using the loaded jit reader (if any).
|
|
ENTRY_ADDR is the address of the struct jit_code_entry in the
|
|
inferior address space. */
|
|
|
|
static int
|
|
jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
|
|
CORE_ADDR entry_addr)
|
|
{
|
|
int status;
|
|
jit_dbg_reader_data priv_data;
|
|
struct gdb_reader_funcs *funcs;
|
|
struct gdb_symbol_callbacks callbacks =
|
|
{
|
|
jit_object_open_impl,
|
|
jit_symtab_open_impl,
|
|
jit_block_open_impl,
|
|
jit_symtab_close_impl,
|
|
jit_object_close_impl,
|
|
|
|
jit_symtab_line_mapping_add_impl,
|
|
jit_target_read_impl,
|
|
|
|
&priv_data
|
|
};
|
|
|
|
priv_data = entry_addr;
|
|
|
|
if (!loaded_jit_reader)
|
|
return 0;
|
|
|
|
gdb::byte_vector gdb_mem (code_entry->symfile_size);
|
|
|
|
status = 1;
|
|
try
|
|
{
|
|
if (target_read_memory (code_entry->symfile_addr, gdb_mem.data (),
|
|
code_entry->symfile_size))
|
|
status = 0;
|
|
}
|
|
catch (const gdb_exception &e)
|
|
{
|
|
status = 0;
|
|
}
|
|
|
|
if (status)
|
|
{
|
|
funcs = loaded_jit_reader->functions;
|
|
if (funcs->read (funcs, &callbacks, gdb_mem.data (),
|
|
code_entry->symfile_size)
|
|
!= GDB_SUCCESS)
|
|
status = 0;
|
|
}
|
|
|
|
if (jit_debug && status == 0)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
"Could not read symtab using the loaded JIT reader.\n");
|
|
return status;
|
|
}
|
|
|
|
/* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
|
|
struct jit_code_entry in the inferior address space. */
|
|
|
|
static void
|
|
jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
|
|
CORE_ADDR entry_addr,
|
|
struct gdbarch *gdbarch)
|
|
{
|
|
struct bfd_section *sec;
|
|
struct objfile *objfile;
|
|
const struct bfd_arch_info *b;
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
"jit_bfd_try_read_symtab, symfile_addr = %s, "
|
|
"symfile_size = %s\n",
|
|
paddress (gdbarch, code_entry->symfile_addr),
|
|
pulongest (code_entry->symfile_size));
|
|
|
|
gdb_bfd_ref_ptr nbfd (bfd_open_from_target_memory (code_entry->symfile_addr,
|
|
code_entry->symfile_size,
|
|
gnutarget));
|
|
if (nbfd == NULL)
|
|
{
|
|
puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
|
|
return;
|
|
}
|
|
|
|
/* Check the format. NOTE: This initializes important data that GDB uses!
|
|
We would segfault later without this line. */
|
|
if (!bfd_check_format (nbfd.get (), bfd_object))
|
|
{
|
|
printf_unfiltered (_("\
|
|
JITed symbol file is not an object file, ignoring it.\n"));
|
|
return;
|
|
}
|
|
|
|
/* Check bfd arch. */
|
|
b = gdbarch_bfd_arch_info (gdbarch);
|
|
if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
|
|
warning (_("JITed object file architecture %s is not compatible "
|
|
"with target architecture %s."),
|
|
bfd_get_arch_info (nbfd.get ())->printable_name,
|
|
b->printable_name);
|
|
|
|
/* Read the section address information out of the symbol file. Since the
|
|
file is generated by the JIT at runtime, it should all of the absolute
|
|
addresses that we care about. */
|
|
section_addr_info sai;
|
|
for (sec = nbfd->sections; sec != NULL; sec = sec->next)
|
|
if ((bfd_section_flags (sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
|
|
{
|
|
/* We assume that these virtual addresses are absolute, and do not
|
|
treat them as offsets. */
|
|
sai.emplace_back (bfd_section_vma (sec),
|
|
bfd_section_name (sec),
|
|
sec->index);
|
|
}
|
|
|
|
/* This call does not take ownership of SAI. */
|
|
objfile = symbol_file_add_from_bfd (nbfd.get (),
|
|
bfd_get_filename (nbfd.get ()), 0,
|
|
&sai,
|
|
OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
|
|
|
|
add_objfile_entry (objfile, entry_addr);
|
|
}
|
|
|
|
/* This function registers code associated with a JIT code entry. It uses the
|
|
pointer and size pair in the entry to read the symbol file from the remote
|
|
and then calls symbol_file_add_from_local_memory to add it as though it were
|
|
a symbol file added by the user. */
|
|
|
|
static void
|
|
jit_register_code (struct gdbarch *gdbarch,
|
|
CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
|
|
{
|
|
int success;
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
"jit_register_code, symfile_addr = %s, "
|
|
"symfile_size = %s\n",
|
|
paddress (gdbarch, code_entry->symfile_addr),
|
|
pulongest (code_entry->symfile_size));
|
|
|
|
success = jit_reader_try_read_symtab (code_entry, entry_addr);
|
|
|
|
if (!success)
|
|
jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
|
|
}
|
|
|
|
/* Look up the objfile with this code entry address. */
|
|
|
|
static struct objfile *
|
|
jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
|
|
{
|
|
for (objfile *objf : current_program_space->objfiles ())
|
|
{
|
|
struct jit_objfile_data *objf_data;
|
|
|
|
objf_data
|
|
= (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
|
|
if (objf_data != NULL && objf_data->addr == entry_addr)
|
|
return objf;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* This is called when a breakpoint is deleted. It updates the
|
|
inferior's cache, if needed. */
|
|
|
|
static void
|
|
jit_breakpoint_deleted (struct breakpoint *b)
|
|
{
|
|
struct bp_location *iter;
|
|
|
|
if (b->type != bp_jit_event)
|
|
return;
|
|
|
|
for (iter = b->loc; iter != NULL; iter = iter->next)
|
|
{
|
|
struct jit_program_space_data *ps_data;
|
|
|
|
ps_data = jit_program_space_key.get (iter->pspace);
|
|
if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
|
|
{
|
|
ps_data->cached_code_address = 0;
|
|
ps_data->jit_breakpoint = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* (Re-)Initialize the jit breakpoint if necessary.
|
|
Return 0 if the jit breakpoint has been successfully initialized. */
|
|
|
|
static int
|
|
jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
|
|
struct jit_program_space_data *ps_data)
|
|
{
|
|
struct bound_minimal_symbol reg_symbol;
|
|
struct bound_minimal_symbol desc_symbol;
|
|
struct jit_objfile_data *objf_data;
|
|
CORE_ADDR addr;
|
|
|
|
if (ps_data->objfile == NULL)
|
|
{
|
|
/* Lookup the registration symbol. If it is missing, then we
|
|
assume we are not attached to a JIT. */
|
|
reg_symbol = lookup_bound_minimal_symbol (jit_break_name);
|
|
if (reg_symbol.minsym == NULL
|
|
|| BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
|
|
return 1;
|
|
|
|
desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
|
|
reg_symbol.objfile);
|
|
if (desc_symbol.minsym == NULL
|
|
|| BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
|
|
return 1;
|
|
|
|
objf_data = get_jit_objfile_data (reg_symbol.objfile);
|
|
objf_data->register_code = reg_symbol.minsym;
|
|
objf_data->descriptor = desc_symbol.minsym;
|
|
|
|
ps_data->objfile = reg_symbol.objfile;
|
|
}
|
|
else
|
|
objf_data = get_jit_objfile_data (ps_data->objfile);
|
|
|
|
addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
"jit_breakpoint_re_set_internal, "
|
|
"breakpoint_addr = %s\n",
|
|
paddress (gdbarch, addr));
|
|
|
|
if (ps_data->cached_code_address == addr)
|
|
return 0;
|
|
|
|
/* Delete the old breakpoint. */
|
|
if (ps_data->jit_breakpoint != NULL)
|
|
delete_breakpoint (ps_data->jit_breakpoint);
|
|
|
|
/* Put a breakpoint in the registration symbol. */
|
|
ps_data->cached_code_address = addr;
|
|
ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* The private data passed around in the frame unwind callback
|
|
functions. */
|
|
|
|
struct jit_unwind_private
|
|
{
|
|
/* Cached register values. See jit_frame_sniffer to see how this
|
|
works. */
|
|
detached_regcache *regcache;
|
|
|
|
/* The frame being unwound. */
|
|
struct frame_info *this_frame;
|
|
};
|
|
|
|
/* Sets the value of a particular register in this frame. */
|
|
|
|
static void
|
|
jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
|
|
struct gdb_reg_value *value)
|
|
{
|
|
struct jit_unwind_private *priv;
|
|
int gdb_reg;
|
|
|
|
priv = (struct jit_unwind_private *) cb->priv_data;
|
|
|
|
gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
|
|
dwarf_regnum);
|
|
if (gdb_reg == -1)
|
|
{
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog,
|
|
_("Could not recognize DWARF regnum %d"),
|
|
dwarf_regnum);
|
|
value->free (value);
|
|
return;
|
|
}
|
|
|
|
priv->regcache->raw_supply (gdb_reg, value->value);
|
|
value->free (value);
|
|
}
|
|
|
|
static void
|
|
reg_value_free_impl (struct gdb_reg_value *value)
|
|
{
|
|
xfree (value);
|
|
}
|
|
|
|
/* Get the value of register REGNUM in the previous frame. */
|
|
|
|
static struct gdb_reg_value *
|
|
jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
|
|
{
|
|
struct jit_unwind_private *priv;
|
|
struct gdb_reg_value *value;
|
|
int gdb_reg, size;
|
|
struct gdbarch *frame_arch;
|
|
|
|
priv = (struct jit_unwind_private *) cb->priv_data;
|
|
frame_arch = get_frame_arch (priv->this_frame);
|
|
|
|
gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
|
|
size = register_size (frame_arch, gdb_reg);
|
|
value = ((struct gdb_reg_value *)
|
|
xmalloc (sizeof (struct gdb_reg_value) + size - 1));
|
|
value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
|
|
value->value);
|
|
value->size = size;
|
|
value->free = reg_value_free_impl;
|
|
return value;
|
|
}
|
|
|
|
/* gdb_reg_value has a free function, which must be called on each
|
|
saved register value. */
|
|
|
|
static void
|
|
jit_dealloc_cache (struct frame_info *this_frame, void *cache)
|
|
{
|
|
struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
|
|
|
|
gdb_assert (priv_data->regcache != NULL);
|
|
delete priv_data->regcache;
|
|
xfree (priv_data);
|
|
}
|
|
|
|
/* The frame sniffer for the pseudo unwinder.
|
|
|
|
While this is nominally a frame sniffer, in the case where the JIT
|
|
reader actually recognizes the frame, it does a lot more work -- it
|
|
unwinds the frame and saves the corresponding register values in
|
|
the cache. jit_frame_prev_register simply returns the saved
|
|
register values. */
|
|
|
|
static int
|
|
jit_frame_sniffer (const struct frame_unwind *self,
|
|
struct frame_info *this_frame, void **cache)
|
|
{
|
|
struct jit_unwind_private *priv_data;
|
|
struct gdb_unwind_callbacks callbacks;
|
|
struct gdb_reader_funcs *funcs;
|
|
|
|
callbacks.reg_get = jit_unwind_reg_get_impl;
|
|
callbacks.reg_set = jit_unwind_reg_set_impl;
|
|
callbacks.target_read = jit_target_read_impl;
|
|
|
|
if (loaded_jit_reader == NULL)
|
|
return 0;
|
|
|
|
funcs = loaded_jit_reader->functions;
|
|
|
|
gdb_assert (!*cache);
|
|
|
|
*cache = XCNEW (struct jit_unwind_private);
|
|
priv_data = (struct jit_unwind_private *) *cache;
|
|
/* Take a snapshot of current regcache. */
|
|
priv_data->regcache = new detached_regcache (get_frame_arch (this_frame),
|
|
true);
|
|
priv_data->this_frame = this_frame;
|
|
|
|
callbacks.priv_data = priv_data;
|
|
|
|
/* Try to coax the provided unwinder to unwind the stack */
|
|
if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
|
|
{
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
|
|
"JIT reader.\n"));
|
|
return 1;
|
|
}
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
|
|
"JIT reader.\n"));
|
|
|
|
jit_dealloc_cache (this_frame, *cache);
|
|
*cache = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* The frame_id function for the pseudo unwinder. Relays the call to
|
|
the loaded plugin. */
|
|
|
|
static void
|
|
jit_frame_this_id (struct frame_info *this_frame, void **cache,
|
|
struct frame_id *this_id)
|
|
{
|
|
struct jit_unwind_private priv;
|
|
struct gdb_frame_id frame_id;
|
|
struct gdb_reader_funcs *funcs;
|
|
struct gdb_unwind_callbacks callbacks;
|
|
|
|
priv.regcache = NULL;
|
|
priv.this_frame = this_frame;
|
|
|
|
/* We don't expect the frame_id function to set any registers, so we
|
|
set reg_set to NULL. */
|
|
callbacks.reg_get = jit_unwind_reg_get_impl;
|
|
callbacks.reg_set = NULL;
|
|
callbacks.target_read = jit_target_read_impl;
|
|
callbacks.priv_data = &priv;
|
|
|
|
gdb_assert (loaded_jit_reader);
|
|
funcs = loaded_jit_reader->functions;
|
|
|
|
frame_id = funcs->get_frame_id (funcs, &callbacks);
|
|
*this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
|
|
}
|
|
|
|
/* Pseudo unwinder function. Reads the previously fetched value for
|
|
the register from the cache. */
|
|
|
|
static struct value *
|
|
jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
|
|
{
|
|
struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
|
|
struct gdbarch *gdbarch;
|
|
|
|
if (priv == NULL)
|
|
return frame_unwind_got_optimized (this_frame, reg);
|
|
|
|
gdbarch = priv->regcache->arch ();
|
|
gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
|
|
enum register_status status = priv->regcache->cooked_read (reg, buf);
|
|
|
|
if (status == REG_VALID)
|
|
return frame_unwind_got_bytes (this_frame, reg, buf);
|
|
else
|
|
return frame_unwind_got_optimized (this_frame, reg);
|
|
}
|
|
|
|
/* Relay everything back to the unwinder registered by the JIT debug
|
|
info reader.*/
|
|
|
|
static const struct frame_unwind jit_frame_unwind =
|
|
{
|
|
NORMAL_FRAME,
|
|
default_frame_unwind_stop_reason,
|
|
jit_frame_this_id,
|
|
jit_frame_prev_register,
|
|
NULL,
|
|
jit_frame_sniffer,
|
|
jit_dealloc_cache
|
|
};
|
|
|
|
|
|
/* This is the information that is stored at jit_gdbarch_data for each
|
|
architecture. */
|
|
|
|
struct jit_gdbarch_data_type
|
|
{
|
|
/* Has the (pseudo) unwinder been prepended? */
|
|
int unwinder_registered;
|
|
};
|
|
|
|
/* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
|
|
|
|
static void
|
|
jit_prepend_unwinder (struct gdbarch *gdbarch)
|
|
{
|
|
struct jit_gdbarch_data_type *data;
|
|
|
|
data
|
|
= (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
|
|
if (!data->unwinder_registered)
|
|
{
|
|
frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
|
|
data->unwinder_registered = 1;
|
|
}
|
|
}
|
|
|
|
/* Register any already created translations. */
|
|
|
|
static void
|
|
jit_inferior_init (struct gdbarch *gdbarch)
|
|
{
|
|
struct jit_descriptor descriptor;
|
|
struct jit_code_entry cur_entry;
|
|
struct jit_program_space_data *ps_data;
|
|
CORE_ADDR cur_entry_addr;
|
|
|
|
if (jit_debug)
|
|
fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
|
|
|
|
jit_prepend_unwinder (gdbarch);
|
|
|
|
ps_data = get_jit_program_space_data ();
|
|
if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
|
|
return;
|
|
|
|
/* Read the descriptor so we can check the version number and load
|
|
any already JITed functions. */
|
|
if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
|
|
return;
|
|
|
|
/* Check that the version number agrees with that we support. */
|
|
if (descriptor.version != 1)
|
|
{
|
|
printf_unfiltered (_("Unsupported JIT protocol version %ld "
|
|
"in descriptor (expected 1)\n"),
|
|
(long) descriptor.version);
|
|
return;
|
|
}
|
|
|
|
/* If we've attached to a running program, we need to check the descriptor
|
|
to register any functions that were already generated. */
|
|
for (cur_entry_addr = descriptor.first_entry;
|
|
cur_entry_addr != 0;
|
|
cur_entry_addr = cur_entry.next_entry)
|
|
{
|
|
jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
|
|
|
|
/* This hook may be called many times during setup, so make sure we don't
|
|
add the same symbol file twice. */
|
|
if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
|
|
continue;
|
|
|
|
jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
|
|
}
|
|
}
|
|
|
|
/* inferior_created observer. */
|
|
|
|
static void
|
|
jit_inferior_created (struct target_ops *ops, int from_tty)
|
|
{
|
|
jit_inferior_created_hook ();
|
|
}
|
|
|
|
/* Exported routine to call when an inferior has been created. */
|
|
|
|
void
|
|
jit_inferior_created_hook (void)
|
|
{
|
|
jit_inferior_init (target_gdbarch ());
|
|
}
|
|
|
|
/* Exported routine to call to re-set the jit breakpoints,
|
|
e.g. when a program is rerun. */
|
|
|
|
void
|
|
jit_breakpoint_re_set (void)
|
|
{
|
|
jit_breakpoint_re_set_internal (target_gdbarch (),
|
|
get_jit_program_space_data ());
|
|
}
|
|
|
|
/* This function cleans up any code entries left over when the
|
|
inferior exits. We get left over code when the inferior exits
|
|
without unregistering its code, for example when it crashes. */
|
|
|
|
static void
|
|
jit_inferior_exit_hook (struct inferior *inf)
|
|
{
|
|
for (objfile *objf : current_program_space->objfiles_safe ())
|
|
{
|
|
struct jit_objfile_data *objf_data
|
|
= (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
|
|
|
|
if (objf_data != NULL && objf_data->addr != 0)
|
|
objf->unlink ();
|
|
}
|
|
}
|
|
|
|
void
|
|
jit_event_handler (struct gdbarch *gdbarch)
|
|
{
|
|
struct jit_descriptor descriptor;
|
|
struct jit_code_entry code_entry;
|
|
CORE_ADDR entry_addr;
|
|
struct objfile *objf;
|
|
|
|
/* Read the descriptor from remote memory. */
|
|
if (!jit_read_descriptor (gdbarch, &descriptor,
|
|
get_jit_program_space_data ()))
|
|
return;
|
|
entry_addr = descriptor.relevant_entry;
|
|
|
|
/* Do the corresponding action. */
|
|
switch (descriptor.action_flag)
|
|
{
|
|
case JIT_NOACTION:
|
|
break;
|
|
case JIT_REGISTER:
|
|
jit_read_code_entry (gdbarch, entry_addr, &code_entry);
|
|
jit_register_code (gdbarch, entry_addr, &code_entry);
|
|
break;
|
|
case JIT_UNREGISTER:
|
|
objf = jit_find_objf_with_entry_addr (entry_addr);
|
|
if (objf == NULL)
|
|
printf_unfiltered (_("Unable to find JITed code "
|
|
"entry at address: %s\n"),
|
|
paddress (gdbarch, entry_addr));
|
|
else
|
|
objf->unlink ();
|
|
|
|
break;
|
|
default:
|
|
error (_("Unknown action_flag value in JIT descriptor!"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Called to free the data allocated to the jit_program_space_data slot. */
|
|
|
|
static void
|
|
free_objfile_data (struct objfile *objfile, void *data)
|
|
{
|
|
struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
|
|
|
|
if (objf_data->register_code != NULL)
|
|
{
|
|
struct jit_program_space_data *ps_data;
|
|
|
|
ps_data = jit_program_space_key.get (objfile->pspace);
|
|
if (ps_data != NULL && ps_data->objfile == objfile)
|
|
{
|
|
ps_data->objfile = NULL;
|
|
if (ps_data->jit_breakpoint != NULL)
|
|
delete_breakpoint (ps_data->jit_breakpoint);
|
|
ps_data->cached_code_address = 0;
|
|
}
|
|
}
|
|
|
|
xfree (data);
|
|
}
|
|
|
|
/* Initialize the jit_gdbarch_data slot with an instance of struct
|
|
jit_gdbarch_data_type */
|
|
|
|
static void *
|
|
jit_gdbarch_data_init (struct obstack *obstack)
|
|
{
|
|
struct jit_gdbarch_data_type *data =
|
|
XOBNEW (obstack, struct jit_gdbarch_data_type);
|
|
|
|
data->unwinder_registered = 0;
|
|
|
|
return data;
|
|
}
|
|
|
|
void _initialize_jit ();
|
|
void
|
|
_initialize_jit ()
|
|
{
|
|
jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
|
|
JIT_READER_DIR_RELOCATABLE);
|
|
add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
|
|
_("Set JIT debugging."),
|
|
_("Show JIT debugging."),
|
|
_("When non-zero, JIT debugging is enabled."),
|
|
NULL,
|
|
show_jit_debug,
|
|
&setdebuglist, &showdebuglist);
|
|
|
|
gdb::observers::inferior_created.attach (jit_inferior_created);
|
|
gdb::observers::inferior_exit.attach (jit_inferior_exit_hook);
|
|
gdb::observers::breakpoint_deleted.attach (jit_breakpoint_deleted);
|
|
|
|
jit_objfile_data =
|
|
register_objfile_data_with_cleanup (NULL, free_objfile_data);
|
|
jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
|
|
if (is_dl_available ())
|
|
{
|
|
struct cmd_list_element *c;
|
|
|
|
c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
|
|
Load FILE as debug info reader and unwinder for JIT compiled code.\n\
|
|
Usage: jit-reader-load FILE\n\
|
|
Try to load file FILE as a debug info reader (and unwinder) for\n\
|
|
JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
|
|
relocated relative to the GDB executable if required."));
|
|
set_cmd_completer (c, filename_completer);
|
|
|
|
c = add_com ("jit-reader-unload", no_class,
|
|
jit_reader_unload_command, _("\
|
|
Unload the currently loaded JIT debug info reader.\n\
|
|
Usage: jit-reader-unload\n\n\
|
|
Do \"help jit-reader-load\" for info on loading debug info readers."));
|
|
set_cmd_completer (c, noop_completer);
|
|
}
|
|
}
|