mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
18d2988e5d
Now that defs.h, server.h and common-defs.h are included via the `-include` option, it is no longer necessary for source files to include them. Remove all the inclusions of these files I could find. Update the generation scripts where relevant. Change-Id: Ia026cff269c1b7ae7386dd3619bc9bb6a5332837 Approved-By: Pedro Alves <pedro@palves.net>
418 lines
12 KiB
C
418 lines
12 KiB
C
/* Native-dependent code for GNU/Linux on LoongArch processors.
|
|
|
|
Copyright (C) 2022-2024 Free Software Foundation, Inc.
|
|
Contributed by Loongson Ltd.
|
|
|
|
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 "elf/common.h"
|
|
#include "gregset.h"
|
|
#include "inferior.h"
|
|
#include "linux-nat-trad.h"
|
|
#include "loongarch-tdep.h"
|
|
#include "nat/gdb_ptrace.h"
|
|
#include "target-descriptions.h"
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
/* LoongArch Linux native additions to the default Linux support. */
|
|
|
|
class loongarch_linux_nat_target final : public linux_nat_trad_target
|
|
{
|
|
public:
|
|
/* Add our register access methods. */
|
|
void fetch_registers (struct regcache *, int) override;
|
|
void store_registers (struct regcache *, int) override;
|
|
|
|
protected:
|
|
/* Override linux_nat_trad_target methods. */
|
|
CORE_ADDR register_u_offset (struct gdbarch *gdbarch, int regnum,
|
|
int store_p) override;
|
|
};
|
|
|
|
/* Fill GDB's register array with the general-purpose, orig_a0, pc and badv
|
|
register values from the current thread. */
|
|
|
|
static void
|
|
fetch_gregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_gregset_t regset;
|
|
|
|
if (regnum == -1 || (regnum >= 0 && regnum < 32)
|
|
|| regnum == LOONGARCH_ORIG_A0_REGNUM
|
|
|| regnum == LOONGARCH_PC_REGNUM
|
|
|| regnum == LOONGARCH_BADV_REGNUM)
|
|
{
|
|
struct iovec iov;
|
|
|
|
iov.iov_base = ®set;
|
|
iov.iov_len = sizeof (regset);
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
|
|
perror_with_name (_("Couldn't get NT_PRSTATUS registers"));
|
|
else
|
|
loongarch_gregset.supply_regset (nullptr, regcache, -1,
|
|
®set, sizeof (regset));
|
|
}
|
|
}
|
|
|
|
/* Store to the current thread the valid general-purpose, orig_a0, pc and badv
|
|
register values in the GDB's register array. */
|
|
|
|
static void
|
|
store_gregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_gregset_t regset;
|
|
|
|
if (regnum == -1 || (regnum >= 0 && regnum < 32)
|
|
|| regnum == LOONGARCH_ORIG_A0_REGNUM
|
|
|| regnum == LOONGARCH_PC_REGNUM
|
|
|| regnum == LOONGARCH_BADV_REGNUM)
|
|
{
|
|
struct iovec iov;
|
|
|
|
iov.iov_base = ®set;
|
|
iov.iov_len = sizeof (regset);
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
|
|
perror_with_name (_("Couldn't get NT_PRSTATUS registers"));
|
|
else
|
|
{
|
|
loongarch_gregset.collect_regset (nullptr, regcache, regnum,
|
|
®set, sizeof (regset));
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
|
|
perror_with_name (_("Couldn't set NT_PRSTATUS registers"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Fill GDB's register array with the fp, fcc and fcsr
|
|
register values from the current thread. */
|
|
|
|
static void
|
|
fetch_fpregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_fpregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum <= LOONGARCH_FCSR_REGNUM))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
|
|
perror_with_name (_("Couldn't get NT_FPREGSET registers"));
|
|
else
|
|
loongarch_fpregset.supply_regset (nullptr, regcache, -1,
|
|
®set, sizeof (regset));
|
|
}
|
|
}
|
|
|
|
/* Store to the current thread the valid fp, fcc and fcsr
|
|
register values in the GDB's register array. */
|
|
|
|
static void
|
|
store_fpregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_fpregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum <= LOONGARCH_FCSR_REGNUM))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
|
|
perror_with_name (_("Couldn't get NT_FPREGSET registers"));
|
|
else
|
|
{
|
|
loongarch_fpregset.collect_regset (nullptr, regcache, regnum,
|
|
®set, sizeof (regset));
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
|
|
perror_with_name (_("Couldn't set NT_FPREGSET registers"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Fill GDB's register array with the Loongson SIMD Extension
|
|
register values from the current thread. */
|
|
|
|
static void
|
|
fetch_lsxregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_lsxregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
|
|
{
|
|
/* If kernel dose not support lsx, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
|
|
perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
|
|
}
|
|
else
|
|
loongarch_lsxregset.supply_regset (nullptr, regcache, -1,
|
|
®set, sizeof (regset));
|
|
}
|
|
}
|
|
|
|
/* Store to the current thread the valid Loongson SIMD Extension
|
|
register values in the GDB's register array. */
|
|
|
|
static void
|
|
store_lsxregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_lsxregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
|
|
{
|
|
/* If kernel dose not support lsx, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
|
|
perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
|
|
}
|
|
else
|
|
{
|
|
loongarch_lsxregset.collect_regset (nullptr, regcache, regnum,
|
|
®set, sizeof (regset));
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
|
|
perror_with_name (_("Couldn't set NT_LARCH_LSX registers"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Fill GDB's register array with the Loongson Advanced SIMD Extension
|
|
register values from the current thread. */
|
|
|
|
static void
|
|
fetch_lasxregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_lasxregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_LASX_REGNUM
|
|
&& regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
|
|
{
|
|
/* If kernel dose not support lasx, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
|
|
perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
|
|
}
|
|
else
|
|
loongarch_lasxregset.supply_regset (nullptr, regcache, -1,
|
|
®set, sizeof (regset));
|
|
}
|
|
}
|
|
|
|
/* Store to the current thread the valid Loongson Advanced SIMD Extension
|
|
register values in the GDB's register array. */
|
|
|
|
static void
|
|
store_lasxregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
elf_lasxregset_t regset;
|
|
|
|
if ((regnum == -1)
|
|
|| (regnum >= LOONGARCH_FIRST_LASX_REGNUM
|
|
&& regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET))
|
|
{
|
|
struct iovec iovec = { .iov_base = ®set, .iov_len = sizeof (regset) };
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
|
|
{
|
|
/* If kernel dose not support lasx, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
|
|
perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
|
|
}
|
|
else
|
|
{
|
|
loongarch_lasxregset.collect_regset (nullptr, regcache, regnum,
|
|
®set, sizeof (regset));
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
|
|
perror_with_name (_("Couldn't set NT_LARCH_LASX registers"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Fill GDB's register array with the lbt register values
|
|
from the current thread. */
|
|
|
|
static void
|
|
fetch_lbt_from_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
gdb_byte regset[LOONGARCH_LBT_REGS_SIZE];
|
|
|
|
if (regnum == -1
|
|
|| (regnum >= LOONGARCH_FIRST_SCR_REGNUM
|
|
&& regnum <= LOONGARCH_FTOP_REGNUM))
|
|
{
|
|
struct iovec iov;
|
|
|
|
iov.iov_base = regset;
|
|
iov.iov_len = LOONGARCH_LBT_REGS_SIZE;
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
|
|
{
|
|
/* If kernel dose not support lbt, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
perror_with_name (_("Couldn't get NT_LARCH_LBT registers"));
|
|
}
|
|
else
|
|
loongarch_lbtregset.supply_regset (nullptr, regcache, -1,
|
|
regset, LOONGARCH_LBT_REGS_SIZE);
|
|
}
|
|
}
|
|
|
|
/* Store to the current thread the valid lbt register values
|
|
in the GDB's register array. */
|
|
|
|
static void
|
|
store_lbt_to_thread (struct regcache *regcache, int regnum, pid_t tid)
|
|
{
|
|
gdb_byte regset[LOONGARCH_LBT_REGS_SIZE];
|
|
|
|
if (regnum == -1
|
|
|| (regnum >= LOONGARCH_FIRST_SCR_REGNUM
|
|
&& regnum <= LOONGARCH_FTOP_REGNUM))
|
|
{
|
|
struct iovec iov;
|
|
|
|
iov.iov_base = regset;
|
|
iov.iov_len = LOONGARCH_LBT_REGS_SIZE;
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
|
|
{
|
|
/* If kernel dose not support lbt, just return. */
|
|
if (errno == EINVAL)
|
|
return;
|
|
perror_with_name (_("Couldn't get NT_LARCH_LBT registers"));
|
|
}
|
|
else
|
|
{
|
|
loongarch_lbtregset.collect_regset (nullptr, regcache, regnum,
|
|
regset, LOONGARCH_LBT_REGS_SIZE);
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
|
|
perror_with_name (_("Couldn't set NT_LARCH_LBT registers"));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Implement the "fetch_registers" target_ops method. */
|
|
|
|
void
|
|
loongarch_linux_nat_target::fetch_registers (struct regcache *regcache,
|
|
int regnum)
|
|
{
|
|
pid_t tid = get_ptrace_pid (regcache->ptid ());
|
|
|
|
fetch_gregs_from_thread(regcache, regnum, tid);
|
|
fetch_fpregs_from_thread(regcache, regnum, tid);
|
|
fetch_lsxregs_from_thread(regcache, regnum, tid);
|
|
fetch_lasxregs_from_thread(regcache, regnum, tid);
|
|
fetch_lbt_from_thread (regcache, regnum, tid);
|
|
}
|
|
|
|
/* Implement the "store_registers" target_ops method. */
|
|
|
|
void
|
|
loongarch_linux_nat_target::store_registers (struct regcache *regcache,
|
|
int regnum)
|
|
{
|
|
pid_t tid = get_ptrace_pid (regcache->ptid ());
|
|
|
|
store_gregs_to_thread (regcache, regnum, tid);
|
|
store_fpregs_to_thread(regcache, regnum, tid);
|
|
store_lsxregs_to_thread(regcache, regnum, tid);
|
|
store_lasxregs_to_thread(regcache, regnum, tid);
|
|
store_lbt_to_thread (regcache, regnum, tid);
|
|
}
|
|
|
|
/* Return the address in the core dump or inferior of register REGNO. */
|
|
|
|
CORE_ADDR
|
|
loongarch_linux_nat_target::register_u_offset (struct gdbarch *gdbarch,
|
|
int regnum, int store_p)
|
|
{
|
|
if (regnum >= 0 && regnum < 32)
|
|
return regnum;
|
|
else if (regnum == LOONGARCH_PC_REGNUM)
|
|
return LOONGARCH_PC_REGNUM;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
static loongarch_linux_nat_target the_loongarch_linux_nat_target;
|
|
|
|
/* Wrapper functions. These are only used by libthread_db. */
|
|
|
|
void
|
|
supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregset)
|
|
{
|
|
loongarch_gregset.supply_regset (nullptr, regcache, -1, gregset,
|
|
sizeof (gdb_gregset_t));
|
|
}
|
|
|
|
void
|
|
fill_gregset (const struct regcache *regcache, gdb_gregset_t *gregset,
|
|
int regnum)
|
|
{
|
|
loongarch_gregset.collect_regset (nullptr, regcache, regnum, gregset,
|
|
sizeof (gdb_gregset_t));
|
|
}
|
|
|
|
void
|
|
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregset)
|
|
{
|
|
loongarch_fpregset.supply_regset (nullptr, regcache, -1, fpregset,
|
|
sizeof (gdb_fpregset_t));
|
|
}
|
|
|
|
void
|
|
fill_fpregset (const struct regcache *regcache, gdb_fpregset_t *fpregset,
|
|
int regnum)
|
|
{
|
|
loongarch_fpregset.collect_regset (nullptr, regcache, regnum, fpregset,
|
|
sizeof (gdb_fpregset_t));
|
|
}
|
|
|
|
/* Initialize LoongArch Linux native support. */
|
|
|
|
void _initialize_loongarch_linux_nat ();
|
|
void
|
|
_initialize_loongarch_linux_nat ()
|
|
{
|
|
linux_target = &the_loongarch_linux_nat_target;
|
|
add_inf_child_target (&the_loongarch_linux_nat_target);
|
|
}
|