gdb/frame.c

   1 /* Cache and manage frames 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 #include "gdb_assert.h"
  30
  31 /* Return a frame uniq ID that can be used to, later re-find the
  32    frame.  */
  33
  34 void
  35 get_frame_id (struct frame_info *fi, struct frame_id *id)
  36 {
  37   if (fi == NULL)
  38     {
  39       id->base = 0;
  40       id->pc = 0;
  41     }
  42   else
  43     {
  44       id->base = FRAME_FP (fi);
  45       id->pc = fi->pc;
  46     }
  47 }
  48
  49 struct frame_info *
  50 frame_find_by_id (struct frame_id id)
  51 {
  52   struct frame_info *frame;
  53
  54   /* ZERO denotes the null frame, let the caller decide what to do
  55      about it.  Should it instead return get_current_frame()?  */
  56   if (id.base == 0 && id.pc == 0)
  57     return NULL;
  58
  59   for (frame = get_current_frame ();
  60        frame != NULL;
  61        frame = get_prev_frame (frame))
  62     {
  63       if (INNER_THAN (FRAME_FP (frame), id.base))
  64         /* ``inner/current < frame < id.base''.  Keep looking along
  65            the frame chain.  */
  66         continue;
  67       if (INNER_THAN (id.base, FRAME_FP (frame)))
  68         /* ``inner/current < id.base < frame''.  Oops, gone past it.
  69            Just give up.  */
  70         return NULL;
  71       /* FIXME: cagney/2002-04-21: This isn't sufficient.  It should
  72          use id.pc to check that the two frames belong to the same
  73          function.  Otherwise we'll do things like match dummy frames
  74          or mis-match frameless functions.  However, until someone
  75          notices, stick with the existing behavour.  */
  76       return frame;
  77     }
  78   return NULL;
  79 }
  80
  81 /* FIND_SAVED_REGISTER ()
  82
  83    Return the address in which frame FRAME's value of register REGNUM
  84    has been saved in memory.  Or return zero if it has not been saved.
  85    If REGNUM specifies the SP, the value we return is actually
  86    the SP value, not an address where it was saved.  */
  87
  88 CORE_ADDR
  89 find_saved_register (struct frame_info *frame, int regnum)
  90 {
  91   register struct frame_info *frame1 = NULL;
  92   register CORE_ADDR addr = 0;
  93
  94   if (frame == NULL)            /* No regs saved if want current frame */
  95     return 0;
  96
  97   /* Note that this next routine assumes that registers used in
  98      frame x will be saved only in the frame that x calls and
  99      frames interior to it.  This is not true on the sparc, but the
 100      above macro takes care of it, so we should be all right. */
 101   while (1)
 102     {
 103       QUIT;
 104       frame1 = get_next_frame (frame);
 105       if (frame1 == 0)
 106         break;
 107       frame = frame1;
 108       FRAME_INIT_SAVED_REGS (frame1);
 109       if (frame1->saved_regs[regnum])
 110         addr = frame1->saved_regs[regnum];
 111     }
 112
 113   return addr;
 114 }
 115
 116 void
 117 frame_register_unwind (struct frame_info *frame, int regnum,
 118                        int *optimizedp, enum lval_type *lvalp,
 119                        CORE_ADDR *addrp, int *realnump, void *bufferp)
 120 {
 121   struct frame_unwind_cache *cache;
 122
 123   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
 124      that the value proper does not need to be fetched.  */
 125   gdb_assert (optimizedp != NULL);
 126   gdb_assert (lvalp != NULL);
 127   gdb_assert (addrp != NULL);
 128   gdb_assert (realnump != NULL);
 129   /* gdb_assert (bufferp != NULL); */
 130
 131   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
 132      special case, there was always an inner frame dedicated to the
 133      hardware registers.  Unfortunatly, there is too much unwind code
 134      around that looks up/down the frame chain while making the
 135      assumption that each frame level is using the same unwind code.  */
 136
 137   if (frame == NULL)
 138     {
 139       /* We're in the inner-most frame, get the value direct from the
 140          register cache.  */
 141       *optimizedp = 0;
 142       *lvalp = lval_register;
 143       *addrp = 0;
 144       /* Should this code test ``register_cached (regnum) < 0'' and do
 145          something like set realnum to -1 when the register isn't
 146          available?  */
 147       *realnump = regnum;
 148       if (bufferp)
 149         read_register_gen (regnum, bufferp);
 150       return;
 151     }
 152
 153   /* Ask this frame to unwind its register.  */
 154   frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
 155                           optimizedp, lvalp, addrp, realnump, bufferp);
 156 }
 157
 158
 159 void
 160 generic_unwind_get_saved_register (char *raw_buffer,
 161                                    int *optimizedp,
 162                                    CORE_ADDR *addrp,
 163                                    struct frame_info *frame,
 164                                    int regnum,
 165                                    enum lval_type *lvalp)
 166 {
 167   int optimizedx;
 168   CORE_ADDR addrx;
 169   int realnumx;
 170   enum lval_type lvalx;
 171
 172   if (!target_has_registers)
 173     error ("No registers.");
 174
 175   /* Keep things simple, ensure that all the pointers (except valuep)
 176      are non NULL.  */
 177   if (optimizedp == NULL)
 178     optimizedp = &optimizedx;
 179   if (lvalp == NULL)
 180     lvalp = &lvalx;
 181   if (addrp == NULL)
 182     addrp = &addrx;
 183
 184   /* Reached the the bottom (youngest, inner most) of the frame chain
 185      (youngest, inner most) frame, go direct to the hardware register
 186      cache (do not pass go, do not try to cache the value, ...).  The
 187      unwound value would have been cached in frame->next but that
 188      doesn't exist.  This doesn't matter as the hardware register
 189      cache is stopping any unnecessary accesses to the target.  */
 190
 191   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
 192      special case, there was always an inner frame dedicated to the
 193      hardware registers.  Unfortunatly, there is too much unwind code
 194      around that looks up/down the frame chain while making the
 195      assumption that each frame level is using the same unwind code.  */
 196
 197   if (frame == NULL)
 198     frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
 199                            raw_buffer);
 200   else
 201     frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 202                            &realnumx, raw_buffer);
 203 }
 204
 205 void
 206 get_saved_register (char *raw_buffer,
 207                     int *optimized,
 208                     CORE_ADDR *addrp,
 209                     struct frame_info *frame,
 210                     int regnum,
 211                     enum lval_type *lval)
 212 {
 213   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 214 }
 215
 216 /* frame_register_read ()
 217
 218    Find and return the value of REGNUM for the specified stack frame.
 219    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 220
 221    Returns 0 if the register value could not be found.  */
 222
 223 int
 224 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 225 {
 226   int optim;
 227   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 228                       regnum, (enum lval_type *) NULL);
 229
 230   /* FIXME: cagney/2002-05-15: This test, is just bogus.
 231
 232      It indicates that the target failed to supply a value for a
 233      register because it was "not available" at this time.  Problem
 234      is, the target still has the register and so get saved_register()
 235      may be returning a value saved on the stack.  */
 236
 237   if (register_cached (regnum) < 0)
 238     return 0;                   /* register value not available */
 239
 240   return !optim;
 241 }