gdbserver/regcache.cc

   1 /* Register support routines for the remote server for GDB.
   2    Copyright (C) 2001-2024 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 "regdef.h"
  20 #include "gdbthread.h"
  21 #include "tdesc.h"
  22 #include "gdbsupport/rsp-low.h"
  23 #include "gdbsupport/gdb-checked-static-cast.h"
  24
  25 #ifndef IN_PROCESS_AGENT
  26
  27 struct regcache *
  28 get_thread_regcache (struct thread_info *thread, int fetch)
  29 {
  30   struct regcache *regcache;
  31
  32   regcache = thread_regcache_data (thread);
  33
  34   /* Threads' regcaches are created lazily, because biarch targets add
  35      the main thread/lwp before seeing it stop for the first time, and
  36      it is only after the target sees the thread stop for the first
  37      time that the target has a chance of determining the process's
  38      architecture.  IOW, when we first add the process's main thread
  39      we don't know which architecture/tdesc its regcache should
  40      have.  */
  41   if (regcache == NULL)
  42     {
  43       struct process_info *proc = get_thread_process (thread);
  44
  45       gdb_assert (proc->tdesc != NULL);
  46
  47       regcache = new_register_cache (proc->tdesc);
  48       set_thread_regcache_data (thread, regcache);
  49     }
  50
  51   if (fetch && regcache->registers_valid == 0)
  52     {
  53       scoped_restore_current_thread restore_thread;
  54
  55       switch_to_thread (thread);
  56       /* Invalidate all registers, to prevent stale left-overs.  */
  57       memset (regcache->register_status, REG_UNAVAILABLE,
  58               regcache->tdesc->reg_defs.size ());
  59       fetch_inferior_registers (regcache, -1);
  60       regcache->registers_valid = 1;
  61     }
  62
  63   return regcache;
  64 }
  65
  66 /* See gdbsupport/common-regcache.h.  */
  67
  68 reg_buffer_common *
  69 get_thread_regcache_for_ptid (ptid_t ptid)
  70 {
  71   return get_thread_regcache (find_thread_ptid (ptid), 1);
  72 }
  73
  74 void
  75 regcache_invalidate_thread (struct thread_info *thread)
  76 {
  77   struct regcache *regcache;
  78
  79   regcache = thread_regcache_data (thread);
  80
  81   if (regcache == NULL)
  82     return;
  83
  84   if (regcache->registers_valid)
  85     {
  86       scoped_restore_current_thread restore_thread;
  87
  88       switch_to_thread (thread);
  89       store_inferior_registers (regcache, -1);
  90     }
  91
  92   regcache->registers_valid = 0;
  93 }
  94
  95 /* See regcache.h.  */
  96
  97 void
  98 regcache_invalidate_pid (int pid)
  99 {
 100   /* Only invalidate the regcaches of threads of this process.  */
 101   for_each_thread (pid, regcache_invalidate_thread);
 102 }
 103
 104 /* See regcache.h.  */
 105
 106 void
 107 regcache_invalidate (void)
 108 {
 109   /* Only update the threads of the current process.  */
 110   int pid = current_thread->id.pid ();
 111
 112   regcache_invalidate_pid (pid);
 113 }
 114
 115 #endif
 116
 117 struct regcache *
 118 init_register_cache (struct regcache *regcache,
 119                      const struct target_desc *tdesc,
 120                      unsigned char *regbuf)
 121 {
 122   if (regbuf == NULL)
 123     {
 124 #ifndef IN_PROCESS_AGENT
 125       /* Make sure to zero-initialize the register cache when it is
 126          created, in case there are registers the target never
 127          fetches.  This way they'll read as zero instead of
 128          garbage.  */
 129       regcache->tdesc = tdesc;
 130       regcache->registers
 131         = (unsigned char *) xcalloc (1, tdesc->registers_size);
 132       regcache->registers_owned = 1;
 133       regcache->register_status
 134         = (unsigned char *) xmalloc (tdesc->reg_defs.size ());
 135       memset ((void *) regcache->register_status, REG_UNAVAILABLE,
 136               tdesc->reg_defs.size ());
 137 #else
 138       gdb_assert_not_reached ("can't allocate memory from the heap");
 139 #endif
 140     }
 141   else
 142     {
 143       regcache->tdesc = tdesc;
 144       regcache->registers = regbuf;
 145       regcache->registers_owned = 0;
 146 #ifndef IN_PROCESS_AGENT
 147       regcache->register_status = NULL;
 148 #endif
 149     }
 150
 151   regcache->registers_valid = 0;
 152
 153   return regcache;
 154 }
 155
 156 #ifndef IN_PROCESS_AGENT
 157
 158 struct regcache *
 159 new_register_cache (const struct target_desc *tdesc)
 160 {
 161   struct regcache *regcache = new struct regcache;
 162
 163   gdb_assert (tdesc->registers_size != 0);
 164
 165   return init_register_cache (regcache, tdesc, NULL);
 166 }
 167
 168 void
 169 free_register_cache (struct regcache *regcache)
 170 {
 171   if (regcache)
 172     {
 173       if (regcache->registers_owned)
 174         free (regcache->registers);
 175       free (regcache->register_status);
 176       delete regcache;
 177     }
 178 }
 179
 180 #endif
 181
 182 void
 183 regcache_cpy (struct regcache *dst, struct regcache *src)
 184 {
 185   gdb_assert (src != NULL && dst != NULL);
 186   gdb_assert (src->tdesc == dst->tdesc);
 187   gdb_assert (src != dst);
 188
 189   memcpy (dst->registers, src->registers, src->tdesc->registers_size);
 190 #ifndef IN_PROCESS_AGENT
 191   if (dst->register_status != NULL && src->register_status != NULL)
 192     memcpy (dst->register_status, src->register_status,
 193             src->tdesc->reg_defs.size ());
 194 #endif
 195   dst->registers_valid = src->registers_valid;
 196 }
 197
 198 /* Return a reference to the description of register N.  */
 199
 200 static const struct gdb::reg &
 201 find_register_by_number (const struct target_desc *tdesc, int n)
 202 {
 203   gdb_assert (n >= 0);
 204   gdb_assert (n < tdesc->reg_defs.size ());
 205
 206   return tdesc->reg_defs[n];
 207 }
 208
 209 #ifndef IN_PROCESS_AGENT
 210
 211 void
 212 registers_to_string (struct regcache *regcache, char *buf)
 213 {
 214   unsigned char *registers = regcache->registers;
 215   const struct target_desc *tdesc = regcache->tdesc;
 216
 217   for (int i = 0; i < tdesc->reg_defs.size (); ++i)
 218     {
 219       if (regcache->register_status[i] == REG_VALID)
 220         {
 221           bin2hex (registers, buf, register_size (tdesc, i));
 222           buf += register_size (tdesc, i) * 2;
 223         }
 224       else
 225         {
 226           memset (buf, 'x', register_size (tdesc, i) * 2);
 227           buf += register_size (tdesc, i) * 2;
 228         }
 229       registers += register_size (tdesc, i);
 230     }
 231   *buf = '\0';
 232 }
 233
 234 void
 235 registers_from_string (struct regcache *regcache, char *buf)
 236 {
 237   int len = strlen (buf);
 238   unsigned char *registers = regcache->registers;
 239   const struct target_desc *tdesc = regcache->tdesc;
 240
 241   if (len != tdesc->registers_size * 2)
 242     {
 243       warning ("Wrong sized register packet (expected %d bytes, got %d)",
 244                2 * tdesc->registers_size, len);
 245       if (len > tdesc->registers_size * 2)
 246         len = tdesc->registers_size * 2;
 247     }
 248   hex2bin (buf, registers, len / 2);
 249 }
 250
 251 /* See regcache.h */
 252
 253 std::optional<int>
 254 find_regno_no_throw (const struct target_desc *tdesc, const char *name)
 255 {
 256   for (int i = 0; i < tdesc->reg_defs.size (); ++i)
 257     {
 258       if (strcmp (name, find_register_by_number (tdesc, i).name) == 0)
 259         return i;
 260     }
 261   return {};
 262 }
 263
 264 int
 265 find_regno (const struct target_desc *tdesc, const char *name)
 266 {
 267   std::optional<int> regnum = find_regno_no_throw (tdesc, name);
 268
 269   if (regnum.has_value ())
 270     return *regnum;
 271
 272   internal_error ("Unknown register %s requested", name);
 273 }
 274
 275 static void
 276 free_register_cache_thread (struct thread_info *thread)
 277 {
 278   struct regcache *regcache = thread_regcache_data (thread);
 279
 280   if (regcache != NULL)
 281     {
 282       regcache_invalidate_thread (thread);
 283       free_register_cache (regcache);
 284       set_thread_regcache_data (thread, NULL);
 285     }
 286 }
 287
 288 void
 289 regcache_release (void)
 290 {
 291   /* Flush and release all pre-existing register caches.  */
 292   for_each_thread (free_register_cache_thread);
 293 }
 294 #endif
 295
 296 int
 297 register_cache_size (const struct target_desc *tdesc)
 298 {
 299   return tdesc->registers_size;
 300 }
 301
 302 int
 303 register_size (const struct target_desc *tdesc, int n)
 304 {
 305   return find_register_by_number (tdesc, n).size / 8;
 306 }
 307
 308 /* See gdbsupport/common-regcache.h.  */
 309
 310 int
 311 regcache_register_size (const reg_buffer_common *regcache, int n)
 312 {
 313   return register_size
 314     (gdb::checked_static_cast<const struct regcache *> (regcache)->tdesc, n);
 315 }
 316
 317 static gdb::array_view<gdb_byte>
 318 register_data (const struct regcache *regcache, int n)
 319 {
 320   const gdb::reg &reg = find_register_by_number (regcache->tdesc, n);
 321   return gdb::make_array_view (regcache->registers + reg.offset / 8,
 322                                reg.size / 8);
 323 }
 324
 325 void
 326 supply_register (struct regcache *regcache, int n, const void *vbuf)
 327 {
 328   const gdb::reg &reg = find_register_by_number (regcache->tdesc, n);
 329   const gdb_byte *buf = static_cast<const gdb_byte *> (vbuf);
 330   return regcache->raw_supply (n, gdb::make_array_view (buf, reg.size / 8));
 331 }
 332
 333 /* See gdbsupport/common-regcache.h.  */
 334
 335 void
 336 regcache::raw_supply (int n, gdb::array_view<const gdb_byte> src)
 337 {
 338   auto dst = register_data (this, n);
 339
 340   if (src.data () != nullptr)
 341     {
 342       copy (src, dst);
 343 #ifndef IN_PROCESS_AGENT
 344       if (register_status != NULL)
 345         register_status[n] = REG_VALID;
 346 #endif
 347     }
 348   else
 349     {
 350       memset (dst.data (), 0, dst.size ());
 351 #ifndef IN_PROCESS_AGENT
 352       if (register_status != NULL)
 353         register_status[n] = REG_UNAVAILABLE;
 354 #endif
 355     }
 356 }
 357
 358 /* Supply register N with value zero to REGCACHE.  */
 359
 360 void
 361 supply_register_zeroed (struct regcache *regcache, int n)
 362 {
 363   auto dst = register_data (regcache, n);
 364   memset (dst.data (), 0, dst.size ());
 365 #ifndef IN_PROCESS_AGENT
 366   if (regcache->register_status != NULL)
 367     regcache->register_status[n] = REG_VALID;
 368 #endif
 369 }
 370
 371 #ifndef IN_PROCESS_AGENT
 372
 373 /* Supply register called NAME with value zero to REGCACHE.  */
 374
 375 void
 376 supply_register_by_name_zeroed (struct regcache *regcache,
 377                                 const char *name)
 378 {
 379   supply_register_zeroed (regcache, find_regno (regcache->tdesc, name));
 380 }
 381
 382 #endif
 383
 384 /* Supply the whole register set whose contents are stored in BUF, to
 385    REGCACHE.  If BUF is NULL, all the registers' values are recorded
 386    as unavailable.  */
 387
 388 void
 389 supply_regblock (struct regcache *regcache, const void *buf)
 390 {
 391   if (buf)
 392     {
 393       const struct target_desc *tdesc = regcache->tdesc;
 394
 395       memcpy (regcache->registers, buf, tdesc->registers_size);
 396 #ifndef IN_PROCESS_AGENT
 397       {
 398         int i;
 399
 400         for (i = 0; i < tdesc->reg_defs.size (); i++)
 401           regcache->register_status[i] = REG_VALID;
 402       }
 403 #endif
 404     }
 405   else
 406     {
 407       const struct target_desc *tdesc = regcache->tdesc;
 408
 409       memset (regcache->registers, 0, tdesc->registers_size);
 410 #ifndef IN_PROCESS_AGENT
 411       {
 412         int i;
 413
 414         for (i = 0; i < tdesc->reg_defs.size (); i++)
 415           regcache->register_status[i] = REG_UNAVAILABLE;
 416       }
 417 #endif
 418     }
 419 }
 420
 421 #ifndef IN_PROCESS_AGENT
 422
 423 void
 424 supply_register_by_name (struct regcache *regcache,
 425                          const char *name, const void *buf)
 426 {
 427   supply_register (regcache, find_regno (regcache->tdesc, name), buf);
 428 }
 429
 430 #endif
 431
 432 void
 433 collect_register (struct regcache *regcache, int n, void *vbuf)
 434 {
 435   const gdb::reg &reg = find_register_by_number (regcache->tdesc, n);
 436   gdb_byte *buf = static_cast<gdb_byte *> (vbuf);
 437   regcache->raw_collect (n, gdb::make_array_view (buf, reg.size / 8));
 438 }
 439
 440 /* See gdbsupport/common-regcache.h.  */
 441
 442 void
 443 regcache::raw_collect (int n, gdb::array_view<gdb_byte> dst) const
 444 {
 445   auto src = register_data (this, n);
 446   copy (src, dst);
 447 }
 448
 449 enum register_status
 450 regcache_raw_read_unsigned (reg_buffer_common *reg_buf, int regnum,
 451                             ULONGEST *val)
 452 {
 453   int size;
 454   regcache *regcache = gdb::checked_static_cast<struct regcache *> (reg_buf);
 455
 456   gdb_assert (regcache != NULL);
 457
 458   size = register_size (regcache->tdesc, regnum);
 459
 460   if (size > (int) sizeof (ULONGEST))
 461     error (_("That operation is not available on integers of more than"
 462             "%d bytes."),
 463           (int) sizeof (ULONGEST));
 464
 465   *val = 0;
 466   collect_register (regcache, regnum, val);
 467
 468   return REG_VALID;
 469 }
 470
 471 #ifndef IN_PROCESS_AGENT
 472
 473 /* See regcache.h.  */
 474
 475 ULONGEST
 476 regcache_raw_get_unsigned_by_name (struct regcache *regcache,
 477                                    const char *name)
 478 {
 479   return regcache_raw_get_unsigned (regcache,
 480                                     find_regno (regcache->tdesc, name));
 481 }
 482
 483 void
 484 collect_register_as_string (struct regcache *regcache, int n, char *buf)
 485 {
 486   bin2hex (register_data (regcache, n), buf);
 487 }
 488
 489 void
 490 collect_register_by_name (struct regcache *regcache,
 491                           const char *name, void *buf)
 492 {
 493   collect_register (regcache, find_regno (regcache->tdesc, name), buf);
 494 }
 495
 496 /* Special handling for register PC.  */
 497
 498 CORE_ADDR
 499 regcache_read_pc (reg_buffer_common *regcache)
 500 {
 501   return the_target->read_pc
 502     (gdb::checked_static_cast<struct regcache *> (regcache));
 503 }
 504
 505 void
 506 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
 507 {
 508   the_target->write_pc (regcache, pc);
 509 }
 510
 511 #endif
 512
 513 /* See gdbsupport/common-regcache.h.  */
 514
 515 enum register_status
 516 regcache::get_register_status (int regnum) const
 517 {
 518 #ifndef IN_PROCESS_AGENT
 519   gdb_assert (regnum >= 0 && regnum < tdesc->reg_defs.size ());
 520   return (enum register_status) (register_status[regnum]);
 521 #else
 522   return REG_VALID;
 523 #endif
 524 }
 525
 526 /* See gdbsupport/common-regcache.h.  */
 527
 528 bool
 529 regcache::raw_compare (int regnum, const void *buf, int offset) const
 530 {
 531   gdb_assert (buf != NULL);
 532
 533   gdb::array_view<const gdb_byte> regbuf = register_data (this, regnum);
 534   gdb_assert (offset < regbuf.size ());
 535   regbuf = regbuf.slice (offset);
 536
 537   return memcmp (buf, regbuf.data (), regbuf.size ()) == 0;
 538 }