mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
a9ed7a0814
This reverts commit 98bcde5e26
. This
commit was causing build problems on at least sparc, ppc, and s390,
though I suspect some other targets might be impacted too.
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_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);
|
|
}
|