gdb/am29k-tdep.c

   1 /* Target-machine dependent code for the AMD 29000
   2    Copyright 1990, 1991 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Jim Kingdon.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include "gdbcore.h"
  23 #include "frame.h"
  24 #include "value.h"
  25 /*#include <sys/param.h> */
  26 #include "symtab.h"
  27 #include "inferior.h"
  28 #include "gdbcmd.h"
  29
  30 extern CORE_ADDR text_start;    /* FIXME, kludge... */
  31
  32 /* The user-settable top of the register stack in virtual memory.  We
  33    won't attempt to access any stored registers above this address, if set
  34    nonzero.  */
  35
  36 static CORE_ADDR rstack_high_address = UINT_MAX;
  37
  38 /* Structure to hold cached info about function prologues.  */
  39 struct prologue_info
  40 {
  41   CORE_ADDR pc;                 /* First addr after fn prologue */
  42   unsigned rsize, msize;        /* register stack frame size, mem stack ditto */
  43   unsigned mfp_used : 1;        /* memory frame pointer used */
  44   unsigned rsize_valid : 1;     /* Validity bits for the above */
  45   unsigned msize_valid : 1;
  46   unsigned mfp_valid : 1;
  47 };
  48
  49 /* Examine the prologue of a function which starts at PC.  Return
  50    the first addess past the prologue.  If MSIZE is non-NULL, then
  51    set *MSIZE to the memory stack frame size.  If RSIZE is non-NULL,
  52    then set *RSIZE to the register stack frame size (not including
  53    incoming arguments and the return address & frame pointer stored
  54    with them).  If no prologue is found, *RSIZE is set to zero.
  55    If no prologue is found, or a prologue which doesn't involve
  56    allocating a memory stack frame, then set *MSIZE to zero.
  57
  58    Note that both msize and rsize are in bytes.  This is not consistent
  59    with the _User's Manual_ with respect to rsize, but it is much more
  60    convenient.
  61
  62    If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
  63    frame pointer is being used.  */
  64 CORE_ADDR
  65 examine_prologue (pc, rsize, msize, mfp_used)
  66      CORE_ADDR pc;
  67      unsigned *msize;
  68      unsigned *rsize;
  69      int *mfp_used;
  70 {
  71   long insn;
  72   CORE_ADDR p = pc;
  73   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
  74   struct prologue_info *mi = 0;
  75
  76   if (msymbol != NULL)
  77     mi = (struct prologue_info *) msymbol -> info;
  78
  79   if (mi != 0)
  80     {
  81       int valid = 1;
  82       if (rsize != NULL)
  83         {
  84           *rsize = mi->rsize;
  85           valid &= mi->rsize_valid;
  86         }
  87       if (msize != NULL)
  88         {
  89           *msize = mi->msize;
  90           valid &= mi->msize_valid;
  91         }
  92       if (mfp_used != NULL)
  93         {
  94           *mfp_used = mi->mfp_used;
  95           valid &= mi->mfp_valid;
  96         }
  97       if (valid)
  98         return mi->pc;
  99     }
 100
 101   if (rsize != NULL)
 102     *rsize = 0;
 103   if (msize != NULL)
 104     *msize = 0;
 105   if (mfp_used != NULL)
 106     *mfp_used = 0;
 107
 108   /* Prologue must start with subtracting a constant from gr1.
 109      Normally this is sub gr1,gr1,<rsize * 4>.  */
 110   insn = read_memory_integer (p, 4);
 111   if ((insn & 0xffffff00) != 0x25010100)
 112     {
 113       /* If the frame is large, instead of a single instruction it
 114          might be a pair of instructions:
 115          const <reg>, <rsize * 4>
 116          sub gr1,gr1,<reg>
 117          */
 118       int reg;
 119       /* Possible value for rsize.  */
 120       unsigned int rsize0;
 121
 122       if ((insn & 0xff000000) != 0x03000000)
 123         {
 124           p = pc;
 125           goto done;
 126         }
 127       reg = (insn >> 8) & 0xff;
 128       rsize0 = (((insn >> 8) & 0xff00) | (insn & 0xff));
 129       p += 4;
 130       insn = read_memory_integer (p, 4);
 131       if ((insn & 0xffffff00) != 0x24010100
 132           || (insn & 0xff) != reg)
 133         {
 134           p = pc;
 135           goto done;
 136         }
 137       if (rsize != NULL)
 138         *rsize = rsize0;
 139     }
 140   else
 141     {
 142       if (rsize != NULL)
 143         *rsize = (insn & 0xff);
 144     }
 145   p += 4;
 146
 147   /* Next instruction must be asgeu V_SPILL,gr1,rab.
 148    * We don't check the vector number to allow for kernel debugging.  The
 149    * kernel will use a different trap number.
 150    */
 151   insn = read_memory_integer (p, 4);
 152   if ((insn & 0xff00ffff) != (0x5e000100|RAB_HW_REGNUM))
 153     {
 154       p = pc;
 155       goto done;
 156     }
 157   p += 4;
 158
 159   /* Next instruction usually sets the frame pointer (lr1) by adding
 160      <size * 4> from gr1.  However, this can (and high C does) be
 161      deferred until anytime before the first function call.  So it is
 162      OK if we don't see anything which sets lr1.
 163      To allow for alternate register sets (gcc -mkernel-registers)  the msp
 164      register number is a compile time constant. */
 165
 166   /* Normally this is just add lr1,gr1,<size * 4>.  */
 167   insn = read_memory_integer (p, 4);
 168   if ((insn & 0xffffff00) == 0x15810100)
 169     p += 4;
 170   else
 171     {
 172       /* However, for large frames it can be
 173          const <reg>, <size *4>
 174          add lr1,gr1,<reg>
 175          */
 176       int reg;
 177       CORE_ADDR q;
 178
 179       if ((insn & 0xff000000) == 0x03000000)
 180         {
 181           reg = (insn >> 8) & 0xff;
 182           q = p + 4;
 183           insn = read_memory_integer (q, 4);
 184           if ((insn & 0xffffff00) == 0x14810100
 185               && (insn & 0xff) == reg)
 186             p = q;
 187         }
 188     }
 189
 190   /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
 191      frame pointer is in use.  We just check for add lr<anything>,msp,0;
 192      we don't check this rsize against the first instruction, and
 193      we don't check that the trace-back tag indicates a memory frame pointer
 194      is in use.
 195      To allow for alternate register sets (gcc -mkernel-registers)  the msp
 196      register number is a compile time constant.
 197
 198      The recommended instruction is actually "sll lr<whatever>,msp,0".
 199      We check for that, too.  Originally Jim Kingdon's code seemed
 200      to be looking for a "sub" instruction here, but the mask was set
 201      up to lose all the time. */
 202   insn = read_memory_integer (p, 4);
 203   if (((insn & 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM<<8)))     /* add */
 204    || ((insn & 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM<<8))))    /* sll */
 205     {
 206       p += 4;
 207       if (mfp_used != NULL)
 208         *mfp_used = 1;
 209     }
 210
 211   /* Next comes a subtraction from msp to allocate a memory frame,
 212      but only if a memory frame is
 213      being used.  We don't check msize against the trace-back tag.
 214
 215      To allow for alternate register sets (gcc -mkernel-registers) the msp
 216      register number is a compile time constant.
 217
 218      Normally this is just
 219      sub msp,msp,<msize>
 220      */
 221   insn = read_memory_integer (p, 4);
 222   if ((insn & 0xffffff00) ==
 223                 (0x25000000|(MSP_HW_REGNUM<<16)|(MSP_HW_REGNUM<<8)))
 224     {
 225       p += 4;
 226       if (msize != NULL)
 227         *msize = insn & 0xff;
 228     }
 229   else
 230     {
 231       /* For large frames, instead of a single instruction it might
 232          be
 233
 234          const <reg>, <msize>
 235          consth <reg>, <msize>     ; optional
 236          sub msp,msp,<reg>
 237          */
 238       int reg;
 239       unsigned msize0;
 240       CORE_ADDR q = p;
 241
 242       if ((insn & 0xff000000) == 0x03000000)
 243         {
 244           reg = (insn >> 8) & 0xff;
 245           msize0 = ((insn >> 8) & 0xff00) | (insn & 0xff);
 246           q += 4;
 247           insn = read_memory_integer (q, 4);
 248           /* Check for consth.  */
 249           if ((insn & 0xff000000) == 0x02000000
 250               && (insn & 0x0000ff00) == reg)
 251             {
 252               msize0 |= (insn << 8) & 0xff000000;
 253               msize0 |= (insn << 16) & 0x00ff0000;
 254               q += 4;
 255               insn = read_memory_integer (q, 4);
 256             }
 257           /* Check for sub msp,msp,<reg>.  */
 258           if ((insn & 0xffffff00) ==
 259                 (0x24000000|(MSP_HW_REGNUM<<16)|(MSP_HW_REGNUM<<8))
 260               && (insn & 0xff) == reg)
 261             {
 262               p = q + 4;
 263               if (msize != NULL)
 264                 *msize = msize0;
 265             }
 266         }
 267     }
 268
 269  done:
 270   if (msymbol != NULL)
 271     {
 272       if (mi == 0)
 273         {
 274           /* Add a new cache entry.  */
 275           mi = (struct prologue_info *)xmalloc (sizeof (struct prologue_info));
 276           msymbol -> info = (char *)mi;
 277           mi->rsize_valid = 0;
 278           mi->msize_valid = 0;
 279           mi->mfp_valid = 0;
 280         }
 281       /* else, cache entry exists, but info is incomplete.  */
 282       mi->pc = p;
 283       if (rsize != NULL)
 284         {
 285           mi->rsize = *rsize;
 286           mi->rsize_valid = 1;
 287         }
 288       if (msize != NULL)
 289         {
 290           mi->msize = *msize;
 291           mi->msize_valid = 1;
 292         }
 293       if (mfp_used != NULL)
 294         {
 295           mi->mfp_used = *mfp_used;
 296           mi->mfp_valid = 1;
 297         }
 298     }
 299   return p;
 300 }
 301
 302 /* Advance PC across any function entry prologue instructions
 303    to reach some "real" code.  */
 304
 305 CORE_ADDR
 306 skip_prologue (pc)
 307      CORE_ADDR pc;
 308 {
 309   return examine_prologue (pc, (unsigned *)NULL, (unsigned *)NULL,
 310                            (int *)NULL);
 311 }
 312 /*
 313  * Examine the one or two word tag at the beginning of a function.
 314  * The tag word is expect to be at 'p', if it is not there, we fail
 315  * by returning 0.  The documentation for the tag word was taken from
 316  * page 7-15 of the 29050 User's Manual.  We are assuming that the
 317  * m bit is in bit 22 of the tag word, which seems to be the agreed upon
 318  * convention today (1/15/92).
 319  * msize is return in bytes.
 320  */
 321 static int      /* 0/1 - failure/success of finding the tag word  */
 322 examine_tag(p, is_trans, argcount, msize, mfp_used)
 323      CORE_ADDR p;
 324      int *is_trans;
 325      int   *argcount;
 326      unsigned *msize;
 327      int *mfp_used;
 328 {
 329   unsigned int tag1, tag2;
 330
 331   tag1 = read_memory_integer (p, 4);
 332   if ((tag1 & 0xff000000) != 0)         /* Not a tag word */
 333     return 0;
 334   if (tag1 & (1<<23))                   /* A two word tag */
 335     {
 336        tag2 = read_memory_integer (p+4, 4);
 337        if (msize)
 338          *msize = tag2;
 339     }
 340   else                                  /* A one word tag */
 341     {
 342        if (msize)
 343          *msize = tag1 & 0x7ff;
 344     }
 345   if (is_trans)
 346     *is_trans = ((tag1 & (1<<21)) ? 1 : 0);
 347   if (argcount)
 348     *argcount = (tag1 >> 16) & 0x1f;
 349   if (mfp_used)
 350     *mfp_used = ((tag1 & (1<<22)) ? 1 : 0);
 351   return(1);
 352 }
 353
 354 /* Initialize the frame.  In addition to setting "extra" frame info,
 355    we also set ->frame because we use it in a nonstandard way, and ->pc
 356    because we need to know it to get the other stuff.  See the diagram
 357    of stacks and the frame cache in tm-29k.h for more detail.  */
 358 static void
 359 init_frame_info (innermost_frame, fci)
 360      int innermost_frame;
 361      struct frame_info *fci;
 362 {
 363   CORE_ADDR p;
 364   long insn;
 365   unsigned rsize;
 366   unsigned msize;
 367   int mfp_used, trans;
 368   struct symbol *func;
 369
 370   p = fci->pc;
 371
 372   if (innermost_frame)
 373     fci->frame = read_register (GR1_REGNUM);
 374   else
 375     fci->frame = fci->next_frame + fci->next->rsize;
 376
 377 #if CALL_DUMMY_LOCATION == ON_STACK
 378   This wont work;
 379 #else
 380   if (PC_IN_CALL_DUMMY (p, 0, 0))
 381 #endif
 382     {
 383       fci->rsize = DUMMY_FRAME_RSIZE;
 384       /* This doesn't matter since we never try to get locals or args
 385          from a dummy frame.  */
 386       fci->msize = 0;
 387       /* Dummy frames always use a memory frame pointer.  */
 388       fci->saved_msp =
 389         read_register_stack_integer (fci->frame + DUMMY_FRAME_RSIZE - 4, 4);
 390       fci->flags |= (TRANSPARENT|MFP_USED);
 391       return;
 392     }
 393
 394   func = find_pc_function (p);
 395   if (func != NULL)
 396     p = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
 397   else
 398     {
 399       /* Search backward to find the trace-back tag.  However,
 400          do not trace back beyond the start of the text segment
 401          (just as a sanity check to avoid going into never-never land).  */
 402       while (p >= text_start
 403              && ((insn = read_memory_integer (p, 4)) & 0xff000000) != 0)
 404         p -= 4;
 405
 406       if (p < text_start)
 407         {
 408           /* Couldn't find the trace-back tag.
 409              Something strange is going on.  */
 410           fci->saved_msp = 0;
 411           fci->rsize = 0;
 412           fci->msize = 0;
 413           fci->flags = TRANSPARENT;
 414           return;
 415         }
 416       else
 417         /* Advance to the first word of the function, i.e. the word
 418            after the trace-back tag.  */
 419         p += 4;
 420     }
 421   /* We've found the start of the function.
 422    * Try looking for a tag word that indicates whether there is a
 423    * memory frame pointer and what the memory stack allocation is.
 424    * If one doesn't exist, try using a more exhaustive search of
 425    * the prologue.  For now we don't care about the argcount or
 426    * whether or not the routine is transparent.
 427    */
 428   if (examine_tag(p-4,&trans,NULL,&msize,&mfp_used)) /* Found a good tag */
 429       examine_prologue (p, &rsize, 0, 0);
 430   else                                          /* No tag try prologue */
 431       examine_prologue (p, &rsize, &msize, &mfp_used);
 432
 433   fci->rsize = rsize;
 434   fci->msize = msize;
 435   fci->flags = 0;
 436   if (mfp_used)
 437         fci->flags |= MFP_USED;
 438   if (trans)
 439         fci->flags |= TRANSPARENT;
 440   if (innermost_frame)
 441     {
 442       fci->saved_msp = read_register (MSP_REGNUM) + msize;
 443     }
 444   else
 445     {
 446       if (mfp_used)
 447          fci->saved_msp =
 448               read_register_stack_integer (fci->frame + rsize - 4, 4);
 449       else
 450             fci->saved_msp = fci->next->saved_msp + msize;
 451     }
 452 }
 453
 454 void
 455 init_extra_frame_info (fci)
 456      struct frame_info *fci;
 457 {
 458   if (fci->next == 0)
 459     /* Assume innermost frame.  May produce strange results for "info frame"
 460        but there isn't any way to tell the difference.  */
 461     init_frame_info (1, fci);
 462   else {
 463       /* We're in get_prev_frame_info.
 464          Take care of everything in init_frame_pc.  */
 465       ;
 466     }
 467 }
 468
 469 void
 470 init_frame_pc (fromleaf, fci)
 471      int fromleaf;
 472      struct frame_info *fci;
 473 {
 474   fci->pc = (fromleaf ? SAVED_PC_AFTER_CALL (fci->next) :
 475              fci->next ? FRAME_SAVED_PC (fci->next) : read_pc ());
 476   init_frame_info (fromleaf, fci);
 477 }
 478 \f
 479 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
 480    offsets being relative to the memory stack pointer (high C) or
 481    saved_msp (gcc).  */
 482
 483 CORE_ADDR
 484 frame_locals_address (fi)
 485      struct frame_info *fi;
 486 {
 487   if (fi->flags & MFP_USED)
 488     return fi->saved_msp;
 489   else
 490     return fi->saved_msp - fi->msize;
 491 }
 492 \f
 493 /* Routines for reading the register stack.  The caller gets to treat
 494    the register stack as a uniform stack in memory, from address $gr1
 495    straight through $rfb and beyond.  */
 496
 497 /* Analogous to read_memory except the length is understood to be 4.
 498    Also, myaddr can be NULL (meaning don't bother to read), and
 499    if actual_mem_addr is non-NULL, store there the address that it
 500    was fetched from (or if from a register the offset within
 501    registers).  Set *LVAL to lval_memory or lval_register, depending
 502    on where it came from.  */
 503 void
 504 read_register_stack (memaddr, myaddr, actual_mem_addr, lval)
 505      CORE_ADDR memaddr;
 506      char *myaddr;
 507      CORE_ADDR *actual_mem_addr;
 508      enum lval_type *lval;
 509 {
 510   long rfb = read_register (RFB_REGNUM);
 511   long rsp = read_register (RSP_REGNUM);
 512
 513   /* If we don't do this 'info register' stops in the middle. */
 514   if (memaddr >= rstack_high_address)
 515     {
 516       int val = -1;                     /* a bogus value */
 517       /* It's in a local register, but off the end of the stack.  */
 518       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 519       if (myaddr != NULL)
 520         *(int*)myaddr = val;            /* Provide bogusness */
 521       supply_register(regnum,&val);     /* More bogusness */
 522       if (lval != NULL)
 523         *lval = lval_register;
 524       if (actual_mem_addr != NULL)
 525         *actual_mem_addr = REGISTER_BYTE (regnum);
 526     }
 527   else if (memaddr < rfb)
 528     {
 529       /* It's in a register.  */
 530       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 531       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127)
 532         error ("Attempt to read register stack out of range.");
 533       if (myaddr != NULL)
 534         read_register_gen (regnum, myaddr);
 535       if (lval != NULL)
 536         *lval = lval_register;
 537       if (actual_mem_addr != NULL)
 538         *actual_mem_addr = REGISTER_BYTE (regnum);
 539     }
 540   else
 541     {
 542       /* It's in the memory portion of the register stack.  */
 543       if (myaddr != NULL)
 544            read_memory (memaddr, myaddr, 4);
 545       if (lval != NULL)
 546         *lval = lval_memory;
 547       if (actual_mem_addr != NULL)
 548         *actual_mem_addr = memaddr;
 549     }
 550 }
 551
 552 /* Analogous to read_memory_integer
 553    except the length is understood to be 4.  */
 554 long
 555 read_register_stack_integer (memaddr, len)
 556      CORE_ADDR memaddr;
 557      int len;
 558 {
 559   long buf;
 560   read_register_stack (memaddr, &buf, NULL, NULL);
 561   SWAP_TARGET_AND_HOST (&buf, 4);
 562   return buf;
 563 }
 564
 565 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
 566    at MEMADDR and put the actual address written into in
 567    *ACTUAL_MEM_ADDR.  */
 568 static void
 569 write_register_stack (memaddr, myaddr, actual_mem_addr)
 570      CORE_ADDR memaddr;
 571      char *myaddr;
 572      CORE_ADDR *actual_mem_addr;
 573 {
 574   long rfb = read_register (RFB_REGNUM);
 575   long rsp = read_register (RSP_REGNUM);
 576   /* If we don't do this 'info register' stops in the middle. */
 577   if (memaddr >= rstack_high_address)
 578     {
 579       /* It's in a register, but off the end of the stack.  */
 580       if (actual_mem_addr != NULL)
 581         *actual_mem_addr = NULL;
 582     }
 583   else if (memaddr < rfb)
 584     {
 585       /* It's in a register.  */
 586       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 587       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127)
 588         error ("Attempt to read register stack out of range.");
 589       if (myaddr != NULL)
 590         write_register (regnum, *(long *)myaddr);
 591       if (actual_mem_addr != NULL)
 592         *actual_mem_addr = NULL;
 593     }
 594   else
 595     {
 596       /* It's in the memory portion of the register stack.  */
 597       if (myaddr != NULL)
 598         write_memory (memaddr, myaddr, 4);
 599       if (actual_mem_addr != NULL)
 600         *actual_mem_addr = memaddr;
 601     }
 602 }
 603 \f
 604 /* Find register number REGNUM relative to FRAME and put its
 605    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
 606    was optimized out (and thus can't be fetched).  If the variable
 607    was fetched from memory, set *ADDRP to where it was fetched from,
 608    otherwise it was fetched from a register.
 609
 610    The argument RAW_BUFFER must point to aligned memory.  */
 611 void
 612 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lvalp)
 613      char *raw_buffer;
 614      int *optimized;
 615      CORE_ADDR *addrp;
 616      FRAME frame;
 617      int regnum;
 618      enum lval_type *lvalp;
 619 {
 620   struct frame_info *fi;
 621   CORE_ADDR addr;
 622   enum lval_type lval;
 623
 624   if (frame == 0)
 625     return;
 626
 627   fi = get_frame_info (frame);
 628
 629   /* Once something has a register number, it doesn't get optimized out.  */
 630   if (optimized != NULL)
 631     *optimized = 0;
 632   if (regnum == RSP_REGNUM)
 633     {
 634       if (raw_buffer != NULL)
 635         *(CORE_ADDR *)raw_buffer = fi->frame;
 636       if (lvalp != NULL)
 637         *lvalp = not_lval;
 638       return;
 639     }
 640   else if (regnum == PC_REGNUM)
 641     {
 642       if (raw_buffer != NULL)
 643         *(CORE_ADDR *)raw_buffer = fi->pc;
 644
 645       /* Not sure we have to do this.  */
 646       if (lvalp != NULL)
 647         *lvalp = not_lval;
 648
 649       return;
 650     }
 651   else if (regnum == MSP_REGNUM)
 652     {
 653       if (raw_buffer != NULL)
 654         {
 655           if (fi->next != NULL)
 656             *(CORE_ADDR *)raw_buffer = fi->next->saved_msp;
 657           else
 658             *(CORE_ADDR *)raw_buffer = read_register (MSP_REGNUM);
 659         }
 660       /* The value may have been computed, not fetched.  */
 661       if (lvalp != NULL)
 662         *lvalp = not_lval;
 663       return;
 664     }
 665   else if (regnum < LR0_REGNUM || regnum >= LR0_REGNUM + 128)
 666     {
 667       /* These registers are not saved over procedure calls,
 668          so just print out the current values.  */
 669       if (raw_buffer != NULL)
 670         *(CORE_ADDR *)raw_buffer = read_register (regnum);
 671       if (lvalp != NULL)
 672         *lvalp = lval_register;
 673       if (addrp != NULL)
 674         *addrp = REGISTER_BYTE (regnum);
 675       return;
 676     }
 677
 678   addr = fi->frame + (regnum - LR0_REGNUM) * 4;
 679   if (raw_buffer != NULL)
 680     read_register_stack (addr, raw_buffer, &addr, &lval);
 681   if (lvalp != NULL)
 682     *lvalp = lval;
 683   if (addrp != NULL)
 684     *addrp = addr;
 685 }
 686 \f
 687
 688 /* Discard from the stack the innermost frame,
 689    restoring all saved registers.  */
 690
 691 void
 692 pop_frame ()
 693 {
 694   FRAME frame = get_current_frame ();
 695   struct frame_info *fi = get_frame_info (frame);
 696   CORE_ADDR rfb = read_register (RFB_REGNUM);
 697   CORE_ADDR gr1 = fi->frame + fi->rsize;
 698   CORE_ADDR lr1;
 699   int i;
 700
 701   /* If popping a dummy frame, need to restore registers.  */
 702   if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM),
 703                         read_register (SP_REGNUM),
 704                         FRAME_FP (fi)))
 705     {
 706       int lrnum = LR0_REGNUM + DUMMY_ARG/4;
 707       for (i = 0; i < DUMMY_SAVE_SR128; ++i)
 708         write_register (SR_REGNUM (i + 128),read_register (lrnum++));
 709       for (i = 0; i < DUMMY_SAVE_SR160; ++i)
 710         write_register (SR_REGNUM(i+160), read_register (lrnum++));
 711       for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
 712         write_register (RETURN_REGNUM + i, read_register (lrnum++));
 713       /* Restore the PCs.  */
 714       write_register(PC_REGNUM, read_register (lrnum++));
 715       write_register(NPC_REGNUM, read_register (lrnum));
 716     }
 717
 718   /* Restore the memory stack pointer.  */
 719   write_register (MSP_REGNUM, fi->saved_msp);
 720   /* Restore the register stack pointer.  */
 721   write_register (GR1_REGNUM, gr1);
 722   /* Check whether we need to fill registers.  */
 723   lr1 = read_register (LR0_REGNUM + 1);
 724   if (lr1 > rfb)
 725     {
 726       /* Fill.  */
 727       int num_bytes = lr1 - rfb;
 728       int i;
 729       long word;
 730       write_register (RAB_REGNUM, read_register (RAB_REGNUM) + num_bytes);
 731       write_register (RFB_REGNUM, lr1);
 732       for (i = 0; i < num_bytes; i += 4)
 733         {
 734           /* Note: word is in host byte order.  */
 735           word = read_memory_integer (rfb + i, 4);
 736           write_register (LR0_REGNUM + ((rfb - gr1) % 0x80) + i / 4, word);
 737         }
 738     }
 739   flush_cached_frames ();
 740   set_current_frame (create_new_frame (0, read_pc()));
 741 }
 742
 743 /* Push an empty stack frame, to record the current PC, etc.  */
 744
 745 void
 746 push_dummy_frame ()
 747 {
 748   long w;
 749   CORE_ADDR rab, gr1;
 750   CORE_ADDR msp = read_register (MSP_REGNUM);
 751   int lrnum,  i, saved_lr0;
 752
 753
 754   /* Allocate the new frame. */
 755   gr1 = read_register (GR1_REGNUM) - DUMMY_FRAME_RSIZE;
 756   write_register (GR1_REGNUM, gr1);
 757
 758   rab = read_register (RAB_REGNUM);
 759   if (gr1 < rab)
 760     {
 761       /* We need to spill registers.  */
 762       int num_bytes = rab - gr1;
 763       CORE_ADDR rfb = read_register (RFB_REGNUM);
 764       int i;
 765       long word;
 766
 767       write_register (RFB_REGNUM, rfb - num_bytes);
 768       write_register (RAB_REGNUM, gr1);
 769       for (i = 0; i < num_bytes; i += 4)
 770         {
 771           /* Note:  word is in target byte order.  */
 772           read_register_gen (LR0_REGNUM + i / 4, &word);
 773           write_memory (rfb - num_bytes + i, &word, 4);
 774         }
 775     }
 776
 777   /* There are no arguments in to the dummy frame, so we don't need
 778      more than rsize plus the return address and lr1.  */
 779   write_register (LR0_REGNUM + 1, gr1 + DUMMY_FRAME_RSIZE + 2 * 4);
 780
 781   /* Set the memory frame pointer.  */
 782   write_register (LR0_REGNUM + DUMMY_FRAME_RSIZE / 4 - 1, msp);
 783
 784   /* Allocate arg_slop.  */
 785   write_register (MSP_REGNUM, msp - 16 * 4);
 786
 787   /* Save registers.  */
 788   lrnum = LR0_REGNUM + DUMMY_ARG/4;
 789   for (i = 0; i < DUMMY_SAVE_SR128; ++i)
 790     write_register (lrnum++, read_register (SR_REGNUM (i + 128)));
 791   for (i = 0; i < DUMMY_SAVE_SR160; ++i)
 792     write_register (lrnum++, read_register (SR_REGNUM (i + 160)));
 793   for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
 794     write_register (lrnum++, read_register (RETURN_REGNUM + i));
 795   /* Save the PCs.  */
 796   write_register (lrnum++, read_register (PC_REGNUM));
 797   write_register (lrnum, read_register (NPC_REGNUM));
 798 }
 799
 800 reginv_com (args, fromtty)
 801      char       *args;
 802      int        fromtty;
 803 {
 804    registers_changed();
 805    if (fromtty)
 806         printf_filtered("Gdb's register cache invalidated.\n");
 807 }
 808
 809 /* We use this mostly for debugging gdb */
 810 void
 811 _initialize_29k()
 812 {
 813   add_com ("reginv ", class_obscure, reginv_com,
 814         "Invalidate gdb's internal register cache.");
 815
 816   /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
 817   add_show_from_set
 818     (add_set_cmd ("rstack_high_address", class_support, var_uinteger,
 819                   (char *)&rstack_high_address,
 820                   "Set top address in memory of the register stack.\n\
 821 Attempts to access registers saved above this address will be ignored\n\
 822 or will produce the value -1.", &setlist),
 823      &showlist);
 824 }