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 #include "gdb_string.h"
  31 #include "builtin-regs.h"
  32
  33 /* Return a frame uniq ID that can be used to, later re-find the
  34    frame.  */
  35
  36 void
  37 get_frame_id (struct frame_info *fi, struct frame_id *id)
  38 {
  39   if (fi == NULL)
  40     {
  41       id->base = 0;
  42       id->pc = 0;
  43     }
  44   else
  45     {
  46       id->base = FRAME_FP (fi);
  47       id->pc = fi->pc;
  48     }
  49 }
  50
  51 struct frame_info *
  52 frame_find_by_id (struct frame_id id)
  53 {
  54   struct frame_info *frame;
  55
  56   /* ZERO denotes the null frame, let the caller decide what to do
  57      about it.  Should it instead return get_current_frame()?  */
  58   if (id.base == 0 && id.pc == 0)
  59     return NULL;
  60
  61   for (frame = get_current_frame ();
  62        frame != NULL;
  63        frame = get_prev_frame (frame))
  64     {
  65       if (INNER_THAN (FRAME_FP (frame), id.base))
  66         /* ``inner/current < frame < id.base''.  Keep looking along
  67            the frame chain.  */
  68         continue;
  69       if (INNER_THAN (id.base, FRAME_FP (frame)))
  70         /* ``inner/current < id.base < frame''.  Oops, gone past it.
  71            Just give up.  */
  72         return NULL;
  73       /* FIXME: cagney/2002-04-21: This isn't sufficient.  It should
  74          use id.pc to check that the two frames belong to the same
  75          function.  Otherwise we'll do things like match dummy frames
  76          or mis-match frameless functions.  However, until someone
  77          notices, stick with the existing behavour.  */
  78       return frame;
  79     }
  80   return NULL;
  81 }
  82
  83 void
  84 frame_register_unwind (struct frame_info *frame, int regnum,
  85                        int *optimizedp, enum lval_type *lvalp,
  86                        CORE_ADDR *addrp, int *realnump, void *bufferp)
  87 {
  88   struct frame_unwind_cache *cache;
  89
  90   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
  91      that the value proper does not need to be fetched.  */
  92   gdb_assert (optimizedp != NULL);
  93   gdb_assert (lvalp != NULL);
  94   gdb_assert (addrp != NULL);
  95   gdb_assert (realnump != NULL);
  96   /* gdb_assert (bufferp != NULL); */
  97
  98   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
  99      special case, there was always an inner frame dedicated to the
 100      hardware registers.  Unfortunatly, there is too much unwind code
 101      around that looks up/down the frame chain while making the
 102      assumption that each frame level is using the same unwind code.  */
 103
 104   if (frame == NULL)
 105     {
 106       /* We're in the inner-most frame, get the value direct from the
 107          register cache.  */
 108       *optimizedp = 0;
 109       *lvalp = lval_register;
 110       /* ULGH!  Code uses the offset into the raw register byte array
 111          as a way of identifying a register.  */
 112       *addrp = REGISTER_BYTE (regnum);
 113       /* Should this code test ``register_cached (regnum) < 0'' and do
 114          something like set realnum to -1 when the register isn't
 115          available?  */
 116       *realnump = regnum;
 117       if (bufferp)
 118         read_register_gen (regnum, bufferp);
 119       return;
 120     }
 121
 122   /* Ask this frame to unwind its register.  */
 123   frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
 124                           optimizedp, lvalp, addrp, realnump, bufferp);
 125 }
 126
 127 void
 128 frame_unwind_signed_register (struct frame_info *frame, int regnum,
 129                               LONGEST *val)
 130 {
 131   int optimized;
 132   CORE_ADDR addr;
 133   int realnum;
 134   enum lval_type lval;
 135   void *buf = alloca (MAX_REGISTER_RAW_SIZE);
 136   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 137                          &realnum, buf);
 138   (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 139 }
 140
 141 void
 142 frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
 143                                 ULONGEST *val)
 144 {
 145   int optimized;
 146   CORE_ADDR addr;
 147   int realnum;
 148   enum lval_type lval;
 149   void *buf = alloca (MAX_REGISTER_RAW_SIZE);
 150   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 151                          &realnum, buf);
 152   (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 153 }
 154
 155 void
 156 generic_unwind_get_saved_register (char *raw_buffer,
 157                                    int *optimizedp,
 158                                    CORE_ADDR *addrp,
 159                                    struct frame_info *frame,
 160                                    int regnum,
 161                                    enum lval_type *lvalp)
 162 {
 163   int optimizedx;
 164   CORE_ADDR addrx;
 165   int realnumx;
 166   enum lval_type lvalx;
 167
 168   if (!target_has_registers)
 169     error ("No registers.");
 170
 171   /* Keep things simple, ensure that all the pointers (except valuep)
 172      are non NULL.  */
 173   if (optimizedp == NULL)
 174     optimizedp = &optimizedx;
 175   if (lvalp == NULL)
 176     lvalp = &lvalx;
 177   if (addrp == NULL)
 178     addrp = &addrx;
 179
 180   /* Reached the the bottom (youngest, inner most) of the frame chain
 181      (youngest, inner most) frame, go direct to the hardware register
 182      cache (do not pass go, do not try to cache the value, ...).  The
 183      unwound value would have been cached in frame->next but that
 184      doesn't exist.  This doesn't matter as the hardware register
 185      cache is stopping any unnecessary accesses to the target.  */
 186
 187   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
 188      special case, there was always an inner frame dedicated to the
 189      hardware registers.  Unfortunatly, there is too much unwind code
 190      around that looks up/down the frame chain while making the
 191      assumption that each frame level is using the same unwind code.  */
 192
 193   if (frame == NULL)
 194     frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
 195                            raw_buffer);
 196   else
 197     frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 198                            &realnumx, raw_buffer);
 199 }
 200
 201 void
 202 get_saved_register (char *raw_buffer,
 203                     int *optimized,
 204                     CORE_ADDR *addrp,
 205                     struct frame_info *frame,
 206                     int regnum,
 207                     enum lval_type *lval)
 208 {
 209   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 210 }
 211
 212 /* frame_register_read ()
 213
 214    Find and return the value of REGNUM for the specified stack frame.
 215    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 216
 217    Returns 0 if the register value could not be found.  */
 218
 219 int
 220 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 221 {
 222   int optim;
 223   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 224                       regnum, (enum lval_type *) NULL);
 225
 226   /* FIXME: cagney/2002-05-15: This test, is just bogus.
 227
 228      It indicates that the target failed to supply a value for a
 229      register because it was "not available" at this time.  Problem
 230      is, the target still has the register and so get saved_register()
 231      may be returning a value saved on the stack.  */
 232
 233   if (register_cached (regnum) < 0)
 234     return 0;                   /* register value not available */
 235
 236   return !optim;
 237 }
 238
 239
 240 /* Map between a frame register number and its name.  A frame register
 241    space is a superset of the cooked register space --- it also
 242    includes builtin registers.  */
 243
 244 int
 245 frame_map_name_to_regnum (const char *name, int len)
 246 {
 247   int i;
 248
 249   /* Search register name space. */
 250   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
 251     if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
 252         && strncmp (name, REGISTER_NAME (i), len) == 0)
 253       {
 254         return i;
 255       }
 256
 257   /* Try builtin registers.  */
 258   i = builtin_reg_map_name_to_regnum (name, len);
 259   if (i >= 0)
 260     {
 261       /* A builtin register doesn't fall into the architecture's
 262          register range.  */
 263       gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
 264       return i;
 265     }
 266
 267   return -1;
 268 }
 269
 270 const char *
 271 frame_map_regnum_to_name (int regnum)
 272 {
 273   if (regnum < 0)
 274     return NULL;
 275   if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
 276     return REGISTER_NAME (regnum);
 277   return builtin_reg_map_regnum_to_name (regnum);
 278 }