← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to gdb/regcache.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdb/regcache.c
1
1
/* Cache and manage the values of registers for GDB, the GNU debugger.
2
2
 
3
 
   Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4
 
   2001, 2002, 2004 Free Software Foundation, Inc.
 
3
   Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
 
4
   2002, 2004, 2007 Free Software Foundation, Inc.
5
5
 
6
6
   This file is part of GDB.
7
7
 
8
8
   This program is free software; you can redistribute it and/or modify
9
9
   it under the terms of the GNU General Public License as published by
10
 
   the Free Software Foundation; either version 2 of the License, or
 
10
   the Free Software Foundation; either version 3 of the License, or
11
11
   (at your option) any later version.
12
12
 
13
13
   This program is distributed in the hope that it will be useful,
16
16
   GNU General Public License for more details.
17
17
 
18
18
   You should have received a copy of the GNU General Public License
19
 
   along with this program; if not, write to the Free Software
20
 
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
21
 
   Boston, MA 02110-1301, USA.  */
 
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
20
 
23
21
#include "defs.h"
24
22
#include "inferior.h"
94
92
  /* Total size of the register space.  The raw registers are mapped
95
93
     directly onto the raw register cache while the pseudo's are
96
94
     either mapped onto raw-registers or memory.  */
97
 
  descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
98
 
  descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
 
95
  descr->nr_cooked_registers = gdbarch_num_regs (current_gdbarch)
 
96
                               + gdbarch_num_pseudo_regs (current_gdbarch);
 
97
  descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
 
98
                                          + gdbarch_num_pseudo_regs 
 
99
                                              (current_gdbarch);
99
100
 
100
101
  /* Fill in a table of register types.  */
101
102
  descr->register_type
105
106
 
106
107
  /* Construct a strictly RAW register cache.  Don't allow pseudo's
107
108
     into the register cache.  */
108
 
  descr->nr_raw_registers = NUM_REGS;
 
109
  descr->nr_raw_registers = gdbarch_num_regs (current_gdbarch);
109
110
 
110
111
  /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
111
112
     array.  This pretects GDB from erant code that accesses elements
112
 
     of the global register_valid_p[] array in the range [NUM_REGS
113
 
     .. NUM_REGS + NUM_PSEUDO_REGS).  */
 
113
     of the global register_valid_p[] array in the range 
 
114
     [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs).  */
114
115
  descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
115
116
 
116
117
  /* Lay out the register cache.
172
173
{
173
174
  struct regcache_descr *descr = regcache_descr (gdbarch);
174
175
  int size;
175
 
  gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
 
176
  gdb_assert (regnum >= 0
 
177
              && regnum < (gdbarch_num_regs (current_gdbarch)
 
178
                           + gdbarch_num_pseudo_regs (current_gdbarch)));
176
179
  size = descr->sizeof_register[regnum];
177
180
  return size;
178
181
}
183
186
{
184
187
  struct regcache_descr *descr;
185
188
  /* The register buffers.  A read-only register cache can hold the
186
 
     full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
187
 
     register cache can only hold [0 .. NUM_REGS).  */
 
189
     full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
 
190
     register cache can only hold [0 .. gdbarch_num_regs).  */
188
191
  gdb_byte *registers;
189
192
  /* Register cache status:
190
193
     register_valid_p[REG] == 0 if REG value is not in the cache
198
201
     regcache_cpy().  The actual contents are determined by the
199
202
     reggroup_save and reggroup_restore methods.  */
200
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;
201
207
};
202
208
 
203
209
struct regcache *
214
220
  regcache->register_valid_p
215
221
    = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
216
222
  regcache->readonly_p = 1;
 
223
  regcache->ptid = minus_one_ptid;
217
224
  return regcache;
218
225
}
219
226
 
270
277
  memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
271
278
  memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
272
279
  /* Copy over any registers (identified by their membership in the
273
 
     save_reggroup) and mark them as valid.  The full [0 .. NUM_REGS +
274
 
     NUM_PSEUDO_REGS) range is checked since some architectures need
 
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
275
282
     to save/restore `cooked' registers that live in memory.  */
276
283
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
277
284
    {
300
307
     doesn't make much sense.  */
301
308
  gdb_assert (!dst->readonly_p);
302
309
  /* Copy over any registers, being careful to only restore those that
303
 
     were both saved and need to be restored.  The full [0 .. NUM_REGS
304
 
     + NUM_PSEUDO_REGS) range is checked since some architectures need
 
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
305
312
     to save/restore `cooked' registers that live in memory.  */
306
313
  for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
307
314
    {
352
359
  gdb_assert (src != NULL && dst != NULL);
353
360
  gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
354
361
  /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
355
 
     move of data into the current_regcache().  Doing this would be
 
362
     move of data into the current regcache.  Doing this would be
356
363
     silly - it would mean that valid_p would be completely invalid.  */
357
 
  gdb_assert (dst != current_regcache);
 
364
  gdb_assert (dst->readonly_p);
358
365
  memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
359
366
  memcpy (dst->register_valid_p, src->register_valid_p,
360
367
          dst->descr->sizeof_raw_register_valid_p);
364
371
regcache_dup (struct regcache *src)
365
372
{
366
373
  struct regcache *newbuf;
367
 
  gdb_assert (current_regcache != NULL);
368
374
  newbuf = regcache_xmalloc (src->descr->gdbarch);
369
375
  regcache_cpy (newbuf, src);
370
376
  return newbuf;
374
380
regcache_dup_no_passthrough (struct regcache *src)
375
381
{
376
382
  struct regcache *newbuf;
377
 
  gdb_assert (current_regcache != NULL);
378
383
  newbuf = regcache_xmalloc (src->descr->gdbarch);
379
384
  regcache_cpy_no_passthrough (newbuf, src);
380
385
  return newbuf;
381
386
}
382
387
 
383
388
int
384
 
regcache_valid_p (struct regcache *regcache, int regnum)
 
389
regcache_valid_p (const struct regcache *regcache, int regnum)
385
390
{
386
391
  gdb_assert (regcache != NULL);
387
 
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
 
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
 
388
398
  return regcache->register_valid_p[regnum];
389
399
}
390
400
 
391
 
gdb_byte *
392
 
deprecated_grub_regcache_for_registers (struct regcache *regcache)
 
401
void
 
402
regcache_invalidate (struct regcache *regcache, int regnum)
393
403
{
394
 
  return regcache->registers;
 
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;
395
409
}
396
410
 
 
411
 
397
412
/* Global structure containing the current regcache.  */
398
413
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
399
414
   deprecated_register_valid[] currently point into this structure.  */
400
 
struct regcache *current_regcache;
 
415
static struct regcache *current_regcache;
401
416
 
402
417
/* NOTE: this is a write-through cache.  There is no "dirty" bit for
403
418
   recording if the register values have been changed (eg. by the
404
419
   user).  Therefore all registers must be written back to the
405
420
   target when appropriate.  */
406
421
 
407
 
/* The thread/process associated with the current set of registers. */
408
 
 
409
 
static ptid_t registers_ptid;
410
 
 
411
 
/*
412
 
 * FUNCTIONS:
413
 
 */
414
 
 
415
 
/* REGISTER_CACHED()
416
 
 
417
 
   Returns 0 if the value is not in the cache (needs fetch).
418
 
          >0 if the value is in the cache.
419
 
          <0 if the value is permanently unavailable (don't ask again).  */
420
 
 
421
 
int
422
 
register_cached (int regnum)
423
 
{
424
 
  return current_regcache->register_valid_p[regnum];
425
 
}
426
 
 
427
 
/* Record that REGNUM's value is cached if STATE is >0, uncached but
428
 
   fetchable if STATE is 0, and uncached and unfetchable if STATE is <0.  */
429
 
 
430
 
void
431
 
set_register_cached (int regnum, int state)
432
 
{
433
 
  gdb_assert (regnum >= 0);
434
 
  gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
435
 
  current_regcache->register_valid_p[regnum] = state;
436
 
}
 
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
 
437
447
 
438
448
/* Observer for the target_changed event.  */
439
449
 
459
469
{
460
470
  int i;
461
471
 
462
 
  registers_ptid = pid_to_ptid (-1);
 
472
  regcache_xfree (current_regcache);
 
473
  current_regcache = NULL;
463
474
 
464
475
  /* Force cleanup of any alloca areas if using C alloca instead of
465
476
     a builtin alloca.  This particular call is used to clean up
467
478
     during lengthy interactions between gdb and the target before
468
479
     gdb gives control to the user (ie watchpoints).  */
469
480
  alloca (0);
470
 
 
471
 
  for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
472
 
    set_register_cached (i, 0);
473
 
 
474
 
  if (deprecated_registers_changed_hook)
475
 
    deprecated_registers_changed_hook ();
476
 
}
477
 
 
478
 
/* DEPRECATED_REGISTERS_FETCHED ()
479
 
 
480
 
   Indicate that all registers have been fetched, so mark them all valid.  */
481
 
 
482
 
/* FIXME: cagney/2001-12-04: This function is DEPRECATED.  The target
483
 
   code was blatting the registers[] array and then calling this.
484
 
   Since targets should only be using regcache_raw_supply() the need for
485
 
   this function/hack is eliminated.  */
486
 
 
487
 
void
488
 
deprecated_registers_fetched (void)
489
 
{
490
 
  int i;
491
 
 
492
 
  for (i = 0; i < NUM_REGS; i++)
493
 
    set_register_cached (i, 1);
494
 
  /* Do not assume that the pseudo-regs have also been fetched.
495
 
     Fetching all real regs NEVER accounts for pseudo-regs.  */
496
 
}
497
 
 
498
 
/* deprecated_read_register_bytes and deprecated_write_register_bytes
499
 
   are generally a *BAD* idea.  They are inefficient because they need
500
 
   to check for partial updates, which can only be done by scanning
501
 
   through all of the registers and seeing if the bytes that are being
502
 
   read/written fall inside of an invalid register.  [The main reason
503
 
   this is necessary is that register sizes can vary, so a simple
504
 
   index won't suffice.]  It is far better to call read_register_gen
505
 
   and write_register_gen if you want to get at the raw register
506
 
   contents, as it only takes a regnum as an argument, and therefore
507
 
   can't do a partial register update.
508
 
 
509
 
   Prior to the recent fixes to check for partial updates, both read
510
 
   and deprecated_write_register_bytes always checked to see if any
511
 
   registers were stale, and then called target_fetch_registers (-1)
512
 
   to update the whole set.  This caused really slowed things down for
513
 
   remote targets.  */
514
 
 
515
 
/* Copy INLEN bytes of consecutive data from registers
516
 
   starting with the INREGBYTE'th byte of register data
517
 
   into memory at MYADDR.  */
518
 
 
519
 
void
520
 
deprecated_read_register_bytes (int in_start, gdb_byte *in_buf, int in_len)
521
 
{
522
 
  int in_end = in_start + in_len;
523
 
  int regnum;
524
 
  gdb_byte reg_buf[MAX_REGISTER_SIZE];
525
 
 
526
 
  /* See if we are trying to read bytes from out-of-date registers.  If so,
527
 
     update just those registers.  */
528
 
 
529
 
  for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
530
 
    {
531
 
      int reg_start;
532
 
      int reg_end;
533
 
      int reg_len;
534
 
      int start;
535
 
      int end;
536
 
      int byte;
537
 
 
538
 
      reg_start = DEPRECATED_REGISTER_BYTE (regnum);
539
 
      reg_len = register_size (current_gdbarch, regnum);
540
 
      reg_end = reg_start + reg_len;
541
 
 
542
 
      if (reg_end <= in_start || in_end <= reg_start)
543
 
        /* The range the user wants to read doesn't overlap with regnum.  */
544
 
        continue;
545
 
 
546
 
      if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
547
 
        /* Force the cache to fetch the entire register.  */
548
 
        deprecated_read_register_gen (regnum, reg_buf);
549
 
 
550
 
      /* Legacy note: This function, for some reason, allows a NULL
551
 
         input buffer.  If the buffer is NULL, the registers are still
552
 
         fetched, just the final transfer is skipped. */
553
 
      if (in_buf == NULL)
554
 
        continue;
555
 
 
556
 
      /* start = max (reg_start, in_start) */
557
 
      if (reg_start > in_start)
558
 
        start = reg_start;
559
 
      else
560
 
        start = in_start;
561
 
 
562
 
      /* end = min (reg_end, in_end) */
563
 
      if (reg_end < in_end)
564
 
        end = reg_end;
565
 
      else
566
 
        end = in_end;
567
 
 
568
 
      /* Transfer just the bytes common to both IN_BUF and REG_BUF */
569
 
      for (byte = start; byte < end; byte++)
570
 
        {
571
 
          in_buf[byte - in_start] = reg_buf[byte - reg_start];
572
 
        }
573
 
    }
574
 
}
 
481
}
 
482
 
575
483
 
576
484
void
577
485
regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
584
492
     On the bright side, at least there is a regcache object.  */
585
493
  if (!regcache->readonly_p)
586
494
    {
587
 
      gdb_assert (regcache == current_regcache);
588
 
      if (! ptid_equal (registers_ptid, inferior_ptid))
 
495
      if (!regcache_valid_p (regcache, regnum))
589
496
        {
590
 
          registers_changed ();
591
 
          registers_ptid = inferior_ptid;
 
497
          struct cleanup *old_chain = save_inferior_ptid ();
 
498
          inferior_ptid = regcache->ptid;
 
499
          target_fetch_registers (regcache, regnum);
 
500
          do_cleanups (old_chain);
592
501
        }
593
 
      if (!register_cached (regnum))
594
 
        target_fetch_registers (regnum);
595
502
#if 0
596
503
      /* FIXME: cagney/2004-08-07: At present a number of targets
597
504
         forget (or didn't know that they needed) to set this leading to
599
506
         that a register is in one of the possible states: valid,
600
507
         undefined, unknown.  The last of which isn't yet
601
508
         possible.  */
602
 
      gdb_assert (register_cached (regnum));
 
509
      gdb_assert (regcache_valid_p (regcache, regnum));
603
510
#endif
604
511
    }
605
512
  /* Copy the value directly into the register cache.  */
656
563
}
657
564
 
658
565
void
659
 
deprecated_read_register_gen (int regnum, gdb_byte *buf)
660
 
{
661
 
  gdb_assert (current_regcache != NULL);
662
 
  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
663
 
  regcache_cooked_read (current_regcache, regnum, buf);
664
 
}
665
 
 
666
 
void
667
566
regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
668
567
{
669
568
  gdb_assert (regnum >= 0);
735
634
regcache_raw_write (struct regcache *regcache, int regnum,
736
635
                    const gdb_byte *buf)
737
636
{
 
637
  struct cleanup *old_chain;
 
638
 
738
639
  gdb_assert (regcache != NULL && buf != NULL);
739
640
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
740
641
  gdb_assert (!regcache->readonly_p);
741
642
 
742
643
  /* On the sparc, writing %g0 is a no-op, so we don't even want to
743
644
     change the registers array if something writes to this register.  */
744
 
  if (CANNOT_STORE_REGISTER (regnum))
 
645
  if (gdbarch_cannot_store_register (current_gdbarch, regnum))
745
646
    return;
746
647
 
747
 
  /* Make certain that the correct cache is selected.  */
748
 
  gdb_assert (regcache == current_regcache);
749
 
  if (! ptid_equal (registers_ptid, inferior_ptid))
750
 
    {
751
 
      registers_changed ();
752
 
      registers_ptid = inferior_ptid;
753
 
    }
754
 
 
755
648
  /* If we have a valid copy of the register, and new value == old
756
649
     value, then don't bother doing the actual store. */
757
650
  if (regcache_valid_p (regcache, regnum)
759
652
                  regcache->descr->sizeof_register[regnum]) == 0))
760
653
    return;
761
654
 
762
 
  target_prepare_to_store ();
 
655
  old_chain = save_inferior_ptid ();
 
656
  inferior_ptid = regcache->ptid;
 
657
 
 
658
  target_prepare_to_store (regcache);
763
659
  memcpy (register_buffer (regcache, regnum), buf,
764
660
          regcache->descr->sizeof_register[regnum]);
765
661
  regcache->register_valid_p[regnum] = 1;
766
 
  target_store_registers (regnum);
767
 
}
 
662
  target_store_registers (regcache, regnum);
768
663
 
769
 
void
770
 
deprecated_write_register_gen (int regnum, gdb_byte *buf)
771
 
{
772
 
  gdb_assert (current_regcache != NULL);
773
 
  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
774
 
  regcache_cooked_write (current_regcache, regnum, buf);
 
664
  do_cleanups (old_chain);
775
665
}
776
666
 
777
667
void
787
677
                                   regnum, buf);
788
678
}
789
679
 
790
 
/* Copy INLEN bytes of consecutive data from memory at MYADDR
791
 
   into registers starting with the MYREGSTART'th byte of register data.  */
792
 
 
793
 
void
794
 
deprecated_write_register_bytes (int myregstart, gdb_byte *myaddr, int inlen)
795
 
{
796
 
  int myregend = myregstart + inlen;
797
 
  int regnum;
798
 
 
799
 
  target_prepare_to_store ();
800
 
 
801
 
  /* Scan through the registers updating any that are covered by the
802
 
     range myregstart<=>myregend using write_register_gen, which does
803
 
     nice things like handling threads, and avoiding updates when the
804
 
     new and old contents are the same.  */
805
 
 
806
 
  for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
807
 
    {
808
 
      int regstart, regend;
809
 
 
810
 
      regstart = DEPRECATED_REGISTER_BYTE (regnum);
811
 
      regend = regstart + register_size (current_gdbarch, regnum);
812
 
 
813
 
      /* Is this register completely outside the range the user is writing?  */
814
 
      if (myregend <= regstart || regend <= myregstart)
815
 
        /* do nothing */ ;              
816
 
 
817
 
      /* Is this register completely within the range the user is writing?  */
818
 
      else if (myregstart <= regstart && regend <= myregend)
819
 
        deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart));
820
 
 
821
 
      /* The register partially overlaps the range being written.  */
822
 
      else
823
 
        {
824
 
          gdb_byte regbuf[MAX_REGISTER_SIZE];
825
 
          /* What's the overlap between this register's bytes and
826
 
             those the caller wants to write?  */
827
 
          int overlapstart = max (regstart, myregstart);
828
 
          int overlapend   = min (regend,   myregend);
829
 
 
830
 
          /* We may be doing a partial update of an invalid register.
831
 
             Update it from the target before scribbling on it.  */
832
 
          deprecated_read_register_gen (regnum, regbuf);
833
 
 
834
 
          target_store_registers (regnum);
835
 
        }
836
 
    }
837
 
}
838
 
 
839
680
/* Perform a partial register transfer using a read, modify, write
840
681
   operation.  */
841
682
 
931
772
  return descr->register_offset[regnum];
932
773
}
933
774
 
934
 
/* Hack to keep code using register_bytes working.  */
935
 
 
936
 
int
937
 
deprecated_register_bytes (void)
938
 
{
939
 
  return current_regcache->descr->sizeof_raw_registers;
940
 
}
941
 
 
942
 
/* Return the contents of register REGNUM as an unsigned integer.  */
943
 
 
944
 
ULONGEST
945
 
read_register (int regnum)
946
 
{
947
 
  gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
948
 
  deprecated_read_register_gen (regnum, buf);
949
 
  return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
950
 
}
951
 
 
952
 
ULONGEST
953
 
read_register_pid (int regnum, ptid_t ptid)
954
 
{
955
 
  ptid_t save_ptid;
956
 
  int save_pid;
957
 
  CORE_ADDR retval;
958
 
 
959
 
  if (ptid_equal (ptid, inferior_ptid))
960
 
    return read_register (regnum);
961
 
 
962
 
  save_ptid = inferior_ptid;
963
 
 
964
 
  inferior_ptid = ptid;
965
 
 
966
 
  retval = read_register (regnum);
967
 
 
968
 
  inferior_ptid = save_ptid;
969
 
 
970
 
  return retval;
971
 
}
972
 
 
973
 
/* Store VALUE into the raw contents of register number REGNUM.  */
974
 
 
975
 
void
976
 
write_register (int regnum, LONGEST val)
977
 
{
978
 
  void *buf;
979
 
  int size;
980
 
  size = register_size (current_gdbarch, regnum);
981
 
  buf = alloca (size);
982
 
  store_signed_integer (buf, size, (LONGEST) val);
983
 
  deprecated_write_register_gen (regnum, buf);
984
 
}
985
 
 
986
 
void
987
 
write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
988
 
{
989
 
  ptid_t save_ptid;
990
 
 
991
 
  if (ptid_equal (ptid, inferior_ptid))
992
 
    {
993
 
      write_register (regnum, val);
994
 
      return;
995
 
    }
996
 
 
997
 
  save_ptid = inferior_ptid;
998
 
 
999
 
  inferior_ptid = ptid;
1000
 
 
1001
 
  write_register (regnum, val);
1002
 
 
1003
 
  inferior_ptid = save_ptid;
1004
 
}
1005
775
 
1006
776
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE.  */
1007
777
 
1015
785
  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1016
786
  gdb_assert (!regcache->readonly_p);
1017
787
 
1018
 
  /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
1019
 
     CURRENT_REGCACHE specially here.  */
1020
 
  if (regcache == current_regcache
1021
 
      && !ptid_equal (registers_ptid, inferior_ptid))
1022
 
    {
1023
 
      registers_changed ();
1024
 
      registers_ptid = inferior_ptid;
1025
 
    }
1026
 
 
1027
788
  regbuf = register_buffer (regcache, regnum);
1028
789
  size = regcache->descr->sizeof_register[regnum];
1029
790
 
1053
814
}
1054
815
 
1055
816
 
1056
 
/* read_pc, write_pc, read_sp, etc.  Special handling for registers
1057
 
   PC, SP, and FP.  */
 
817
/* read_pc, write_pc, etc.  Special handling for register PC.  */
1058
818
 
1059
819
/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
1060
820
   read_sp(), will eventually be replaced by per-frame methods.
1069
829
CORE_ADDR
1070
830
read_pc_pid (ptid_t ptid)
1071
831
{
1072
 
  ptid_t saved_inferior_ptid;
 
832
  struct regcache *regcache = get_thread_regcache (ptid);
 
833
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
834
 
1073
835
  CORE_ADDR pc_val;
1074
836
 
1075
 
  /* In case ptid != inferior_ptid. */
1076
 
  saved_inferior_ptid = inferior_ptid;
1077
 
  inferior_ptid = ptid;
1078
 
 
1079
 
  if (TARGET_READ_PC_P ())
1080
 
    pc_val = TARGET_READ_PC (ptid);
 
837
  if (gdbarch_read_pc_p (gdbarch))
 
838
    pc_val = gdbarch_read_pc (gdbarch, regcache);
1081
839
  /* Else use per-frame method on get_current_frame.  */
1082
 
  else if (PC_REGNUM >= 0)
 
840
  else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
1083
841
    {
1084
 
      CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
1085
 
      pc_val = ADDR_BITS_REMOVE (raw_val);
 
842
      ULONGEST raw_val;
 
843
      regcache_cooked_read_unsigned (regcache,
 
844
                                     gdbarch_pc_regnum (current_gdbarch),
 
845
                                     &raw_val);
 
846
      pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
1086
847
    }
1087
848
  else
1088
849
    internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
1089
850
 
1090
 
  inferior_ptid = saved_inferior_ptid;
1091
851
  return pc_val;
1092
852
}
1093
853
 
1098
858
}
1099
859
 
1100
860
void
1101
 
generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
 
861
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1102
862
{
1103
 
  if (PC_REGNUM >= 0)
1104
 
    write_register_pid (PC_REGNUM, pc, ptid);
 
863
  struct regcache *regcache = get_thread_regcache (ptid);
 
864
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
865
 
 
866
  if (gdbarch_write_pc_p (gdbarch))
 
867
    gdbarch_write_pc (gdbarch, regcache, pc);
 
868
  else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
 
869
    regcache_cooked_write_unsigned (regcache,
 
870
                                    gdbarch_pc_regnum (current_gdbarch), pc);
1105
871
  else
1106
872
    internal_error (__FILE__, __LINE__,
1107
 
                    _("generic_target_write_pc"));
1108
 
}
1109
 
 
1110
 
void
1111
 
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1112
 
{
1113
 
  ptid_t saved_inferior_ptid;
1114
 
 
1115
 
  /* In case ptid != inferior_ptid. */
1116
 
  saved_inferior_ptid = inferior_ptid;
1117
 
  inferior_ptid = ptid;
1118
 
 
1119
 
  TARGET_WRITE_PC (pc, ptid);
1120
 
 
1121
 
  inferior_ptid = saved_inferior_ptid;
 
873
                    _("write_pc_pid: Unable to update PC"));
1122
874
}
1123
875
 
1124
876
void
1127
879
  write_pc_pid (pc, inferior_ptid);
1128
880
}
1129
881
 
1130
 
/* Cope with strage ways of getting to the stack and frame pointers */
1131
 
 
1132
 
CORE_ADDR
1133
 
read_sp (void)
1134
 
{
1135
 
  if (TARGET_READ_SP_P ())
1136
 
    return TARGET_READ_SP ();
1137
 
  else if (gdbarch_unwind_sp_p (current_gdbarch))
1138
 
    return get_frame_sp (get_current_frame ());
1139
 
  else if (SP_REGNUM >= 0)
1140
 
    /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1141
 
       about the architecture so put it at the end.  */
1142
 
    return read_register (SP_REGNUM);
1143
 
  internal_error (__FILE__, __LINE__, _("read_sp: Unable to find SP"));
1144
 
}
1145
882
 
1146
883
static void
1147
884
reg_flush_command (char *command, int from_tty)
1153
890
}
1154
891
 
1155
892
static void
1156
 
build_regcache (void)
1157
 
{
1158
 
  current_regcache = regcache_xmalloc (current_gdbarch);
1159
 
  current_regcache->readonly_p = 0;
1160
 
}
1161
 
 
1162
 
static void
1163
893
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1164
894
                   const unsigned char *buf, long len)
1165
895
{
1207
937
                      regcache->descr->sizeof_raw_registers);
1208
938
  fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1209
939
                      regcache->descr->sizeof_raw_register_valid_p);
1210
 
  fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1211
 
  fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
 
940
  fprintf_unfiltered (file, "gdbarch_num_regs %d\n", 
 
941
                      gdbarch_num_regs (current_gdbarch));
 
942
  fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
 
943
                      gdbarch_num_pseudo_regs (current_gdbarch));
1212
944
#endif
1213
945
 
1214
946
  gdb_assert (regcache->descr->nr_cooked_registers
1215
 
              == (NUM_REGS + NUM_PSEUDO_REGS));
 
947
              == (gdbarch_num_regs (current_gdbarch)
 
948
                  + gdbarch_num_pseudo_regs (current_gdbarch)));
1216
949
 
1217
950
  for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1218
951
    {
1221
954
        fprintf_unfiltered (file, " %-10s", "Name");
1222
955
      else
1223
956
        {
1224
 
          const char *p = REGISTER_NAME (regnum);
 
957
          const char *p = gdbarch_register_name (current_gdbarch, regnum);
1225
958
          if (p == NULL)
1226
959
            p = "";
1227
960
          else if (p[0] == '\0')
1238
971
      /* Relative number.  */
1239
972
      if (regnum < 0)
1240
973
        fprintf_unfiltered (file, " %4s", "Rel");
1241
 
      else if (regnum < NUM_REGS)
 
974
      else if (regnum < gdbarch_num_regs (current_gdbarch))
1242
975
        fprintf_unfiltered (file, " %4d", regnum);
1243
976
      else
1244
 
        fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
 
977
        fprintf_unfiltered (file, " %4d",
 
978
                            (regnum - gdbarch_num_regs (current_gdbarch)));
1245
979
 
1246
980
      /* Offset.  */
1247
981
      if (regnum < 0)
1251
985
          fprintf_unfiltered (file, " %6ld",
1252
986
                              regcache->descr->register_offset[regnum]);
1253
987
          if (register_offset != regcache->descr->register_offset[regnum]
1254
 
              || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
1255
988
              || (regnum > 0
1256
989
                  && (regcache->descr->register_offset[regnum]
1257
990
                      != (regcache->descr->register_offset[regnum - 1]
1316
1049
            {
1317
1050
              regcache_raw_read (regcache, regnum, buf);
1318
1051
              fprintf_unfiltered (file, "0x");
1319
 
              dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
 
1052
              dump_endian_bytes (file,
 
1053
                                 gdbarch_byte_order (current_gdbarch), buf,
1320
1054
                                 regcache->descr->sizeof_register[regnum]);
1321
1055
            }
1322
1056
        }
1330
1064
            {
1331
1065
              regcache_cooked_read (regcache, regnum, buf);
1332
1066
              fprintf_unfiltered (file, "0x");
1333
 
              dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
 
1067
              dump_endian_bytes (file,
 
1068
                                 gdbarch_byte_order (current_gdbarch), buf,
1334
1069
                                 regcache->descr->sizeof_register[regnum]);
1335
1070
            }
1336
1071
        }
1377
1112
regcache_print (char *args, enum regcache_dump_what what_to_dump)
1378
1113
{
1379
1114
  if (args == NULL)
1380
 
    regcache_dump (current_regcache, gdb_stdout, what_to_dump);
 
1115
    regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1381
1116
  else
1382
1117
    {
1383
1118
      struct ui_file *file = gdb_fopen (args, "w");
1384
1119
      if (file == NULL)
1385
1120
        perror_with_name (_("maintenance print architecture"));
1386
 
      regcache_dump (current_regcache, file, what_to_dump);    
 
1121
      regcache_dump (get_current_regcache (), file, what_to_dump);
1387
1122
      ui_file_delete (file);
1388
1123
    }
1389
1124
}
1418
1153
_initialize_regcache (void)
1419
1154
{
1420
1155
  regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1421
 
  DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1422
 
  deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1423
1156
 
1424
1157
  observer_attach_target_changed (regcache_observer_target_changed);
1425
1158
 
1426
1159
  add_com ("flushregs", class_maintenance, reg_flush_command,
1427
1160
           _("Force gdb to flush its register cache (maintainer command)"));
1428
1161
 
1429
 
   /* Initialize the thread/process associated with the current set of
1430
 
      registers.  For now, -1 is special, and means `no current process'.  */
1431
 
  registers_ptid = pid_to_ptid (-1);
1432
 
 
1433
1162
  add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1434
1163
Print the internal register configuration.\n\
1435
1164
Takes an optional file parameter."), &maintenanceprintlist);