OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 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, 2009, 2010 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
 
189
  /* The address space of this register cache (for registers where it
190
     makes sense, like PC or SP).  */
191
  struct address_space *aspace;
192
 
193
  /* The register buffers.  A read-only register cache can hold the
194
     full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
195
     register cache can only hold [0 .. gdbarch_num_regs).  */
196
  gdb_byte *registers;
197
  /* Register cache status:
198
     register_valid_p[REG] == 0 if REG value is not in the cache
199
                            > 0 if REG value is in the cache
200
                            < 0 if REG value is permanently unavailable */
201
  signed char *register_valid_p;
202
  /* Is this a read-only cache?  A read-only cache is used for saving
203
     the target's register state (e.g, across an inferior function
204
     call or just before forcing a function return).  A read-only
205
     cache can only be updated via the methods regcache_dup() and
206
     regcache_cpy().  The actual contents are determined by the
207
     reggroup_save and reggroup_restore methods.  */
208
  int readonly_p;
209
  /* If this is a read-write cache, which thread's registers is
210
     it connected to?  */
211
  ptid_t ptid;
212
};
213
 
214
struct regcache *
215
regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
216
{
217
  struct regcache_descr *descr;
218
  struct regcache *regcache;
219
  gdb_assert (gdbarch != NULL);
220
  descr = regcache_descr (gdbarch);
221
  regcache = XMALLOC (struct regcache);
222
  regcache->descr = descr;
223
  regcache->registers
224
    = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
225
  regcache->register_valid_p
226
    = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
227
  regcache->aspace = aspace;
228
  regcache->readonly_p = 1;
229
  regcache->ptid = minus_one_ptid;
230
  return regcache;
231
}
232
 
233
void
234
regcache_xfree (struct regcache *regcache)
235
{
236
  if (regcache == NULL)
237
    return;
238
  xfree (regcache->registers);
239
  xfree (regcache->register_valid_p);
240
  xfree (regcache);
241
}
242
 
243
static void
244
do_regcache_xfree (void *data)
245
{
246
  regcache_xfree (data);
247
}
248
 
249
struct cleanup *
250
make_cleanup_regcache_xfree (struct regcache *regcache)
251
{
252
  return make_cleanup (do_regcache_xfree, regcache);
253
}
254
 
255
/* Return REGCACHE's architecture.  */
256
 
257
struct gdbarch *
258
get_regcache_arch (const struct regcache *regcache)
259
{
260
  return regcache->descr->gdbarch;
261
}
262
 
263
struct address_space *
264
get_regcache_aspace (const struct regcache *regcache)
265
{
266
  return regcache->aspace;
267
}
268
 
269
/* Return  a pointer to register REGNUM's buffer cache.  */
270
 
271
static gdb_byte *
272
register_buffer (const struct regcache *regcache, int regnum)
273
{
274
  return regcache->registers + regcache->descr->register_offset[regnum];
275
}
276
 
277
void
278
regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
279
               void *src)
280
{
281
  struct gdbarch *gdbarch = dst->descr->gdbarch;
282
  gdb_byte buf[MAX_REGISTER_SIZE];
283
  int regnum;
284
  /* The DST should be `read-only', if it wasn't then the save would
285
     end up trying to write the register values back out to the
286
     target.  */
287
  gdb_assert (dst->readonly_p);
288
  /* Clear the dest.  */
289
  memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
290
  memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
291
  /* Copy over any registers (identified by their membership in the
292
     save_reggroup) and mark them as valid.  The full [0 .. gdbarch_num_regs +
293
     gdbarch_num_pseudo_regs) range is checked since some architectures need
294
     to save/restore `cooked' registers that live in memory.  */
295
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
296
    {
297
      if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
298
        {
299
          int valid = cooked_read (src, regnum, buf);
300
          if (valid)
301
            {
302
              memcpy (register_buffer (dst, regnum), buf,
303
                      register_size (gdbarch, regnum));
304
              dst->register_valid_p[regnum] = 1;
305
            }
306
        }
307
    }
308
}
309
 
310
void
311
regcache_restore (struct regcache *dst,
312
                  regcache_cooked_read_ftype *cooked_read,
313
                  void *cooked_read_context)
314
{
315
  struct gdbarch *gdbarch = dst->descr->gdbarch;
316
  gdb_byte buf[MAX_REGISTER_SIZE];
317
  int regnum;
318
  /* The dst had better not be read-only.  If it is, the `restore'
319
     doesn't make much sense.  */
320
  gdb_assert (!dst->readonly_p);
321
  /* Copy over any registers, being careful to only restore those that
322
     were both saved and need to be restored.  The full [0 .. gdbarch_num_regs
323
     + gdbarch_num_pseudo_regs) range is checked since some architectures need
324
     to save/restore `cooked' registers that live in memory.  */
325
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
326
    {
327
      if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
328
        {
329
          int valid = cooked_read (cooked_read_context, regnum, buf);
330
          if (valid)
331
            regcache_cooked_write (dst, regnum, buf);
332
        }
333
    }
334
}
335
 
336
static int
337
do_cooked_read (void *src, int regnum, gdb_byte *buf)
338
{
339
  struct regcache *regcache = src;
340
  if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
341
    /* Don't even think about fetching a register from a read-only
342
       cache when the register isn't yet valid.  There isn't a target
343
       from which the register value can be fetched.  */
344
    return 0;
345
  regcache_cooked_read (regcache, regnum, buf);
346
  return 1;
347
}
348
 
349
 
350
void
351
regcache_cpy (struct regcache *dst, struct regcache *src)
352
{
353
  int i;
354
  gdb_byte *buf;
355
 
356
  gdb_assert (src != NULL && dst != NULL);
357
  gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
358
  gdb_assert (src != dst);
359
  gdb_assert (src->readonly_p || dst->readonly_p);
360
 
361
  if (!src->readonly_p)
362
    regcache_save (dst, do_cooked_read, src);
363
  else if (!dst->readonly_p)
364
    regcache_restore (dst, do_cooked_read, src);
365
  else
366
    regcache_cpy_no_passthrough (dst, src);
367
}
368
 
369
void
370
regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
371
{
372
  int i;
373
  gdb_assert (src != NULL && dst != NULL);
374
  gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
375
  /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
376
     move of data into the current regcache.  Doing this would be
377
     silly - it would mean that valid_p would be completely invalid.  */
378
  gdb_assert (dst->readonly_p);
379
 
380
  memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
381
  memcpy (dst->register_valid_p, src->register_valid_p,
382
          dst->descr->sizeof_raw_register_valid_p);
383
}
384
 
385
struct regcache *
386
regcache_dup (struct regcache *src)
387
{
388
  struct regcache *newbuf;
389
  newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
390
  regcache_cpy (newbuf, src);
391
  return newbuf;
392
}
393
 
394
struct regcache *
395
regcache_dup_no_passthrough (struct regcache *src)
396
{
397
  struct regcache *newbuf;
398
  newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
399
  regcache_cpy_no_passthrough (newbuf, src);
400
  return newbuf;
401
}
402
 
403
int
404
regcache_valid_p (const struct regcache *regcache, int regnum)
405
{
406
  gdb_assert (regcache != NULL);
407
  gdb_assert (regnum >= 0);
408
  if (regcache->readonly_p)
409
    gdb_assert (regnum < regcache->descr->nr_cooked_registers);
410
  else
411
    gdb_assert (regnum < regcache->descr->nr_raw_registers);
412
 
413
  return regcache->register_valid_p[regnum];
414
}
415
 
416
void
417
regcache_invalidate (struct regcache *regcache, int regnum)
418
{
419
  gdb_assert (regcache != NULL);
420
  gdb_assert (regnum >= 0);
421
  gdb_assert (!regcache->readonly_p);
422
  gdb_assert (regnum < regcache->descr->nr_raw_registers);
423
  regcache->register_valid_p[regnum] = 0;
424
}
425
 
426
 
427
/* Global structure containing the current regcache.  */
428
 
429
/* NOTE: this is a write-through cache.  There is no "dirty" bit for
430
   recording if the register values have been changed (eg. by the
431
   user).  Therefore all registers must be written back to the
432
   target when appropriate.  */
433
 
434
struct regcache_list
435
{
436
  struct regcache *regcache;
437
  struct regcache_list *next;
438
};
439
 
440
static struct regcache_list *current_regcache;
441
 
442
struct regcache *
443
get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
444
{
445
  struct regcache_list *list;
446
  struct regcache *new_regcache;
447
 
448
  for (list = current_regcache; list; list = list->next)
449
    if (ptid_equal (list->regcache->ptid, ptid)
450
        && get_regcache_arch (list->regcache) == gdbarch)
451
      return list->regcache;
452
 
453
  new_regcache = regcache_xmalloc (gdbarch,
454
                                   target_thread_address_space (ptid));
455
  new_regcache->readonly_p = 0;
456
  new_regcache->ptid = ptid;
457
  gdb_assert (new_regcache->aspace != NULL);
458
 
459
  list = xmalloc (sizeof (struct regcache_list));
460
  list->regcache = new_regcache;
461
  list->next = current_regcache;
462
  current_regcache = list;
463
 
464
  return new_regcache;
465
}
466
 
467
static ptid_t current_thread_ptid;
468
static struct gdbarch *current_thread_arch;
469
 
470
struct regcache *
471
get_thread_regcache (ptid_t ptid)
472
{
473
  if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
474
    {
475
      current_thread_ptid = ptid;
476
      current_thread_arch = target_thread_architecture (ptid);
477
    }
478
 
479
  return get_thread_arch_regcache (ptid, current_thread_arch);
480
}
481
 
482
struct regcache *
483
get_current_regcache (void)
484
{
485
  return get_thread_regcache (inferior_ptid);
486
}
487
 
488
 
489
/* Observer for the target_changed event.  */
490
 
491
static void
492
regcache_observer_target_changed (struct target_ops *target)
493
{
494
  registers_changed ();
495
}
496
 
497
/* Update global variables old ptids to hold NEW_PTID if they were
498
   holding OLD_PTID.  */
499
static void
500
regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
501
{
502
  struct regcache_list *list;
503
 
504
  for (list = current_regcache; list; list = list->next)
505
    if (ptid_equal (list->regcache->ptid, old_ptid))
506
      list->regcache->ptid = new_ptid;
507
}
508
 
509
/* Low level examining and depositing of registers.
510
 
511
   The caller is responsible for making sure that the inferior is
512
   stopped before calling the fetching routines, or it will get
513
   garbage.  (a change from GDB version 3, in which the caller got the
514
   value from the last stop).  */
515
 
516
/* REGISTERS_CHANGED ()
517
 
518
   Indicate that registers may have changed, so invalidate the cache.  */
519
 
520
void
521
registers_changed (void)
522
{
523
  struct regcache_list *list, *next;
524
 
525
  for (list = current_regcache; list; list = next)
526
    {
527
      next = list->next;
528
      regcache_xfree (list->regcache);
529
      xfree (list);
530
    }
531
 
532
  current_regcache = NULL;
533
 
534
  current_thread_ptid = null_ptid;
535
  current_thread_arch = NULL;
536
 
537
  /* Need to forget about any frames we have cached, too. */
538
  reinit_frame_cache ();
539
 
540
  /* Force cleanup of any alloca areas if using C alloca instead of
541
     a builtin alloca.  This particular call is used to clean up
542
     areas allocated by low level target code which may build up
543
     during lengthy interactions between gdb and the target before
544
     gdb gives control to the user (ie watchpoints).  */
545
  alloca (0);
546
}
547
 
548
 
549
void
550
regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
551
{
552
  gdb_assert (regcache != NULL && buf != NULL);
553
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
554
  /* Make certain that the register cache is up-to-date with respect
555
     to the current thread.  This switching shouldn't be necessary
556
     only there is still only one target side register cache.  Sigh!
557
     On the bright side, at least there is a regcache object.  */
558
  if (!regcache->readonly_p)
559
    {
560
      if (!regcache_valid_p (regcache, regnum))
561
        {
562
          struct cleanup *old_chain = save_inferior_ptid ();
563
          inferior_ptid = regcache->ptid;
564
          target_fetch_registers (regcache, regnum);
565
          do_cleanups (old_chain);
566
        }
567
#if 0
568
      /* FIXME: cagney/2004-08-07: At present a number of targets
569
         forget (or didn't know that they needed) to set this leading to
570
         panics.  Also is the problem that targets need to indicate
571
         that a register is in one of the possible states: valid,
572
         undefined, unknown.  The last of which isn't yet
573
         possible.  */
574
      gdb_assert (regcache_valid_p (regcache, regnum));
575
#endif
576
    }
577
  /* Copy the value directly into the register cache.  */
578
  memcpy (buf, register_buffer (regcache, regnum),
579
          regcache->descr->sizeof_register[regnum]);
580
}
581
 
582
void
583
regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
584
{
585
  gdb_byte *buf;
586
  gdb_assert (regcache != NULL);
587
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
588
  buf = alloca (regcache->descr->sizeof_register[regnum]);
589
  regcache_raw_read (regcache, regnum, buf);
590
  (*val) = extract_signed_integer
591
             (buf, regcache->descr->sizeof_register[regnum],
592
              gdbarch_byte_order (regcache->descr->gdbarch));
593
}
594
 
595
void
596
regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
597
                            ULONGEST *val)
598
{
599
  gdb_byte *buf;
600
  gdb_assert (regcache != NULL);
601
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
602
  buf = alloca (regcache->descr->sizeof_register[regnum]);
603
  regcache_raw_read (regcache, regnum, buf);
604
  (*val) = extract_unsigned_integer
605
             (buf, regcache->descr->sizeof_register[regnum],
606
              gdbarch_byte_order (regcache->descr->gdbarch));
607
}
608
 
609
void
610
regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
611
{
612
  void *buf;
613
  gdb_assert (regcache != NULL);
614
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
615
  buf = alloca (regcache->descr->sizeof_register[regnum]);
616
  store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
617
                        gdbarch_byte_order (regcache->descr->gdbarch), val);
618
  regcache_raw_write (regcache, regnum, buf);
619
}
620
 
621
void
622
regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
623
                             ULONGEST val)
624
{
625
  void *buf;
626
  gdb_assert (regcache != NULL);
627
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
628
  buf = alloca (regcache->descr->sizeof_register[regnum]);
629
  store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
630
                          gdbarch_byte_order (regcache->descr->gdbarch), val);
631
  regcache_raw_write (regcache, regnum, buf);
632
}
633
 
634
void
635
regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
636
{
637
  gdb_assert (regnum >= 0);
638
  gdb_assert (regnum < regcache->descr->nr_cooked_registers);
639
  if (regnum < regcache->descr->nr_raw_registers)
640
    regcache_raw_read (regcache, regnum, buf);
641
  else if (regcache->readonly_p
642
           && regnum < regcache->descr->nr_cooked_registers
643
           && regcache->register_valid_p[regnum])
644
    /* Read-only register cache, perhaps the cooked value was cached?  */
645
    memcpy (buf, register_buffer (regcache, regnum),
646
            regcache->descr->sizeof_register[regnum]);
647
  else
648
    gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
649
                                  regnum, buf);
650
}
651
 
652
void
653
regcache_cooked_read_signed (struct regcache *regcache, int regnum,
654
                             LONGEST *val)
655
{
656
  gdb_byte *buf;
657
  gdb_assert (regcache != NULL);
658
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
659
  buf = alloca (regcache->descr->sizeof_register[regnum]);
660
  regcache_cooked_read (regcache, regnum, buf);
661
  (*val) = extract_signed_integer
662
             (buf, regcache->descr->sizeof_register[regnum],
663
              gdbarch_byte_order (regcache->descr->gdbarch));
664
}
665
 
666
void
667
regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
668
                               ULONGEST *val)
669
{
670
  gdb_byte *buf;
671
  gdb_assert (regcache != NULL);
672
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
673
  buf = alloca (regcache->descr->sizeof_register[regnum]);
674
  regcache_cooked_read (regcache, regnum, buf);
675
  (*val) = extract_unsigned_integer
676
             (buf, regcache->descr->sizeof_register[regnum],
677
              gdbarch_byte_order (regcache->descr->gdbarch));
678
}
679
 
680
void
681
regcache_cooked_write_signed (struct regcache *regcache, int regnum,
682
                              LONGEST val)
683
{
684
  void *buf;
685
  gdb_assert (regcache != NULL);
686
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
687
  buf = alloca (regcache->descr->sizeof_register[regnum]);
688
  store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
689
                        gdbarch_byte_order (regcache->descr->gdbarch), val);
690
  regcache_cooked_write (regcache, regnum, buf);
691
}
692
 
693
void
694
regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
695
                                ULONGEST val)
696
{
697
  void *buf;
698
  gdb_assert (regcache != NULL);
699
  gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
700
  buf = alloca (regcache->descr->sizeof_register[regnum]);
701
  store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
702
                          gdbarch_byte_order (regcache->descr->gdbarch), val);
703
  regcache_cooked_write (regcache, regnum, buf);
704
}
705
 
706
void
707
regcache_raw_write (struct regcache *regcache, int regnum,
708
                    const gdb_byte *buf)
709
{
710
  struct cleanup *old_chain;
711
 
712
  gdb_assert (regcache != NULL && buf != NULL);
713
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
714
  gdb_assert (!regcache->readonly_p);
715
 
716
  /* On the sparc, writing %g0 is a no-op, so we don't even want to
717
     change the registers array if something writes to this register.  */
718
  if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
719
    return;
720
 
721
  /* If we have a valid copy of the register, and new value == old
722
     value, then don't bother doing the actual store. */
723
  if (regcache_valid_p (regcache, regnum)
724
      && (memcmp (register_buffer (regcache, regnum), buf,
725
                  regcache->descr->sizeof_register[regnum]) == 0))
726
    return;
727
 
728
  old_chain = save_inferior_ptid ();
729
  inferior_ptid = regcache->ptid;
730
 
731
  target_prepare_to_store (regcache);
732
  memcpy (register_buffer (regcache, regnum), buf,
733
          regcache->descr->sizeof_register[regnum]);
734
  regcache->register_valid_p[regnum] = 1;
735
  target_store_registers (regcache, regnum);
736
 
737
  do_cleanups (old_chain);
738
}
739
 
740
void
741
regcache_cooked_write (struct regcache *regcache, int regnum,
742
                       const gdb_byte *buf)
743
{
744
  gdb_assert (regnum >= 0);
745
  gdb_assert (regnum < regcache->descr->nr_cooked_registers);
746
  if (regnum < regcache->descr->nr_raw_registers)
747
    regcache_raw_write (regcache, regnum, buf);
748
  else
749
    gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
750
                                   regnum, buf);
751
}
752
 
753
/* Perform a partial register transfer using a read, modify, write
754
   operation.  */
755
 
756
typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
757
                                    void *buf);
758
typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
759
                                     const void *buf);
760
 
761
static void
762
regcache_xfer_part (struct regcache *regcache, int regnum,
763
                    int offset, int len, void *in, const void *out,
764
                    void (*read) (struct regcache *regcache, int regnum,
765
                                  gdb_byte *buf),
766
                    void (*write) (struct regcache *regcache, int regnum,
767
                                   const gdb_byte *buf))
768
{
769
  struct regcache_descr *descr = regcache->descr;
770
  gdb_byte reg[MAX_REGISTER_SIZE];
771
  gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
772
  gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
773
  /* Something to do?  */
774
  if (offset + len == 0)
775
    return;
776
  /* Read (when needed) ... */
777
  if (in != NULL
778
      || offset > 0
779
      || offset + len < descr->sizeof_register[regnum])
780
    {
781
      gdb_assert (read != NULL);
782
      read (regcache, regnum, reg);
783
    }
784
  /* ... modify ... */
785
  if (in != NULL)
786
    memcpy (in, reg + offset, len);
787
  if (out != NULL)
788
    memcpy (reg + offset, out, len);
789
  /* ... write (when needed).  */
790
  if (out != NULL)
791
    {
792
      gdb_assert (write != NULL);
793
      write (regcache, regnum, reg);
794
    }
795
}
796
 
797
void
798
regcache_raw_read_part (struct regcache *regcache, int regnum,
799
                        int offset, int len, gdb_byte *buf)
800
{
801
  struct regcache_descr *descr = regcache->descr;
802
  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
803
  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
804
                      regcache_raw_read, regcache_raw_write);
805
}
806
 
807
void
808
regcache_raw_write_part (struct regcache *regcache, int regnum,
809
                         int offset, int len, const gdb_byte *buf)
810
{
811
  struct regcache_descr *descr = regcache->descr;
812
  gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
813
  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
814
                      regcache_raw_read, regcache_raw_write);
815
}
816
 
817
void
818
regcache_cooked_read_part (struct regcache *regcache, int regnum,
819
                           int offset, int len, gdb_byte *buf)
820
{
821
  struct regcache_descr *descr = regcache->descr;
822
  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
823
  regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
824
                      regcache_cooked_read, regcache_cooked_write);
825
}
826
 
827
void
828
regcache_cooked_write_part (struct regcache *regcache, int regnum,
829
                            int offset, int len, const gdb_byte *buf)
830
{
831
  struct regcache_descr *descr = regcache->descr;
832
  gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
833
  regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
834
                      regcache_cooked_read, regcache_cooked_write);
835
}
836
 
837
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
838
 
839
void
840
regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
841
{
842
  void *regbuf;
843
  size_t size;
844
 
845
  gdb_assert (regcache != NULL);
846
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
847
  gdb_assert (!regcache->readonly_p);
848
 
849
  regbuf = register_buffer (regcache, regnum);
850
  size = regcache->descr->sizeof_register[regnum];
851
 
852
  if (buf)
853
    memcpy (regbuf, buf, size);
854
  else
855
    memset (regbuf, 0, size);
856
 
857
  /* Mark the register as cached.  */
858
  regcache->register_valid_p[regnum] = 1;
859
}
860
 
861
/* Collect register REGNUM from REGCACHE and store its contents in BUF.  */
862
 
863
void
864
regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
865
{
866
  const void *regbuf;
867
  size_t size;
868
 
869
  gdb_assert (regcache != NULL && buf != NULL);
870
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
871
 
872
  regbuf = register_buffer (regcache, regnum);
873
  size = regcache->descr->sizeof_register[regnum];
874
  memcpy (buf, regbuf, size);
875
}
876
 
877
 
878
/* Special handling for register PC.  */
879
 
880
CORE_ADDR
881
regcache_read_pc (struct regcache *regcache)
882
{
883
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
884
 
885
  CORE_ADDR pc_val;
886
 
887
  if (gdbarch_read_pc_p (gdbarch))
888
    pc_val = gdbarch_read_pc (gdbarch, regcache);
889
  /* Else use per-frame method on get_current_frame.  */
890
  else if (gdbarch_pc_regnum (gdbarch) >= 0)
891
    {
892
      ULONGEST raw_val;
893
      regcache_cooked_read_unsigned (regcache,
894
                                     gdbarch_pc_regnum (gdbarch),
895
                                     &raw_val);
896
      pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
897
    }
898
  else
899
    internal_error (__FILE__, __LINE__,
900
                    _("regcache_read_pc: Unable to find PC"));
901
  return pc_val;
902
}
903
 
904
void
905
regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
906
{
907
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
908
 
909
  if (gdbarch_write_pc_p (gdbarch))
910
    gdbarch_write_pc (gdbarch, regcache, pc);
911
  else if (gdbarch_pc_regnum (gdbarch) >= 0)
912
    regcache_cooked_write_unsigned (regcache,
913
                                    gdbarch_pc_regnum (gdbarch), pc);
914
  else
915
    internal_error (__FILE__, __LINE__,
916
                    _("regcache_write_pc: Unable to update PC"));
917
 
918
  /* Writing the PC (for instance, from "load") invalidates the
919
     current frame.  */
920
  reinit_frame_cache ();
921
}
922
 
923
 
924
static void
925
reg_flush_command (char *command, int from_tty)
926
{
927
  /* Force-flush the register cache.  */
928
  registers_changed ();
929
  if (from_tty)
930
    printf_filtered (_("Register cache flushed.\n"));
931
}
932
 
933
static void
934
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
935
                   const unsigned char *buf, long len)
936
{
937
  int i;
938
  switch (endian)
939
    {
940
    case BFD_ENDIAN_BIG:
941
      for (i = 0; i < len; i++)
942
        fprintf_unfiltered (file, "%02x", buf[i]);
943
      break;
944
    case BFD_ENDIAN_LITTLE:
945
      for (i = len - 1; i >= 0; i--)
946
        fprintf_unfiltered (file, "%02x", buf[i]);
947
      break;
948
    default:
949
      internal_error (__FILE__, __LINE__, _("Bad switch"));
950
    }
951
}
952
 
953
enum regcache_dump_what
954
{
955
  regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
956
};
957
 
958
static void
959
regcache_dump (struct regcache *regcache, struct ui_file *file,
960
               enum regcache_dump_what what_to_dump)
961
{
962
  struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
963
  struct gdbarch *gdbarch = regcache->descr->gdbarch;
964
  int regnum;
965
  int footnote_nr = 0;
966
  int footnote_register_size = 0;
967
  int footnote_register_offset = 0;
968
  int footnote_register_type_name_null = 0;
969
  long register_offset = 0;
970
  unsigned char buf[MAX_REGISTER_SIZE];
971
 
972
#if 0
973
  fprintf_unfiltered (file, "nr_raw_registers %d\n",
974
                      regcache->descr->nr_raw_registers);
975
  fprintf_unfiltered (file, "nr_cooked_registers %d\n",
976
                      regcache->descr->nr_cooked_registers);
977
  fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
978
                      regcache->descr->sizeof_raw_registers);
979
  fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
980
                      regcache->descr->sizeof_raw_register_valid_p);
981
  fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
982
                      gdbarch_num_regs (gdbarch));
983
  fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
984
                      gdbarch_num_pseudo_regs (gdbarch));
985
#endif
986
 
987
  gdb_assert (regcache->descr->nr_cooked_registers
988
              == (gdbarch_num_regs (gdbarch)
989
                  + gdbarch_num_pseudo_regs (gdbarch)));
990
 
991
  for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
992
    {
993
      /* Name.  */
994
      if (regnum < 0)
995
        fprintf_unfiltered (file, " %-10s", "Name");
996
      else
997
        {
998
          const char *p = gdbarch_register_name (gdbarch, regnum);
999
          if (p == NULL)
1000
            p = "";
1001
          else if (p[0] == '\0')
1002
            p = "''";
1003
          fprintf_unfiltered (file, " %-10s", p);
1004
        }
1005
 
1006
      /* Number.  */
1007
      if (regnum < 0)
1008
        fprintf_unfiltered (file, " %4s", "Nr");
1009
      else
1010
        fprintf_unfiltered (file, " %4d", regnum);
1011
 
1012
      /* Relative number.  */
1013
      if (regnum < 0)
1014
        fprintf_unfiltered (file, " %4s", "Rel");
1015
      else if (regnum < gdbarch_num_regs (gdbarch))
1016
        fprintf_unfiltered (file, " %4d", regnum);
1017
      else
1018
        fprintf_unfiltered (file, " %4d",
1019
                            (regnum - gdbarch_num_regs (gdbarch)));
1020
 
1021
      /* Offset.  */
1022
      if (regnum < 0)
1023
        fprintf_unfiltered (file, " %6s  ", "Offset");
1024
      else
1025
        {
1026
          fprintf_unfiltered (file, " %6ld",
1027
                              regcache->descr->register_offset[regnum]);
1028
          if (register_offset != regcache->descr->register_offset[regnum]
1029
              || (regnum > 0
1030
                  && (regcache->descr->register_offset[regnum]
1031
                      != (regcache->descr->register_offset[regnum - 1]
1032
                          + regcache->descr->sizeof_register[regnum - 1])))
1033
              )
1034
            {
1035
              if (!footnote_register_offset)
1036
                footnote_register_offset = ++footnote_nr;
1037
              fprintf_unfiltered (file, "*%d", footnote_register_offset);
1038
            }
1039
          else
1040
            fprintf_unfiltered (file, "  ");
1041
          register_offset = (regcache->descr->register_offset[regnum]
1042
                             + regcache->descr->sizeof_register[regnum]);
1043
        }
1044
 
1045
      /* Size.  */
1046
      if (regnum < 0)
1047
        fprintf_unfiltered (file, " %5s ", "Size");
1048
      else
1049
        fprintf_unfiltered (file, " %5ld",
1050
                            regcache->descr->sizeof_register[regnum]);
1051
 
1052
      /* Type.  */
1053
      {
1054
        const char *t;
1055
        if (regnum < 0)
1056
          t = "Type";
1057
        else
1058
          {
1059
            static const char blt[] = "builtin_type";
1060
            t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1061
            if (t == NULL)
1062
              {
1063
                char *n;
1064
                if (!footnote_register_type_name_null)
1065
                  footnote_register_type_name_null = ++footnote_nr;
1066
                n = xstrprintf ("*%d", footnote_register_type_name_null);
1067
                make_cleanup (xfree, n);
1068
                t = n;
1069
              }
1070
            /* Chop a leading builtin_type.  */
1071
            if (strncmp (t, blt, strlen (blt)) == 0)
1072
              t += strlen (blt);
1073
          }
1074
        fprintf_unfiltered (file, " %-15s", t);
1075
      }
1076
 
1077
      /* Leading space always present.  */
1078
      fprintf_unfiltered (file, " ");
1079
 
1080
      /* Value, raw.  */
1081
      if (what_to_dump == regcache_dump_raw)
1082
        {
1083
          if (regnum < 0)
1084
            fprintf_unfiltered (file, "Raw value");
1085
          else if (regnum >= regcache->descr->nr_raw_registers)
1086
            fprintf_unfiltered (file, "<cooked>");
1087
          else if (!regcache_valid_p (regcache, regnum))
1088
            fprintf_unfiltered (file, "<invalid>");
1089
          else
1090
            {
1091
              regcache_raw_read (regcache, regnum, buf);
1092
              fprintf_unfiltered (file, "0x");
1093
              dump_endian_bytes (file,
1094
                                 gdbarch_byte_order (gdbarch), buf,
1095
                                 regcache->descr->sizeof_register[regnum]);
1096
            }
1097
        }
1098
 
1099
      /* Value, cooked.  */
1100
      if (what_to_dump == regcache_dump_cooked)
1101
        {
1102
          if (regnum < 0)
1103
            fprintf_unfiltered (file, "Cooked value");
1104
          else
1105
            {
1106
              regcache_cooked_read (regcache, regnum, buf);
1107
              fprintf_unfiltered (file, "0x");
1108
              dump_endian_bytes (file,
1109
                                 gdbarch_byte_order (gdbarch), buf,
1110
                                 regcache->descr->sizeof_register[regnum]);
1111
            }
1112
        }
1113
 
1114
      /* Group members.  */
1115
      if (what_to_dump == regcache_dump_groups)
1116
        {
1117
          if (regnum < 0)
1118
            fprintf_unfiltered (file, "Groups");
1119
          else
1120
            {
1121
              const char *sep = "";
1122
              struct reggroup *group;
1123
              for (group = reggroup_next (gdbarch, NULL);
1124
                   group != NULL;
1125
                   group = reggroup_next (gdbarch, group))
1126
                {
1127
                  if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1128
                    {
1129
                      fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1130
                      sep = ",";
1131
                    }
1132
                }
1133
            }
1134
        }
1135
 
1136
      fprintf_unfiltered (file, "\n");
1137
    }
1138
 
1139
  if (footnote_register_size)
1140
    fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1141
                        footnote_register_size);
1142
  if (footnote_register_offset)
1143
    fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1144
                        footnote_register_offset);
1145
  if (footnote_register_type_name_null)
1146
    fprintf_unfiltered (file,
1147
                        "*%d: Register type's name NULL.\n",
1148
                        footnote_register_type_name_null);
1149
  do_cleanups (cleanups);
1150
}
1151
 
1152
static void
1153
regcache_print (char *args, enum regcache_dump_what what_to_dump)
1154
{
1155
  if (args == NULL)
1156
    regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1157
  else
1158
    {
1159
      struct cleanup *cleanups;
1160
      struct ui_file *file = gdb_fopen (args, "w");
1161
      if (file == NULL)
1162
        perror_with_name (_("maintenance print architecture"));
1163
      cleanups = make_cleanup_ui_file_delete (file);
1164
      regcache_dump (get_current_regcache (), file, what_to_dump);
1165
      do_cleanups (cleanups);
1166
    }
1167
}
1168
 
1169
static void
1170
maintenance_print_registers (char *args, int from_tty)
1171
{
1172
  regcache_print (args, regcache_dump_none);
1173
}
1174
 
1175
static void
1176
maintenance_print_raw_registers (char *args, int from_tty)
1177
{
1178
  regcache_print (args, regcache_dump_raw);
1179
}
1180
 
1181
static void
1182
maintenance_print_cooked_registers (char *args, int from_tty)
1183
{
1184
  regcache_print (args, regcache_dump_cooked);
1185
}
1186
 
1187
static void
1188
maintenance_print_register_groups (char *args, int from_tty)
1189
{
1190
  regcache_print (args, regcache_dump_groups);
1191
}
1192
 
1193
extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1194
 
1195
void
1196
_initialize_regcache (void)
1197
{
1198
  regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1199
 
1200
  observer_attach_target_changed (regcache_observer_target_changed);
1201
  observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1202
 
1203
  add_com ("flushregs", class_maintenance, reg_flush_command,
1204
           _("Force gdb to flush its register cache (maintainer command)"));
1205
 
1206
  add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1207
Print the internal register configuration.\n\
1208
Takes an optional file parameter."), &maintenanceprintlist);
1209
  add_cmd ("raw-registers", class_maintenance,
1210
           maintenance_print_raw_registers, _("\
1211
Print the internal register configuration including raw values.\n\
1212
Takes an optional file parameter."), &maintenanceprintlist);
1213
  add_cmd ("cooked-registers", class_maintenance,
1214
           maintenance_print_cooked_registers, _("\
1215
Print the internal register configuration including cooked values.\n\
1216
Takes an optional file parameter."), &maintenanceprintlist);
1217
  add_cmd ("register-groups", class_maintenance,
1218
           maintenance_print_register_groups, _("\
1219
Print the internal register configuration including each register's group.\n\
1220
Takes an optional file parameter."),
1221
           &maintenanceprintlist);
1222
 
1223
}

powered by: WebSVN 2.1.0

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