gdb/riscv-linux-nat.c

   1 /* Native-dependent code for GNU/Linux RISC-V.
   2    Copyright (C) 2018-2023 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "regcache.h"
  21 #include "gregset.h"
  22 #include "linux-nat.h"
  23 #include "riscv-tdep.h"
  24 #include "inferior.h"
  25
  26 #include "elf/common.h"
  27
  28 #include "nat/riscv-linux-tdesc.h"
  29
  30 #include <sys/ptrace.h>
  31
  32 /* Work around glibc header breakage causing ELF_NFPREG not to be usable.  */
  33 #ifndef NFPREG
  34 # define NFPREG 33
  35 #endif
  36
  37 /* RISC-V Linux native additions to the default linux support.  */
  38
  39 class riscv_linux_nat_target final : public linux_nat_target
  40 {
  41 public:
  42   /* Add our register access methods.  */
  43   void fetch_registers (struct regcache *regcache, int regnum) override;
  44   void store_registers (struct regcache *regcache, int regnum) override;
  45
  46   /* Read suitable target description.  */
  47   const struct target_desc *read_description () override;
  48 };
  49
  50 static riscv_linux_nat_target the_riscv_linux_nat_target;
  51
  52 /* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1)
  53    from regset GREGS into REGCACHE.  */
  54
  55 static void
  56 supply_gregset_regnum (struct regcache *regcache, const prgregset_t *gregs,
  57                        int regnum)
  58 {
  59   int i;
  60   const elf_greg_t *regp = *gregs;
  61
  62   if (regnum == -1)
  63     {
  64       /* We only support the integer registers and PC here.  */
  65       for (i = RISCV_ZERO_REGNUM + 1; i < RISCV_PC_REGNUM; i++)
  66         regcache->raw_supply (i, regp + i);
  67
  68       /* GDB stores PC in reg 32.  Linux kernel stores it in reg 0.  */
  69       regcache->raw_supply (RISCV_PC_REGNUM, regp + 0);
  70
  71       /* Fill the inaccessible zero register with zero.  */
  72       regcache->raw_supply_zeroed (RISCV_ZERO_REGNUM);
  73     }
  74   else if (regnum == RISCV_ZERO_REGNUM)
  75     regcache->raw_supply_zeroed (RISCV_ZERO_REGNUM);
  76   else if (regnum > RISCV_ZERO_REGNUM && regnum < RISCV_PC_REGNUM)
  77     regcache->raw_supply (regnum, regp + regnum);
  78   else if (regnum == RISCV_PC_REGNUM)
  79     regcache->raw_supply (RISCV_PC_REGNUM, regp + 0);
  80 }
  81
  82 /* Copy all general purpose registers from regset GREGS into REGCACHE.  */
  83
  84 void
  85 supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
  86 {
  87   supply_gregset_regnum (regcache, gregs, -1);
  88 }
  89
  90 /* Copy floating point register REGNUM (or all fp regs if REGNUM == -1)
  91    from regset FPREGS into REGCACHE.  */
  92
  93 static void
  94 supply_fpregset_regnum (struct regcache *regcache, const prfpregset_t *fpregs,
  95                         int regnum)
  96 {
  97   int flen = register_size (regcache->arch (), RISCV_FIRST_FP_REGNUM);
  98   union
  99     {
 100       const prfpregset_t *fpregs;
 101       const gdb_byte *buf;
 102     }
 103   fpbuf = { .fpregs = fpregs };
 104   int i;
 105
 106   if (regnum == -1)
 107     {
 108       /* We only support the FP registers and FCSR here.  */
 109       for (i = RISCV_FIRST_FP_REGNUM;
 110            i <= RISCV_LAST_FP_REGNUM;
 111            i++, fpbuf.buf += flen)
 112         regcache->raw_supply (i, fpbuf.buf);
 113
 114       regcache->raw_supply (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
 115     }
 116   else if (regnum >= RISCV_FIRST_FP_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
 117     {
 118       fpbuf.buf += flen * (regnum - RISCV_FIRST_FP_REGNUM);
 119       regcache->raw_supply (regnum, fpbuf.buf);
 120     }
 121   else if (regnum == RISCV_CSR_FCSR_REGNUM)
 122     {
 123       fpbuf.buf += flen * (RISCV_LAST_FP_REGNUM - RISCV_FIRST_FP_REGNUM + 1);
 124       regcache->raw_supply (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
 125     }
 126 }
 127
 128 /* Copy all floating point registers from regset FPREGS into REGCACHE.  */
 129
 130 void
 131 supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
 132 {
 133   supply_fpregset_regnum (regcache, fpregs, -1);
 134 }
 135
 136 /* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1)
 137    from REGCACHE into regset GREGS.  */
 138
 139 void
 140 fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum)
 141 {
 142   elf_greg_t *regp = *gregs;
 143
 144   if (regnum == -1)
 145     {
 146       /* We only support the integer registers and PC here.  */
 147       for (int i = RISCV_ZERO_REGNUM + 1; i < RISCV_PC_REGNUM; i++)
 148         regcache->raw_collect (i, regp + i);
 149
 150       regcache->raw_collect (RISCV_PC_REGNUM, regp + 0);
 151     }
 152   else if (regnum == RISCV_ZERO_REGNUM)
 153     /* Nothing to do here.  */
 154     ;
 155   else if (regnum > RISCV_ZERO_REGNUM && regnum < RISCV_PC_REGNUM)
 156     regcache->raw_collect (regnum, regp + regnum);
 157   else if (regnum == RISCV_PC_REGNUM)
 158     regcache->raw_collect (RISCV_PC_REGNUM, regp + 0);
 159 }
 160
 161 /* Copy floating point register REGNUM (or all fp regs if REGNUM == -1)
 162    from REGCACHE into regset FPREGS.  */
 163
 164 void
 165 fill_fpregset (const struct regcache *regcache, prfpregset_t *fpregs,
 166                int regnum)
 167 {
 168   int flen = register_size (regcache->arch (), RISCV_FIRST_FP_REGNUM);
 169   union
 170     {
 171       prfpregset_t *fpregs;
 172       gdb_byte *buf;
 173     }
 174   fpbuf = { .fpregs = fpregs };
 175   int i;
 176
 177   if (regnum == -1)
 178     {
 179       /* We only support the FP registers and FCSR here.  */
 180       for (i = RISCV_FIRST_FP_REGNUM;
 181            i <= RISCV_LAST_FP_REGNUM;
 182            i++, fpbuf.buf += flen)
 183         regcache->raw_collect (i, fpbuf.buf);
 184
 185       regcache->raw_collect (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
 186     }
 187   else if (regnum >= RISCV_FIRST_FP_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
 188     {
 189       fpbuf.buf += flen * (regnum - RISCV_FIRST_FP_REGNUM);
 190       regcache->raw_collect (regnum, fpbuf.buf);
 191     }
 192   else if (regnum == RISCV_CSR_FCSR_REGNUM)
 193     {
 194       fpbuf.buf += flen * (RISCV_LAST_FP_REGNUM - RISCV_FIRST_FP_REGNUM + 1);
 195       regcache->raw_collect (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
 196     }
 197 }
 198
 199 /* Return a target description for the current target.  */
 200
 201 const struct target_desc *
 202 riscv_linux_nat_target::read_description ()
 203 {
 204   if (inferior_ptid == null_ptid)
 205     return this->beneath ()->read_description ();
 206
 207   const struct riscv_gdbarch_features features
 208     = riscv_linux_read_features (inferior_ptid.pid ());
 209   return riscv_lookup_target_description (features);
 210 }
 211
 212 /* Fetch REGNUM (or all registers if REGNUM == -1) from the target
 213    into REGCACHE using PTRACE_GETREGSET.  */
 214
 215 void
 216 riscv_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
 217 {
 218   int tid;
 219
 220   tid = get_ptrace_pid (regcache->ptid());
 221
 222   if ((regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_PC_REGNUM)
 223       || (regnum == -1))
 224     {
 225       struct iovec iov;
 226       elf_gregset_t regs;
 227
 228       iov.iov_base = &regs;
 229       iov.iov_len = sizeof (regs);
 230
 231       if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS,
 232                   (PTRACE_TYPE_ARG3) &iov) == -1)
 233         perror_with_name (_("Couldn't get registers"));
 234       else
 235         supply_gregset_regnum (regcache, &regs, regnum);
 236     }
 237
 238   if ((regnum >= RISCV_FIRST_FP_REGNUM
 239        && regnum <= RISCV_LAST_FP_REGNUM)
 240       || (regnum == RISCV_CSR_FCSR_REGNUM)
 241       || (regnum == -1))
 242     {
 243       struct iovec iov;
 244       elf_fpregset_t regs;
 245
 246       iov.iov_base = &regs;
 247       iov.iov_len = ELF_NFPREG * register_size (regcache->arch (),
 248                                                 RISCV_FIRST_FP_REGNUM);
 249       gdb_assert (iov.iov_len <= sizeof (regs));
 250
 251       if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET,
 252                   (PTRACE_TYPE_ARG3) &iov) == -1)
 253         perror_with_name (_("Couldn't get registers"));
 254       else
 255         supply_fpregset_regnum (regcache, &regs, regnum);
 256     }
 257
 258   if ((regnum == RISCV_CSR_MISA_REGNUM)
 259       || (regnum == -1))
 260     {
 261       /* TODO: Need to add a ptrace call for this.  */
 262       regcache->raw_supply_zeroed (RISCV_CSR_MISA_REGNUM);
 263     }
 264
 265   /* Access to other CSRs has potential security issues, don't support them for
 266      now.  */
 267 }
 268
 269 /* Store REGNUM (or all registers if REGNUM == -1) to the target
 270    from REGCACHE using PTRACE_SETREGSET.  */
 271
 272 void
 273 riscv_linux_nat_target::store_registers (struct regcache *regcache, int regnum)
 274 {
 275   int tid;
 276
 277   tid = get_ptrace_pid (regcache->ptid ());
 278
 279   if ((regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_PC_REGNUM)
 280       || (regnum == -1))
 281     {
 282       struct iovec iov;
 283       elf_gregset_t regs;
 284
 285       iov.iov_base = &regs;
 286       iov.iov_len = sizeof (regs);
 287
 288       if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS,
 289                   (PTRACE_TYPE_ARG3) &iov) == -1)
 290         perror_with_name (_("Couldn't get registers"));
 291       else
 292         {
 293           fill_gregset (regcache, &regs, regnum);
 294
 295           if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS,
 296                       (PTRACE_TYPE_ARG3) &iov) == -1)
 297             perror_with_name (_("Couldn't set registers"));
 298         }
 299     }
 300
 301   if ((regnum >= RISCV_FIRST_FP_REGNUM
 302        && regnum <= RISCV_LAST_FP_REGNUM)
 303       || (regnum == RISCV_CSR_FCSR_REGNUM)
 304       || (regnum == -1))
 305     {
 306       struct iovec iov;
 307       elf_fpregset_t regs;
 308
 309       iov.iov_base = &regs;
 310       iov.iov_len = ELF_NFPREG * register_size (regcache->arch (),
 311                                                 RISCV_FIRST_FP_REGNUM);
 312       gdb_assert (iov.iov_len <= sizeof (regs));
 313
 314       if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET,
 315                   (PTRACE_TYPE_ARG3) &iov) == -1)
 316         perror_with_name (_("Couldn't get registers"));
 317       else
 318         {
 319           fill_fpregset (regcache, &regs, regnum);
 320
 321           if (ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET,
 322                       (PTRACE_TYPE_ARG3) &iov) == -1)
 323             perror_with_name (_("Couldn't set registers"));
 324         }
 325     }
 326
 327   /* Access to CSRs has potential security issues, don't support them for
 328      now.  */
 329 }
 330
 331 /* Initialize RISC-V Linux native support.  */
 332
 333 void _initialize_riscv_linux_nat ();
 334 void
 335 _initialize_riscv_linux_nat ()
 336 {
 337   /* Register the target.  */
 338   linux_target = &the_riscv_linux_nat_target;
 339   add_inf_child_target (&the_riscv_linux_nat_target);
 340 }