mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-23 01:53:38 +08:00
1048062a3f
Problem Description ------------------- On a Windows machine I built gdbserver, configured for the target 'x86_64-w64-mingw32', then on a GNU/Linux machine I built GDB with support for all target (--enable-targets=all). On the Windows machine I start gdbserver with a small test binary: $ gdbserver 192.168.129.25:54321 C:\some\directory\executable.exe On the GNU/Linux machine I start GDB without the test binary, and connect to gdbserver. As I have not given GDB the test binary, my expectation is that GDB would connect to gdbserver and then download the file over the remote protocol, but instead I was presented with this message: (gdb) target remote 192.168.129.25:54321 Remote debugging using 192.168.129.25:54321 warning: C:\some\directory\executable.exe: No such file or directory. 0x00007ffa3e1e1741 in ?? () (gdb) What I found is that if I told GDB where to find the binary, like this: (gdb) file target:C:/some/directory/executable.exe A program is being debugged already. Are you sure you want to change the file? (y or n) y Reading C:/some/directory/executable.exe from remote target... warning: File transfers from remote targets can be slow. Use "set sysroot" to access files locally instead. Reading C:/some/directory/executable.exe from remote target... Reading symbols from target:C:/some/directory/executable.exe... (gdb) then GDB would download the executable. The Actual Issue ---------------- I tracked the problem down to exec_file_find (solib.c). The remote target was passing an absolute Windows filename (beginning with "C:/" in this case), but in exec_file_find GDB was failing the IS_TARGET_ABSOLUTE_PATH call, and so was treating the filename as relative. The IS_TARGET_ABSOLUTE_PATH call was failing because GDB thought that the file system kind was "unix", and as the filename didn't start with a "/" it assumed the filename was not absolute. But I'm connecting to a Windows target and 'target-file-system-kind' was set to "auto", so GDB should be figuring out that the target file-system is "dos-based". Looking in effective_target_file_system_kind (filesystem.c), we find that the logic of "auto" is delegated to the current gdbarch. However in windows-tdep.c we see: set_gdbarch_has_dos_based_file_system (gdbarch, 1); So if we are using a Windows gdbarch we should have "dos-based" filesystems. What this means is that after connecting to the remote target GDB has selected the wrong gdbarch. What's happening is that the target description sent back by the remote target only includes the x86-64 registers. There's no information about which OS we're on. As a consequence, GDB picks the first x86-64 gdbarch which can handle the provided register set, which happens to be a GNU/Linux gdbarch. And indeed, there doesn't appear to be anywhere in gdbserver that sets the osabi on the target descriptions. Some target descriptions do have their osabi set when the description is created, e.g. in: gdb/arch/amd64.c - Sets GNU/Linux osabi when appropriate. gdb/arch/i386.c - Likewise. gdb/arch/tic6x.c - Always set GNU/Linux osabi. There are also some cases in gdb/features/*.c where the tdesc is set, but these locations are only called from GDB, not from gdbserver. This means that many target descriptions are created without an osabi, gdbserver does nothing to fix this, and the description is returned to GDB without an osabi included. This leaves GDB having to guess what the target osabi is, and in some cases, GDB can get this wrong. Proposed Solution ----------------- I propose to change init_target_desc so that it requires an gdb_osabi to be passed in, this will then be used to set the target_desc osabi field. I believe that within gdbserver init_target_desc is called for every target_desc, so this should mean that every target_desc has an opportunity to set the osabi to something sane. I did consider passing the osabi into the code which creates the target_desc objects, but that would require updating far more code, as each target has its own code for creating target descriptions. The approach taken here requires minimal changes and forces every user of init_target_desc to think about what the correct osabi is. In some cases, e.g. amd64, where the osabi is already set when the target_desc is created, the init_target_desc call will override the current value, however, we should always be replacing it with the same actual value. i.e. if the target_desc is created with the osabi set to GNU/Linux, then this should only happen when gdbserver is built for GNU/Linux, in which case the init_target_desc should also be setting the osabi to GNU/Linux. The Tricky Bits --------------- Some targets, like amd64, use a features based approach for creating target_desc objects, there's a function in arch/amd64.c which creates a target_desc, adds features too it, and returns the new target_desc. This target_desc is then passed to an init_target_desc call within gdbserver. This is the easy case to handle. Then there are other targets which instead have a fixed set of xml files, each of which is converted into a .dat file, which is then used to generate a .cc file, which is compiled into gdbserver. The generated .cc file creates the target_desc object and calls init_target_desc on it. In this case though the target description that is sent to GDB isn't generated from the target_desc object, but is instead the contents of the fixed xml file. For this case the osabi which we pass to init_target_desc should match the osabi that exists in the fixed xml file. Luckily, in the previous commit I copied the osabi information from the fixed xml files into the .dat files. So in this commit I have extended regdat.sh to read the osabi from the .dat file and use it in the generated init_target_desc call. The problem with some of these .dat base targets is that their fixed xml files don't currently contain any osabi information, and the file names don't indicate that they are Linux only (despite them currently only being used from gdbserver for Linux targets), so I don't currently feel confident adding any osabi information to these files. An example would be features/rs6000/powerpc-64.xml. For now I've just ignored these cases. The init_target_desc will use GDB_OSABI_UNKNOWN which is the default. This means that for these targets nothing changes from the current behaviour. But many other targets do now pass the osabi back. Targets that do pass the osabi back are improved with this commit. Conclusion ---------- Now when I connect to the Windows remote the target description returned includes the osabi name. With this extra information GDB selects the correct gdbarch object, which means that GDB understands the target has a "dos-based" file-system. With that correct GDB understands that the filename it was given is absolute, and so fetches the file from the remote as we'd like. Reviewed-By: Kevin Buettner <kevinb@redhat.com>
354 lines
9.6 KiB
C++
354 lines
9.6 KiB
C++
/* GNU/Linux/MIPS specific low level interface, for the remote server for GDB.
|
|
Copyright (C) 2022-2024 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 "tdesc.h"
|
|
#include "linux-low.h"
|
|
#include <sys/ptrace.h>
|
|
#include "gdb_proc_service.h"
|
|
#include <asm/ptrace.h>
|
|
#include <elf.h>
|
|
#include "arch/csky.h"
|
|
|
|
/* Linux target op definitions for the CSKY architecture. */
|
|
|
|
class csky_target : public linux_process_target
|
|
{
|
|
public:
|
|
|
|
const regs_info *get_regs_info () override;
|
|
|
|
const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override;
|
|
|
|
bool supports_z_point_type (char z_type) override;
|
|
|
|
bool supports_hardware_single_step () override;
|
|
|
|
protected:
|
|
|
|
void low_arch_setup () override;
|
|
|
|
bool low_cannot_fetch_register (int regno) override;
|
|
|
|
bool low_cannot_store_register (int regno) override;
|
|
|
|
CORE_ADDR low_get_pc (regcache *regcache) override;
|
|
|
|
void low_set_pc (regcache *regcache, CORE_ADDR newpc) override;
|
|
|
|
bool low_breakpoint_at (CORE_ADDR pc) override;
|
|
};
|
|
|
|
/* The singleton target ops object. */
|
|
|
|
static csky_target the_csky_target;
|
|
|
|
/* Return the ptrace "address" of register REGNO. */
|
|
static int csky_regmap[] = {
|
|
0*4, 1*4, 2*4, 3*4, 4*4, 5*4, 6*4, 7*4,
|
|
8*4, 9*4, 10*4, 11*4, 12*4, 13*4, 14*4, 15*4,
|
|
16*4, 17*4, 18*4, 19*4, 20*4, 21*4, 22*4, 23*4,
|
|
24*4, 25*4, 26*4, 27*4, 28*4, 29*4, 30*4, 31*4,
|
|
-1, -1, -1, -1, 34*4, 35*4, -1, -1,
|
|
40*4, 42*4, 44*4, 46*4, 48*4, 50*4, 52*4, 54*4, /* fr0 ~ fr15, 64bit */
|
|
56*4, 58*4, 60*4, 62*4, 64*4, 66*4, 68*4, 70*4,
|
|
72*4, 76*4, 80*4, 84*4, 88*4, 92*4, 96*4,100*4, /* vr0 ~ vr15, 128bit */
|
|
104*4,108*4,112*4,116*4,120*4,124*4,128*4,132*4,
|
|
33*4, /* pc */
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
32*4, -1, -1, -1, -1, -1, -1, -1, /* psr */
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
73*4, 72*4, 74*4, -1, -1, -1, 14*4, /* fcr, fid, fesr, usp */
|
|
};
|
|
|
|
/* CSKY software breakpoint instruction code. */
|
|
|
|
/* When the kernel code version is behind v4.x,
|
|
illegal insn 0x1464 will be a software bkpt trigger.
|
|
When an illegal insn exception happens, the case
|
|
that insn at EPC is 0x1464 will be recognized as SIGTRAP. */
|
|
static unsigned short csky_breakpoint_illegal_2_v2 = 0x1464;
|
|
static unsigned int csky_breakpoint_illegal_4_v2 = 0x14641464;
|
|
|
|
bool
|
|
csky_target::low_cannot_fetch_register (int regno)
|
|
{
|
|
if (csky_regmap[regno] == -1)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
csky_target::low_cannot_store_register (int regno)
|
|
{
|
|
if (csky_regmap[regno] == -1)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Get the value of pc register. */
|
|
|
|
CORE_ADDR
|
|
csky_target::low_get_pc (struct regcache *regcache)
|
|
{
|
|
unsigned long pc;
|
|
collect_register_by_name (regcache, "pc", &pc);
|
|
return pc;
|
|
}
|
|
|
|
/* Set pc register. */
|
|
|
|
void
|
|
csky_target::low_set_pc (struct regcache *regcache, CORE_ADDR pc)
|
|
{
|
|
unsigned long new_pc = pc;
|
|
supply_register_by_name (regcache, "pc", &new_pc);
|
|
}
|
|
|
|
|
|
void
|
|
csky_target::low_arch_setup ()
|
|
{
|
|
static const char *expedite_regs[] = { "r14", "pc", NULL };
|
|
target_desc_up tdesc = csky_create_target_description ();
|
|
|
|
if (tdesc->expedite_regs.empty ())
|
|
{
|
|
init_target_desc (tdesc.get (), expedite_regs, GDB_OSABI_LINUX);
|
|
gdb_assert (!tdesc->expedite_regs.empty ());
|
|
}
|
|
|
|
current_process ()->tdesc = tdesc.release ();
|
|
|
|
return;
|
|
}
|
|
|
|
/* Fetch the thread-local storage pointer for libthread_db. */
|
|
|
|
ps_err_e
|
|
ps_get_thread_area (struct ps_prochandle *ph,
|
|
lwpid_t lwpid, int idx, void **base)
|
|
{
|
|
struct pt_regs regset;
|
|
if (ptrace (PTRACE_GETREGSET, lwpid,
|
|
(PTRACE_TYPE_ARG3) (long) NT_PRSTATUS, ®set) != 0)
|
|
return PS_ERR;
|
|
|
|
*base = (void *) regset.tls;
|
|
|
|
/* IDX is the bias from the thread pointer to the beginning of the
|
|
thread descriptor. It has to be subtracted due to implementation
|
|
quirks in libthread_db. */
|
|
*base = (void *) ((char *)*base - idx);
|
|
|
|
return PS_OK;
|
|
}
|
|
|
|
/* Gdbserver uses PTRACE_GET/SET_RGESET. */
|
|
|
|
static void
|
|
csky_fill_pt_gregset (struct regcache *regcache, void *buf)
|
|
{
|
|
int i, base;
|
|
struct pt_regs *regset = (struct pt_regs *)buf;
|
|
|
|
collect_register_by_name (regcache, "r15", ®set->lr);
|
|
collect_register_by_name (regcache, "pc", ®set->pc);
|
|
collect_register_by_name (regcache, "psr", ®set->sr);
|
|
collect_register_by_name (regcache, "r14", ®set->usp);
|
|
|
|
collect_register_by_name (regcache, "r0", ®set->a0);
|
|
collect_register_by_name (regcache, "r1", ®set->a1);
|
|
collect_register_by_name (regcache, "r2", ®set->a2);
|
|
collect_register_by_name (regcache, "r3", ®set->a3);
|
|
|
|
base = find_regno (regcache->tdesc, "r4");
|
|
|
|
for (i = 0; i < 10; i++)
|
|
collect_register (regcache, base + i, ®set->regs[i]);
|
|
|
|
base = find_regno (regcache->tdesc, "r16");
|
|
for (i = 0; i < 16; i++)
|
|
collect_register (regcache, base + i, ®set->exregs[i]);
|
|
|
|
collect_register_by_name (regcache, "hi", ®set->rhi);
|
|
collect_register_by_name (regcache, "lo", ®set->rlo);
|
|
}
|
|
|
|
static void
|
|
csky_store_pt_gregset (struct regcache *regcache, const void *buf)
|
|
{
|
|
int i, base;
|
|
const struct pt_regs *regset = (const struct pt_regs *) buf;
|
|
|
|
supply_register_by_name (regcache, "r15", ®set->lr);
|
|
supply_register_by_name (regcache, "pc", ®set->pc);
|
|
supply_register_by_name (regcache, "psr", ®set->sr);
|
|
supply_register_by_name (regcache, "r14", ®set->usp);
|
|
|
|
supply_register_by_name (regcache, "r0", ®set->a0);
|
|
supply_register_by_name (regcache, "r1", ®set->a1);
|
|
supply_register_by_name (regcache, "r2", ®set->a2);
|
|
supply_register_by_name (regcache, "r3", ®set->a3);
|
|
|
|
base = find_regno (regcache->tdesc, "r4");
|
|
|
|
for (i = 0; i < 10; i++)
|
|
supply_register (regcache, base + i, ®set->regs[i]);
|
|
|
|
base = find_regno (regcache->tdesc, "r16");
|
|
for (i = 0; i < 16; i++)
|
|
supply_register (regcache, base + i, ®set->exregs[i]);
|
|
|
|
supply_register_by_name (regcache, "hi", ®set->rhi);
|
|
supply_register_by_name (regcache, "lo", ®set->rlo);
|
|
}
|
|
|
|
static void
|
|
csky_fill_pt_vrregset (struct regcache *regcache, void *buf)
|
|
{
|
|
int i, base;
|
|
struct user_fp *regset = (struct user_fp *)buf;
|
|
|
|
base = find_regno (regcache->tdesc, "vr0");
|
|
|
|
for (i = 0; i < 16; i++)
|
|
collect_register (regcache, base + i, ®set->vr[i * 4]);
|
|
collect_register_by_name (regcache, "fcr", ®set->fcr);
|
|
collect_register_by_name (regcache, "fesr", ®set->fesr);
|
|
collect_register_by_name (regcache, "fid", ®set->fid);
|
|
}
|
|
|
|
|
|
static void
|
|
csky_store_pt_vrregset (struct regcache *regcache, const void *buf)
|
|
{
|
|
int i, base;
|
|
const struct user_fp *regset = (const struct user_fp *)buf;
|
|
|
|
base = find_regno (regcache->tdesc, "vr0");
|
|
|
|
for (i = 0; i < 16; i++)
|
|
supply_register (regcache, base + i, ®set->vr[i * 4]);
|
|
|
|
base = find_regno (regcache->tdesc, "fr0");
|
|
|
|
for (i = 0; i < 16; i++)
|
|
supply_register (regcache, base + i, ®set->vr[i * 4]);
|
|
supply_register_by_name (regcache, "fcr", ®set->fcr);
|
|
supply_register_by_name (regcache, "fesr", ®set->fesr);
|
|
supply_register_by_name (regcache, "fid", ®set->fid);
|
|
}
|
|
|
|
struct regset_info csky_regsets[] = {
|
|
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS, sizeof(struct pt_regs),
|
|
GENERAL_REGS, csky_fill_pt_gregset, csky_store_pt_gregset},
|
|
|
|
{ PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET, sizeof(struct user_fp),
|
|
FP_REGS, csky_fill_pt_vrregset, csky_store_pt_vrregset},
|
|
NULL_REGSET
|
|
};
|
|
|
|
|
|
static struct regsets_info csky_regsets_info =
|
|
{
|
|
csky_regsets, /* Regsets */
|
|
0, /* Num_regsets */
|
|
NULL, /* Disabled_regsets */
|
|
};
|
|
|
|
|
|
static struct regs_info csky_regs_info =
|
|
{
|
|
NULL, /* FIXME: what's this */
|
|
NULL, /* PEEKUSER/POKEUSR isn't supported by kernel > 4.x */
|
|
&csky_regsets_info
|
|
};
|
|
|
|
|
|
const regs_info *
|
|
csky_target::get_regs_info ()
|
|
{
|
|
return &csky_regs_info;
|
|
}
|
|
|
|
/* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */
|
|
|
|
const gdb_byte *
|
|
csky_target::sw_breakpoint_from_kind (int kind, int *size)
|
|
{
|
|
if (kind == 4)
|
|
{
|
|
*size = 4;
|
|
return (const gdb_byte *) &csky_breakpoint_illegal_4_v2;
|
|
}
|
|
else
|
|
{
|
|
*size = 2;
|
|
return (const gdb_byte *) &csky_breakpoint_illegal_2_v2;
|
|
}
|
|
}
|
|
|
|
bool
|
|
csky_target::supports_z_point_type (char z_type)
|
|
{
|
|
/* FIXME: hardware breakpoint support ?? */
|
|
if (z_type == Z_PACKET_SW_BP)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
csky_target::low_breakpoint_at (CORE_ADDR where)
|
|
{
|
|
unsigned int insn;
|
|
|
|
/* Here just read 2 bytes, as csky_breakpoint_illegal_4_v2
|
|
is double of csky_breakpoint_illegal_2_v2, csky_breakpoint_bkpt_4
|
|
is double of csky_breakpoint_bkpt_2. Others are 2 bytes bkpt. */
|
|
read_memory (where, (unsigned char *) &insn, 2);
|
|
|
|
if (insn == csky_breakpoint_illegal_2_v2)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Support for hardware single step. */
|
|
|
|
bool
|
|
csky_target::supports_hardware_single_step ()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/* The linux target ops object. */
|
|
|
|
linux_process_target *the_linux_target = &the_csky_target;
|
|
|
|
void
|
|
initialize_low_arch (void)
|
|
{
|
|
initialize_regsets_info (&csky_regsets_info);
|
|
}
|