gdb/loongarch-linux-nat.c

   1 /* Native-dependent code for GNU/Linux on LoongArch processors.
   2
   3    Copyright (C) 2022-2024 Free Software Foundation, Inc.
   4    Contributed by Loongson Ltd.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "elf/common.h"
  22 #include "gregset.h"
  23 #include "inferior.h"
  24 #include "linux-nat-trad.h"
  25 #include "loongarch-tdep.h"
  26 #include "nat/gdb_ptrace.h"
  27 #include "target-descriptions.h"
  28
  29 #include <asm/ptrace.h>
  30
  31 /* LoongArch Linux native additions to the default Linux support.  */
  32
  33 class loongarch_linux_nat_target final : public linux_nat_trad_target
  34 {
  35 public:
  36   /* Add our register access methods.  */
  37   void fetch_registers (struct regcache *, int) override;
  38   void store_registers (struct regcache *, int) override;
  39
  40 protected:
  41   /* Override linux_nat_trad_target methods.  */
  42   CORE_ADDR register_u_offset (struct gdbarch *gdbarch, int regnum,
  43                                int store_p) override;
  44 };
  45
  46 /* Fill GDB's register array with the general-purpose, orig_a0, pc and badv
  47    register values from the current thread.  */
  48
  49 static void
  50 fetch_gregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
  51 {
  52   elf_gregset_t regset;
  53
  54   if (regnum == -1 || (regnum >= 0 && regnum < 32)
  55       || regnum == LOONGARCH_ORIG_A0_REGNUM
  56       || regnum == LOONGARCH_PC_REGNUM
  57       || regnum == LOONGARCH_BADV_REGNUM)
  58   {
  59     struct iovec iov;
  60
  61     iov.iov_base = &regset;
  62     iov.iov_len = sizeof (regset);
  63
  64     if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
  65       perror_with_name (_("Couldn't get NT_PRSTATUS registers"));
  66     else
  67       loongarch_gregset.supply_regset (nullptr, regcache, -1,
  68                                        &regset, sizeof (regset));
  69   }
  70 }
  71
  72 /* Store to the current thread the valid general-purpose, orig_a0, pc and badv
  73    register values in the GDB's register array.  */
  74
  75 static void
  76 store_gregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
  77 {
  78   elf_gregset_t regset;
  79
  80   if (regnum == -1 || (regnum >= 0 && regnum < 32)
  81       || regnum == LOONGARCH_ORIG_A0_REGNUM
  82       || regnum == LOONGARCH_PC_REGNUM
  83       || regnum == LOONGARCH_BADV_REGNUM)
  84   {
  85     struct iovec iov;
  86
  87     iov.iov_base = &regset;
  88     iov.iov_len = sizeof (regset);
  89
  90     if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
  91       perror_with_name (_("Couldn't get NT_PRSTATUS registers"));
  92     else
  93       {
  94         loongarch_gregset.collect_regset (nullptr, regcache, regnum,
  95                                           &regset, sizeof (regset));
  96         if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, (long) &iov) < 0)
  97           perror_with_name (_("Couldn't set NT_PRSTATUS registers"));
  98       }
  99   }
 100 }
 101
 102 /* Fill GDB's register array with the fp, fcc and fcsr
 103    register values from the current thread.  */
 104
 105 static void
 106 fetch_fpregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
 107 {
 108   elf_fpregset_t regset;
 109
 110   if ((regnum == -1)
 111       || (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum <= LOONGARCH_FCSR_REGNUM))
 112     {
 113       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 114
 115       if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
 116         perror_with_name (_("Couldn't get NT_FPREGSET registers"));
 117       else
 118         loongarch_fpregset.supply_regset (nullptr, regcache, -1,
 119                                           &regset, sizeof (regset));
 120     }
 121 }
 122
 123 /* Store to the current thread the valid fp, fcc and fcsr
 124    register values in the GDB's register array.  */
 125
 126 static void
 127 store_fpregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
 128 {
 129   elf_fpregset_t regset;
 130
 131   if ((regnum == -1)
 132       || (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum <= LOONGARCH_FCSR_REGNUM))
 133     {
 134       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 135
 136       if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
 137         perror_with_name (_("Couldn't get NT_FPREGSET registers"));
 138       else
 139         {
 140           loongarch_fpregset.collect_regset (nullptr, regcache, regnum,
 141                                              &regset, sizeof (regset));
 142           if (ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, (long) &iovec) < 0)
 143             perror_with_name (_("Couldn't set NT_FPREGSET registers"));
 144         }
 145     }
 146 }
 147
 148 /* Fill GDB's register array with the Loongson SIMD Extension
 149    register values from the current thread.  */
 150
 151 static void
 152 fetch_lsxregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
 153 {
 154   elf_lsxregset_t regset;
 155
 156   if ((regnum == -1)
 157       || (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM))
 158     {
 159       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 160
 161       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
 162         {
 163           /* If kernel dose not support lsx, just return. */
 164           if (errno == EINVAL)
 165             return;
 166
 167           perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
 168         }
 169       else
 170         loongarch_lsxregset.supply_regset (nullptr, regcache, -1,
 171                                            &regset, sizeof (regset));
 172     }
 173 }
 174
 175 /* Store to the current thread the valid Loongson SIMD Extension
 176    register values in the GDB's register array.  */
 177
 178 static void
 179 store_lsxregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
 180 {
 181   elf_lsxregset_t regset;
 182
 183   if ((regnum == -1)
 184       || (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM))
 185     {
 186       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 187
 188       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
 189         {
 190           /* If kernel dose not support lsx, just return. */
 191           if (errno == EINVAL)
 192             return;
 193
 194           perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
 195         }
 196       else
 197         {
 198           loongarch_lsxregset.collect_regset (nullptr, regcache, regnum,
 199                                              &regset, sizeof (regset));
 200           if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LSX, (long) &iovec) < 0)
 201             perror_with_name (_("Couldn't set NT_LARCH_LSX registers"));
 202         }
 203     }
 204 }
 205
 206 /* Fill GDB's register array with the Loongson Advanced SIMD Extension
 207    register values from the current thread.  */
 208
 209 static void
 210 fetch_lasxregs_from_thread (struct regcache *regcache, int regnum, pid_t tid)
 211 {
 212   elf_lasxregset_t regset;
 213
 214   if ((regnum == -1)
 215       || (regnum >= LOONGARCH_FIRST_LASX_REGNUM
 216           && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET))
 217     {
 218       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 219
 220       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
 221         {
 222           /* If kernel dose not support lasx, just return. */
 223           if (errno == EINVAL)
 224             return;
 225
 226           perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
 227         }
 228       else
 229         loongarch_lasxregset.supply_regset (nullptr, regcache, -1,
 230                                             &regset, sizeof (regset));
 231     }
 232 }
 233
 234 /* Store to the current thread the valid Loongson Advanced SIMD Extension
 235    register values in the GDB's register array.  */
 236
 237 static void
 238 store_lasxregs_to_thread (struct regcache *regcache, int regnum, pid_t tid)
 239 {
 240   elf_lasxregset_t regset;
 241
 242   if ((regnum == -1)
 243       || (regnum >= LOONGARCH_FIRST_LASX_REGNUM
 244           && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET))
 245     {
 246       struct iovec iovec = { .iov_base = &regset, .iov_len = sizeof (regset) };
 247
 248       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
 249         {
 250           /* If kernel dose not support lasx, just return. */
 251           if (errno == EINVAL)
 252             return;
 253
 254           perror_with_name (_("Couldn't get NT_LARCH_LSX registers"));
 255         }
 256       else
 257         {
 258           loongarch_lasxregset.collect_regset (nullptr, regcache, regnum,
 259                                               &regset, sizeof (regset));
 260           if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LASX, (long) &iovec) < 0)
 261             perror_with_name (_("Couldn't set NT_LARCH_LASX registers"));
 262         }
 263     }
 264 }
 265
 266
 267 /* Fill GDB's register array with the lbt register values
 268    from the current thread.  */
 269
 270 static void
 271 fetch_lbt_from_thread (struct regcache *regcache, int regnum, pid_t tid)
 272 {
 273   gdb_byte regset[LOONGARCH_LBT_REGS_SIZE];
 274
 275   if (regnum == -1
 276       || (regnum >= LOONGARCH_FIRST_SCR_REGNUM
 277           && regnum <= LOONGARCH_FTOP_REGNUM))
 278     {
 279       struct iovec iov;
 280
 281       iov.iov_base = regset;
 282       iov.iov_len = LOONGARCH_LBT_REGS_SIZE;
 283
 284       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
 285         {
 286           /* If kernel dose not support lbt, just return. */
 287           if (errno == EINVAL)
 288             return;
 289           perror_with_name (_("Couldn't get NT_LARCH_LBT registers"));
 290         }
 291       else
 292         loongarch_lbtregset.supply_regset (nullptr, regcache, -1,
 293                                            regset, LOONGARCH_LBT_REGS_SIZE);
 294     }
 295 }
 296
 297 /* Store to the current thread the valid lbt register values
 298    in the GDB's register array.  */
 299
 300 static void
 301 store_lbt_to_thread (struct regcache *regcache, int regnum, pid_t tid)
 302 {
 303   gdb_byte regset[LOONGARCH_LBT_REGS_SIZE];
 304
 305   if (regnum == -1
 306       || (regnum >= LOONGARCH_FIRST_SCR_REGNUM
 307           && regnum <= LOONGARCH_FTOP_REGNUM))
 308     {
 309       struct iovec iov;
 310
 311       iov.iov_base = regset;
 312       iov.iov_len = LOONGARCH_LBT_REGS_SIZE;
 313
 314       if (ptrace (PTRACE_GETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
 315         {
 316           /* If kernel dose not support lbt, just return. */
 317           if (errno == EINVAL)
 318             return;
 319           perror_with_name (_("Couldn't get NT_LARCH_LBT registers"));
 320         }
 321       else
 322         {
 323           loongarch_lbtregset.collect_regset (nullptr, regcache, regnum,
 324                                             regset, LOONGARCH_LBT_REGS_SIZE);
 325           if (ptrace (PTRACE_SETREGSET, tid, NT_LARCH_LBT, (long) &iov) < 0)
 326             perror_with_name (_("Couldn't set NT_LARCH_LBT registers"));
 327         }
 328     }
 329 }
 330
 331 /* Implement the "fetch_registers" target_ops method.  */
 332
 333 void
 334 loongarch_linux_nat_target::fetch_registers (struct regcache *regcache,
 335                                              int regnum)
 336 {
 337   pid_t tid = get_ptrace_pid (regcache->ptid ());
 338
 339   fetch_gregs_from_thread(regcache, regnum, tid);
 340   fetch_fpregs_from_thread(regcache, regnum, tid);
 341   fetch_lsxregs_from_thread(regcache, regnum, tid);
 342   fetch_lasxregs_from_thread(regcache, regnum, tid);
 343   fetch_lbt_from_thread (regcache, regnum, tid);
 344 }
 345
 346 /* Implement the "store_registers" target_ops method.  */
 347
 348 void
 349 loongarch_linux_nat_target::store_registers (struct regcache *regcache,
 350                                              int regnum)
 351 {
 352   pid_t tid = get_ptrace_pid (regcache->ptid ());
 353
 354   store_gregs_to_thread (regcache, regnum, tid);
 355   store_fpregs_to_thread(regcache, regnum, tid);
 356   store_lsxregs_to_thread(regcache, regnum, tid);
 357   store_lasxregs_to_thread(regcache, regnum, tid);
 358   store_lbt_to_thread (regcache, regnum, tid);
 359 }
 360
 361 /* Return the address in the core dump or inferior of register REGNO.  */
 362
 363 CORE_ADDR
 364 loongarch_linux_nat_target::register_u_offset (struct gdbarch *gdbarch,
 365                                                int regnum, int store_p)
 366 {
 367   if (regnum >= 0 && regnum < 32)
 368     return regnum;
 369   else if (regnum == LOONGARCH_PC_REGNUM)
 370     return LOONGARCH_PC_REGNUM;
 371   else
 372     return -1;
 373 }
 374
 375 static loongarch_linux_nat_target the_loongarch_linux_nat_target;
 376
 377 /* Wrapper functions.  These are only used by libthread_db.  */
 378
 379 void
 380 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregset)
 381 {
 382   loongarch_gregset.supply_regset (nullptr, regcache, -1, gregset,
 383                                    sizeof (gdb_gregset_t));
 384 }
 385
 386 void
 387 fill_gregset (const struct regcache *regcache, gdb_gregset_t *gregset,
 388               int regnum)
 389 {
 390   loongarch_gregset.collect_regset (nullptr, regcache, regnum, gregset,
 391                                     sizeof (gdb_gregset_t));
 392 }
 393
 394 void
 395 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregset)
 396 {
 397   loongarch_fpregset.supply_regset (nullptr, regcache, -1, fpregset,
 398                                     sizeof (gdb_fpregset_t));
 399 }
 400
 401 void
 402 fill_fpregset (const struct regcache *regcache, gdb_fpregset_t *fpregset,
 403                int regnum)
 404 {
 405   loongarch_fpregset.collect_regset (nullptr, regcache, regnum, fpregset,
 406                                      sizeof (gdb_fpregset_t));
 407 }
 408
 409 /* Initialize LoongArch Linux native support.  */
 410
 411 void _initialize_loongarch_linux_nat ();
 412 void
 413 _initialize_loongarch_linux_nat ()
 414 {
 415   linux_target = &the_loongarch_linux_nat_target;
 416   add_inf_child_target (&the_loongarch_linux_nat_target);
 417 }