OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [regcache.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Cache and manage the values of registers for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4
   2002, 2004, 2007, 2008 Free Software Foundation, Inc.
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 "defs.h"
22
#include "inferior.h"
23
#include "target.h"
24
#include "gdbarch.h"
25
#include "gdbcmd.h"
26
#include "regcache.h"
27
#include "reggroups.h"
28
#include "gdb_assert.h"
29
#include "gdb_string.h"
30
#include "gdbcmd.h"             /* For maintenanceprintlist.  */
31
#include "observer.h"
32
 
33
/*
34
 * DATA STRUCTURE
35
 *
36
 * Here is the actual register cache.
37
 */
38
 
39
/* Per-architecture object describing the layout of a register cache.
40
   Computed once when the architecture is created */
41
 
42
struct gdbarch_data *regcache_descr_handle;
43
 
44
struct regcache_descr
45
{
46
  /* The architecture this descriptor belongs to.  */
47
  struct gdbarch *gdbarch;
48
 
49
  /* The raw register cache.  Each raw (or hard) register is supplied
50
     by the target interface.  The raw cache should not contain
51
     redundant information - if the PC is constructed from two
52
     registers then those registers and not the PC lives in the raw
53
     cache.  */
54
  int nr_raw_registers;
55
  long sizeof_raw_registers;
56
  long sizeof_raw_register_valid_p;
57
 
58
  /* The cooked register space.  Each cooked register in the range
59
     [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60
     register.  The remaining [NR_RAW_REGISTERS
61
     .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62
     both raw registers and memory by the architecture methods
63
     gdbarch_pseudo_register_read and gdbarch_pseudo_register_write.  */
64
  int nr_cooked_registers;
65
  long sizeof_cooked_registers;
66
  long sizeof_cooked_register_valid_p;
67
 
68
  /* Offset and size (in 8 bit bytes), of reach register in the
69
     register cache.  All registers (including those in the range
70
     [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
71
     Assigning all registers an offset makes it possible to keep
72
     legacy code, such as that found in read_register_bytes() and
73
     write_register_bytes() working.  */
74
  long *register_offset;
75
  long *sizeof_register;
76
 
77
  /* Cached table containing the type of each register.  */
78
  struct type **register_type;
79
};
80
 
81
static void *
82
init_regcache_descr (struct gdbarch *gdbarch)
83
{
84
  int i;
85
  struct regcache_descr *descr;
86
  gdb_assert (gdbarch != NULL);
87
 
88
  /* Create an initial, zero filled, table.  */
89
  descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
90
  descr->gdbarch = gdbarch;
91
 
92
  /* Total size of the register space.  The raw registers are mapped
93
     directly onto the raw register cache while the pseudo's are
94
     either mapped onto raw-registers or memory.  */
95
  descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
96
                               + gdbarch_num_pseudo_regs (gdbarch);
97
  descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
98
                                          + gdbarch_num_pseudo_regs
99
                                              (gdbarch);
100
 
101
  /* Fill in a table of register types.  */
102
  descr->register_type
103
    = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
104
  for (i = 0; i < descr->nr_cooked_registers; i++)
105
    descr->register_type[i] = gdbarch_register_type (gdbarch, i);
106
 
107
  /* Construct a strictly RAW register cache.  Don't allow pseudo's
108
     into the register cache.  */
109
  descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
110
 
111
  /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
112
     array.  This pretects GDB from erant code that accesses elements
113
     of the global register_valid_p[] array in the range
114
     [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs).  */
115
  descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
116
 
117
  /* Lay out the register cache.
118
 
119
     NOTE: cagney/2002-05-22: Only register_type() is used when
120
     constructing the register cache.  It is assumed that the
121
     register's raw size, virtual size and type length are all the
122
     same.  */
123
 
124
  {
125
    long offset = 0;
126
    descr->sizeof_register
127
      = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
128
    descr->register_offset
129
      = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
130
    for (i = 0; i < descr->nr_cooked_registers; i++)
131
      {
132
        descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
133
        descr->register_offset[i] = offset;
134
        offset += descr->sizeof_register[i];
135
        gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
136
      }
137
    /* Set the real size of the register cache buffer.  */
138
    descr->sizeof_cooked_registers = offset;
139
  }
140
 
141
  /* FIXME: cagney/2002-05-22: Should only need to allocate space for
142
     the raw registers.  Unfortunately some code still accesses the
143
     register array directly using the global registers[].  Until that
144
     code has been purged, play safe and over allocating the register
145
     buffer.  Ulgh!  */
146
  descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
147
 
148
  return descr;
149
}
150
 
151
static struct regcache_descr *
152
regcache_descr (struct gdbarch *gdbarch)
153
{
154
  return gdbarch_data (gdbarch, regcache_descr_handle);
155
}
156
 
157
/* Utility functions returning useful register attributes stored in
158
   the regcache descr.  */
159
 
160
struct type *
161
register_type (struct gdbarch *gdbarch, int regnum)
162
{
163
  struct regcache_descr *descr = regcache_descr (gdbarch);
164
  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
165
  return descr->register_type[regnum];
166
}
167
 
168
/* Utility functions returning useful register attributes stored in
169
   the regcache descr.  */
170
 
171
int
172
register_size (struct gdbarch *gdbarch, int regnum)
173
{
174
  struct regcache_descr *descr = regcache_descr (gdbarch);
175
  int size;
176
  gdb_assert (regnum >= 0
177
              && regnum < (gdbarch_num_regs (gdbarch)
178
                           + gdbarch_num_pseudo_regs (gdbarch)));
179
  size = descr->sizeof_register[regnum];
180
  return size;
181
}
182
 
183
/* The register cache for storing raw register values.  */
184
 
185
struct regcache
186
{
187
  struct regcache_descr *descr;
188
  /* The register buffers.  A read-only register cache can hold the
189
     full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
190
     register cache can only hold [0 .. gdbarch_num_regs).  */
191
  gdb_byte *registers;
192
  /* Register cache status:
193
     register_valid_p[REG] == 0 if REG value is not in the cache
194
                            > 0 if REG value is in the cache
195
                            < 0 if REG value is permanently unavailable */
196
  signed char *register_valid_p;
197
  /* Is this a read-only cache?  A read-only cache is used for saving
198
     the target's register state (e.g, across an inferior function
199
     call or just before forcing a function return).  A read-only
200
     cache can only be updated via the methods regcache_dup() and
201
     regcache_cpy().  The actual contents are determined by the
202
     reggroup_save and reggroup_restore methods.  */
203
  int readonly_p;
204
  /* If this is a read-write cache, which thread's registers is
205
     it connected to?  */
206
  ptid_t ptid;
207
};
208
 
209
struct regcache *
210
regcache_xmalloc (struct gdbarch *gdbarch)
211
{
212
  struct regcache_descr *descr;
213
  struct regcache *regcache;
214
  gdb_assert (gdbarch != NULL);
215
  descr = regcache_descr (gdbarch);
216
  regcache = XMALLOC (struct regcache);
217
  regcache->descr = descr;
218
  regcache->registers
219
    = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
220
  regcache->register_valid_p
221
    = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
222
  regcache->readonly_p = 1;
223
  regcache->ptid = minus_one_ptid;
224
  return regcache;
225
}
226
 
227
void
228
regcache_xfree (struct regcache *regcache)
229
{
230
  if (regcache == NULL)
231
    return;
232
  xfree (regcache->registers);
233
  xfree (regcache->register_valid_p);
234
  xfree (regcache);
235
}
236
 
237
static void
238
do_regcache_xfree (void *data)
239
{
240
  regcache_xfree (data);
241
}
242
 
243
struct cleanup *
244
make_cleanup_regcache_xfree (struct regcache *regcache)
245
{
246
  return make_cleanup (do_regcache_xfree, regcache);
247
}
248
 
249
/* Return REGCACHE's architecture.  */
250
 
251
struct gdbarch *
252
get_regcache_arch (const struct regcache *regcache)
253
{
254
  return regcache->descr->gdbarch;
255
}
256
 
257
/* Return  a pointer to register REGNUM's buffer cache.  */
258
 
259
static gdb_byte *
260
register_buffer (const struct regcache *regcache, int regnum)
261
{
262
  return regcache->registers + regcache->descr->register_offset[regnum];
263
}
264
 
265
void
266
regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
267
               void *src)
268
{
269
  struct gdbarch *gdbarch = dst->descr->gdbarch;
270
  gdb_byte buf[MAX_REGISTER_SIZE];
271
  int regnum;
272
  /* The DST should be `read-only', if it wasn't then the save would
273
     end up trying to write the register values back out to the
274
     target.  */
275
  gdb_assert (dst->readonly_p);
276
  /* Clear the dest.  */
277
  memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
278
  memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
279
  /* Copy over any registers (identified by their membership in the
280
     save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
281
     gdbarch_num_pseudo_regs) range is checked since some architectures need
282
     to save/restore `cooked' registers that live in memory.  */
283
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
284
    {
285
      if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
286
        {
287
          int valid = cooked_read (src, regnum, buf);
288
          if (valid)
289
            {
290
              memcpy (register_buffer (dst, regnum), buf,
291
                      register_size (gdbarch, regnum));
292
              dst->register_valid_p[regnum] = 1;
293
            }
294
        }
295
    }
296
}
297
 
298
void
299
regcache_restore (struct regcache *dst,
300
                  regcache_cooked_read_ftype *cooked_read,
301
                  void *cooked_read_context)
302
{
303
  struct gdbarch *gdbarch = dst->descr->gdbarch;
304
  gdb_byte buf[MAX_REGISTER_SIZE];
305
  int regnum;
306
  /* The dst had better not be read-only.  If it is, the `restore'
307
     doesn't make much sense.  */
308
  gdb_assert (!dst->readonly_p);
309
  /* Copy over any registers, being careful to only restore those that
310
     were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
311
     + gdbarch_num_pseudo_regs) range is checked since some architectures need
312
     to save/restore `cooked' registers that live in memory.  */
313
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
314
    {
315
      if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
316
        {
317
          int valid = cooked_read (cooked_read_context, regnum, buf);
318
          if (valid)
319
            regcache_cooked_write (dst, regnum, buf);
320
        }
321
    }
322
}
323
 
324
static int
325
do_cooked_read (void *src, int regnum, gdb_byte *buf)
326
{
327
  struct regcache *regcache = src;
328
  if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
329
    /* Don't even think about fetching a register from a read-only
330
       cache when the register isn't yet valid.  There isn't a target
331
       from which the register value can be fetched.  */
332
    return 0;
333
  regcache_cooked_read (regcache, regnum, buf);
334
  return 1;
335
}
336
 
337
 
338
void
339
regcache_cpy (struct regcache *dst, struct regcache *src)
340
{
341
  int i;
342
  gdb_byte *buf;
343
  gdb_assert (src != NULL && dst != NULL);
344
  gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
345
  gdb_assert (src != dst);
346
  gdb_assert (src->readonly_p || dst->readonly_p);
347
  if (!src->readonly_p)
348
    regcache_save (dst, do_cooked_read, src);
349
  else if (!dst->readonly_p)
350
    regcache_restore (dst, do_cooked_read, src);
351
  else
352
    regcache_cpy_no_passthrough (dst, src);
353
}
354
 
355
void
356
regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
357
{
358
  int i;
359
  gdb_assert (src != NULL && dst != NULL);
360
  gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
361
  /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
362
     move of data into the current regcache.  Doing this would be
363
     silly - it would mean that valid_p would be completely invalid.  */
364
  gdb_assert (dst->readonly_p);
365
  memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
366
  memcpy (dst->register_valid_p, src->register_valid_p,
367
          dst->descr->sizeof_raw_register_valid_p);
368
}
369
 
370
struct regcache *
371
regcache_dup (struct regcache *src)
372
{
373
  struct regcache *newbuf;
374
  newbuf = regcache_xmalloc (src->descr->gdbarch);
375
  regcache_cpy (newbuf, src);
376
  return newbuf;
377
}
378
 
379
struct regcache *
380
regcache_dup_no_passthrough (struct regcache *src)
381
{
382
  struct regcache *newbuf;
383
  newbuf = regcache_xmalloc (src->descr->gdbarch);
384
  regcache_cpy_no_passthrough (newbuf, src);
385
  return newbuf;
386
}
387
 
388
int
389
regcache_valid_p (const struct regcache *regcache, int regnum)
390
{
391
  gdb_assert (regcache != NULL);
392
  gdb_assert (regnum >= 0);
393
  if (regcache->readonly_p)
394
    gdb_assert (regnum < regcache->descr->nr_cooked_registers);
395
  else
396
    gdb_assert (regnum < regcache->descr->nr_raw_registers);
397
 
398
  return regcache->register_valid_p[regnum];
399
}
400
 
401
void
402
regcache_invalidate (struct regcache *regcache, int regnum)
403
{
404
  gdb_assert (regcache != NULL);
405
  gdb_assert (regnum >= 0);
406
  gdb_assert (!regcache->readonly_p);
407
  gdb_assert (regnum < regcache->descr->nr_raw_registers);
408
  regcache->register_valid_p[regnum] = 0;
409
}
410
 
411
 
412
/* Global structure containing the current regcache.  */
413
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
414
   deprecated_register_valid[] currently point into this structure.  */
415
static struct regcache *current_regcache;
416
 
417
/* NOTE: this is a write-through cache.  There is no "dirty" bit for
418
   recording if the register values have been changed (eg. by the
419
   user).  Therefore all registers must be written back to the
420
   target when appropriate.  */
421
 
422
struct regcache *get_thread_regcache (ptid_t ptid)
423
{
424
  /* NOTE: uweigand/2007-05-05:  We need to detect the thread's
425
     current architecture at this point.  */
426
  struct gdbarch *thread_gdbarch = current_gdbarch;
427
 
428
  if (current_regcache && ptid_equal (current_regcache->ptid, ptid)
429
      && get_regcache_arch (current_regcache) == thread_gdbarch)
430
    return current_regcache;
431
 
432
  if (current_regcache)
433
    regcache_xfree (current_regcache);
434
 
435
  current_regcache = regcache_xmalloc (thread_gdbarch);
436
  current_regcache->readonly_p = 0;
437
  current_regcache->ptid = ptid;
438
 
439
  return current_regcache;
440
}
441
 
442
struct regcache *get_current_regcache (void)
443
{
444
  return get_thread_regcache (inferior_ptid);
445
}
446
 
447
 
448
/* Observer for the target_changed event.  */
449
 
450
void
451
regcache_observer_target_changed (struct target_ops *target)
452
{
453
  registers_changed ();
454
}
455
 
456
/* Low level examining and depositing of registers.
457
 
458
   The caller is responsible for making sure that the inferior is
459
   stopped before calling the fetching routines, or it will get
460
   garbage.  (a change from GDB version 3, in which the caller got the
461
   value from the last stop).  */
462
 
463
/* REGISTERS_CHANGED ()
464
 
465
   Indicate that registers may have changed, so invalidate the cache.  */
466
 
467
void
468
registers_changed (void)
469
{
470
  int i;
471
 
472
  regcache_xfree (current_regcache);
473
  current_regcache = NULL;
474
 
475
  /* Need to forget about any frames we have cached, too. */
476
  reinit_frame_cache ();
477
 
478
  /* Force cleanup of any alloca areas if using C alloca instead of
479
     a builtin alloca.  This particular call is used to clean up
480
     areas allocated by low level target code which may build up
481
     during lengthy interactions between gdb and the target before
482
     gdb gives control to the user (ie watchpoints).  */
483
  alloca (0);
484
}
485
 
486
 
487
void
488
regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
489
{
490
  gdb_assert (regcache != NULL && buf != NULL);
491
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
492
  /* Make certain that the register cache is up-to-date with respect
493
     to the current thread.  This switching shouldn't be necessary
494
     only there is still only one target side register cache.  Sigh!
495
     On the bright side, at least there is a regcache object.  */
496
  if (!regcache->readonly_p)
497
    {
498
      if (!regcache_valid_p (regcache, regnum))
499
        {
500
          struct cleanup *old_chain = save_inferior_ptid ();
501
          inferior_ptid = regcache->ptid;
502
          target_fetch_registers (regcache, regnum);
503
          do_cleanups (old_chain);
504
        }
505
#if 0
506
      /* FIXME: cagney/2004-08-07: At present a number of targets
507
         forget (or didn't know that they needed) to set this leading to
508
         panics.  Also is the problem that targets need to indicate
509
         that a register is in one of the possible states: valid,
510
         undefined, unknown.  The last of which isn't yet
511
         possible.  */
512
      gdb_assert (regcache_valid_p (regcache, regnum));
513
#endif
514
    }
515
  /* Copy the value directly into the register cache.  */
516
  memcpy (buf, register_buffer (regcache, regnum),
517
          regcache->descr->sizeof_register[regnum]);
518
}
519
 
520
void
521
regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
522
{
523
  gdb_byte *buf;
524
  gdb_assert (regcache != NULL);
525
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
526
  buf = alloca (regcache->descr->sizeof_register[regnum]);
527
  regcache_raw_read (regcache, regnum, buf);
528
  (*val) = extract_signed_integer (buf,
529
                                   regcache->descr->sizeof_register[regnum]);
530
}
531
 
532
void
533
regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
534
                            ULONGEST *val)
535
{
536
  gdb_byte *buf;
537
  gdb_assert (regcache != NULL);
538
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
539
  buf = alloca (regcache->descr->sizeof_register[regnum]);
540
  regcache_raw_read (regcache, regnum, buf);
541
  (*val) = extract_unsigned_integer (buf,
542
                                     regcache->descr->sizeof_register[regnum]);
543
}
544
 
545
void
546
regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
547
{
548
  void *buf;
549
  gdb_assert (regcache != NULL);
550
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
551
  buf = alloca (regcache->descr->sizeof_register[regnum]);
552
  store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
553
  regcache_raw_write (regcache, regnum, buf);
554
}
555
 
556
void
557
regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
558
                             ULONGEST val)
559
{
560
  void *buf;
561
  gdb_assert (regcache != NULL);
562
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
563
  buf = alloca (regcache->descr->sizeof_register[regnum]);
564
  store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
565
  regcache_raw_write (regcache, regnum, buf);
566
}
567
 
568
void
569
regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
570
{
571
  gdb_assert (regnum >= 0);
572
  gdb_assert (regnum < regcache->descr->nr_cooked_registers);
573
  if (regnum < regcache->descr->nr_raw_registers)
574
    regcache_raw_read (regcache, regnum, buf);
575
  else if (regcache->readonly_p
576
           && regnum < regcache->descr->nr_cooked_registers
577
           && regcache->register_valid_p[regnum])
578
    /* Read-only register cache, perhaps the cooked value was cached?  */
579
    memcpy (buf, register_buffer (regcache, regnum),
580
            regcache->descr->sizeof_register[regnum]);
581
  else
582
    gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
583
                                  regnum, buf);
584
}
585
 
586
void
587
regcache_cooked_read_signed (struct regcache *regcache, int regnum,
588
                             LONGEST *val)
589
{
590
  gdb_byte *buf;
591
  gdb_assert (regcache != NULL);
592
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
593
  buf = alloca (regcache->descr->sizeof_register[regnum]);
594
  regcache_cooked_read (regcache, regnum, buf);
595
  (*val) = extract_signed_integer (buf,
596
                                   regcache->descr->sizeof_register[regnum]);
597
}
598
 
599
void
600
regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
601
                               ULONGEST *val)
602
{
603
  gdb_byte *buf;
604
  gdb_assert (regcache != NULL);
605
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
606
  buf = alloca (regcache->descr->sizeof_register[regnum]);
607
  regcache_cooked_read (regcache, regnum, buf);
608
  (*val) = extract_unsigned_integer (buf,
609
                                     regcache->descr->sizeof_register[regnum]);
610
}
611
 
612
void
613
regcache_cooked_write_signed (struct regcache *regcache, int regnum,
614
                              LONGEST val)
615
{
616
  void *buf;
617
  gdb_assert (regcache != NULL);
618
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
619
  buf = alloca (regcache->descr->sizeof_register[regnum]);
620
  store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
621
  regcache_cooked_write (regcache, regnum, buf);
622
}
623
 
624
void
625
regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
626
                                ULONGEST val)
627
{
628
  void *buf;
629
  gdb_assert (regcache != NULL);
630
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
631
  buf = alloca (regcache->descr->sizeof_register[regnum]);
632
  store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
633
  regcache_cooked_write (regcache, regnum, buf);
634
}
635
 
636
void
637
regcache_raw_write (struct regcache *regcache, int regnum,
638
                    const gdb_byte *buf)
639
{
640
  struct cleanup *old_chain;
641
 
642
  gdb_assert (regcache != NULL && buf != NULL);
643
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
644
  gdb_assert (!regcache->readonly_p);
645
 
646
  /* On the sparc, writing %g0 is a no-op, so we don't even want to
647
     change the registers array if something writes to this register.  */
648
  if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
649
    return;
650
 
651
  /* If we have a valid copy of the register, and new value == old
652
     value, then don't bother doing the actual store. */
653
  if (regcache_valid_p (regcache, regnum)
654
      && (memcmp (register_buffer (regcache, regnum), buf,
655
                  regcache->descr->sizeof_register[regnum]) == 0))
656
    return;
657
 
658
  old_chain = save_inferior_ptid ();
659
  inferior_ptid = regcache->ptid;
660
 
661
  target_prepare_to_store (regcache);
662
  memcpy (register_buffer (regcache, regnum), buf,
663
          regcache->descr->sizeof_register[regnum]);
664
  regcache->register_valid_p[regnum] = 1;
665
  target_store_registers (regcache, regnum);
666
 
667
  do_cleanups (old_chain);
668
}
669
 
670
void
671
regcache_cooked_write (struct regcache *regcache, int regnum,
672
                       const gdb_byte *buf)
673
{
674
  gdb_assert (regnum >= 0);
675
  gdb_assert (regnum < regcache->descr->nr_cooked_registers);
676
  if (regnum < regcache->descr->nr_raw_registers)
677
    regcache_raw_write (regcache, regnum, buf);
678
  else
679
    gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
680
                                   regnum, buf);
681
}
682
 
683
/* Perform a partial register transfer using a read, modify, write
684
   operation.  */
685
 
686
typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
687
                                    void *buf);
688
typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
689
                                     const void *buf);
690
 
691
static void
692
regcache_xfer_part (struct regcache *regcache, int regnum,
693
                    int offset, int len, void *in, const void *out,
694
                    void (*read) (struct regcache *regcache, int regnum,
695
                                  gdb_byte *buf),
696
                    void (*write) (struct regcache *regcache, int regnum,
697
                                   const gdb_byte *buf))
698
{
699
  struct regcache_descr *descr = regcache->descr;
700
  gdb_byte reg[MAX_REGISTER_SIZE];
701
  gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
702
  gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
703
  /* Something to do?  */
704
  if (offset + len == 0)
705
    return;
706
  /* Read (when needed) ... */
707
  if (in != NULL
708
      || offset > 0
709
      || offset + len < descr->sizeof_register[regnum])
710
    {
711
      gdb_assert (read != NULL);
712
      read (regcache, regnum, reg);
713
    }
714
  /* ... modify ... */
715
  if (in != NULL)
716
    memcpy (in, reg + offset, len);
717
  if (out != NULL)
718
    memcpy (reg + offset, out, len);
719
  /* ... write (when needed).  */
720
  if (out != NULL)
721
    {
722
      gdb_assert (write != NULL);
723
      write (regcache, regnum, reg);
724
    }
725
}
726
 
727
void
728
regcache_raw_read_part (struct regcache *regcache, int regnum,
729
                        int offset, int len, gdb_byte *buf)
730
{
731
  struct regcache_descr *descr = regcache->descr;
732
  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
733
  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
734
                      regcache_raw_read, regcache_raw_write);
735
}
736
 
737
void
738
regcache_raw_write_part (struct regcache *regcache, int regnum,
739
                         int offset, int len, const gdb_byte *buf)
740
{
741
  struct regcache_descr *descr = regcache->descr;
742
  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
743
  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
744
                      regcache_raw_read, regcache_raw_write);
745
}
746
 
747
void
748
regcache_cooked_read_part (struct regcache *regcache, int regnum,
749
                           int offset, int len, gdb_byte *buf)
750
{
751
  struct regcache_descr *descr = regcache->descr;
752
  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
753
  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
754
                      regcache_cooked_read, regcache_cooked_write);
755
}
756
 
757
void
758
regcache_cooked_write_part (struct regcache *regcache, int regnum,
759
                            int offset, int len, const gdb_byte *buf)
760
{
761
  struct regcache_descr *descr = regcache->descr;
762
  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
763
  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
764
                      regcache_cooked_read, regcache_cooked_write);
765
}
766
 
767
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
768
 
769
void
770
regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
771
{
772
  void *regbuf;
773
  size_t size;
774
 
775
  gdb_assert (regcache != NULL);
776
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
777
  gdb_assert (!regcache->readonly_p);
778
 
779
  regbuf = register_buffer (regcache, regnum);
780
  size = regcache->descr->sizeof_register[regnum];
781
 
782
  if (buf)
783
    memcpy (regbuf, buf, size);
784
  else
785
    memset (regbuf, 0, size);
786
 
787
  /* Mark the register as cached.  */
788
  regcache->register_valid_p[regnum] = 1;
789
}
790
 
791
/* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
792
 
793
void
794
regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
795
{
796
  const void *regbuf;
797
  size_t size;
798
 
799
  gdb_assert (regcache != NULL && buf != NULL);
800
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
801
 
802
  regbuf = register_buffer (regcache, regnum);
803
  size = regcache->descr->sizeof_register[regnum];
804
  memcpy (buf, regbuf, size);
805
}
806
 
807
 
808
/* read_pc, write_pc, etc.  Special handling for register PC.  */
809
 
810
/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
811
   read_sp(), will eventually be replaced by per-frame methods.
812
   Instead of relying on the global INFERIOR_PTID, they will use the
813
   contextual information provided by the FRAME.  These functions do
814
   not belong in the register cache.  */
815
 
816
/* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
817
   write_pc_pid() and write_pc(), all need to be replaced by something
818
   that does not rely on global state.  But what?  */
819
 
820
CORE_ADDR
821
read_pc_pid (ptid_t ptid)
822
{
823
  struct regcache *regcache = get_thread_regcache (ptid);
824
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
825
 
826
  CORE_ADDR pc_val;
827
 
828
  if (gdbarch_read_pc_p (gdbarch))
829
    pc_val = gdbarch_read_pc (gdbarch, regcache);
830
  /* Else use per-frame method on get_current_frame.  */
831
  else if (gdbarch_pc_regnum (gdbarch) >= 0)
832
    {
833
      ULONGEST raw_val;
834
      regcache_cooked_read_unsigned (regcache,
835
                                     gdbarch_pc_regnum (gdbarch),
836
                                     &raw_val);
837
      pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
838
    }
839
  else
840
    internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
841
 
842
  return pc_val;
843
}
844
 
845
CORE_ADDR
846
read_pc (void)
847
{
848
  return read_pc_pid (inferior_ptid);
849
}
850
 
851
void
852
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
853
{
854
  struct regcache *regcache = get_thread_regcache (ptid);
855
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
856
 
857
  if (gdbarch_write_pc_p (gdbarch))
858
    gdbarch_write_pc (gdbarch, regcache, pc);
859
  else if (gdbarch_pc_regnum (gdbarch) >= 0)
860
    regcache_cooked_write_unsigned (regcache,
861
                                    gdbarch_pc_regnum (gdbarch), pc);
862
  else
863
    internal_error (__FILE__, __LINE__,
864
                    _("write_pc_pid: Unable to update PC"));
865
}
866
 
867
void
868
write_pc (CORE_ADDR pc)
869
{
870
  write_pc_pid (pc, inferior_ptid);
871
}
872
 
873
 
874
static void
875
reg_flush_command (char *command, int from_tty)
876
{
877
  /* Force-flush the register cache.  */
878
  registers_changed ();
879
  if (from_tty)
880
    printf_filtered (_("Register cache flushed.\n"));
881
}
882
 
883
static void
884
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
885
                   const unsigned char *buf, long len)
886
{
887
  int i;
888
  switch (endian)
889
    {
890
    case BFD_ENDIAN_BIG:
891
      for (i = 0; i < len; i++)
892
        fprintf_unfiltered (file, "%02x", buf[i]);
893
      break;
894
    case BFD_ENDIAN_LITTLE:
895
      for (i = len - 1; i >= 0; i--)
896
        fprintf_unfiltered (file, "%02x", buf[i]);
897
      break;
898
    default:
899
      internal_error (__FILE__, __LINE__, _("Bad switch"));
900
    }
901
}
902
 
903
enum regcache_dump_what
904
{
905
  regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
906
};
907
 
908
static void
909
regcache_dump (struct regcache *regcache, struct ui_file *file,
910
               enum regcache_dump_what what_to_dump)
911
{
912
  struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
913
  struct gdbarch *gdbarch = regcache->descr->gdbarch;
914
  int regnum;
915
  int footnote_nr = 0;
916
  int footnote_register_size = 0;
917
  int footnote_register_offset = 0;
918
  int footnote_register_type_name_null = 0;
919
  long register_offset = 0;
920
  unsigned char buf[MAX_REGISTER_SIZE];
921
 
922
#if 0
923
  fprintf_unfiltered (file, "nr_raw_registers %d\n",
924
                      regcache->descr->nr_raw_registers);
925
  fprintf_unfiltered (file, "nr_cooked_registers %d\n",
926
                      regcache->descr->nr_cooked_registers);
927
  fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
928
                      regcache->descr->sizeof_raw_registers);
929
  fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
930
                      regcache->descr->sizeof_raw_register_valid_p);
931
  fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
932
                      gdbarch_num_regs (gdbarch));
933
  fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
934
                      gdbarch_num_pseudo_regs (gdbarch));
935
#endif
936
 
937
  gdb_assert (regcache->descr->nr_cooked_registers
938
              == (gdbarch_num_regs (gdbarch)
939
                  + gdbarch_num_pseudo_regs (gdbarch)));
940
 
941
  for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
942
    {
943
      /* Name.  */
944
      if (regnum < 0)
945
        fprintf_unfiltered (file, " %-10s", "Name");
946
      else
947
        {
948
          const char *p = gdbarch_register_name (gdbarch, regnum);
949
          if (p == NULL)
950
            p = "";
951
          else if (p[0] == '\0')
952
            p = "''";
953
          fprintf_unfiltered (file, " %-10s", p);
954
        }
955
 
956
      /* Number.  */
957
      if (regnum < 0)
958
        fprintf_unfiltered (file, " %4s", "Nr");
959
      else
960
        fprintf_unfiltered (file, " %4d", regnum);
961
 
962
      /* Relative number.  */
963
      if (regnum < 0)
964
        fprintf_unfiltered (file, " %4s", "Rel");
965
      else if (regnum < gdbarch_num_regs (gdbarch))
966
        fprintf_unfiltered (file, " %4d", regnum);
967
      else
968
        fprintf_unfiltered (file, " %4d",
969
                            (regnum - gdbarch_num_regs (gdbarch)));
970
 
971
      /* Offset.  */
972
      if (regnum < 0)
973
        fprintf_unfiltered (file, " %6s  ", "Offset");
974
      else
975
        {
976
          fprintf_unfiltered (file, " %6ld",
977
                              regcache->descr->register_offset[regnum]);
978
          if (register_offset != regcache->descr->register_offset[regnum]
979
              || (regnum > 0
980
                  && (regcache->descr->register_offset[regnum]
981
                      != (regcache->descr->register_offset[regnum - 1]
982
                          + regcache->descr->sizeof_register[regnum - 1])))
983
              )
984
            {
985
              if (!footnote_register_offset)
986
                footnote_register_offset = ++footnote_nr;
987
              fprintf_unfiltered (file, "*%d", footnote_register_offset);
988
            }
989
          else
990
            fprintf_unfiltered (file, "  ");
991
          register_offset = (regcache->descr->register_offset[regnum]
992
                             + regcache->descr->sizeof_register[regnum]);
993
        }
994
 
995
      /* Size.  */
996
      if (regnum < 0)
997
        fprintf_unfiltered (file, " %5s ", "Size");
998
      else
999
        fprintf_unfiltered (file, " %5ld",
1000
                            regcache->descr->sizeof_register[regnum]);
1001
 
1002
      /* Type.  */
1003
      {
1004
        const char *t;
1005
        if (regnum < 0)
1006
          t = "Type";
1007
        else
1008
          {
1009
            static const char blt[] = "builtin_type";
1010
            t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1011
            if (t == NULL)
1012
              {
1013
                char *n;
1014
                if (!footnote_register_type_name_null)
1015
                  footnote_register_type_name_null = ++footnote_nr;
1016
                n = xstrprintf ("*%d", footnote_register_type_name_null);
1017
                make_cleanup (xfree, n);
1018
                t = n;
1019
              }
1020
            /* Chop a leading builtin_type.  */
1021
            if (strncmp (t, blt, strlen (blt)) == 0)
1022
              t += strlen (blt);
1023
          }
1024
        fprintf_unfiltered (file, " %-15s", t);
1025
      }
1026
 
1027
      /* Leading space always present.  */
1028
      fprintf_unfiltered (file, " ");
1029
 
1030
      /* Value, raw.  */
1031
      if (what_to_dump == regcache_dump_raw)
1032
        {
1033
          if (regnum < 0)
1034
            fprintf_unfiltered (file, "Raw value");
1035
          else if (regnum >= regcache->descr->nr_raw_registers)
1036
            fprintf_unfiltered (file, "<cooked>");
1037
          else if (!regcache_valid_p (regcache, regnum))
1038
            fprintf_unfiltered (file, "<invalid>");
1039
          else
1040
            {
1041
              regcache_raw_read (regcache, regnum, buf);
1042
              fprintf_unfiltered (file, "0x");
1043
              dump_endian_bytes (file,
1044
                                 gdbarch_byte_order (gdbarch), buf,
1045
                                 regcache->descr->sizeof_register[regnum]);
1046
            }
1047
        }
1048
 
1049
      /* Value, cooked.  */
1050
      if (what_to_dump == regcache_dump_cooked)
1051
        {
1052
          if (regnum < 0)
1053
            fprintf_unfiltered (file, "Cooked value");
1054
          else
1055
            {
1056
              regcache_cooked_read (regcache, regnum, buf);
1057
              fprintf_unfiltered (file, "0x");
1058
              dump_endian_bytes (file,
1059
                                 gdbarch_byte_order (gdbarch), buf,
1060
                                 regcache->descr->sizeof_register[regnum]);
1061
            }
1062
        }
1063
 
1064
      /* Group members.  */
1065
      if (what_to_dump == regcache_dump_groups)
1066
        {
1067
          if (regnum < 0)
1068
            fprintf_unfiltered (file, "Groups");
1069
          else
1070
            {
1071
              const char *sep = "";
1072
              struct reggroup *group;
1073
              for (group = reggroup_next (gdbarch, NULL);
1074
                   group != NULL;
1075
                   group = reggroup_next (gdbarch, group))
1076
                {
1077
                  if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1078
                    {
1079
                      fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1080
                      sep = ",";
1081
                    }
1082
                }
1083
            }
1084
        }
1085
 
1086
      fprintf_unfiltered (file, "\n");
1087
    }
1088
 
1089
  if (footnote_register_size)
1090
    fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1091
                        footnote_register_size);
1092
  if (footnote_register_offset)
1093
    fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1094
                        footnote_register_offset);
1095
  if (footnote_register_type_name_null)
1096
    fprintf_unfiltered (file,
1097
                        "*%d: Register type's name NULL.\n",
1098
                        footnote_register_type_name_null);
1099
  do_cleanups (cleanups);
1100
}
1101
 
1102
static void
1103
regcache_print (char *args, enum regcache_dump_what what_to_dump)
1104
{
1105
  if (args == NULL)
1106
    regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1107
  else
1108
    {
1109
      struct ui_file *file = gdb_fopen (args, "w");
1110
      if (file == NULL)
1111
        perror_with_name (_("maintenance print architecture"));
1112
      regcache_dump (get_current_regcache (), file, what_to_dump);
1113
      ui_file_delete (file);
1114
    }
1115
}
1116
 
1117
static void
1118
maintenance_print_registers (char *args, int from_tty)
1119
{
1120
  regcache_print (args, regcache_dump_none);
1121
}
1122
 
1123
static void
1124
maintenance_print_raw_registers (char *args, int from_tty)
1125
{
1126
  regcache_print (args, regcache_dump_raw);
1127
}
1128
 
1129
static void
1130
maintenance_print_cooked_registers (char *args, int from_tty)
1131
{
1132
  regcache_print (args, regcache_dump_cooked);
1133
}
1134
 
1135
static void
1136
maintenance_print_register_groups (char *args, int from_tty)
1137
{
1138
  regcache_print (args, regcache_dump_groups);
1139
}
1140
 
1141
extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1142
 
1143
void
1144
_initialize_regcache (void)
1145
{
1146
  regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1147
 
1148
  observer_attach_target_changed (regcache_observer_target_changed);
1149
 
1150
  add_com ("flushregs", class_maintenance, reg_flush_command,
1151
           _("Force gdb to flush its register cache (maintainer command)"));
1152
 
1153
  add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1154
Print the internal register configuration.\n\
1155
Takes an optional file parameter."), &maintenanceprintlist);
1156
  add_cmd ("raw-registers", class_maintenance,
1157
           maintenance_print_raw_registers, _("\
1158
Print the internal register configuration including raw values.\n\
1159
Takes an optional file parameter."), &maintenanceprintlist);
1160
  add_cmd ("cooked-registers", class_maintenance,
1161
           maintenance_print_cooked_registers, _("\
1162
Print the internal register configuration including cooked values.\n\
1163
Takes an optional file parameter."), &maintenanceprintlist);
1164
  add_cmd ("register-groups", class_maintenance,
1165
           maintenance_print_register_groups, _("\
1166
Print the internal register configuration including each register's group.\n\
1167
Takes an optional file parameter."),
1168
           &maintenanceprintlist);
1169
 
1170
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.