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 frame_read_unsigned_register (struct frame_info *frame, int regnum,
 157                               ULONGEST *val)
 158 {
 159   /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
 160      always a frame.  Both this, and the equivalent
 161      frame_read_signed_register() function, can only be called with a
 162      valid frame.  If, for some reason, this function is called
 163      without a frame then the problem isn't here, but rather in the
 164      caller.  It should of first created a frame and then passed that
 165      in.  */
 166   /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
 167      ``current_frame'' should not be treated as a special case.  While
 168      ``get_next_frame (current_frame) == NULL'' currently holds, it
 169      should, as far as possible, not be relied upon.  In the future,
 170      ``get_next_frame (current_frame)'' may instead simply return a
 171      normal frame object that simply always gets register values from
 172      the register cache.  Consequently, frame code should try to avoid
 173      tests like ``if get_next_frame() == NULL'' and instead just rely
 174      on recursive frame calls (like the below code) when manipulating
 175      a frame chain.  */
 176   gdb_assert (frame != NULL);
 177   frame_unwind_unsigned_register (get_next_frame (frame), regnum, val);
 178 }
 179
 180 void
 181 frame_read_signed_register (struct frame_info *frame, int regnum,
 182                             LONGEST *val)
 183 {
 184   /* See note in frame_read_unsigned_register().  */
 185   gdb_assert (frame != NULL);
 186   frame_unwind_signed_register (get_next_frame (frame), regnum, val);
 187 }
 188
 189 void
 190 generic_unwind_get_saved_register (char *raw_buffer,
 191                                    int *optimizedp,
 192                                    CORE_ADDR *addrp,
 193                                    struct frame_info *frame,
 194                                    int regnum,
 195                                    enum lval_type *lvalp)
 196 {
 197   int optimizedx;
 198   CORE_ADDR addrx;
 199   int realnumx;
 200   enum lval_type lvalx;
 201
 202   if (!target_has_registers)
 203     error ("No registers.");
 204
 205   /* Keep things simple, ensure that all the pointers (except valuep)
 206      are non NULL.  */
 207   if (optimizedp == NULL)
 208     optimizedp = &optimizedx;
 209   if (lvalp == NULL)
 210     lvalp = &lvalx;
 211   if (addrp == NULL)
 212     addrp = &addrx;
 213
 214   /* Reached the the bottom (youngest, inner most) of the frame chain
 215      (youngest, inner most) frame, go direct to the hardware register
 216      cache (do not pass go, do not try to cache the value, ...).  The
 217      unwound value would have been cached in frame->next but that
 218      doesn't exist.  This doesn't matter as the hardware register
 219      cache is stopping any unnecessary accesses to the target.  */
 220
 221   /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
 222      special case, there was always an inner frame dedicated to the
 223      hardware registers.  Unfortunatly, there is too much unwind code
 224      around that looks up/down the frame chain while making the
 225      assumption that each frame level is using the same unwind code.  */
 226
 227   if (frame == NULL)
 228     frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
 229                            raw_buffer);
 230   else
 231     frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 232                            &realnumx, raw_buffer);
 233 }
 234
 235 void
 236 get_saved_register (char *raw_buffer,
 237                     int *optimized,
 238                     CORE_ADDR *addrp,
 239                     struct frame_info *frame,
 240                     int regnum,
 241                     enum lval_type *lval)
 242 {
 243   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 244 }
 245
 246 /* frame_register_read ()
 247
 248    Find and return the value of REGNUM for the specified stack frame.
 249    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 250
 251    Returns 0 if the register value could not be found.  */
 252
 253 int
 254 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 255 {
 256   int optim;
 257   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 258                       regnum, (enum lval_type *) NULL);
 259
 260   /* FIXME: cagney/2002-05-15: This test, is just bogus.
 261
 262      It indicates that the target failed to supply a value for a
 263      register because it was "not available" at this time.  Problem
 264      is, the target still has the register and so get saved_register()
 265      may be returning a value saved on the stack.  */
 266
 267   if (register_cached (regnum) < 0)
 268     return 0;                   /* register value not available */
 269
 270   return !optim;
 271 }
 272
 273
 274 /* Map between a frame register number and its name.  A frame register
 275    space is a superset of the cooked register space --- it also
 276    includes builtin registers.  */
 277
 278 int
 279 frame_map_name_to_regnum (const char *name, int len)
 280 {
 281   int i;
 282
 283   /* Search register name space. */
 284   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
 285     if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
 286         && strncmp (name, REGISTER_NAME (i), len) == 0)
 287       {
 288         return i;
 289       }
 290
 291   /* Try builtin registers.  */
 292   i = builtin_reg_map_name_to_regnum (name, len);
 293   if (i >= 0)
 294     {
 295       /* A builtin register doesn't fall into the architecture's
 296          register range.  */
 297       gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
 298       return i;
 299     }
 300
 301   return -1;
 302 }
 303
 304 const char *
 305 frame_map_regnum_to_name (int regnum)
 306 {
 307   if (regnum < 0)
 308     return NULL;
 309   if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
 310     return REGISTER_NAME (regnum);
 311   return builtin_reg_map_regnum_to_name (regnum);
 312 }