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