gdb/arc-linux-nat.c

   1 /* Native-dependent code for GNU/Linux ARC.
   2
   3    Copyright 2020-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "frame.h"
  21 #include "inferior.h"
  22 #include "gdbcore.h"
  23 #include "regcache.h"
  24 #include "gdbsupport/gdb_assert.h"
  25 #include "target.h"
  26 #include "linux-nat.h"
  27 #include "nat/gdb_ptrace.h"
  28
  29 #include <stdint.h>
  30 #include <sys/types.h>
  31 #include <sys/param.h>
  32 #include <signal.h>
  33 #include <sys/user.h>
  34 #include <sys/ioctl.h>
  35 #include "gdbsupport/gdb_wait.h"
  36 #include <fcntl.h>
  37 #include <sys/procfs.h>
  38 #include <linux/elf.h>
  39
  40 #include "gregset.h"
  41 #include "arc-tdep.h"
  42 #include "arc-linux-tdep.h"
  43 #include "arch/arc.h"
  44
  45 /* Defines ps_err_e, struct ps_prochandle.  */
  46 #include "gdb_proc_service.h"
  47
  48 /* Print an "arc-linux-nat" debug statement.  */
  49
  50 #define arc_linux_nat_debug_printf(fmt, ...) \
  51   debug_prefixed_printf_cond (arc_debug, "arc-linux-nat", fmt, ##__VA_ARGS__)
  52
  53 /* Linux starting with 4.12 supports NT_ARC_V2 note type, which adds R30,
  54    R58 and R59 registers, which are specific to ARC HS and aren't
  55    available in ARC 700.  */
  56 #if defined (NT_ARC_V2) && defined (__ARCHS__)
  57 #define ARC_HAS_V2_REGSET
  58 #endif
  59
  60 class arc_linux_nat_target final : public linux_nat_target
  61 {
  62 public:
  63   /* Add ARC register access methods.  */
  64   void fetch_registers (struct regcache *, int) override;
  65   void store_registers (struct regcache *, int) override;
  66
  67   const struct target_desc *read_description () override;
  68
  69   /* Handle threads  */
  70   void low_prepare_to_resume (struct lwp_info *lp) override;
  71 };
  72
  73 static arc_linux_nat_target the_arc_linux_nat_target;
  74
  75 /* Read general registers from target process/thread (via ptrace)
  76    into REGCACHE.  */
  77
  78 static void
  79 fetch_gregs (struct regcache *regcache, int regnum)
  80 {
  81   const int tid = get_ptrace_pid (regcache->ptid ());
  82   struct iovec iov;
  83   gdb_gregset_t regs;
  84
  85   iov.iov_base = &regs;
  86   iov.iov_len = sizeof (gdb_gregset_t);
  87
  88   if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
  89     perror_with_name (_("Couldn't get general registers"));
  90   else
  91     arc_linux_supply_gregset (NULL, regcache, regnum, &regs, 0);
  92 }
  93
  94 #ifdef ARC_HAS_V2_REGSET
  95 /* Read ARC v2 registers from target process/thread (via ptrace)
  96    into REGCACHE.  */
  97
  98 static void
  99 fetch_v2_regs (struct regcache *regcache, int regnum)
 100 {
 101   const int tid = get_ptrace_pid (regcache->ptid ());
 102   struct iovec iov;
 103   bfd_byte v2_buffer[ARC_LINUX_SIZEOF_V2_REGSET];
 104
 105   iov.iov_base = &v2_buffer;
 106   iov.iov_len = ARC_LINUX_SIZEOF_V2_REGSET;
 107
 108   if (ptrace (PTRACE_GETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
 109     perror_with_name (_("Couldn't get ARC HS registers"));
 110   else
 111     arc_linux_supply_v2_regset (NULL, regcache, regnum, v2_buffer, 0);
 112 }
 113 #endif
 114
 115 /* Store general registers from REGCACHE into the target process/thread.  */
 116
 117 static void
 118 store_gregs (const struct regcache *regcache, int regnum)
 119 {
 120   const int tid = get_ptrace_pid (regcache->ptid ());
 121   struct iovec iov;
 122   gdb_gregset_t regs;
 123
 124   iov.iov_base = &regs;
 125   iov.iov_len = sizeof (gdb_gregset_t);
 126
 127   if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
 128     perror_with_name (_("Couldn't get general registers"));
 129   else
 130     {
 131       arc_linux_collect_gregset (NULL, regcache, regnum, regs, 0);
 132
 133       if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, (void *) &iov) < 0)
 134         perror_with_name (_("Couldn't write general registers"));
 135     }
 136 }
 137
 138 #ifdef ARC_HAS_V2_REGSET
 139 /* Store ARC v2 registers from REGCACHE into the target process/thread.  */
 140
 141 static void
 142 store_v2_regs (const struct regcache *regcache, int regnum)
 143 {
 144   const int tid = get_ptrace_pid (regcache->ptid ());
 145   struct iovec iov;
 146   bfd_byte v2_buffer[ARC_LINUX_SIZEOF_V2_REGSET];
 147
 148   iov.iov_base = &v2_buffer;
 149   iov.iov_len = ARC_LINUX_SIZEOF_V2_REGSET;
 150
 151   if (ptrace (PTRACE_GETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
 152     perror_with_name (_("Couldn't get ARC HS registers"));
 153   else
 154     {
 155       arc_linux_collect_v2_regset (NULL, regcache, regnum, v2_buffer, 0);
 156
 157       if (ptrace (PTRACE_SETREGSET, tid, NT_ARC_V2, (void *) &iov) < 0)
 158         perror_with_name (_("Couldn't write ARC HS registers"));
 159     }
 160 }
 161 #endif
 162
 163 /* Target operation: Read REGNUM register (all registers if REGNUM == -1)
 164    from target process into REGCACHE.  */
 165
 166 void
 167 arc_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
 168 {
 169
 170   if (regnum == -1 || regnum <= ARC_LAST_REGNUM)
 171     fetch_gregs (regcache, regnum);
 172
 173 #ifdef ARC_HAS_V2_REGSET
 174   if (regnum == -1
 175       || regnum == ARC_R30_REGNUM
 176       || regnum == ARC_R58_REGNUM
 177       || regnum == ARC_R59_REGNUM)
 178       fetch_v2_regs (regcache, regnum);
 179 #endif
 180 }
 181
 182 /* Target operation: Store REGNUM register (all registers if REGNUM == -1)
 183    to the target process from REGCACHE.  */
 184
 185 void
 186 arc_linux_nat_target::store_registers (struct regcache *regcache, int regnum)
 187 {
 188   if (regnum == -1 || regnum <= ARC_LAST_REGNUM)
 189     store_gregs (regcache, regnum);
 190
 191 #ifdef ARC_HAS_V2_REGSET
 192   if (regnum == -1
 193       || regnum == ARC_R30_REGNUM
 194       || regnum == ARC_R58_REGNUM
 195       || regnum == ARC_R59_REGNUM)
 196     store_v2_regs (regcache, regnum);
 197 #endif
 198 }
 199
 200 /* Copy general purpose register(s) from REGCACHE into regset GREGS.
 201    This function is exported to proc-service.c  */
 202
 203 void
 204 fill_gregset (const struct regcache *regcache,
 205               gdb_gregset_t *gregs, int regnum)
 206 {
 207   arc_linux_collect_gregset (NULL, regcache, regnum, gregs, 0);
 208 }
 209
 210 /* Copy all the general purpose registers from regset GREGS into REGCACHE.
 211    This function is exported to proc-service.c.  */
 212
 213 void
 214 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregs)
 215 {
 216   arc_linux_supply_gregset (NULL, regcache, -1, gregs, 0);
 217 }
 218
 219 /* ARC doesn't have separate FP registers.  This function is exported
 220    to proc-service.c.  */
 221
 222 void
 223 fill_fpregset (const struct regcache *regcache,
 224                gdb_fpregset_t *fpregsetp, int regnum)
 225 {
 226   arc_linux_nat_debug_printf ("called");
 227 }
 228
 229 /* ARC doesn't have separate FP registers.  This function is exported
 230    to proc-service.c.  */
 231
 232 void
 233 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 234 {
 235   arc_linux_nat_debug_printf ("called");
 236 }
 237
 238 /* Implement the "read_description" method of linux_nat_target.  */
 239
 240 const struct target_desc *
 241 arc_linux_nat_target::read_description ()
 242 {
 243   /* This is a native target, hence description is hardcoded.  */
 244 #ifdef __ARCHS__
 245   arc_arch_features features (4, ARC_ISA_ARCV2);
 246 #else
 247   arc_arch_features features (4, ARC_ISA_ARCV1);
 248 #endif
 249   return arc_lookup_target_description (features);
 250 }
 251
 252 /* As described in arc_linux_collect_gregset(), we need to write resume-PC
 253    to ERET.  However by default GDB for native targets doesn't write
 254    registers if they haven't been changed.  This is a callback called by
 255    generic GDB, and in this callback we have to rewrite PC value so it
 256    would force rewrite of register on target.  It seems that the only
 257    other arch that utilizes this hook is x86/x86-64 for HW breakpoint
 258    support.  But then, AFAIK no other arch has this stop_pc/eret
 259    complexity.
 260
 261    No better way was found, other than this fake write of register value,
 262    to force GDB into writing register to target.  Is there any?  */
 263
 264 void
 265 arc_linux_nat_target::low_prepare_to_resume (struct lwp_info *lwp)
 266 {
 267   /* When new processes and threads are created we do not have the address
 268      space for them and calling get_thread_regcache will cause an internal
 269      error in GDB.  It looks like that checking for last_resume_kind is the
 270      sensible way to determine processes for which we cannot get regcache.
 271      Ultimately, a better way would be removing the need for
 272      low_prepare_to_resume in the first place.  */
 273   if (lwp->last_resume_kind == resume_stop)
 274     return;
 275
 276   struct regcache *regcache = get_thread_regcache (this, lwp->ptid);
 277   struct gdbarch *gdbarch = regcache->arch ();
 278
 279   /* Read current PC value, then write it back.  It is required to call
 280      invalidate(), otherwise GDB will note that new value is equal to old
 281      value and will skip write.  */
 282   ULONGEST new_pc;
 283   regcache_cooked_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch),
 284                                  &new_pc);
 285   regcache->invalidate (gdbarch_pc_regnum (gdbarch));
 286   regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch),
 287                                   new_pc);
 288 }
 289
 290 /* Fetch the thread-local storage pointer for libthread_db.  Note that
 291    this function is not called from GDB, but is called from libthread_db.
 292    This is required to debug multithreaded applications with NPTL.  */
 293
 294 ps_err_e
 295 ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx,
 296                     void **base)
 297 {
 298   arc_linux_nat_debug_printf ("called");
 299
 300   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
 301     return PS_ERR;
 302
 303   /* IDX is the bias from the thread pointer to the beginning of the
 304      thread descriptor.  It has to be subtracted due to implementation
 305      quirks in libthread_db.  */
 306   *base = (void *) ((char *) *base - idx);
 307
 308   return PS_OK;
 309 }
 310
 311 /* Suppress warning from -Wmissing-prototypes.  */
 312 void _initialize_arc_linux_nat ();
 313 void
 314 _initialize_arc_linux_nat ()
 315 {
 316   /* Register the target.  */
 317   linux_target = &the_arc_linux_nat_target;
 318   add_inf_child_target (&the_arc_linux_nat_target);
 319 }