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 #ifdef HAVE_REGISTER_WINDOWS
  47   /* We assume that a register in a register window will only be saved
  48      in one place (since the name changes and/or disappears as you go
  49      towards inner frames), so we only call get_frame_saved_regs on
  50      the current frame.  This is directly in contradiction to the
  51      usage below, which assumes that registers used in a frame must be
  52      saved in a lower (more interior) frame.  This change is a result
  53      of working on a register window machine; get_frame_saved_regs
  54      always returns the registers saved within a frame, within the
  55      context (register namespace) of that frame. */
  56
  57   /* However, note that we don't want this to return anything if
  58      nothing is saved (if there's a frame inside of this one).  Also,
  59      callers to this routine asking for the stack pointer want the
  60      stack pointer saved for *this* frame; this is returned from the
  61      next frame.  */
  62
  63   if (REGISTER_IN_WINDOW_P (regnum))
  64     {
  65       frame1 = get_next_frame (frame);
  66       if (!frame1)
  67         return 0;               /* Registers of this frame are active.  */
  68
  69       /* Get the SP from the next frame in; it will be this
  70          current frame.  */
  71       if (regnum != SP_REGNUM)
  72         frame1 = frame;
  73
  74       FRAME_INIT_SAVED_REGS (frame1);
  75       return frame1->saved_regs[regnum];        /* ... which might be zero */
  76     }
  77 #endif /* HAVE_REGISTER_WINDOWS */
  78
  79   /* Note that this next routine assumes that registers used in
  80      frame x will be saved only in the frame that x calls and
  81      frames interior to it.  This is not true on the sparc, but the
  82      above macro takes care of it, so we should be all right. */
  83   while (1)
  84     {
  85       QUIT;
  86       frame1 = get_next_frame (frame);
  87       if (frame1 == 0)
  88         break;
  89       frame = frame1;
  90       FRAME_INIT_SAVED_REGS (frame1);
  91       if (frame1->saved_regs[regnum])
  92         addr = frame1->saved_regs[regnum];
  93     }
  94
  95   return addr;
  96 }
  97
  98 /* DEFAULT_GET_SAVED_REGISTER ()
  99
 100    Find register number REGNUM relative to FRAME and put its (raw,
 101    target format) contents in *RAW_BUFFER.  Set *OPTIMIZED if the
 102    variable was optimized out (and thus can't be fetched).  Set *LVAL
 103    to lval_memory, lval_register, or not_lval, depending on whether
 104    the value was fetched from memory, from a register, or in a strange
 105    and non-modifiable way (e.g. a frame pointer which was calculated
 106    rather than fetched).  Set *ADDRP to the address, either in memory
 107    on as a REGISTER_BYTE offset into the registers array.
 108
 109    Note that this implementation never sets *LVAL to not_lval.  But
 110    it can be replaced by defining GET_SAVED_REGISTER and supplying
 111    your own.
 112
 113    The argument RAW_BUFFER must point to aligned memory.  */
 114
 115 static void
 116 default_get_saved_register (char *raw_buffer,
 117                             int *optimized,
 118                             CORE_ADDR *addrp,
 119                             struct frame_info *frame,
 120                             int regnum,
 121                             enum lval_type *lval)
 122 {
 123   CORE_ADDR addr;
 124
 125   if (!target_has_registers)
 126     error ("No registers.");
 127
 128   /* Normal systems don't optimize out things with register numbers.  */
 129   if (optimized != NULL)
 130     *optimized = 0;
 131   addr = find_saved_register (frame, regnum);
 132   if (addr != 0)
 133     {
 134       if (lval != NULL)
 135         *lval = lval_memory;
 136       if (regnum == SP_REGNUM)
 137         {
 138           if (raw_buffer != NULL)
 139             {
 140               /* Put it back in target format.  */
 141               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
 142                              (LONGEST) addr);
 143             }
 144           if (addrp != NULL)
 145             *addrp = 0;
 146           return;
 147         }
 148       if (raw_buffer != NULL)
 149         target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 150     }
 151   else
 152     {
 153       if (lval != NULL)
 154         *lval = lval_register;
 155       addr = REGISTER_BYTE (regnum);
 156       if (raw_buffer != NULL)
 157         read_register_gen (regnum, raw_buffer);
 158     }
 159   if (addrp != NULL)
 160     *addrp = addr;
 161 }
 162
 163 #if !defined (GET_SAVED_REGISTER)
 164 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
 165   default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
 166 #endif
 167
 168 void
 169 get_saved_register (char *raw_buffer,
 170                     int *optimized,
 171                     CORE_ADDR *addrp,
 172                     struct frame_info *frame,
 173                     int regnum,
 174                     enum lval_type *lval)
 175 {
 176   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 177 }
 178
 179 /* frame_register_read ()
 180
 181    Find and return the value of REGNUM for the specified stack frame.
 182    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 183
 184    Returns 0 if the register value could not be found.  */
 185
 186 int
 187 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 188 {
 189   int optim;
 190   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 191                       regnum, (enum lval_type *) NULL);
 192
 193   /* FIXME: cagney/2002-04-10: This test is just bogus.  It is no
 194      indication of the validity of the register.  The value could
 195      easily be found (on the stack) even though the corresponding
 196      register isn't available.  */
 197   if (register_cached (regnum) < 0)
 198     return 0;                   /* register value not available */
 199
 200   return !optim;
 201 }