gdb/frame.c

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
   4    2001, 2002 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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "target.h"
  26 #include "value.h"
  27 #include "inferior.h"   /* for inferior_ptid */
  28 #include "regcache.h"
  29
  30 /* FIND_SAVED_REGISTER ()
  31
  32    Return the address in which frame FRAME's value of register REGNUM
  33    has been saved in memory.  Or return zero if it has not been saved.
  34    If REGNUM specifies the SP, the value we return is actually
  35    the SP value, not an address where it was saved.  */
  36
  37 CORE_ADDR
  38 find_saved_register (struct frame_info *frame, int regnum)
  39 {
  40   register struct frame_info *frame1 = NULL;
  41   register CORE_ADDR addr = 0;
  42
  43   if (frame == NULL)            /* No regs saved if want current frame */
  44     return 0;
  45
  46   /* Note that this next routine assumes that registers used in
  47      frame x will be saved only in the frame that x calls and
  48      frames interior to it.  This is not true on the sparc, but the
  49      above macro takes care of it, so we should be all right. */
  50   while (1)
  51     {
  52       QUIT;
  53       frame1 = get_next_frame (frame);
  54       if (frame1 == 0)
  55         break;
  56       frame = frame1;
  57       FRAME_INIT_SAVED_REGS (frame1);
  58       if (frame1->saved_regs[regnum])
  59         addr = frame1->saved_regs[regnum];
  60     }
  61
  62   return addr;
  63 }
  64
  65 /* DEFAULT_GET_SAVED_REGISTER ()
  66
  67    Find register number REGNUM relative to FRAME and put its (raw,
  68    target format) contents in *RAW_BUFFER.  Set *OPTIMIZED if the
  69    variable was optimized out (and thus can't be fetched).  Set *LVAL
  70    to lval_memory, lval_register, or not_lval, depending on whether
  71    the value was fetched from memory, from a register, or in a strange
  72    and non-modifiable way (e.g. a frame pointer which was calculated
  73    rather than fetched).  Set *ADDRP to the address, either in memory
  74    on as a REGISTER_BYTE offset into the registers array.
  75
  76    Note that this implementation never sets *LVAL to not_lval.  But
  77    it can be replaced by defining GET_SAVED_REGISTER and supplying
  78    your own.
  79
  80    The argument RAW_BUFFER must point to aligned memory.  */
  81
  82 static void
  83 default_get_saved_register (char *raw_buffer,
  84                             int *optimized,
  85                             CORE_ADDR *addrp,
  86                             struct frame_info *frame,
  87                             int regnum,
  88                             enum lval_type *lval)
  89 {
  90   CORE_ADDR addr;
  91
  92   if (!target_has_registers)
  93     error ("No registers.");
  94
  95   /* Normal systems don't optimize out things with register numbers.  */
  96   if (optimized != NULL)
  97     *optimized = 0;
  98   addr = find_saved_register (frame, regnum);
  99   if (addr != 0)
 100     {
 101       if (lval != NULL)
 102         *lval = lval_memory;
 103       if (regnum == SP_REGNUM)
 104         {
 105           if (raw_buffer != NULL)
 106             {
 107               /* Put it back in target format.  */
 108               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
 109                              (LONGEST) addr);
 110             }
 111           if (addrp != NULL)
 112             *addrp = 0;
 113           return;
 114         }
 115       if (raw_buffer != NULL)
 116         target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 117     }
 118   else
 119     {
 120       if (lval != NULL)
 121         *lval = lval_register;
 122       addr = REGISTER_BYTE (regnum);
 123       if (raw_buffer != NULL)
 124         read_register_gen (regnum, raw_buffer);
 125     }
 126   if (addrp != NULL)
 127     *addrp = addr;
 128 }
 129
 130 #if !defined (GET_SAVED_REGISTER)
 131 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
 132   default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
 133 #endif
 134
 135 void
 136 get_saved_register (char *raw_buffer,
 137                     int *optimized,
 138                     CORE_ADDR *addrp,
 139                     struct frame_info *frame,
 140                     int regnum,
 141                     enum lval_type *lval)
 142 {
 143   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 144 }
 145
 146 /* frame_register_read ()
 147
 148    Find and return the value of REGNUM for the specified stack frame.
 149    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 150
 151    Returns 0 if the register value could not be found.  */
 152
 153 int
 154 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 155 {
 156   int optim;
 157   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 158                       regnum, (enum lval_type *) NULL);
 159
 160   /* FIXME: cagney/2002-04-10: This test is just bogus.  It is no
 161      indication of the validity of the register.  The value could
 162      easily be found (on the stack) even though the corresponding
 163      register isn't available.  */
 164   if (register_cached (regnum) < 0)
 165     return 0;                   /* register value not available */
 166
 167   return !optim;
 168 }