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 void
  82 frame_register_unwind (struct frame_info *frame, int regnum,
  83                        int *optimizedp, enum lval_type *lvalp,
  84                        CORE_ADDR *addrp, int *realnump, void *bufferp)
  85 {
  86   struct frame_unwind_cache *cache;
  87
  88   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
  89      that the value proper does not need to be fetched.  */
  90   gdb_assert (optimizedp != NULL);
  91   gdb_assert (lvalp != NULL);
  92   gdb_assert (addrp != NULL);
  93   gdb_assert (realnump != NULL);
  94   /* gdb_assert (bufferp != NULL); */
  95
  96   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
  97      special case, there was always an inner frame dedicated to the
  98      hardware registers.  Unfortunatly, there is too much unwind code
  99      around that looks up/down the frame chain while making the
 100      assumption that each frame level is using the same unwind code.  */
 101
 102   if (frame == NULL)
 103     {
 104       /* We're in the inner-most frame, get the value direct from the
 105          register cache.  */
 106       *optimizedp = 0;
 107       *lvalp = lval_register;
 108       /* ULGH!  Code uses the offset into the raw register byte array
 109          as a way of identifying a register.  */
 110       *addrp = REGISTER_BYTE (regnum);
 111       /* Should this code test ``register_cached (regnum) < 0'' and do
 112          something like set realnum to -1 when the register isn't
 113          available?  */
 114       *realnump = regnum;
 115       if (bufferp)
 116         read_register_gen (regnum, bufferp);
 117       return;
 118     }
 119
 120   /* Ask this frame to unwind its register.  */
 121   frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
 122                           optimizedp, lvalp, addrp, realnump, bufferp);
 123 }
 124
 125 void
 126 frame_unwind_signed_register (struct frame_info *frame, int regnum,
 127                               LONGEST *val)
 128 {
 129   int optimized;
 130   CORE_ADDR addr;
 131   int realnum;
 132   enum lval_type lval;
 133   void *buf = alloca (MAX_REGISTER_RAW_SIZE);
 134   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 135                          &realnum, buf);
 136   (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 137 }
 138
 139 void
 140 frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
 141                                 ULONGEST *val)
 142 {
 143   int optimized;
 144   CORE_ADDR addr;
 145   int realnum;
 146   enum lval_type lval;
 147   void *buf = alloca (MAX_REGISTER_RAW_SIZE);
 148   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 149                          &realnum, buf);
 150   (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 151 }
 152
 153 void
 154 generic_unwind_get_saved_register (char *raw_buffer,
 155                                    int *optimizedp,
 156                                    CORE_ADDR *addrp,
 157                                    struct frame_info *frame,
 158                                    int regnum,
 159                                    enum lval_type *lvalp)
 160 {
 161   int optimizedx;
 162   CORE_ADDR addrx;
 163   int realnumx;
 164   enum lval_type lvalx;
 165
 166   if (!target_has_registers)
 167     error ("No registers.");
 168
 169   /* Keep things simple, ensure that all the pointers (except valuep)
 170      are non NULL.  */
 171   if (optimizedp == NULL)
 172     optimizedp = &optimizedx;
 173   if (lvalp == NULL)
 174     lvalp = &lvalx;
 175   if (addrp == NULL)
 176     addrp = &addrx;
 177
 178   /* Reached the the bottom (youngest, inner most) of the frame chain
 179      (youngest, inner most) frame, go direct to the hardware register
 180      cache (do not pass go, do not try to cache the value, ...).  The
 181      unwound value would have been cached in frame->next but that
 182      doesn't exist.  This doesn't matter as the hardware register
 183      cache is stopping any unnecessary accesses to the target.  */
 184
 185   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
 186      special case, there was always an inner frame dedicated to the
 187      hardware registers.  Unfortunatly, there is too much unwind code
 188      around that looks up/down the frame chain while making the
 189      assumption that each frame level is using the same unwind code.  */
 190
 191   if (frame == NULL)
 192     frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
 193                            raw_buffer);
 194   else
 195     frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 196                            &realnumx, raw_buffer);
 197 }
 198
 199 void
 200 get_saved_register (char *raw_buffer,
 201                     int *optimized,
 202                     CORE_ADDR *addrp,
 203                     struct frame_info *frame,
 204                     int regnum,
 205                     enum lval_type *lval)
 206 {
 207   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 208 }
 209
 210 /* frame_register_read ()
 211
 212    Find and return the value of REGNUM for the specified stack frame.
 213    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 214
 215    Returns 0 if the register value could not be found.  */
 216
 217 int
 218 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 219 {
 220   int optim;
 221   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 222                       regnum, (enum lval_type *) NULL);
 223
 224   /* FIXME: cagney/2002-05-15: This test, is just bogus.
 225
 226      It indicates that the target failed to supply a value for a
 227      register because it was "not available" at this time.  Problem
 228      is, the target still has the register and so get saved_register()
 229      may be returning a value saved on the stack.  */
 230
 231   if (register_cached (regnum) < 0)
 232     return 0;                   /* register value not available */
 233
 234   return !optim;
 235 }