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