mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
3aee891821
This patch makes GDBserver support multi-process + biarch. Currently, if you're debugging more than one process at once with a single gdbserver (in extended-remote mode), then all processes must have the same architecture (e.g., 64-bit vs 32-bit). Otherwise, you see this: Added inferior 2 [Switching to inferior 2 [<null>] (<noexec>)] Reading symbols from /home/pedro/gdb/tests/main32...done. Temporary breakpoint 2 at 0x4004cf: main. (2 locations) Starting program: /home/pedro/gdb/tests/main32 warning: Selected architecture i386 is not compatible with reported target architecture i386:x86-64 warning: Architecture rejected target-supplied description Remote 'g' packet reply is too long: 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090cfffff0000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000b042f7460000000000020000230000002b0000002b0000002b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007f03000000000000ffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000801f00003b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ... etc, etc ... Even though the process was running a 32-bit program, GDBserver sent back to GDB a register set in 64-bit layout. A patch (http://sourceware.org/ml/gdb-patches/2012-11/msg00228.html) a while ago made GDB track a target_gdbarch per inferior, and as consequence, fetch a target description per-inferior. This patch is the GDBserver counterpart, that makes GDBserver keep track of each process'es XML target description and register layout. So in the example above, GDBserver will send the correct register set in 32-bit layout to GDB. A new "struct target_desc" object (tdesc for short) is added, that holds the target description and register layout information about each process. Each `struct process_info' holds a pointer to a target description. The regcache also gains a pointer to a target description, mainly for convenience, and parallel with GDB (and possible future support for programs that flip processor modes). The low target's arch_setup routines are responsible for setting the process'es correct tdesc. This isn't that much different to how things were done before, except that instead of detecting the inferior process'es architecture and calling the corresponding init_registers_FOO routine, which would change the regcache layout globals and recreate the threads' regcaches, the regcache.c globals are gone, and the init_registers_$BAR routines now each initialize a separate global struct target_desc object (one for each arch variant GDBserver supports), and so all the init_registers_$BAR routines that are built into GDBserver are called early at GDBserver startup time (similarly to how GDB handles its built-in target descriptions), and then the arch_setup routine is responsible for making process_info->tdesc point to one of these target description globals. The regcache module is all parameterized to get the regcache's layout from the tdesc object instead of the old register_bytes, etc. globals. The threads' regcaches are now created lazily. The old scheme where we created each of them when we added a new thread doesn't work anymore, because we add the main thread/lwp before we see it stop for the first time, and it is only when we see the thread stop for the first time that we have a chance of determining the inferior's architecture (through the_low_target.arch_setup). Therefore when we add the main thread we don't know which architecture/tdesc its regcache should have. This patch makes the gdb.multi/multi-arch.exp test now pass against (extended-remote) GDBserver. It currently fails, without this patch. The IPA also uses the regcache, so it gains a new global struct target_desc pointer, which points at the description of the process it is loaded in. Re. the linux-low.c & friends changes. Since the register map etc. may differ between processes (64-bit vs 32-bit) etc., the linux_target_ops num_regs, regmap and regset_bitmap data fields are no longer sufficient. A new method is added in their place that returns a pointer to a new struct that includes all info linux-low.c needs to access registers of the current inferior. The patch/discussion that originally introduced linux-low.c:disabled_regsets mentions that the disabled_regsets set may be different per mode (in a biarch setup), and indeed that is cleared whenever we start a new (first) inferior, so that global is moved as well behind the new `struct regs_info'. On the x86 side: I simply replaced the i387-fp.c:num_xmm_registers global with a check for 64-bit or 32-bit process, which is equivalent to how the global was set. This avoided coming up with some more general mechanism that would work for all targets that use this module (GNU/Linux, Windows, etc.). Tested: GNU/Linux IA64 GNU/Linux MIPS64 GNU/Linux PowerPC (Fedora 16) GNU/Linux s390x (Fedora 16) GNU/Linux sparc64 (Debian) GNU/Linux x86_64, -m64 and -m32 (Fedora 17) Cross built, and smoke tested: i686-w64-mingw32, under Wine. GNU/Linux TI C6x, by Yao Qi. Cross built but otherwise not tested: aarch64-linux-gnu arm-linux-gnu m68k-linux nios2-linux-gnu sh-linux-gnu spu tilegx-unknown-linux-gnu Completely untested: GNU/Linux Blackfin GNU/Linux CRIS GNU/Linux CRISv32 GNU/Linux TI Xtensa GNU/Linux M32R LynxOS QNX NTO gdb/gdbserver/ 2013-06-07 Pedro Alves <palves@redhat.com> * Makefile.in (OBS): Add tdesc.o. (IPA_OBJS): Add tdesc-ipa.o. (tdesc-ipa.o): New rule. * ax.c (gdb_eval_agent_expr): Adjust register_size call to new interface. * linux-low.c (new_inferior): Delete. (disabled_regsets, num_regsets): Delete. (linux_add_process): Adjust to set the new per-process new_inferior flag. (linux_detach_one_lwp): Adjust to call regcache_invalidate_thread. (linux_wait_for_lwp): Adjust. Only call arch_setup if the event was a stop. When calling arch_setup, switch the current inferior to the thread that got an event. (linux_resume_one_lwp): Adjust to call regcache_invalidate_thread. (regsets_fetch_inferior_registers) (regsets_store_inferior_registers): New regsets_info parameter. Adjust to use it. (linux_register_in_regsets): New regs_info parameter. Adjust to use it. (register_addr, fetch_register, store_register): New usrregs_info parameter. Adjust to use it. (usr_fetch_inferior_registers, usr_store_inferior_registers): New parameter regs_info. Adjust to use it. (linux_fetch_registers): Get the current inferior's regs_info, and adjust to use it. (linux_store_registers): Ditto. [HAVE_LINUX_REGSETS] (initialize_regsets_info): New. (initialize_low): Don't initialize the target_regsets here. Call initialize_low_arch. * linux-low.h (target_regsets): Delete declaration. (struct regsets_info): New. (struct usrregs_info): New. (struct regs_info): New. (struct process_info_private) <new_inferior>: New field. (struct linux_target_ops): Delete the num_regs, regmap, and regset_bitmap fields. New field regs_info. [HAVE_LINUX_REGSETS] (initialize_regsets_info): Declare. * i387-fp.c (num_xmm_registers): Delete. (i387_cache_to_fsave, i387_fsave_to_cache): Adjust find_regno calls to new interface. (i387_cache_to_fxsave, i387_cache_to_xsave, i387_fxsave_to_cache) (i387_xsave_to_cache): Adjust find_regno calls to new interface. Infer the number of xmm registers from the regcache's target description. * i387-fp.h (num_xmm_registers): Delete. * inferiors.c (add_thread): Don't install the thread's regcache here. * proc-service.c (gregset_info): Fetch the current inferior's regs_info. Adjust to use it. * regcache.c: Include tdesc.h. (register_bytes, reg_defs, num_registers) (gdbserver_expedite_regs): Delete. (get_thread_regcache): If the thread doesn't have a regcache yet, create one, instead of aborting gdbserver. (regcache_invalidate_one): Rename to ... (regcache_invalidate_thread): ... this. (regcache_invalidate_one): New. (regcache_invalidate): Only invalidate registers of the current process. (init_register_cache): Add target_desc parameter, and use it. (new_register_cache): Ditto. Assert the target description has a non zero registers_size. (regcache_cpy): Add assertions. Adjust. (realloc_register_cache, set_register_cache): Delete. (registers_to_string, registers_from_string): Adjust. (find_register_by_name, find_regno, find_register_by_number) (register_cache_size): Add target_desc parameter, and use it. (free_register_cache_thread, free_register_cache_thread_one) (regcache_release, register_cache_size): New. (register_size): Add target_desc parameter, and use it. (register_data, supply_register, supply_register_zeroed) (supply_regblock, supply_register_by_name, collect_register) (collect_register_as_string, collect_register_by_name): Adjust. * regcache.h (struct target_desc): Forward declare. (struct regcache) <tdesc>: New field. (init_register_cache, new_register_cache): Add target_desc parameter. (regcache_invalidate_thread): Declare. (regcache_invalidate_one): Delete declaration. (regcache_release): Declare. (find_register_by_number, register_cache_size, register_size) (find_regno): Add target_desc parameter. (gdbserver_expedite_regs, gdbserver_xmltarget): Delete declarations. * remote-utils.c: Include tdesc.h. (outreg, prepare_resume_reply): Adjust. * server.c: Include tdesc.h. (gdbserver_xmltarget): Delete declaration. (get_features_xml, process_serial_event): Adjust. * server.h [IN_PROCESS_AGENT] (struct target_desc): Forward declare. (struct process_info) <tdesc>: New field. (ipa_tdesc): Declare. * tdesc.c: New file. * tdesc.h: New file. * tracepoint.c: Include tdesc.h. [IN_PROCESS_AGENT] (ipa_tdesc): Define. (get_context_regcache): Adjust to pass ipa_tdesc down. (do_action_at_tracepoint): Adjust to get the register cache size from the context regcache's description. (traceframe_walk_blocks): Adjust to get the register cache size from the current trace frame's description. (traceframe_get_pc): Adjust to get current trace frame's description and pass it down. (gdb_collect): Adjust to get the register cache size from the IPA's description. * linux-amd64-ipa.c (tdesc_amd64_linux): Declare. (gdbserver_xmltarget): Delete. (initialize_low_tracepoint): Set the ipa's target description. * linux-i386-ipa.c (tdesc_i386_linux): Declare. (initialize_low_tracepoint): Set the ipa's target description. * linux-x86-low.c: Include tdesc.h. [__x86_64__] (is_64bit_tdesc): New. (ps_get_thread_area, x86_get_thread_area): Use it. (i386_cannot_store_register): Rename to ... (x86_cannot_store_register): ... this. Use is_64bit_tdesc. (i386_cannot_fetch_register): Rename to ... (x86_cannot_fetch_register): ... this. Use is_64bit_tdesc. (x86_fill_gregset, x86_store_gregset): Adjust register_size calls to new interface. (target_regsets): Rename to ... (x86_regsets): ... this. (x86_get_pc, x86_set_pc): Adjust register_size calls to new interface. (x86_siginfo_fixup): Use is_64bit_tdesc. [__x86_64__] (tdesc_amd64_linux, tdesc_amd64_avx_linux) (tdesc_x32_avx_linux, tdesc_x32_linux) (tdesc_i386_linux, tdesc_i386_mmx_linux, tdesc_i386_avx_linux): Declare. (x86_linux_update_xmltarget): Delete. (I386_LINUX_XSAVE_XCR0_OFFSET): Define. (have_ptrace_getfpxregs, have_ptrace_getregset): New. (AMD64_LINUX_USER64_CS): New. (x86_linux_read_description): New, based on x86_linux_update_xmltarget. (same_process_callback): New. (x86_arch_setup_process_callback): New. (x86_linux_update_xmltarget): New. (x86_regsets_info): New. (amd64_linux_regs_info): New. (i386_linux_usrregs_info): New. (i386_linux_regs_info): New. (x86_linux_regs_info): New. (x86_arch_setup): Reimplement. (x86_install_fast_tracepoint_jump_pad): Use is_64bit_tdesc. (x86_emit_ops): Ditto. (the_low_target): Adjust. Install x86_linux_regs_info, x86_cannot_fetch_register, and x86_cannot_store_register. (initialize_low_arch): New. * linux-ia64-low.c (tdesc_ia64): Declare. (ia64_fetch_register): Adjust. (ia64_usrregs_info, regs_info): New globals. (ia64_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-sparc-low.c (tdesc_sparc64): Declare. (sparc_fill_gregset_to_stack, sparc_store_gregset_from_stack): Adjust. (sparc_arch_setup): New function. (sparc_regsets_info, sparc_usrregs_info, regs_info): New globals. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-ppc-low.c (tdesc_powerpc_32l, tdesc_powerpc_altivec32l) (tdesc_powerpc_cell32l, tdesc_powerpc_vsx32l) (tdesc_powerpc_isa205_32l, tdesc_powerpc_isa205_altivec32l) (tdesc_powerpc_isa205_vsx32l, tdesc_powerpc_e500l) (tdesc_powerpc_64l, tdesc_powerpc_altivec64l) (tdesc_powerpc_cell64l, tdesc_powerpc_vsx64l) (tdesc_powerpc_isa205_64l, tdesc_powerpc_isa205_altivec64l) (tdesc_powerpc_isa205_vsx64l): Declare. (ppc_cannot_store_register, ppc_collect_ptrace_register) (ppc_supply_ptrace_register, parse_spufs_run, ppc_get_pc) (ppc_set_pc, ppc_get_hwcap): Adjust. (ppc_usrregs_info): Forward declare. (!__powerpc64__) ppc_regmap_adjusted: New global. (ppc_arch_setup): Adjust to the current process'es target description. (ppc_fill_vsxregset, ppc_store_vsxregset, ppc_fill_vrregset) (ppc_store_vrregset, ppc_fill_evrregset, ppc_store_evrregse) (ppc_store_evrregset): Adjust. (target_regsets): Rename to ... (ppc_regsets): ... this, and make static. (ppc_usrregs_info, ppc_regsets_info, regs_info): New globals. (ppc_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-s390-low.c (tdesc_s390_linux32, tdesc_s390_linux32v1) (tdesc_s390_linux32v2, tdesc_s390_linux64, tdesc_s390_linux64v1) (tdesc_s390_linux64v2, tdesc_s390x_linux64, tdesc_s390x_linux64v1) (tdesc_s390x_linux64v2): Declare. (s390_collect_ptrace_register, s390_supply_ptrace_register) (s390_fill_gregset, s390_store_last_break): Adjust. (target_regsets): Rename to ... (s390_regsets): ... this, and make static. (s390_get_pc, s390_set_pc): Adjust. (s390_get_hwcap): New target_desc parameter, and use it. [__s390x__] (have_hwcap_s390_high_gprs): New global. (s390_arch_setup): Adjust to set the current process'es target description. Don't adjust the regmap. (s390_usrregs_info, s390_regsets_info, regs_info): New globals. [__s390x__] (s390_usrregs_info_3264, s390_regsets_info_3264) (regs_info_3264): New globals. (s390_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-mips-low.c (tdesc_mips_linux, tdesc_mips_dsp_linux) (tdesc_mips64_linux, tdesc_mips64_dsp_linux): Declare. [__mips64] (init_registers_mips_linux) (init_registers_mips_dsp_linux): Delete defines. [__mips64] (tdesc_mips_linux, tdesc_mips_dsp_linux): New defines. (have_dsp): New global. (mips_read_description): New, based on mips_arch_setup. (mips_arch_setup): Reimplement. (get_usrregs_info): New function. (mips_cannot_fetch_register, mips_cannot_store_register) (mips_get_pc, mips_set_pc, mips_fill_gregset, mips_store_gregset) (mips_fill_fpregset, mips_store_fpregset): Adjust. (target_regsets): Rename to ... (mips_regsets): ... this, and make static. (mips_regsets_info, mips_dsp_usrregs_info, mips_usrregs_info) (dsp_regs_info, regs_info): New globals. (mips_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-arm-low.c (tdesc_arm, tdesc_arm_with_iwmmxt) (tdesc_arm_with_vfpv2, tdesc_arm_with_vfpv3, tdesc_arm_with_neon): Declare. (arm_fill_vfpregset, arm_store_vfpregset): Adjust. (arm_read_description): New, with bits factored from arm_arch_setup. (arm_arch_setup): Reimplement. (target_regsets): Rename to ... (arm_regsets): ... this, and make static. (arm_regsets_info, arm_usrregs_info, regs_info): New globals. (arm_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-m68k-low.c (tdesc_m68k): Declare. (target_regsets): Rename to ... (m68k_regsets): ... this, and make static. (m68k_regsets_info, m68k_usrregs_info, regs_info): New globals. (m68k_regs_info): New function. (m68k_arch_setup): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-sh-low.c (tdesc_sharch): Declare. (target_regsets): Rename to ... (sh_regsets): ... this, and make static. (sh_regsets_info, sh_usrregs_info, regs_info): New globals. (sh_regs_info, sh_arch_setup): New functions. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-bfin-low.c (tdesc_bfin): Declare. (bfin_arch_setup): New function. (bfin_usrregs_info, regs_info): New globals. (bfin_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-cris-low.c (tdesc_cris): Declare. (cris_arch_setup): New function. (cris_usrregs_info, regs_info): New globals. (cris_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-cris-low.c (tdesc_crisv32): Declare. (cris_arch_setup): New function. (cris_regsets_info, cris_usrregs_info, regs_info): New globals. (cris_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-m32r-low.c (tdesc_m32r): Declare. (m32r_arch_setup): New function. (m32r_usrregs_info, regs_info): New globals. (m32r_regs_info): Adjust. (initialize_low_arch): New function. * linux-tic6x-low.c (tdesc_tic6x_c64xp_linux) (tdesc_tic6x_c64x_linux, tdesc_tic6x_c62x_linux): Declare. (tic6x_usrregs_info): Forward declare. (tic6x_read_description): New function, based on ... (tic6x_arch_setup): ... this. Reimplement. (target_regsets): Rename to ... (tic6x_regsets): ... this, and make static. (tic6x_regsets_info, tic6x_usrregs_info, regs_info): New globals. (tic6x_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-xtensa-low.c (tdesc_xtensa): Declare. (xtensa_fill_gregset, xtensa_store_gregset): Adjust. (target_regsets): Rename to ... (xtensa_regsets): ... this, and make static. (xtensa_regsets_info, xtensa_usrregs_info, regs_info): New globals. (xtensa_arch_setup, xtensa_regs_info): New functions. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-nios2-low.c (tdesc_nios2_linux): Declare. (nios2_arch_setup): Set the current process'es tdesc. (target_regsets): Rename to ... (nios2_regsets): ... this. (nios2_regsets_info, nios2_usrregs_info, regs_info): New globals. (nios2_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-aarch64-low.c (tdesc_aarch64): Declare. (aarch64_arch_setup): Set the current process'es tdesc. (target_regsets): Rename to ... (aarch64_regsets): ... this. (aarch64_regsets_info, aarch64_usrregs_info, regs_info): New globals. (aarch64_regs_info): New function. (the_low_target): Adjust. (initialize_low_arch): New function. * linux-tile-low.c (tdesc_tilegx, tdesc_tilegx32): Declare globals. (target_regsets): Rename to ... (tile_regsets): ... this. (tile_regsets_info, tile_usrregs_info, regs_info): New globals. (tile_regs_info): New function. (tile_arch_setup): Set the current process'es tdesc. (the_low_target): Adjust. (initialize_low_arch): New function. * spu-low.c (tdesc_spu): Declare. (spu_create_inferior, spu_attach): Set the new process'es tdesc. * win32-arm-low.c (tdesc_arm): Declare. (arm_arch_setup): New function. (the_low_target): Install arm_arch_setup instead of init_registers_arm. * win32-i386-low.c (tdesc_i386, tdesc_amd64): Declare. (init_windows_x86): Rename to ... (i386_arch_setup): ... this. Set `win32_tdesc'. (the_low_target): Adjust. * win32-low.c (win32_tdesc): New global. (child_add_thread): Don't create the thread cache here. (do_initial_child_stuff): Set the new process'es tdesc. * win32-low.h (struct target_desc): Forward declare. (win32_tdesc): Declare. * lynx-i386-low.c (tdesc_i386): Declare global. (lynx_i386_arch_setup): Set `lynx_tdesc'. * lynx-low.c (lynx_tdesc): New global. (lynx_add_process): Set the new process'es tdesc. * lynx-low.h (struct target_desc): Forward declare. (lynx_tdesc): Declare global. * lynx-ppc-low.c (tdesc_powerpc_32): Declare global. (lynx_ppc_arch_setup): Set `lynx_tdesc'. * nto-low.c (nto_tdesc): New global. (do_attach): Set the new process'es tdesc. * nto-low.h (struct target_desc): Forward declare. (nto_tdesc): Declare. * nto-x86-low.c (tdesc_i386): Declare. (nto_x86_arch_setup): Set `nto_tdesc'. gdb/ 2013-06-07 Pedro Alves <palves@redhat.com> * regformats/regdat.sh: Output #include tdesc.h. Make globals static. Output a global target description pointer. (init_registers_${name}): Adjust to initialize a target description structure.
1781 lines
38 KiB
C
1781 lines
38 KiB
C
/* Remote utility routines for the remote server for GDB.
|
|
Copyright (C) 1986-2013 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 "server.h"
|
|
#include "terminal.h"
|
|
#include "target.h"
|
|
#include "gdbthread.h"
|
|
#include "tdesc.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#if HAVE_SYS_IOCTL_H
|
|
#include <sys/ioctl.h>
|
|
#endif
|
|
#if HAVE_SYS_FILE_H
|
|
#include <sys/file.h>
|
|
#endif
|
|
#if HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#if HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#if HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif
|
|
#if HAVE_NETINET_TCP_H
|
|
#include <netinet/tcp.h>
|
|
#endif
|
|
#if HAVE_SYS_IOCTL_H
|
|
#include <sys/ioctl.h>
|
|
#endif
|
|
#if HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#if HAVE_FCNTL_H
|
|
#include <fcntl.h>
|
|
#endif
|
|
#include <sys/time.h>
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#if HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#include "gdb_stat.h"
|
|
#if HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
#if USE_WIN32API
|
|
#include <winsock2.h>
|
|
#endif
|
|
|
|
#if __QNX__
|
|
#include <sys/iomgr.h>
|
|
#endif /* __QNX__ */
|
|
|
|
#ifndef HAVE_SOCKLEN_T
|
|
typedef int socklen_t;
|
|
#endif
|
|
|
|
#ifndef IN_PROCESS_AGENT
|
|
|
|
#if USE_WIN32API
|
|
# define INVALID_DESCRIPTOR INVALID_SOCKET
|
|
#else
|
|
# define INVALID_DESCRIPTOR -1
|
|
#endif
|
|
|
|
/* Extra value for readchar_callback. */
|
|
enum {
|
|
/* The callback is currently not scheduled. */
|
|
NOT_SCHEDULED = -1
|
|
};
|
|
|
|
/* Status of the readchar callback.
|
|
Either NOT_SCHEDULED or the callback id. */
|
|
static int readchar_callback = NOT_SCHEDULED;
|
|
|
|
static int readchar (void);
|
|
static void reset_readchar (void);
|
|
static void reschedule (void);
|
|
|
|
/* A cache entry for a successfully looked-up symbol. */
|
|
struct sym_cache
|
|
{
|
|
char *name;
|
|
CORE_ADDR addr;
|
|
struct sym_cache *next;
|
|
};
|
|
|
|
int remote_debug = 0;
|
|
struct ui_file *gdb_stdlog;
|
|
|
|
static int remote_is_stdio = 0;
|
|
|
|
static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
|
|
static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
|
|
|
|
/* FIXME headerize? */
|
|
extern int using_threads;
|
|
extern int debug_threads;
|
|
|
|
/* If true, then GDB has requested noack mode. */
|
|
int noack_mode = 0;
|
|
/* If true, then we tell GDB to use noack mode by default. */
|
|
int transport_is_reliable = 0;
|
|
|
|
#ifdef USE_WIN32API
|
|
# define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
|
|
# define write(fd, buf, len) send (fd, (char *) buf, len, 0)
|
|
#endif
|
|
|
|
int
|
|
gdb_connected (void)
|
|
{
|
|
return remote_desc != INVALID_DESCRIPTOR;
|
|
}
|
|
|
|
/* Return true if the remote connection is over stdio. */
|
|
|
|
int
|
|
remote_connection_is_stdio (void)
|
|
{
|
|
return remote_is_stdio;
|
|
}
|
|
|
|
static void
|
|
enable_async_notification (int fd)
|
|
{
|
|
#if defined(F_SETFL) && defined (FASYNC)
|
|
int save_fcntl_flags;
|
|
|
|
save_fcntl_flags = fcntl (fd, F_GETFL, 0);
|
|
fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC);
|
|
#if defined (F_SETOWN)
|
|
fcntl (fd, F_SETOWN, getpid ());
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
handle_accept_event (int err, gdb_client_data client_data)
|
|
{
|
|
struct sockaddr_in sockaddr;
|
|
socklen_t tmp;
|
|
|
|
if (debug_threads)
|
|
fprintf (stderr, "handling possible accept event\n");
|
|
|
|
tmp = sizeof (sockaddr);
|
|
remote_desc = accept (listen_desc, (struct sockaddr *) &sockaddr, &tmp);
|
|
if (remote_desc == -1)
|
|
perror_with_name ("Accept failed");
|
|
|
|
/* Enable TCP keep alive process. */
|
|
tmp = 1;
|
|
setsockopt (remote_desc, SOL_SOCKET, SO_KEEPALIVE,
|
|
(char *) &tmp, sizeof (tmp));
|
|
|
|
/* Tell TCP not to delay small packets. This greatly speeds up
|
|
interactive response. */
|
|
tmp = 1;
|
|
setsockopt (remote_desc, IPPROTO_TCP, TCP_NODELAY,
|
|
(char *) &tmp, sizeof (tmp));
|
|
|
|
#ifndef USE_WIN32API
|
|
signal (SIGPIPE, SIG_IGN); /* If we don't do this, then gdbserver simply
|
|
exits when the remote side dies. */
|
|
#endif
|
|
|
|
if (run_once)
|
|
{
|
|
#ifndef USE_WIN32API
|
|
close (listen_desc); /* No longer need this */
|
|
#else
|
|
closesocket (listen_desc); /* No longer need this */
|
|
#endif
|
|
}
|
|
|
|
/* Even if !RUN_ONCE no longer notice new connections. Still keep the
|
|
descriptor open for add_file_handler to wait for a new connection. */
|
|
delete_file_handler (listen_desc);
|
|
|
|
/* Convert IP address to string. */
|
|
fprintf (stderr, "Remote debugging from host %s\n",
|
|
inet_ntoa (sockaddr.sin_addr));
|
|
|
|
enable_async_notification (remote_desc);
|
|
|
|
/* Register the event loop handler. */
|
|
add_file_handler (remote_desc, handle_serial_event, NULL);
|
|
|
|
/* We have a new GDB connection now. If we were disconnected
|
|
tracing, there's a window where the target could report a stop
|
|
event to the event loop, and since we have a connection now, we'd
|
|
try to send vStopped notifications to GDB. But, don't do that
|
|
until GDB as selected all-stop/non-stop, and has queried the
|
|
threads' status ('?'). */
|
|
target_async (0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Prepare for a later connection to a remote debugger.
|
|
NAME is the filename used for communication. */
|
|
|
|
void
|
|
remote_prepare (char *name)
|
|
{
|
|
char *port_str;
|
|
#ifdef USE_WIN32API
|
|
static int winsock_initialized;
|
|
#endif
|
|
int port;
|
|
struct sockaddr_in sockaddr;
|
|
socklen_t tmp;
|
|
char *port_end;
|
|
|
|
remote_is_stdio = 0;
|
|
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
|
|
{
|
|
/* We need to record fact that we're using stdio sooner than the
|
|
call to remote_open so start_inferior knows the connection is
|
|
via stdio. */
|
|
remote_is_stdio = 1;
|
|
transport_is_reliable = 1;
|
|
return;
|
|
}
|
|
|
|
port_str = strchr (name, ':');
|
|
if (port_str == NULL)
|
|
{
|
|
transport_is_reliable = 0;
|
|
return;
|
|
}
|
|
|
|
port = strtoul (port_str + 1, &port_end, 10);
|
|
if (port_str[1] == '\0' || *port_end != '\0')
|
|
fatal ("Bad port argument: %s", name);
|
|
|
|
#ifdef USE_WIN32API
|
|
if (!winsock_initialized)
|
|
{
|
|
WSADATA wsad;
|
|
|
|
WSAStartup (MAKEWORD (1, 0), &wsad);
|
|
winsock_initialized = 1;
|
|
}
|
|
#endif
|
|
|
|
listen_desc = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
|
if (listen_desc == -1)
|
|
perror_with_name ("Can't open socket");
|
|
|
|
/* Allow rapid reuse of this port. */
|
|
tmp = 1;
|
|
setsockopt (listen_desc, SOL_SOCKET, SO_REUSEADDR, (char *) &tmp,
|
|
sizeof (tmp));
|
|
|
|
sockaddr.sin_family = PF_INET;
|
|
sockaddr.sin_port = htons (port);
|
|
sockaddr.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
if (bind (listen_desc, (struct sockaddr *) &sockaddr, sizeof (sockaddr))
|
|
|| listen (listen_desc, 1))
|
|
perror_with_name ("Can't bind address");
|
|
|
|
transport_is_reliable = 1;
|
|
}
|
|
|
|
/* Open a connection to a remote debugger.
|
|
NAME is the filename used for communication. */
|
|
|
|
void
|
|
remote_open (char *name)
|
|
{
|
|
char *port_str;
|
|
|
|
port_str = strchr (name, ':');
|
|
#ifdef USE_WIN32API
|
|
if (port_str == NULL)
|
|
error ("Only <host>:<port> is supported on this platform.");
|
|
#endif
|
|
|
|
if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
|
|
{
|
|
fprintf (stderr, "Remote debugging using stdio\n");
|
|
|
|
/* Use stdin as the handle of the connection.
|
|
We only select on reads, for example. */
|
|
remote_desc = fileno (stdin);
|
|
|
|
enable_async_notification (remote_desc);
|
|
|
|
/* Register the event loop handler. */
|
|
add_file_handler (remote_desc, handle_serial_event, NULL);
|
|
}
|
|
#ifndef USE_WIN32API
|
|
else if (port_str == NULL)
|
|
{
|
|
struct stat statbuf;
|
|
|
|
if (stat (name, &statbuf) == 0
|
|
&& (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
|
|
remote_desc = open (name, O_RDWR);
|
|
else
|
|
{
|
|
errno = EINVAL;
|
|
remote_desc = -1;
|
|
}
|
|
|
|
if (remote_desc < 0)
|
|
perror_with_name ("Could not open remote device");
|
|
|
|
#ifdef HAVE_TERMIOS
|
|
{
|
|
struct termios termios;
|
|
tcgetattr (remote_desc, &termios);
|
|
|
|
termios.c_iflag = 0;
|
|
termios.c_oflag = 0;
|
|
termios.c_lflag = 0;
|
|
termios.c_cflag &= ~(CSIZE | PARENB);
|
|
termios.c_cflag |= CLOCAL | CS8;
|
|
termios.c_cc[VMIN] = 1;
|
|
termios.c_cc[VTIME] = 0;
|
|
|
|
tcsetattr (remote_desc, TCSANOW, &termios);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_TERMIO
|
|
{
|
|
struct termio termio;
|
|
ioctl (remote_desc, TCGETA, &termio);
|
|
|
|
termio.c_iflag = 0;
|
|
termio.c_oflag = 0;
|
|
termio.c_lflag = 0;
|
|
termio.c_cflag &= ~(CSIZE | PARENB);
|
|
termio.c_cflag |= CLOCAL | CS8;
|
|
termio.c_cc[VMIN] = 1;
|
|
termio.c_cc[VTIME] = 0;
|
|
|
|
ioctl (remote_desc, TCSETA, &termio);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SGTTY
|
|
{
|
|
struct sgttyb sg;
|
|
|
|
ioctl (remote_desc, TIOCGETP, &sg);
|
|
sg.sg_flags = RAW;
|
|
ioctl (remote_desc, TIOCSETP, &sg);
|
|
}
|
|
#endif
|
|
|
|
fprintf (stderr, "Remote debugging using %s\n", name);
|
|
|
|
enable_async_notification (remote_desc);
|
|
|
|
/* Register the event loop handler. */
|
|
add_file_handler (remote_desc, handle_serial_event, NULL);
|
|
}
|
|
#endif /* USE_WIN32API */
|
|
else
|
|
{
|
|
int port;
|
|
socklen_t len;
|
|
struct sockaddr_in sockaddr;
|
|
|
|
len = sizeof (sockaddr);
|
|
if (getsockname (listen_desc,
|
|
(struct sockaddr *) &sockaddr, &len) < 0
|
|
|| len < sizeof (sockaddr))
|
|
perror_with_name ("Can't determine port");
|
|
port = ntohs (sockaddr.sin_port);
|
|
|
|
fprintf (stderr, "Listening on port %d\n", port);
|
|
fflush (stderr);
|
|
|
|
/* Register the event loop handler. */
|
|
add_file_handler (listen_desc, handle_accept_event, NULL);
|
|
}
|
|
}
|
|
|
|
void
|
|
remote_close (void)
|
|
{
|
|
delete_file_handler (remote_desc);
|
|
|
|
#ifdef USE_WIN32API
|
|
closesocket (remote_desc);
|
|
#else
|
|
if (! remote_connection_is_stdio ())
|
|
close (remote_desc);
|
|
#endif
|
|
remote_desc = INVALID_DESCRIPTOR;
|
|
|
|
reset_readchar ();
|
|
}
|
|
|
|
/* Convert hex digit A to a number. */
|
|
|
|
static int
|
|
fromhex (int a)
|
|
{
|
|
if (a >= '0' && a <= '9')
|
|
return a - '0';
|
|
else if (a >= 'a' && a <= 'f')
|
|
return a - 'a' + 10;
|
|
else
|
|
error ("Reply contains invalid hex digit");
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
static const char hexchars[] = "0123456789abcdef";
|
|
|
|
static int
|
|
ishex (int ch, int *val)
|
|
{
|
|
if ((ch >= 'a') && (ch <= 'f'))
|
|
{
|
|
*val = ch - 'a' + 10;
|
|
return 1;
|
|
}
|
|
if ((ch >= 'A') && (ch <= 'F'))
|
|
{
|
|
*val = ch - 'A' + 10;
|
|
return 1;
|
|
}
|
|
if ((ch >= '0') && (ch <= '9'))
|
|
{
|
|
*val = ch - '0';
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifndef IN_PROCESS_AGENT
|
|
|
|
int
|
|
unhexify (char *bin, const char *hex, int count)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
if (hex[0] == 0 || hex[1] == 0)
|
|
{
|
|
/* Hex string is short, or of uneven length.
|
|
Return the count that has been converted so far. */
|
|
return i;
|
|
}
|
|
*bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
|
|
hex += 2;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
void
|
|
decode_address (CORE_ADDR *addrp, const char *start, int len)
|
|
{
|
|
CORE_ADDR addr;
|
|
char ch;
|
|
int i;
|
|
|
|
addr = 0;
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
ch = start[i];
|
|
addr = addr << 4;
|
|
addr = addr | (fromhex (ch) & 0x0f);
|
|
}
|
|
*addrp = addr;
|
|
}
|
|
|
|
const char *
|
|
decode_address_to_semicolon (CORE_ADDR *addrp, const char *start)
|
|
{
|
|
const char *end;
|
|
|
|
end = start;
|
|
while (*end != '\0' && *end != ';')
|
|
end++;
|
|
|
|
decode_address (addrp, start, end - start);
|
|
|
|
if (*end == ';')
|
|
end++;
|
|
return end;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Convert number NIB to a hex digit. */
|
|
|
|
static int
|
|
tohex (int nib)
|
|
{
|
|
if (nib < 10)
|
|
return '0' + nib;
|
|
else
|
|
return 'a' + nib - 10;
|
|
}
|
|
|
|
#ifndef IN_PROCESS_AGENT
|
|
|
|
int
|
|
hexify (char *hex, const char *bin, int count)
|
|
{
|
|
int i;
|
|
|
|
/* May use a length, or a nul-terminated string as input. */
|
|
if (count == 0)
|
|
count = strlen (bin);
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
*hex++ = tohex ((*bin >> 4) & 0xf);
|
|
*hex++ = tohex (*bin++ & 0xf);
|
|
}
|
|
*hex = 0;
|
|
return i;
|
|
}
|
|
|
|
/* Convert BUFFER, binary data at least LEN bytes long, into escaped
|
|
binary data in OUT_BUF. Set *OUT_LEN to the length of the data
|
|
encoded in OUT_BUF, and return the number of bytes in OUT_BUF
|
|
(which may be more than *OUT_LEN due to escape characters). The
|
|
total number of bytes in the output buffer will be at most
|
|
OUT_MAXLEN. */
|
|
|
|
int
|
|
remote_escape_output (const gdb_byte *buffer, int len,
|
|
gdb_byte *out_buf, int *out_len,
|
|
int out_maxlen)
|
|
{
|
|
int input_index, output_index;
|
|
|
|
output_index = 0;
|
|
for (input_index = 0; input_index < len; input_index++)
|
|
{
|
|
gdb_byte b = buffer[input_index];
|
|
|
|
if (b == '$' || b == '#' || b == '}' || b == '*')
|
|
{
|
|
/* These must be escaped. */
|
|
if (output_index + 2 > out_maxlen)
|
|
break;
|
|
out_buf[output_index++] = '}';
|
|
out_buf[output_index++] = b ^ 0x20;
|
|
}
|
|
else
|
|
{
|
|
if (output_index + 1 > out_maxlen)
|
|
break;
|
|
out_buf[output_index++] = b;
|
|
}
|
|
}
|
|
|
|
*out_len = input_index;
|
|
return output_index;
|
|
}
|
|
|
|
/* Convert BUFFER, escaped data LEN bytes long, into binary data
|
|
in OUT_BUF. Return the number of bytes written to OUT_BUF.
|
|
Raise an error if the total number of bytes exceeds OUT_MAXLEN.
|
|
|
|
This function reverses remote_escape_output. It allows more
|
|
escaped characters than that function does, in particular because
|
|
'*' must be escaped to avoid the run-length encoding processing
|
|
in reading packets. */
|
|
|
|
static int
|
|
remote_unescape_input (const gdb_byte *buffer, int len,
|
|
gdb_byte *out_buf, int out_maxlen)
|
|
{
|
|
int input_index, output_index;
|
|
int escaped;
|
|
|
|
output_index = 0;
|
|
escaped = 0;
|
|
for (input_index = 0; input_index < len; input_index++)
|
|
{
|
|
gdb_byte b = buffer[input_index];
|
|
|
|
if (output_index + 1 > out_maxlen)
|
|
error ("Received too much data from the target.");
|
|
|
|
if (escaped)
|
|
{
|
|
out_buf[output_index++] = b ^ 0x20;
|
|
escaped = 0;
|
|
}
|
|
else if (b == '}')
|
|
escaped = 1;
|
|
else
|
|
out_buf[output_index++] = b;
|
|
}
|
|
|
|
if (escaped)
|
|
error ("Unmatched escape character in target response.");
|
|
|
|
return output_index;
|
|
}
|
|
|
|
/* Look for a sequence of characters which can be run-length encoded.
|
|
If there are any, update *CSUM and *P. Otherwise, output the
|
|
single character. Return the number of characters consumed. */
|
|
|
|
static int
|
|
try_rle (char *buf, int remaining, unsigned char *csum, char **p)
|
|
{
|
|
int n;
|
|
|
|
/* Always output the character. */
|
|
*csum += buf[0];
|
|
*(*p)++ = buf[0];
|
|
|
|
/* Don't go past '~'. */
|
|
if (remaining > 97)
|
|
remaining = 97;
|
|
|
|
for (n = 1; n < remaining; n++)
|
|
if (buf[n] != buf[0])
|
|
break;
|
|
|
|
/* N is the index of the first character not the same as buf[0].
|
|
buf[0] is counted twice, so by decrementing N, we get the number
|
|
of characters the RLE sequence will replace. */
|
|
n--;
|
|
|
|
if (n < 3)
|
|
return 1;
|
|
|
|
/* Skip the frame characters. The manual says to skip '+' and '-'
|
|
also, but there's no reason to. Unfortunately these two unusable
|
|
characters double the encoded length of a four byte zero
|
|
value. */
|
|
while (n + 29 == '$' || n + 29 == '#')
|
|
n--;
|
|
|
|
*csum += '*';
|
|
*(*p)++ = '*';
|
|
*csum += n + 29;
|
|
*(*p)++ = n + 29;
|
|
|
|
return n + 1;
|
|
}
|
|
|
|
#endif
|
|
|
|
char *
|
|
unpack_varlen_hex (char *buff, /* packet to parse */
|
|
ULONGEST *result)
|
|
{
|
|
int nibble;
|
|
ULONGEST retval = 0;
|
|
|
|
while (ishex (*buff, &nibble))
|
|
{
|
|
buff++;
|
|
retval = retval << 4;
|
|
retval |= nibble & 0x0f;
|
|
}
|
|
*result = retval;
|
|
return buff;
|
|
}
|
|
|
|
#ifndef IN_PROCESS_AGENT
|
|
|
|
/* Write a PTID to BUF. Returns BUF+CHARACTERS_WRITTEN. */
|
|
|
|
char *
|
|
write_ptid (char *buf, ptid_t ptid)
|
|
{
|
|
int pid, tid;
|
|
|
|
if (multi_process)
|
|
{
|
|
pid = ptid_get_pid (ptid);
|
|
if (pid < 0)
|
|
buf += sprintf (buf, "p-%x.", -pid);
|
|
else
|
|
buf += sprintf (buf, "p%x.", pid);
|
|
}
|
|
tid = ptid_get_lwp (ptid);
|
|
if (tid < 0)
|
|
buf += sprintf (buf, "-%x", -tid);
|
|
else
|
|
buf += sprintf (buf, "%x", tid);
|
|
|
|
return buf;
|
|
}
|
|
|
|
ULONGEST
|
|
hex_or_minus_one (char *buf, char **obuf)
|
|
{
|
|
ULONGEST ret;
|
|
|
|
if (strncmp (buf, "-1", 2) == 0)
|
|
{
|
|
ret = (ULONGEST) -1;
|
|
buf += 2;
|
|
}
|
|
else
|
|
buf = unpack_varlen_hex (buf, &ret);
|
|
|
|
if (obuf)
|
|
*obuf = buf;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Extract a PTID from BUF. If non-null, OBUF is set to the to one
|
|
passed the last parsed char. Returns null_ptid on error. */
|
|
ptid_t
|
|
read_ptid (char *buf, char **obuf)
|
|
{
|
|
char *p = buf;
|
|
char *pp;
|
|
ULONGEST pid = 0, tid = 0;
|
|
|
|
if (*p == 'p')
|
|
{
|
|
/* Multi-process ptid. */
|
|
pp = unpack_varlen_hex (p + 1, &pid);
|
|
if (*pp != '.')
|
|
error ("invalid remote ptid: %s\n", p);
|
|
|
|
p = pp + 1;
|
|
|
|
tid = hex_or_minus_one (p, &pp);
|
|
|
|
if (obuf)
|
|
*obuf = pp;
|
|
return ptid_build (pid, tid, 0);
|
|
}
|
|
|
|
/* No multi-process. Just a tid. */
|
|
tid = hex_or_minus_one (p, &pp);
|
|
|
|
/* Since the stub is not sending a process id, then default to
|
|
what's in the current inferior. */
|
|
pid = ptid_get_pid (current_ptid);
|
|
|
|
if (obuf)
|
|
*obuf = pp;
|
|
return ptid_build (pid, tid, 0);
|
|
}
|
|
|
|
/* Write COUNT bytes in BUF to the client.
|
|
The result is the number of bytes written or -1 if error.
|
|
This may return less than COUNT. */
|
|
|
|
static int
|
|
write_prim (const void *buf, int count)
|
|
{
|
|
if (remote_connection_is_stdio ())
|
|
return write (fileno (stdout), buf, count);
|
|
else
|
|
return write (remote_desc, buf, count);
|
|
}
|
|
|
|
/* Read COUNT bytes from the client and store in BUF.
|
|
The result is the number of bytes read or -1 if error.
|
|
This may return less than COUNT. */
|
|
|
|
static int
|
|
read_prim (void *buf, int count)
|
|
{
|
|
if (remote_connection_is_stdio ())
|
|
return read (fileno (stdin), buf, count);
|
|
else
|
|
return read (remote_desc, buf, count);
|
|
}
|
|
|
|
/* Send a packet to the remote machine, with error checking.
|
|
The data of the packet is in BUF, and the length of the
|
|
packet is in CNT. Returns >= 0 on success, -1 otherwise. */
|
|
|
|
static int
|
|
putpkt_binary_1 (char *buf, int cnt, int is_notif)
|
|
{
|
|
int i;
|
|
unsigned char csum = 0;
|
|
char *buf2;
|
|
char *p;
|
|
int cc;
|
|
|
|
buf2 = xmalloc (strlen ("$") + cnt + strlen ("#nn") + 1);
|
|
|
|
/* Copy the packet into buffer BUF2, encapsulating it
|
|
and giving it a checksum. */
|
|
|
|
p = buf2;
|
|
if (is_notif)
|
|
*p++ = '%';
|
|
else
|
|
*p++ = '$';
|
|
|
|
for (i = 0; i < cnt;)
|
|
i += try_rle (buf + i, cnt - i, &csum, &p);
|
|
|
|
*p++ = '#';
|
|
*p++ = tohex ((csum >> 4) & 0xf);
|
|
*p++ = tohex (csum & 0xf);
|
|
|
|
*p = '\0';
|
|
|
|
/* Send it over and over until we get a positive ack. */
|
|
|
|
do
|
|
{
|
|
if (write_prim (buf2, p - buf2) != p - buf2)
|
|
{
|
|
perror ("putpkt(write)");
|
|
free (buf2);
|
|
return -1;
|
|
}
|
|
|
|
if (noack_mode || is_notif)
|
|
{
|
|
/* Don't expect an ack then. */
|
|
if (remote_debug)
|
|
{
|
|
if (is_notif)
|
|
fprintf (stderr, "putpkt (\"%s\"); [notif]\n", buf2);
|
|
else
|
|
fprintf (stderr, "putpkt (\"%s\"); [noack mode]\n", buf2);
|
|
fflush (stderr);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "putpkt (\"%s\"); [looking for ack]\n", buf2);
|
|
fflush (stderr);
|
|
}
|
|
|
|
cc = readchar ();
|
|
|
|
if (cc < 0)
|
|
{
|
|
free (buf2);
|
|
return -1;
|
|
}
|
|
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "[received '%c' (0x%x)]\n", cc, cc);
|
|
fflush (stderr);
|
|
}
|
|
|
|
/* Check for an input interrupt while we're here. */
|
|
if (cc == '\003' && current_inferior != NULL)
|
|
(*the_target->request_interrupt) ();
|
|
}
|
|
while (cc != '+');
|
|
|
|
free (buf2);
|
|
return 1; /* Success! */
|
|
}
|
|
|
|
int
|
|
putpkt_binary (char *buf, int cnt)
|
|
{
|
|
return putpkt_binary_1 (buf, cnt, 0);
|
|
}
|
|
|
|
/* Send a packet to the remote machine, with error checking. The data
|
|
of the packet is in BUF, and the packet should be a NUL-terminated
|
|
string. Returns >= 0 on success, -1 otherwise. */
|
|
|
|
int
|
|
putpkt (char *buf)
|
|
{
|
|
return putpkt_binary (buf, strlen (buf));
|
|
}
|
|
|
|
int
|
|
putpkt_notif (char *buf)
|
|
{
|
|
return putpkt_binary_1 (buf, strlen (buf), 1);
|
|
}
|
|
|
|
/* Come here when we get an input interrupt from the remote side. This
|
|
interrupt should only be active while we are waiting for the child to do
|
|
something. Thus this assumes readchar:bufcnt is 0.
|
|
About the only thing that should come through is a ^C, which
|
|
will cause us to request child interruption. */
|
|
|
|
static void
|
|
input_interrupt (int unused)
|
|
{
|
|
fd_set readset;
|
|
struct timeval immediate = { 0, 0 };
|
|
|
|
/* Protect against spurious interrupts. This has been observed to
|
|
be a problem under NetBSD 1.4 and 1.5. */
|
|
|
|
FD_ZERO (&readset);
|
|
FD_SET (remote_desc, &readset);
|
|
if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
|
|
{
|
|
int cc;
|
|
char c = 0;
|
|
|
|
cc = read_prim (&c, 1);
|
|
|
|
if (cc != 1 || c != '\003' || current_inferior == NULL)
|
|
{
|
|
fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n",
|
|
cc, c, c);
|
|
return;
|
|
}
|
|
|
|
(*the_target->request_interrupt) ();
|
|
}
|
|
}
|
|
|
|
/* Check if the remote side sent us an interrupt request (^C). */
|
|
void
|
|
check_remote_input_interrupt_request (void)
|
|
{
|
|
/* This function may be called before establishing communications,
|
|
therefore we need to validate the remote descriptor. */
|
|
|
|
if (remote_desc == INVALID_DESCRIPTOR)
|
|
return;
|
|
|
|
input_interrupt (0);
|
|
}
|
|
|
|
/* Asynchronous I/O support. SIGIO must be enabled when waiting, in order to
|
|
accept Control-C from the client, and must be disabled when talking to
|
|
the client. */
|
|
|
|
static void
|
|
unblock_async_io (void)
|
|
{
|
|
#ifndef USE_WIN32API
|
|
sigset_t sigio_set;
|
|
|
|
sigemptyset (&sigio_set);
|
|
sigaddset (&sigio_set, SIGIO);
|
|
sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
|
|
#endif
|
|
}
|
|
|
|
#ifdef __QNX__
|
|
static void
|
|
nto_comctrl (int enable)
|
|
{
|
|
struct sigevent event;
|
|
|
|
if (enable)
|
|
{
|
|
event.sigev_notify = SIGEV_SIGNAL_THREAD;
|
|
event.sigev_signo = SIGIO;
|
|
event.sigev_code = 0;
|
|
event.sigev_value.sival_ptr = NULL;
|
|
event.sigev_priority = -1;
|
|
ionotify (remote_desc, _NOTIFY_ACTION_POLLARM, _NOTIFY_COND_INPUT,
|
|
&event);
|
|
}
|
|
else
|
|
ionotify (remote_desc, _NOTIFY_ACTION_POLL, _NOTIFY_COND_INPUT, NULL);
|
|
}
|
|
#endif /* __QNX__ */
|
|
|
|
|
|
/* Current state of asynchronous I/O. */
|
|
static int async_io_enabled;
|
|
|
|
/* Enable asynchronous I/O. */
|
|
void
|
|
enable_async_io (void)
|
|
{
|
|
if (async_io_enabled)
|
|
return;
|
|
|
|
#ifndef USE_WIN32API
|
|
signal (SIGIO, input_interrupt);
|
|
#endif
|
|
async_io_enabled = 1;
|
|
#ifdef __QNX__
|
|
nto_comctrl (1);
|
|
#endif /* __QNX__ */
|
|
}
|
|
|
|
/* Disable asynchronous I/O. */
|
|
void
|
|
disable_async_io (void)
|
|
{
|
|
if (!async_io_enabled)
|
|
return;
|
|
|
|
#ifndef USE_WIN32API
|
|
signal (SIGIO, SIG_IGN);
|
|
#endif
|
|
async_io_enabled = 0;
|
|
#ifdef __QNX__
|
|
nto_comctrl (0);
|
|
#endif /* __QNX__ */
|
|
|
|
}
|
|
|
|
void
|
|
initialize_async_io (void)
|
|
{
|
|
/* Make sure that async I/O starts disabled. */
|
|
async_io_enabled = 1;
|
|
disable_async_io ();
|
|
|
|
/* Make sure the signal is unblocked. */
|
|
unblock_async_io ();
|
|
}
|
|
|
|
/* Internal buffer used by readchar.
|
|
These are global to readchar because reschedule_remote needs to be
|
|
able to tell whether the buffer is empty. */
|
|
|
|
static unsigned char readchar_buf[BUFSIZ];
|
|
static int readchar_bufcnt = 0;
|
|
static unsigned char *readchar_bufp;
|
|
|
|
/* Returns next char from remote GDB. -1 if error. */
|
|
|
|
static int
|
|
readchar (void)
|
|
{
|
|
int ch;
|
|
|
|
if (readchar_bufcnt == 0)
|
|
{
|
|
readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
|
|
|
|
if (readchar_bufcnt <= 0)
|
|
{
|
|
if (readchar_bufcnt == 0)
|
|
fprintf (stderr, "readchar: Got EOF\n");
|
|
else
|
|
perror ("readchar");
|
|
|
|
return -1;
|
|
}
|
|
|
|
readchar_bufp = readchar_buf;
|
|
}
|
|
|
|
readchar_bufcnt--;
|
|
ch = *readchar_bufp++;
|
|
reschedule ();
|
|
return ch;
|
|
}
|
|
|
|
/* Reset the readchar state machine. */
|
|
|
|
static void
|
|
reset_readchar (void)
|
|
{
|
|
readchar_bufcnt = 0;
|
|
if (readchar_callback != NOT_SCHEDULED)
|
|
{
|
|
delete_callback_event (readchar_callback);
|
|
readchar_callback = NOT_SCHEDULED;
|
|
}
|
|
}
|
|
|
|
/* Process remaining data in readchar_buf. */
|
|
|
|
static int
|
|
process_remaining (void *context)
|
|
{
|
|
int res;
|
|
|
|
/* This is a one-shot event. */
|
|
readchar_callback = NOT_SCHEDULED;
|
|
|
|
if (readchar_bufcnt > 0)
|
|
res = handle_serial_event (0, NULL);
|
|
else
|
|
res = 0;
|
|
|
|
return res;
|
|
}
|
|
|
|
/* If there is still data in the buffer, queue another event to process it,
|
|
we can't sleep in select yet. */
|
|
|
|
static void
|
|
reschedule (void)
|
|
{
|
|
if (readchar_bufcnt > 0 && readchar_callback == NOT_SCHEDULED)
|
|
readchar_callback = append_callback_event (process_remaining, NULL);
|
|
}
|
|
|
|
/* Read a packet from the remote machine, with error checking,
|
|
and store it in BUF. Returns length of packet, or negative if error. */
|
|
|
|
int
|
|
getpkt (char *buf)
|
|
{
|
|
char *bp;
|
|
unsigned char csum, c1, c2;
|
|
int c;
|
|
|
|
while (1)
|
|
{
|
|
csum = 0;
|
|
|
|
while (1)
|
|
{
|
|
c = readchar ();
|
|
if (c == '$')
|
|
break;
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "[getpkt: discarding char '%c']\n", c);
|
|
fflush (stderr);
|
|
}
|
|
|
|
if (c < 0)
|
|
return -1;
|
|
}
|
|
|
|
bp = buf;
|
|
while (1)
|
|
{
|
|
c = readchar ();
|
|
if (c < 0)
|
|
return -1;
|
|
if (c == '#')
|
|
break;
|
|
*bp++ = c;
|
|
csum += c;
|
|
}
|
|
*bp = 0;
|
|
|
|
c1 = fromhex (readchar ());
|
|
c2 = fromhex (readchar ());
|
|
|
|
if (csum == (c1 << 4) + c2)
|
|
break;
|
|
|
|
if (noack_mode)
|
|
{
|
|
fprintf (stderr,
|
|
"Bad checksum, sentsum=0x%x, csum=0x%x, "
|
|
"buf=%s [no-ack-mode, Bad medium?]\n",
|
|
(c1 << 4) + c2, csum, buf);
|
|
/* Not much we can do, GDB wasn't expecting an ack/nac. */
|
|
break;
|
|
}
|
|
|
|
fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
|
|
(c1 << 4) + c2, csum, buf);
|
|
if (write_prim ("-", 1) != 1)
|
|
return -1;
|
|
}
|
|
|
|
if (!noack_mode)
|
|
{
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "getpkt (\"%s\"); [sending ack] \n", buf);
|
|
fflush (stderr);
|
|
}
|
|
|
|
if (write_prim ("+", 1) != 1)
|
|
return -1;
|
|
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "[sent ack]\n");
|
|
fflush (stderr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (remote_debug)
|
|
{
|
|
fprintf (stderr, "getpkt (\"%s\"); [no ack sent] \n", buf);
|
|
fflush (stderr);
|
|
}
|
|
}
|
|
|
|
return bp - buf;
|
|
}
|
|
|
|
void
|
|
write_ok (char *buf)
|
|
{
|
|
buf[0] = 'O';
|
|
buf[1] = 'K';
|
|
buf[2] = '\0';
|
|
}
|
|
|
|
void
|
|
write_enn (char *buf)
|
|
{
|
|
/* Some day, we should define the meanings of the error codes... */
|
|
buf[0] = 'E';
|
|
buf[1] = '0';
|
|
buf[2] = '1';
|
|
buf[3] = '\0';
|
|
}
|
|
|
|
#endif
|
|
|
|
void
|
|
convert_int_to_ascii (const unsigned char *from, char *to, int n)
|
|
{
|
|
int nib;
|
|
int ch;
|
|
while (n--)
|
|
{
|
|
ch = *from++;
|
|
nib = ((ch & 0xf0) >> 4) & 0x0f;
|
|
*to++ = tohex (nib);
|
|
nib = ch & 0x0f;
|
|
*to++ = tohex (nib);
|
|
}
|
|
*to++ = 0;
|
|
}
|
|
|
|
#ifndef IN_PROCESS_AGENT
|
|
|
|
void
|
|
convert_ascii_to_int (const char *from, unsigned char *to, int n)
|
|
{
|
|
int nib1, nib2;
|
|
while (n--)
|
|
{
|
|
nib1 = fromhex (*from++);
|
|
nib2 = fromhex (*from++);
|
|
*to++ = (((nib1 & 0x0f) << 4) & 0xf0) | (nib2 & 0x0f);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
outreg (struct regcache *regcache, int regno, char *buf)
|
|
{
|
|
if ((regno >> 12) != 0)
|
|
*buf++ = tohex ((regno >> 12) & 0xf);
|
|
if ((regno >> 8) != 0)
|
|
*buf++ = tohex ((regno >> 8) & 0xf);
|
|
*buf++ = tohex ((regno >> 4) & 0xf);
|
|
*buf++ = tohex (regno & 0xf);
|
|
*buf++ = ':';
|
|
collect_register_as_string (regcache, regno, buf);
|
|
buf += 2 * register_size (regcache->tdesc, regno);
|
|
*buf++ = ';';
|
|
|
|
return buf;
|
|
}
|
|
|
|
void
|
|
new_thread_notify (int id)
|
|
{
|
|
char own_buf[256];
|
|
|
|
/* The `n' response is not yet part of the remote protocol. Do nothing. */
|
|
if (1)
|
|
return;
|
|
|
|
if (server_waiting == 0)
|
|
return;
|
|
|
|
sprintf (own_buf, "n%x", id);
|
|
disable_async_io ();
|
|
putpkt (own_buf);
|
|
enable_async_io ();
|
|
}
|
|
|
|
void
|
|
dead_thread_notify (int id)
|
|
{
|
|
char own_buf[256];
|
|
|
|
/* The `x' response is not yet part of the remote protocol. Do nothing. */
|
|
if (1)
|
|
return;
|
|
|
|
sprintf (own_buf, "x%x", id);
|
|
disable_async_io ();
|
|
putpkt (own_buf);
|
|
enable_async_io ();
|
|
}
|
|
|
|
void
|
|
prepare_resume_reply (char *buf, ptid_t ptid,
|
|
struct target_waitstatus *status)
|
|
{
|
|
if (debug_threads)
|
|
fprintf (stderr, "Writing resume reply for %s:%d\n",
|
|
target_pid_to_str (ptid), status->kind);
|
|
|
|
switch (status->kind)
|
|
{
|
|
case TARGET_WAITKIND_STOPPED:
|
|
{
|
|
struct thread_info *saved_inferior;
|
|
const char **regp;
|
|
struct regcache *regcache;
|
|
|
|
sprintf (buf, "T%02x", status->value.sig);
|
|
buf += strlen (buf);
|
|
|
|
saved_inferior = current_inferior;
|
|
|
|
current_inferior = find_thread_ptid (ptid);
|
|
|
|
regp = current_target_desc ()->expedite_regs;
|
|
|
|
regcache = get_thread_regcache (current_inferior, 1);
|
|
|
|
if (the_target->stopped_by_watchpoint != NULL
|
|
&& (*the_target->stopped_by_watchpoint) ())
|
|
{
|
|
CORE_ADDR addr;
|
|
int i;
|
|
|
|
strncpy (buf, "watch:", 6);
|
|
buf += 6;
|
|
|
|
addr = (*the_target->stopped_data_address) ();
|
|
|
|
/* Convert each byte of the address into two hexadecimal
|
|
chars. Note that we take sizeof (void *) instead of
|
|
sizeof (addr); this is to avoid sending a 64-bit
|
|
address to a 32-bit GDB. */
|
|
for (i = sizeof (void *) * 2; i > 0; i--)
|
|
*buf++ = tohex ((addr >> (i - 1) * 4) & 0xf);
|
|
*buf++ = ';';
|
|
}
|
|
|
|
while (*regp)
|
|
{
|
|
buf = outreg (regcache, find_regno (regcache->tdesc, *regp), buf);
|
|
regp ++;
|
|
}
|
|
*buf = '\0';
|
|
|
|
/* Formerly, if the debugger had not used any thread features
|
|
we would not burden it with a thread status response. This
|
|
was for the benefit of GDB 4.13 and older. However, in
|
|
recent GDB versions the check (``if (cont_thread != 0)'')
|
|
does not have the desired effect because of sillyness in
|
|
the way that the remote protocol handles specifying a
|
|
thread. Since thread support relies on qSymbol support
|
|
anyway, assume GDB can handle threads. */
|
|
|
|
if (using_threads && !disable_packet_Tthread)
|
|
{
|
|
/* This if (1) ought to be unnecessary. But remote_wait
|
|
in GDB will claim this event belongs to inferior_ptid
|
|
if we do not specify a thread, and there's no way for
|
|
gdbserver to know what inferior_ptid is. */
|
|
if (1 || !ptid_equal (general_thread, ptid))
|
|
{
|
|
int core = -1;
|
|
/* In non-stop, don't change the general thread behind
|
|
GDB's back. */
|
|
if (!non_stop)
|
|
general_thread = ptid;
|
|
sprintf (buf, "thread:");
|
|
buf += strlen (buf);
|
|
buf = write_ptid (buf, ptid);
|
|
strcat (buf, ";");
|
|
buf += strlen (buf);
|
|
|
|
core = target_core_of_thread (ptid);
|
|
|
|
if (core != -1)
|
|
{
|
|
sprintf (buf, "core:");
|
|
buf += strlen (buf);
|
|
sprintf (buf, "%x", core);
|
|
strcat (buf, ";");
|
|
buf += strlen (buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dlls_changed)
|
|
{
|
|
strcpy (buf, "library:;");
|
|
buf += strlen (buf);
|
|
dlls_changed = 0;
|
|
}
|
|
|
|
current_inferior = saved_inferior;
|
|
}
|
|
break;
|
|
case TARGET_WAITKIND_EXITED:
|
|
if (multi_process)
|
|
sprintf (buf, "W%x;process:%x",
|
|
status->value.integer, ptid_get_pid (ptid));
|
|
else
|
|
sprintf (buf, "W%02x", status->value.integer);
|
|
break;
|
|
case TARGET_WAITKIND_SIGNALLED:
|
|
if (multi_process)
|
|
sprintf (buf, "X%x;process:%x",
|
|
status->value.sig, ptid_get_pid (ptid));
|
|
else
|
|
sprintf (buf, "X%02x", status->value.sig);
|
|
break;
|
|
default:
|
|
error ("unhandled waitkind");
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
decode_m_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr)
|
|
{
|
|
int i = 0, j = 0;
|
|
char ch;
|
|
*mem_addr_ptr = *len_ptr = 0;
|
|
|
|
while ((ch = from[i++]) != ',')
|
|
{
|
|
*mem_addr_ptr = *mem_addr_ptr << 4;
|
|
*mem_addr_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
if ((ch = from[i++]) == 0)
|
|
break;
|
|
*len_ptr = *len_ptr << 4;
|
|
*len_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
}
|
|
|
|
void
|
|
decode_M_packet (char *from, CORE_ADDR *mem_addr_ptr, unsigned int *len_ptr,
|
|
unsigned char **to_p)
|
|
{
|
|
int i = 0;
|
|
char ch;
|
|
*mem_addr_ptr = *len_ptr = 0;
|
|
|
|
while ((ch = from[i++]) != ',')
|
|
{
|
|
*mem_addr_ptr = *mem_addr_ptr << 4;
|
|
*mem_addr_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
while ((ch = from[i++]) != ':')
|
|
{
|
|
*len_ptr = *len_ptr << 4;
|
|
*len_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
if (*to_p == NULL)
|
|
*to_p = xmalloc (*len_ptr);
|
|
|
|
convert_ascii_to_int (&from[i++], *to_p, *len_ptr);
|
|
}
|
|
|
|
int
|
|
decode_X_packet (char *from, int packet_len, CORE_ADDR *mem_addr_ptr,
|
|
unsigned int *len_ptr, unsigned char **to_p)
|
|
{
|
|
int i = 0;
|
|
char ch;
|
|
*mem_addr_ptr = *len_ptr = 0;
|
|
|
|
while ((ch = from[i++]) != ',')
|
|
{
|
|
*mem_addr_ptr = *mem_addr_ptr << 4;
|
|
*mem_addr_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
while ((ch = from[i++]) != ':')
|
|
{
|
|
*len_ptr = *len_ptr << 4;
|
|
*len_ptr |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
if (*to_p == NULL)
|
|
*to_p = xmalloc (*len_ptr);
|
|
|
|
if (remote_unescape_input ((const gdb_byte *) &from[i], packet_len - i,
|
|
*to_p, *len_ptr) != *len_ptr)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Decode a qXfer write request. */
|
|
|
|
int
|
|
decode_xfer_write (char *buf, int packet_len, CORE_ADDR *offset,
|
|
unsigned int *len, unsigned char *data)
|
|
{
|
|
char ch;
|
|
char *b = buf;
|
|
|
|
/* Extract the offset. */
|
|
*offset = 0;
|
|
while ((ch = *buf++) != ':')
|
|
{
|
|
*offset = *offset << 4;
|
|
*offset |= fromhex (ch) & 0x0f;
|
|
}
|
|
|
|
/* Get encoded data. */
|
|
packet_len -= buf - b;
|
|
*len = remote_unescape_input ((const gdb_byte *) buf, packet_len,
|
|
data, packet_len);
|
|
return 0;
|
|
}
|
|
|
|
/* Decode the parameters of a qSearch:memory packet. */
|
|
|
|
int
|
|
decode_search_memory_packet (const char *buf, int packet_len,
|
|
CORE_ADDR *start_addrp,
|
|
CORE_ADDR *search_space_lenp,
|
|
gdb_byte *pattern, unsigned int *pattern_lenp)
|
|
{
|
|
const char *p = buf;
|
|
|
|
p = decode_address_to_semicolon (start_addrp, p);
|
|
p = decode_address_to_semicolon (search_space_lenp, p);
|
|
packet_len -= p - buf;
|
|
*pattern_lenp = remote_unescape_input ((const gdb_byte *) p, packet_len,
|
|
pattern, packet_len);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
free_sym_cache (struct sym_cache *sym)
|
|
{
|
|
if (sym != NULL)
|
|
{
|
|
free (sym->name);
|
|
free (sym);
|
|
}
|
|
}
|
|
|
|
void
|
|
clear_symbol_cache (struct sym_cache **symcache_p)
|
|
{
|
|
struct sym_cache *sym, *next;
|
|
|
|
/* Check the cache first. */
|
|
for (sym = *symcache_p; sym; sym = next)
|
|
{
|
|
next = sym->next;
|
|
free_sym_cache (sym);
|
|
}
|
|
|
|
*symcache_p = NULL;
|
|
}
|
|
|
|
/* Get the address of NAME, and return it in ADDRP if found. if
|
|
MAY_ASK_GDB is false, assume symbol cache misses are failures.
|
|
Returns 1 if the symbol is found, 0 if it is not, -1 on error. */
|
|
|
|
int
|
|
look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
|
|
{
|
|
char own_buf[266], *p, *q;
|
|
int len;
|
|
struct sym_cache *sym;
|
|
struct process_info *proc;
|
|
|
|
proc = current_process ();
|
|
|
|
/* Check the cache first. */
|
|
for (sym = proc->symbol_cache; sym; sym = sym->next)
|
|
if (strcmp (name, sym->name) == 0)
|
|
{
|
|
*addrp = sym->addr;
|
|
return 1;
|
|
}
|
|
|
|
/* It might not be an appropriate time to look up a symbol,
|
|
e.g. while we're trying to fetch registers. */
|
|
if (!may_ask_gdb)
|
|
return 0;
|
|
|
|
/* Send the request. */
|
|
strcpy (own_buf, "qSymbol:");
|
|
hexify (own_buf + strlen ("qSymbol:"), name, strlen (name));
|
|
if (putpkt (own_buf) < 0)
|
|
return -1;
|
|
|
|
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
|
|
len = getpkt (own_buf);
|
|
if (len < 0)
|
|
return -1;
|
|
|
|
/* We ought to handle pretty much any packet at this point while we
|
|
wait for the qSymbol "response". That requires re-entering the
|
|
main loop. For now, this is an adequate approximation; allow
|
|
GDB to read from memory while it figures out the address of the
|
|
symbol. */
|
|
while (own_buf[0] == 'm')
|
|
{
|
|
CORE_ADDR mem_addr;
|
|
unsigned char *mem_buf;
|
|
unsigned int mem_len;
|
|
|
|
decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
|
|
mem_buf = xmalloc (mem_len);
|
|
if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
|
|
convert_int_to_ascii (mem_buf, own_buf, mem_len);
|
|
else
|
|
write_enn (own_buf);
|
|
free (mem_buf);
|
|
if (putpkt (own_buf) < 0)
|
|
return -1;
|
|
len = getpkt (own_buf);
|
|
if (len < 0)
|
|
return -1;
|
|
}
|
|
|
|
if (strncmp (own_buf, "qSymbol:", strlen ("qSymbol:")) != 0)
|
|
{
|
|
warning ("Malformed response to qSymbol, ignoring: %s\n", own_buf);
|
|
return -1;
|
|
}
|
|
|
|
p = own_buf + strlen ("qSymbol:");
|
|
q = p;
|
|
while (*q && *q != ':')
|
|
q++;
|
|
|
|
/* Make sure we found a value for the symbol. */
|
|
if (p == q || *q == '\0')
|
|
return 0;
|
|
|
|
decode_address (addrp, p, q - p);
|
|
|
|
/* Save the symbol in our cache. */
|
|
sym = xmalloc (sizeof (*sym));
|
|
sym->name = xstrdup (name);
|
|
sym->addr = *addrp;
|
|
sym->next = proc->symbol_cache;
|
|
proc->symbol_cache = sym;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Relocate an instruction to execute at a different address. OLDLOC
|
|
is the address in the inferior memory where the instruction to
|
|
relocate is currently at. On input, TO points to the destination
|
|
where we want the instruction to be copied (and possibly adjusted)
|
|
to. On output, it points to one past the end of the resulting
|
|
instruction(s). The effect of executing the instruction at TO
|
|
shall be the same as if executing it at OLDLOC. For example, call
|
|
instructions that implicitly push the return address on the stack
|
|
should be adjusted to return to the instruction after OLDLOC;
|
|
relative branches, and other PC-relative instructions need the
|
|
offset adjusted; etc. Returns 0 on success, -1 on failure. */
|
|
|
|
int
|
|
relocate_instruction (CORE_ADDR *to, CORE_ADDR oldloc)
|
|
{
|
|
char own_buf[266];
|
|
int len;
|
|
ULONGEST written = 0;
|
|
|
|
/* Send the request. */
|
|
strcpy (own_buf, "qRelocInsn:");
|
|
sprintf (own_buf, "qRelocInsn:%s;%s", paddress (oldloc),
|
|
paddress (*to));
|
|
if (putpkt (own_buf) < 0)
|
|
return -1;
|
|
|
|
/* FIXME: Eventually add buffer overflow checking (to getpkt?) */
|
|
len = getpkt (own_buf);
|
|
if (len < 0)
|
|
return -1;
|
|
|
|
/* We ought to handle pretty much any packet at this point while we
|
|
wait for the qRelocInsn "response". That requires re-entering
|
|
the main loop. For now, this is an adequate approximation; allow
|
|
GDB to access memory. */
|
|
while (own_buf[0] == 'm' || own_buf[0] == 'M' || own_buf[0] == 'X')
|
|
{
|
|
CORE_ADDR mem_addr;
|
|
unsigned char *mem_buf = NULL;
|
|
unsigned int mem_len;
|
|
|
|
if (own_buf[0] == 'm')
|
|
{
|
|
decode_m_packet (&own_buf[1], &mem_addr, &mem_len);
|
|
mem_buf = xmalloc (mem_len);
|
|
if (read_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
|
|
convert_int_to_ascii (mem_buf, own_buf, mem_len);
|
|
else
|
|
write_enn (own_buf);
|
|
}
|
|
else if (own_buf[0] == 'X')
|
|
{
|
|
if (decode_X_packet (&own_buf[1], len - 1, &mem_addr,
|
|
&mem_len, &mem_buf) < 0
|
|
|| write_inferior_memory (mem_addr, mem_buf, mem_len) != 0)
|
|
write_enn (own_buf);
|
|
else
|
|
write_ok (own_buf);
|
|
}
|
|
else
|
|
{
|
|
decode_M_packet (&own_buf[1], &mem_addr, &mem_len, &mem_buf);
|
|
if (write_inferior_memory (mem_addr, mem_buf, mem_len) == 0)
|
|
write_ok (own_buf);
|
|
else
|
|
write_enn (own_buf);
|
|
}
|
|
free (mem_buf);
|
|
if (putpkt (own_buf) < 0)
|
|
return -1;
|
|
len = getpkt (own_buf);
|
|
if (len < 0)
|
|
return -1;
|
|
}
|
|
|
|
if (own_buf[0] == 'E')
|
|
{
|
|
warning ("An error occurred while relocating an instruction: %s\n",
|
|
own_buf);
|
|
return -1;
|
|
}
|
|
|
|
if (strncmp (own_buf, "qRelocInsn:", strlen ("qRelocInsn:")) != 0)
|
|
{
|
|
warning ("Malformed response to qRelocInsn, ignoring: %s\n",
|
|
own_buf);
|
|
return -1;
|
|
}
|
|
|
|
unpack_varlen_hex (own_buf + strlen ("qRelocInsn:"), &written);
|
|
|
|
*to += written;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
monitor_output (const char *msg)
|
|
{
|
|
char *buf = xmalloc (strlen (msg) * 2 + 2);
|
|
|
|
buf[0] = 'O';
|
|
hexify (buf + 1, msg, 0);
|
|
|
|
putpkt (buf);
|
|
free (buf);
|
|
}
|
|
|
|
#endif
|