mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
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
1187 lines
36 KiB
C
1187 lines
36 KiB
C
/* OpenCL language support for GDB, the GNU debugger.
|
|
Copyright (C) 2010-2020 Free Software Foundation, Inc.
|
|
|
|
Contributed by Ken Werner <ken.werner@de.ibm.com>.
|
|
|
|
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 "gdbtypes.h"
|
|
#include "symtab.h"
|
|
#include "expression.h"
|
|
#include "parser-defs.h"
|
|
#include "language.h"
|
|
#include "varobj.h"
|
|
#include "c-lang.h"
|
|
#include "gdbarch.h"
|
|
|
|
/* This macro generates enum values from a given type. */
|
|
|
|
#define OCL_P_TYPE(TYPE)\
|
|
opencl_primitive_type_##TYPE,\
|
|
opencl_primitive_type_##TYPE##2,\
|
|
opencl_primitive_type_##TYPE##3,\
|
|
opencl_primitive_type_##TYPE##4,\
|
|
opencl_primitive_type_##TYPE##8,\
|
|
opencl_primitive_type_##TYPE##16
|
|
|
|
enum opencl_primitive_types {
|
|
OCL_P_TYPE (char),
|
|
OCL_P_TYPE (uchar),
|
|
OCL_P_TYPE (short),
|
|
OCL_P_TYPE (ushort),
|
|
OCL_P_TYPE (int),
|
|
OCL_P_TYPE (uint),
|
|
OCL_P_TYPE (long),
|
|
OCL_P_TYPE (ulong),
|
|
OCL_P_TYPE (half),
|
|
OCL_P_TYPE (float),
|
|
OCL_P_TYPE (double),
|
|
opencl_primitive_type_bool,
|
|
opencl_primitive_type_unsigned_char,
|
|
opencl_primitive_type_unsigned_short,
|
|
opencl_primitive_type_unsigned_int,
|
|
opencl_primitive_type_unsigned_long,
|
|
opencl_primitive_type_size_t,
|
|
opencl_primitive_type_ptrdiff_t,
|
|
opencl_primitive_type_intptr_t,
|
|
opencl_primitive_type_uintptr_t,
|
|
opencl_primitive_type_void,
|
|
nr_opencl_primitive_types
|
|
};
|
|
|
|
static struct gdbarch_data *opencl_type_data;
|
|
|
|
static struct type **
|
|
builtin_opencl_type (struct gdbarch *gdbarch)
|
|
{
|
|
return (struct type **) gdbarch_data (gdbarch, opencl_type_data);
|
|
}
|
|
|
|
/* Returns the corresponding OpenCL vector type from the given type code,
|
|
the length of the element type, the unsigned flag and the amount of
|
|
elements (N). */
|
|
|
|
static struct type *
|
|
lookup_opencl_vector_type (struct gdbarch *gdbarch, enum type_code code,
|
|
unsigned int el_length, unsigned int flag_unsigned,
|
|
int n)
|
|
{
|
|
int i;
|
|
unsigned int length;
|
|
struct type *type = NULL;
|
|
struct type **types = builtin_opencl_type (gdbarch);
|
|
|
|
/* Check if n describes a valid OpenCL vector size (2, 3, 4, 8, 16). */
|
|
if (n != 2 && n != 3 && n != 4 && n != 8 && n != 16)
|
|
error (_("Invalid OpenCL vector size: %d"), n);
|
|
|
|
/* Triple vectors have the size of a quad vector. */
|
|
length = (n == 3) ? el_length * 4 : el_length * n;
|
|
|
|
for (i = 0; i < nr_opencl_primitive_types; i++)
|
|
{
|
|
LONGEST lowb, highb;
|
|
|
|
if (TYPE_CODE (types[i]) == TYPE_CODE_ARRAY && TYPE_VECTOR (types[i])
|
|
&& get_array_bounds (types[i], &lowb, &highb)
|
|
&& TYPE_CODE (TYPE_TARGET_TYPE (types[i])) == code
|
|
&& TYPE_UNSIGNED (TYPE_TARGET_TYPE (types[i])) == flag_unsigned
|
|
&& TYPE_LENGTH (TYPE_TARGET_TYPE (types[i])) == el_length
|
|
&& TYPE_LENGTH (types[i]) == length
|
|
&& highb - lowb + 1 == n)
|
|
{
|
|
type = types[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
/* Returns nonzero if the array ARR contains duplicates within
|
|
the first N elements. */
|
|
|
|
static int
|
|
array_has_dups (int *arr, int n)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
for (j = i + 1; j < n; j++)
|
|
{
|
|
if (arr[i] == arr[j])
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* The OpenCL component access syntax allows to create lvalues referring to
|
|
selected elements of an original OpenCL vector in arbitrary order. This
|
|
structure holds the information to describe such lvalues. */
|
|
|
|
struct lval_closure
|
|
{
|
|
/* Reference count. */
|
|
int refc;
|
|
/* The number of indices. */
|
|
int n;
|
|
/* The element indices themselves. */
|
|
int *indices;
|
|
/* A pointer to the original value. */
|
|
struct value *val;
|
|
};
|
|
|
|
/* Allocates an instance of struct lval_closure. */
|
|
|
|
static struct lval_closure *
|
|
allocate_lval_closure (int *indices, int n, struct value *val)
|
|
{
|
|
struct lval_closure *c = XCNEW (struct lval_closure);
|
|
|
|
c->refc = 1;
|
|
c->n = n;
|
|
c->indices = XCNEWVEC (int, n);
|
|
memcpy (c->indices, indices, n * sizeof (int));
|
|
value_incref (val); /* Increment the reference counter of the value. */
|
|
c->val = val;
|
|
|
|
return c;
|
|
}
|
|
|
|
static void
|
|
lval_func_read (struct value *v)
|
|
{
|
|
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
|
|
struct type *type = check_typedef (value_type (v));
|
|
struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
|
|
LONGEST offset = value_offset (v);
|
|
LONGEST elsize = TYPE_LENGTH (eltype);
|
|
int n, i, j = 0;
|
|
LONGEST lowb = 0;
|
|
LONGEST highb = 0;
|
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_ARRAY
|
|
&& !get_array_bounds (type, &lowb, &highb))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
/* Assume elsize aligned offset. */
|
|
gdb_assert (offset % elsize == 0);
|
|
offset /= elsize;
|
|
n = offset + highb - lowb + 1;
|
|
gdb_assert (n <= c->n);
|
|
|
|
for (i = offset; i < n; i++)
|
|
memcpy (value_contents_raw (v) + j++ * elsize,
|
|
value_contents (c->val) + c->indices[i] * elsize,
|
|
elsize);
|
|
}
|
|
|
|
static void
|
|
lval_func_write (struct value *v, struct value *fromval)
|
|
{
|
|
struct value *mark = value_mark ();
|
|
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
|
|
struct type *type = check_typedef (value_type (v));
|
|
struct type *eltype = TYPE_TARGET_TYPE (check_typedef (value_type (c->val)));
|
|
LONGEST offset = value_offset (v);
|
|
LONGEST elsize = TYPE_LENGTH (eltype);
|
|
int n, i, j = 0;
|
|
LONGEST lowb = 0;
|
|
LONGEST highb = 0;
|
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_ARRAY
|
|
&& !get_array_bounds (type, &lowb, &highb))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
/* Assume elsize aligned offset. */
|
|
gdb_assert (offset % elsize == 0);
|
|
offset /= elsize;
|
|
n = offset + highb - lowb + 1;
|
|
|
|
/* Since accesses to the fourth component of a triple vector is undefined we
|
|
just skip writes to the fourth element. Imagine something like this:
|
|
int3 i3 = (int3)(0, 1, 2);
|
|
i3.hi.hi = 5;
|
|
In this case n would be 4 (offset=12/4 + 1) while c->n would be 3. */
|
|
if (n > c->n)
|
|
n = c->n;
|
|
|
|
for (i = offset; i < n; i++)
|
|
{
|
|
struct value *from_elm_val = allocate_value (eltype);
|
|
struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
|
|
|
|
memcpy (value_contents_writeable (from_elm_val),
|
|
value_contents (fromval) + j++ * elsize,
|
|
elsize);
|
|
value_assign (to_elm_val, from_elm_val);
|
|
}
|
|
|
|
value_free_to_mark (mark);
|
|
}
|
|
|
|
/* Return nonzero if bits in V from OFFSET and LENGTH represent a
|
|
synthetic pointer. */
|
|
|
|
static int
|
|
lval_func_check_synthetic_pointer (const struct value *v,
|
|
LONGEST offset, int length)
|
|
{
|
|
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
|
|
/* Size of the target type in bits. */
|
|
int elsize =
|
|
TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
|
|
int startrest = offset % elsize;
|
|
int start = offset / elsize;
|
|
int endrest = (offset + length) % elsize;
|
|
int end = (offset + length) / elsize;
|
|
int i;
|
|
|
|
if (endrest)
|
|
end++;
|
|
|
|
if (end > c->n)
|
|
return 0;
|
|
|
|
for (i = start; i < end; i++)
|
|
{
|
|
int comp_offset = (i == start) ? startrest : 0;
|
|
int comp_length = (i == end) ? endrest : elsize;
|
|
|
|
if (!value_bits_synthetic_pointer (c->val,
|
|
c->indices[i] * elsize + comp_offset,
|
|
comp_length))
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void *
|
|
lval_func_copy_closure (const struct value *v)
|
|
{
|
|
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
|
|
|
|
++c->refc;
|
|
|
|
return c;
|
|
}
|
|
|
|
static void
|
|
lval_func_free_closure (struct value *v)
|
|
{
|
|
struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
|
|
|
|
--c->refc;
|
|
|
|
if (c->refc == 0)
|
|
{
|
|
value_decref (c->val); /* Decrement the reference counter of the value. */
|
|
xfree (c->indices);
|
|
xfree (c);
|
|
}
|
|
}
|
|
|
|
static const struct lval_funcs opencl_value_funcs =
|
|
{
|
|
lval_func_read,
|
|
lval_func_write,
|
|
NULL, /* indirect */
|
|
NULL, /* coerce_ref */
|
|
lval_func_check_synthetic_pointer,
|
|
lval_func_copy_closure,
|
|
lval_func_free_closure
|
|
};
|
|
|
|
/* Creates a sub-vector from VAL. The elements are selected by the indices of
|
|
an array with the length of N. Supported values for NOSIDE are
|
|
EVAL_NORMAL and EVAL_AVOID_SIDE_EFFECTS. */
|
|
|
|
static struct value *
|
|
create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
|
|
int *indices, int n)
|
|
{
|
|
struct type *type = check_typedef (value_type (val));
|
|
struct type *elm_type = TYPE_TARGET_TYPE (type);
|
|
struct value *ret;
|
|
|
|
/* Check if a single component of a vector is requested which means
|
|
the resulting type is a (primitive) scalar type. */
|
|
if (n == 1)
|
|
{
|
|
if (noside == EVAL_AVOID_SIDE_EFFECTS)
|
|
ret = value_zero (elm_type, not_lval);
|
|
else
|
|
ret = value_subscript (val, indices[0]);
|
|
}
|
|
else
|
|
{
|
|
/* Multiple components of the vector are requested which means the
|
|
resulting type is a vector as well. */
|
|
struct type *dst_type =
|
|
lookup_opencl_vector_type (gdbarch, TYPE_CODE (elm_type),
|
|
TYPE_LENGTH (elm_type),
|
|
TYPE_UNSIGNED (elm_type), n);
|
|
|
|
if (dst_type == NULL)
|
|
dst_type = init_vector_type (elm_type, n);
|
|
|
|
make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type), dst_type, NULL);
|
|
|
|
if (noside == EVAL_AVOID_SIDE_EFFECTS)
|
|
ret = allocate_value (dst_type);
|
|
else
|
|
{
|
|
/* Check whether to create a lvalue or not. */
|
|
if (VALUE_LVAL (val) != not_lval && !array_has_dups (indices, n))
|
|
{
|
|
struct lval_closure *c = allocate_lval_closure (indices, n, val);
|
|
ret = allocate_computed_value (dst_type, &opencl_value_funcs, c);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
ret = allocate_value (dst_type);
|
|
|
|
/* Copy src val contents into the destination value. */
|
|
for (i = 0; i < n; i++)
|
|
memcpy (value_contents_writeable (ret)
|
|
+ (i * TYPE_LENGTH (elm_type)),
|
|
value_contents (val)
|
|
+ (indices[i] * TYPE_LENGTH (elm_type)),
|
|
TYPE_LENGTH (elm_type));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* OpenCL vector component access. */
|
|
|
|
static struct value *
|
|
opencl_component_ref (struct expression *exp, struct value *val, char *comps,
|
|
enum noside noside)
|
|
{
|
|
LONGEST lowb, highb;
|
|
int src_len;
|
|
struct value *v;
|
|
int indices[16], i;
|
|
int dst_len;
|
|
|
|
if (!get_array_bounds (check_typedef (value_type (val)), &lowb, &highb))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
src_len = highb - lowb + 1;
|
|
|
|
/* Throw an error if the amount of array elements does not fit a
|
|
valid OpenCL vector size (2, 3, 4, 8, 16). */
|
|
if (src_len != 2 && src_len != 3 && src_len != 4 && src_len != 8
|
|
&& src_len != 16)
|
|
error (_("Invalid OpenCL vector size"));
|
|
|
|
if (strcmp (comps, "lo") == 0 )
|
|
{
|
|
dst_len = (src_len == 3) ? 2 : src_len / 2;
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
indices[i] = i;
|
|
}
|
|
else if (strcmp (comps, "hi") == 0)
|
|
{
|
|
dst_len = (src_len == 3) ? 2 : src_len / 2;
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
indices[i] = dst_len + i;
|
|
}
|
|
else if (strcmp (comps, "even") == 0)
|
|
{
|
|
dst_len = (src_len == 3) ? 2 : src_len / 2;
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
indices[i] = i*2;
|
|
}
|
|
else if (strcmp (comps, "odd") == 0)
|
|
{
|
|
dst_len = (src_len == 3) ? 2 : src_len / 2;
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
indices[i] = i*2+1;
|
|
}
|
|
else if (strncasecmp (comps, "s", 1) == 0)
|
|
{
|
|
#define HEXCHAR_TO_INT(C) ((C >= '0' && C <= '9') ? \
|
|
C-'0' : ((C >= 'A' && C <= 'F') ? \
|
|
C-'A'+10 : ((C >= 'a' && C <= 'f') ? \
|
|
C-'a'+10 : -1)))
|
|
|
|
dst_len = strlen (comps);
|
|
/* Skip the s/S-prefix. */
|
|
dst_len--;
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
{
|
|
indices[i] = HEXCHAR_TO_INT(comps[i+1]);
|
|
/* Check if the requested component is invalid or exceeds
|
|
the vector. */
|
|
if (indices[i] < 0 || indices[i] >= src_len)
|
|
error (_("Invalid OpenCL vector component accessor %s"), comps);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dst_len = strlen (comps);
|
|
|
|
for (i = 0; i < dst_len; i++)
|
|
{
|
|
/* x, y, z, w */
|
|
switch (comps[i])
|
|
{
|
|
case 'x':
|
|
indices[i] = 0;
|
|
break;
|
|
case 'y':
|
|
indices[i] = 1;
|
|
break;
|
|
case 'z':
|
|
if (src_len < 3)
|
|
error (_("Invalid OpenCL vector component accessor %s"), comps);
|
|
indices[i] = 2;
|
|
break;
|
|
case 'w':
|
|
if (src_len < 4)
|
|
error (_("Invalid OpenCL vector component accessor %s"), comps);
|
|
indices[i] = 3;
|
|
break;
|
|
default:
|
|
error (_("Invalid OpenCL vector component accessor %s"), comps);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Throw an error if the amount of requested components does not
|
|
result in a valid length (1, 2, 3, 4, 8, 16). */
|
|
if (dst_len != 1 && dst_len != 2 && dst_len != 3 && dst_len != 4
|
|
&& dst_len != 8 && dst_len != 16)
|
|
error (_("Invalid OpenCL vector component accessor %s"), comps);
|
|
|
|
v = create_value (exp->gdbarch, val, noside, indices, dst_len);
|
|
|
|
return v;
|
|
}
|
|
|
|
/* Perform the unary logical not (!) operation. */
|
|
|
|
static struct value *
|
|
opencl_logical_not (struct expression *exp, struct value *arg)
|
|
{
|
|
struct type *type = check_typedef (value_type (arg));
|
|
struct type *rettype;
|
|
struct value *ret;
|
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type))
|
|
{
|
|
struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type));
|
|
LONGEST lowb, highb;
|
|
int i;
|
|
|
|
if (!get_array_bounds (type, &lowb, &highb))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
/* Determine the resulting type of the operation and allocate the
|
|
value. */
|
|
rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
|
|
TYPE_LENGTH (eltype), 0,
|
|
highb - lowb + 1);
|
|
ret = allocate_value (rettype);
|
|
|
|
for (i = 0; i < highb - lowb + 1; i++)
|
|
{
|
|
/* For vector types, the unary operator shall return a 0 if the
|
|
value of its operand compares unequal to 0, and -1 (i.e. all bits
|
|
set) if the value of its operand compares equal to 0. */
|
|
int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
|
|
memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype),
|
|
tmp, TYPE_LENGTH (eltype));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rettype = language_bool_type (exp->language_defn, exp->gdbarch);
|
|
ret = value_from_longest (rettype, value_logical_not (arg));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Perform a relational operation on two scalar operands. */
|
|
|
|
static int
|
|
scalar_relop (struct value *val1, struct value *val2, enum exp_opcode op)
|
|
{
|
|
int ret;
|
|
|
|
switch (op)
|
|
{
|
|
case BINOP_EQUAL:
|
|
ret = value_equal (val1, val2);
|
|
break;
|
|
case BINOP_NOTEQUAL:
|
|
ret = !value_equal (val1, val2);
|
|
break;
|
|
case BINOP_LESS:
|
|
ret = value_less (val1, val2);
|
|
break;
|
|
case BINOP_GTR:
|
|
ret = value_less (val2, val1);
|
|
break;
|
|
case BINOP_GEQ:
|
|
ret = value_less (val2, val1) || value_equal (val1, val2);
|
|
break;
|
|
case BINOP_LEQ:
|
|
ret = value_less (val1, val2) || value_equal (val1, val2);
|
|
break;
|
|
case BINOP_LOGICAL_AND:
|
|
ret = !value_logical_not (val1) && !value_logical_not (val2);
|
|
break;
|
|
case BINOP_LOGICAL_OR:
|
|
ret = !value_logical_not (val1) || !value_logical_not (val2);
|
|
break;
|
|
default:
|
|
error (_("Attempt to perform an unsupported operation"));
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Perform a relational operation on two vector operands. */
|
|
|
|
static struct value *
|
|
vector_relop (struct expression *exp, struct value *val1, struct value *val2,
|
|
enum exp_opcode op)
|
|
{
|
|
struct value *ret;
|
|
struct type *type1, *type2, *eltype1, *eltype2, *rettype;
|
|
int t1_is_vec, t2_is_vec, i;
|
|
LONGEST lowb1, lowb2, highb1, highb2;
|
|
|
|
type1 = check_typedef (value_type (val1));
|
|
type2 = check_typedef (value_type (val2));
|
|
|
|
t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1));
|
|
t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2));
|
|
|
|
if (!t1_is_vec || !t2_is_vec)
|
|
error (_("Vector operations are not supported on scalar types"));
|
|
|
|
eltype1 = check_typedef (TYPE_TARGET_TYPE (type1));
|
|
eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
|
|
|
|
if (!get_array_bounds (type1,&lowb1, &highb1)
|
|
|| !get_array_bounds (type2, &lowb2, &highb2))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
/* Check whether the vector types are compatible. */
|
|
if (TYPE_CODE (eltype1) != TYPE_CODE (eltype2)
|
|
|| TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
|
|
|| TYPE_UNSIGNED (eltype1) != TYPE_UNSIGNED (eltype2)
|
|
|| lowb1 != lowb2 || highb1 != highb2)
|
|
error (_("Cannot perform operation on vectors with different types"));
|
|
|
|
/* Determine the resulting type of the operation and allocate the value. */
|
|
rettype = lookup_opencl_vector_type (exp->gdbarch, TYPE_CODE_INT,
|
|
TYPE_LENGTH (eltype1), 0,
|
|
highb1 - lowb1 + 1);
|
|
ret = allocate_value (rettype);
|
|
|
|
for (i = 0; i < highb1 - lowb1 + 1; i++)
|
|
{
|
|
/* For vector types, the relational, equality and logical operators shall
|
|
return 0 if the specified relation is false and -1 (i.e. all bits set)
|
|
if the specified relation is true. */
|
|
int tmp = scalar_relop (value_subscript (val1, i),
|
|
value_subscript (val2, i), op) ? -1 : 0;
|
|
memset (value_contents_writeable (ret) + i * TYPE_LENGTH (eltype1),
|
|
tmp, TYPE_LENGTH (eltype1));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in
|
|
here from valops.c:value_cast, opencl is different only in the
|
|
behaviour of scalar to vector casting. As far as possibly we're going
|
|
to try and delegate back to the standard value_cast function. */
|
|
|
|
static struct value *
|
|
opencl_value_cast (struct type *type, struct value *arg)
|
|
{
|
|
if (type != value_type (arg))
|
|
{
|
|
/* Casting scalar to vector is a special case for OpenCL, scalar
|
|
is cast to element type of vector then replicated into each
|
|
element of the vector. First though, we need to work out if
|
|
this is a scalar to vector cast; code lifted from
|
|
valops.c:value_cast. */
|
|
enum type_code code1, code2;
|
|
struct type *to_type;
|
|
int scalar;
|
|
|
|
to_type = check_typedef (type);
|
|
|
|
code1 = TYPE_CODE (to_type);
|
|
code2 = TYPE_CODE (check_typedef (value_type (arg)));
|
|
|
|
if (code2 == TYPE_CODE_REF)
|
|
code2 = TYPE_CODE (check_typedef (value_type (coerce_ref (arg))));
|
|
|
|
scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL
|
|
|| code2 == TYPE_CODE_CHAR || code2 == TYPE_CODE_FLT
|
|
|| code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
|
|
|| code2 == TYPE_CODE_RANGE);
|
|
|
|
if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (to_type) && scalar)
|
|
{
|
|
struct type *eltype;
|
|
|
|
/* Cast to the element type of the vector here as
|
|
value_vector_widen will error if the scalar value is
|
|
truncated by the cast. To avoid the error, cast (and
|
|
possibly truncate) here. */
|
|
eltype = check_typedef (TYPE_TARGET_TYPE (to_type));
|
|
arg = value_cast (eltype, arg);
|
|
|
|
return value_vector_widen (arg, type);
|
|
}
|
|
else
|
|
/* Standard cast handler. */
|
|
arg = value_cast (type, arg);
|
|
}
|
|
return arg;
|
|
}
|
|
|
|
/* Perform a relational operation on two operands. */
|
|
|
|
static struct value *
|
|
opencl_relop (struct expression *exp, struct value *arg1, struct value *arg2,
|
|
enum exp_opcode op)
|
|
{
|
|
struct value *val;
|
|
struct type *type1 = check_typedef (value_type (arg1));
|
|
struct type *type2 = check_typedef (value_type (arg2));
|
|
int t1_is_vec = (TYPE_CODE (type1) == TYPE_CODE_ARRAY
|
|
&& TYPE_VECTOR (type1));
|
|
int t2_is_vec = (TYPE_CODE (type2) == TYPE_CODE_ARRAY
|
|
&& TYPE_VECTOR (type2));
|
|
|
|
if (!t1_is_vec && !t2_is_vec)
|
|
{
|
|
int tmp = scalar_relop (arg1, arg2, op);
|
|
struct type *type =
|
|
language_bool_type (exp->language_defn, exp->gdbarch);
|
|
|
|
val = value_from_longest (type, tmp);
|
|
}
|
|
else if (t1_is_vec && t2_is_vec)
|
|
{
|
|
val = vector_relop (exp, arg1, arg2, op);
|
|
}
|
|
else
|
|
{
|
|
/* Widen the scalar operand to a vector. */
|
|
struct value **v = t1_is_vec ? &arg2 : &arg1;
|
|
struct type *t = t1_is_vec ? type2 : type1;
|
|
|
|
if (TYPE_CODE (t) != TYPE_CODE_FLT && !is_integral_type (t))
|
|
error (_("Argument to operation not a number or boolean."));
|
|
|
|
*v = opencl_value_cast (t1_is_vec ? type1 : type2, *v);
|
|
val = vector_relop (exp, arg1, arg2, op);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
/* Expression evaluator for the OpenCL. Most operations are delegated to
|
|
evaluate_subexp_standard; see that function for a description of the
|
|
arguments. */
|
|
|
|
static struct value *
|
|
evaluate_subexp_opencl (struct type *expect_type, struct expression *exp,
|
|
int *pos, enum noside noside)
|
|
{
|
|
enum exp_opcode op = exp->elts[*pos].opcode;
|
|
struct value *arg1 = NULL;
|
|
struct value *arg2 = NULL;
|
|
struct type *type1, *type2;
|
|
|
|
switch (op)
|
|
{
|
|
/* Handle assignment and cast operators to support OpenCL-style
|
|
scalar-to-vector widening. */
|
|
case BINOP_ASSIGN:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
type1 = value_type (arg1);
|
|
arg2 = evaluate_subexp (type1, exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
|
|
return arg1;
|
|
|
|
if (deprecated_value_modifiable (arg1)
|
|
&& VALUE_LVAL (arg1) != lval_internalvar)
|
|
arg2 = opencl_value_cast (type1, arg2);
|
|
|
|
return value_assign (arg1, arg2);
|
|
|
|
case UNOP_CAST:
|
|
type1 = exp->elts[*pos + 1].type;
|
|
(*pos) += 2;
|
|
arg1 = evaluate_subexp (type1, exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP)
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
|
|
return opencl_value_cast (type1, arg1);
|
|
|
|
case UNOP_CAST_TYPE:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
|
|
type1 = value_type (arg1);
|
|
arg1 = evaluate_subexp (type1, exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP)
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
|
|
return opencl_value_cast (type1, arg1);
|
|
|
|
/* Handle binary relational and equality operators that are either not
|
|
or differently defined for GNU vectors. */
|
|
case BINOP_EQUAL:
|
|
case BINOP_NOTEQUAL:
|
|
case BINOP_LESS:
|
|
case BINOP_GTR:
|
|
case BINOP_GEQ:
|
|
case BINOP_LEQ:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP)
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
|
|
return opencl_relop (exp, arg1, arg2, op);
|
|
|
|
/* Handle the logical unary operator not(!). */
|
|
case UNOP_LOGICAL_NOT:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP)
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
|
|
return opencl_logical_not (exp, arg1);
|
|
|
|
/* Handle the logical operator and(&&) and or(||). */
|
|
case BINOP_LOGICAL_AND:
|
|
case BINOP_LOGICAL_OR:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
|
|
if (noside == EVAL_SKIP)
|
|
{
|
|
evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
}
|
|
else
|
|
{
|
|
/* For scalar operations we need to avoid evaluating operands
|
|
unnecessarily. However, for vector operations we always need to
|
|
evaluate both operands. Unfortunately we only know which of the
|
|
two cases apply after we know the type of the second operand.
|
|
Therefore we evaluate it once using EVAL_AVOID_SIDE_EFFECTS. */
|
|
int oldpos = *pos;
|
|
|
|
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
|
|
EVAL_AVOID_SIDE_EFFECTS);
|
|
*pos = oldpos;
|
|
type1 = check_typedef (value_type (arg1));
|
|
type2 = check_typedef (value_type (arg2));
|
|
|
|
if ((TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
|
|
|| (TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)))
|
|
{
|
|
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
|
|
return opencl_relop (exp, arg1, arg2, op);
|
|
}
|
|
else
|
|
{
|
|
/* For scalar built-in types, only evaluate the right
|
|
hand operand if the left hand operand compares
|
|
unequal(&&)/equal(||) to 0. */
|
|
int res;
|
|
int tmp = value_logical_not (arg1);
|
|
|
|
if (op == BINOP_LOGICAL_OR)
|
|
tmp = !tmp;
|
|
|
|
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
|
|
tmp ? EVAL_SKIP : noside);
|
|
type1 = language_bool_type (exp->language_defn, exp->gdbarch);
|
|
|
|
if (op == BINOP_LOGICAL_AND)
|
|
res = !tmp && !value_logical_not (arg2);
|
|
else /* BINOP_LOGICAL_OR */
|
|
res = tmp || !value_logical_not (arg2);
|
|
|
|
return value_from_longest (type1, res);
|
|
}
|
|
}
|
|
|
|
/* Handle the ternary selection operator. */
|
|
case TERNOP_COND:
|
|
(*pos)++;
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
type1 = check_typedef (value_type (arg1));
|
|
if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
|
|
{
|
|
struct value *arg3, *tmp, *ret;
|
|
struct type *eltype2, *type3, *eltype3;
|
|
int t2_is_vec, t3_is_vec, i;
|
|
LONGEST lowb1, lowb2, lowb3, highb1, highb2, highb3;
|
|
|
|
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
arg3 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
type2 = check_typedef (value_type (arg2));
|
|
type3 = check_typedef (value_type (arg3));
|
|
t2_is_vec
|
|
= TYPE_CODE (type2) == TYPE_CODE_ARRAY && TYPE_VECTOR (type2);
|
|
t3_is_vec
|
|
= TYPE_CODE (type3) == TYPE_CODE_ARRAY && TYPE_VECTOR (type3);
|
|
|
|
/* Widen the scalar operand to a vector if necessary. */
|
|
if (t2_is_vec || !t3_is_vec)
|
|
{
|
|
arg3 = opencl_value_cast (type2, arg3);
|
|
type3 = value_type (arg3);
|
|
}
|
|
else if (!t2_is_vec || t3_is_vec)
|
|
{
|
|
arg2 = opencl_value_cast (type3, arg2);
|
|
type2 = value_type (arg2);
|
|
}
|
|
else if (!t2_is_vec || !t3_is_vec)
|
|
{
|
|
/* Throw an error if arg2 or arg3 aren't vectors. */
|
|
error (_("\
|
|
Cannot perform conditional operation on incompatible types"));
|
|
}
|
|
|
|
eltype2 = check_typedef (TYPE_TARGET_TYPE (type2));
|
|
eltype3 = check_typedef (TYPE_TARGET_TYPE (type3));
|
|
|
|
if (!get_array_bounds (type1, &lowb1, &highb1)
|
|
|| !get_array_bounds (type2, &lowb2, &highb2)
|
|
|| !get_array_bounds (type3, &lowb3, &highb3))
|
|
error (_("Could not determine the vector bounds"));
|
|
|
|
/* Throw an error if the types of arg2 or arg3 are incompatible. */
|
|
if (TYPE_CODE (eltype2) != TYPE_CODE (eltype3)
|
|
|| TYPE_LENGTH (eltype2) != TYPE_LENGTH (eltype3)
|
|
|| TYPE_UNSIGNED (eltype2) != TYPE_UNSIGNED (eltype3)
|
|
|| lowb2 != lowb3 || highb2 != highb3)
|
|
error (_("\
|
|
Cannot perform operation on vectors with different types"));
|
|
|
|
/* Throw an error if the sizes of arg1 and arg2/arg3 differ. */
|
|
if (lowb1 != lowb2 || lowb1 != lowb3
|
|
|| highb1 != highb2 || highb1 != highb3)
|
|
error (_("\
|
|
Cannot perform conditional operation on vectors with different sizes"));
|
|
|
|
ret = allocate_value (type2);
|
|
|
|
for (i = 0; i < highb1 - lowb1 + 1; i++)
|
|
{
|
|
tmp = value_logical_not (value_subscript (arg1, i)) ?
|
|
value_subscript (arg3, i) : value_subscript (arg2, i);
|
|
memcpy (value_contents_writeable (ret) +
|
|
i * TYPE_LENGTH (eltype2), value_contents_all (tmp),
|
|
TYPE_LENGTH (eltype2));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
if (value_logical_not (arg1))
|
|
{
|
|
/* Skip the second operand. */
|
|
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
|
|
|
|
return evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
}
|
|
else
|
|
{
|
|
/* Skip the third operand. */
|
|
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
|
|
|
|
return arg2;
|
|
}
|
|
}
|
|
|
|
/* Handle STRUCTOP_STRUCT to allow component access on OpenCL vectors. */
|
|
case STRUCTOP_STRUCT:
|
|
{
|
|
int pc = (*pos)++;
|
|
int tem = longest_to_int (exp->elts[pc + 1].longconst);
|
|
|
|
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
|
|
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
|
type1 = check_typedef (value_type (arg1));
|
|
|
|
if (noside == EVAL_SKIP)
|
|
{
|
|
return value_from_longest (builtin_type (exp->gdbarch)->
|
|
builtin_int, 1);
|
|
}
|
|
else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
|
|
{
|
|
return opencl_component_ref (exp, arg1, &exp->elts[pc + 2].string,
|
|
noside);
|
|
}
|
|
else
|
|
{
|
|
struct value *v = value_struct_elt (&arg1, NULL,
|
|
&exp->elts[pc + 2].string, NULL,
|
|
"structure");
|
|
|
|
if (noside == EVAL_AVOID_SIDE_EFFECTS)
|
|
v = value_zero (value_type (v), VALUE_LVAL (v));
|
|
return v;
|
|
}
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return evaluate_subexp_c (expect_type, exp, pos, noside);
|
|
}
|
|
|
|
/* Print OpenCL types. */
|
|
|
|
static void
|
|
opencl_print_type (struct type *type, const char *varstring,
|
|
struct ui_file *stream, int show, int level,
|
|
const struct type_print_options *flags)
|
|
{
|
|
/* We nearly always defer to C type printing, except that vector
|
|
types are considered primitive in OpenCL, and should always
|
|
be printed using their TYPE_NAME. */
|
|
if (show > 0)
|
|
{
|
|
type = check_typedef (type);
|
|
if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
|
|
&& TYPE_NAME (type) != NULL)
|
|
show = 0;
|
|
}
|
|
|
|
c_print_type (type, varstring, stream, show, level, flags);
|
|
}
|
|
|
|
static void
|
|
opencl_language_arch_info (struct gdbarch *gdbarch,
|
|
struct language_arch_info *lai)
|
|
{
|
|
struct type **types = builtin_opencl_type (gdbarch);
|
|
|
|
/* Copy primitive types vector from gdbarch. */
|
|
lai->primitive_type_vector = types;
|
|
|
|
/* Type of elements of strings. */
|
|
lai->string_char_type = types [opencl_primitive_type_char];
|
|
|
|
/* Specifies the return type of logical and relational operations. */
|
|
lai->bool_type_symbol = "int";
|
|
lai->bool_type_default = types [opencl_primitive_type_int];
|
|
}
|
|
|
|
const struct exp_descriptor exp_descriptor_opencl =
|
|
{
|
|
print_subexp_standard,
|
|
operator_length_standard,
|
|
operator_check_standard,
|
|
op_name_standard,
|
|
dump_subexp_body_standard,
|
|
evaluate_subexp_opencl
|
|
};
|
|
|
|
extern const struct language_defn opencl_language_defn =
|
|
{
|
|
"opencl", /* Language name */
|
|
"OpenCL C",
|
|
language_opencl,
|
|
range_check_off,
|
|
case_sensitive_on,
|
|
array_row_major,
|
|
macro_expansion_c,
|
|
NULL,
|
|
&exp_descriptor_opencl,
|
|
c_parse,
|
|
null_post_parser,
|
|
c_printchar, /* Print a character constant */
|
|
c_printstr, /* Function to print string constant */
|
|
c_emit_char, /* Print a single char */
|
|
opencl_print_type, /* Print a type using appropriate syntax */
|
|
c_print_typedef, /* Print a typedef using appropriate syntax */
|
|
c_val_print, /* Print a value using appropriate syntax */
|
|
c_value_print, /* Print a top-level value */
|
|
default_read_var_value, /* la_read_var_value */
|
|
NULL, /* Language specific skip_trampoline */
|
|
NULL, /* name_of_this */
|
|
false, /* la_store_sym_names_in_linkage_form_p */
|
|
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
|
|
basic_lookup_transparent_type,/* lookup_transparent_type */
|
|
NULL, /* Language specific symbol demangler */
|
|
NULL,
|
|
NULL, /* Language specific
|
|
class_name_from_physname */
|
|
c_op_print_tab, /* expression operators for printing */
|
|
1, /* c-style arrays */
|
|
0, /* String lower bound */
|
|
default_word_break_characters,
|
|
default_collect_symbol_completion_matches,
|
|
opencl_language_arch_info,
|
|
default_print_array_index,
|
|
default_pass_by_reference,
|
|
c_watch_location_expression,
|
|
NULL, /* la_get_symbol_name_matcher */
|
|
iterate_over_symbols,
|
|
default_search_name_hash,
|
|
&default_varobj_ops,
|
|
NULL,
|
|
NULL,
|
|
c_is_string_type_p,
|
|
"{...}" /* la_struct_too_deep_ellipsis */
|
|
};
|
|
|
|
static void *
|
|
build_opencl_types (struct gdbarch *gdbarch)
|
|
{
|
|
struct type **types
|
|
= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_opencl_primitive_types + 1,
|
|
struct type *);
|
|
|
|
/* Helper macro to create strings. */
|
|
#define OCL_STRING(S) #S
|
|
/* This macro allocates and assigns the type struct pointers
|
|
for the vector types. */
|
|
#define BUILD_OCL_VTYPES(TYPE)\
|
|
types[opencl_primitive_type_##TYPE##2] \
|
|
= init_vector_type (types[opencl_primitive_type_##TYPE], 2); \
|
|
TYPE_NAME (types[opencl_primitive_type_##TYPE##2]) = OCL_STRING(TYPE ## 2); \
|
|
types[opencl_primitive_type_##TYPE##3] \
|
|
= init_vector_type (types[opencl_primitive_type_##TYPE], 3); \
|
|
TYPE_NAME (types[opencl_primitive_type_##TYPE##3]) = OCL_STRING(TYPE ## 3); \
|
|
TYPE_LENGTH (types[opencl_primitive_type_##TYPE##3]) \
|
|
= 4 * TYPE_LENGTH (types[opencl_primitive_type_##TYPE]); \
|
|
types[opencl_primitive_type_##TYPE##4] \
|
|
= init_vector_type (types[opencl_primitive_type_##TYPE], 4); \
|
|
TYPE_NAME (types[opencl_primitive_type_##TYPE##4]) = OCL_STRING(TYPE ## 4); \
|
|
types[opencl_primitive_type_##TYPE##8] \
|
|
= init_vector_type (types[opencl_primitive_type_##TYPE], 8); \
|
|
TYPE_NAME (types[opencl_primitive_type_##TYPE##8]) = OCL_STRING(TYPE ## 8); \
|
|
types[opencl_primitive_type_##TYPE##16] \
|
|
= init_vector_type (types[opencl_primitive_type_##TYPE], 16); \
|
|
TYPE_NAME (types[opencl_primitive_type_##TYPE##16]) = OCL_STRING(TYPE ## 16)
|
|
|
|
types[opencl_primitive_type_char]
|
|
= arch_integer_type (gdbarch, 8, 0, "char");
|
|
BUILD_OCL_VTYPES (char);
|
|
types[opencl_primitive_type_uchar]
|
|
= arch_integer_type (gdbarch, 8, 1, "uchar");
|
|
BUILD_OCL_VTYPES (uchar);
|
|
types[opencl_primitive_type_short]
|
|
= arch_integer_type (gdbarch, 16, 0, "short");
|
|
BUILD_OCL_VTYPES (short);
|
|
types[opencl_primitive_type_ushort]
|
|
= arch_integer_type (gdbarch, 16, 1, "ushort");
|
|
BUILD_OCL_VTYPES (ushort);
|
|
types[opencl_primitive_type_int]
|
|
= arch_integer_type (gdbarch, 32, 0, "int");
|
|
BUILD_OCL_VTYPES (int);
|
|
types[opencl_primitive_type_uint]
|
|
= arch_integer_type (gdbarch, 32, 1, "uint");
|
|
BUILD_OCL_VTYPES (uint);
|
|
types[opencl_primitive_type_long]
|
|
= arch_integer_type (gdbarch, 64, 0, "long");
|
|
BUILD_OCL_VTYPES (long);
|
|
types[opencl_primitive_type_ulong]
|
|
= arch_integer_type (gdbarch, 64, 1, "ulong");
|
|
BUILD_OCL_VTYPES (ulong);
|
|
types[opencl_primitive_type_half]
|
|
= arch_float_type (gdbarch, 16, "half", floatformats_ieee_half);
|
|
BUILD_OCL_VTYPES (half);
|
|
types[opencl_primitive_type_float]
|
|
= arch_float_type (gdbarch, 32, "float", floatformats_ieee_single);
|
|
BUILD_OCL_VTYPES (float);
|
|
types[opencl_primitive_type_double]
|
|
= arch_float_type (gdbarch, 64, "double", floatformats_ieee_double);
|
|
BUILD_OCL_VTYPES (double);
|
|
types[opencl_primitive_type_bool]
|
|
= arch_boolean_type (gdbarch, 8, 1, "bool");
|
|
types[opencl_primitive_type_unsigned_char]
|
|
= arch_integer_type (gdbarch, 8, 1, "unsigned char");
|
|
types[opencl_primitive_type_unsigned_short]
|
|
= arch_integer_type (gdbarch, 16, 1, "unsigned short");
|
|
types[opencl_primitive_type_unsigned_int]
|
|
= arch_integer_type (gdbarch, 32, 1, "unsigned int");
|
|
types[opencl_primitive_type_unsigned_long]
|
|
= arch_integer_type (gdbarch, 64, 1, "unsigned long");
|
|
types[opencl_primitive_type_size_t]
|
|
= arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "size_t");
|
|
types[opencl_primitive_type_ptrdiff_t]
|
|
= arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "ptrdiff_t");
|
|
types[opencl_primitive_type_intptr_t]
|
|
= arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 0, "intptr_t");
|
|
types[opencl_primitive_type_uintptr_t]
|
|
= arch_integer_type (gdbarch, gdbarch_ptr_bit (gdbarch), 1, "uintptr_t");
|
|
types[opencl_primitive_type_void]
|
|
= arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
|
|
|
|
return types;
|
|
}
|
|
|
|
void _initialize_opencl_language ();
|
|
void
|
|
_initialize_opencl_language ()
|
|
{
|
|
opencl_type_data = gdbarch_data_register_post_init (build_opencl_types);
|
|
}
|