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 <stdio.h>
  24 #include "frame.h"
  25 #include "value.h"
  26 /*#include <sys/param.h> */
  27 #include "symtab.h"
  28 #include "inferior.h"
  29
  30 extern CORE_ADDR text_start;    /* FIXME, kludge... */
  31
  32 /* Structure to hold cached info about function prologues.  */
  33 struct prologue_info
  34 {
  35   CORE_ADDR pc;                 /* First addr after fn prologue */
  36   unsigned rsize, msize;        /* register stack frame size, mem stack ditto */
  37   unsigned mfp_used : 1;        /* memory frame pointer used */
  38   unsigned rsize_valid : 1;     /* Validity bits for the above */
  39   unsigned msize_valid : 1;
  40   unsigned mfp_valid : 1;
  41 };
  42
  43 /* Examine the prologue of a function which starts at PC.  Return
  44    the first addess past the prologue.  If MSIZE is non-NULL, then
  45    set *MSIZE to the memory stack frame size.  If RSIZE is non-NULL,
  46    then set *RSIZE to the register stack frame size (not including
  47    incoming arguments and the return address & frame pointer stored
  48    with them).  If no prologue is found, *RSIZE is set to zero.
  49    If no prologue is found, or a prologue which doesn't involve
  50    allocating a memory stack frame, then set *MSIZE to zero.
  51
  52    Note that both msize and rsize are in bytes.  This is not consistent
  53    with the _User's Manual_ with respect to rsize, but it is much more
  54    convenient.
  55
  56    If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
  57    frame pointer is being used.  */
  58 CORE_ADDR
  59 examine_prologue (pc, rsize, msize, mfp_used)
  60      CORE_ADDR pc;
  61      unsigned *msize;
  62      unsigned *rsize;
  63      int *mfp_used;
  64 {
  65   long insn;
  66   CORE_ADDR p = pc;
  67   struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
  68   struct prologue_info *mi = 0;
  69
  70   if (msymbol != NULL)
  71     mi = (struct prologue_info *) msymbol -> info;
  72
  73   if (mi != 0)
  74     {
  75       int valid = 1;
  76       if (rsize != NULL)
  77         {
  78           *rsize = mi->rsize;
  79           valid &= mi->rsize_valid;
  80         }
  81       if (msize != NULL)
  82         {
  83           *msize = mi->msize;
  84           valid &= mi->msize_valid;
  85         }
  86       if (mfp_used != NULL)
  87         {
  88           *mfp_used = mi->mfp_used;
  89           valid &= mi->mfp_valid;
  90         }
  91       if (valid)
  92         return mi->pc;
  93     }
  94
  95   if (rsize != NULL)
  96     *rsize = 0;
  97   if (msize != NULL)
  98     *msize = 0;
  99   if (mfp_used != NULL)
 100     *mfp_used = 0;
 101
 102   /* Prologue must start with subtracting a constant from gr1.
 103      Normally this is sub gr1,gr1,<rsize * 4>.  */
 104   insn = read_memory_integer (p, 4);
 105   if ((insn & 0xffffff00) != 0x25010100)
 106     {
 107       /* If the frame is large, instead of a single instruction it
 108          might be a pair of instructions:
 109          const <reg>, <rsize * 4>
 110          sub gr1,gr1,<reg>
 111          */
 112       int reg;
 113       /* Possible value for rsize.  */
 114       unsigned int rsize0;
 115
 116       if ((insn & 0xff000000) != 0x03000000)
 117         {
 118           p = pc;
 119           goto done;
 120         }
 121       reg = (insn >> 8) & 0xff;
 122       rsize0 = (((insn >> 8) & 0xff00) | (insn & 0xff));
 123       p += 4;
 124       insn = read_memory_integer (p, 4);
 125       if ((insn & 0xffffff00) != 0x24010100
 126           || (insn & 0xff) != reg)
 127         {
 128           p = pc;
 129           goto done;
 130         }
 131       if (rsize != NULL)
 132         *rsize = rsize0;
 133     }
 134   else
 135     {
 136       if (rsize != NULL)
 137         *rsize = (insn & 0xff);
 138     }
 139   p += 4;
 140
 141   /* Next instruction must be asgeu V_SPILL,gr1,rab.
 142    * We don't check the vector number to allow for kernel debugging.  The
 143    * kernel will use a different trap number.
 144    */
 145   insn = read_memory_integer (p, 4);
 146   if ((insn & 0xff00ffff) != (0x5e000100|RAB_HW_REGNUM))
 147     {
 148       p = pc;
 149       goto done;
 150     }
 151   p += 4;
 152
 153   /* Next instruction usually sets the frame pointer (lr1) by adding
 154      <size * 4> from gr1.  However, this can (and high C does) be
 155      deferred until anytime before the first function call.  So it is
 156      OK if we don't see anything which sets lr1.
 157      To allow for alternate register sets (gcc -mkernel-registers)  the msp
 158      register number is a compile time constant. */
 159
 160   /* Normally this is just add lr1,gr1,<size * 4>.  */
 161   insn = read_memory_integer (p, 4);
 162   if ((insn & 0xffffff00) == 0x15810100)
 163     p += 4;
 164   else
 165     {
 166       /* However, for large frames it can be
 167          const <reg>, <size *4>
 168          add lr1,gr1,<reg>
 169          */
 170       int reg;
 171       CORE_ADDR q;
 172
 173       if ((insn & 0xff000000) == 0x03000000)
 174         {
 175           reg = (insn >> 8) & 0xff;
 176           q = p + 4;
 177           insn = read_memory_integer (q, 4);
 178           if ((insn & 0xffffff00) == 0x14810100
 179               && (insn & 0xff) == reg)
 180             p = q;
 181         }
 182     }
 183
 184   /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
 185      frame pointer is in use.  We just check for add lr<anything>,msp,0;
 186      we don't check this rsize against the first instruction, and
 187      we don't check that the trace-back tag indicates a memory frame pointer
 188      is in use.
 189      To allow for alternate register sets (gcc -mkernel-registers)  the msp
 190      register number is a compile time constant.
 191
 192      The recommended instruction is actually "sll lr<whatever>,msp,0".
 193      We check for that, too.  Originally Jim Kingdon's code seemed
 194      to be looking for a "sub" instruction here, but the mask was set
 195      up to lose all the time. */
 196   insn = read_memory_integer (p, 4);
 197   if (((insn & 0xff80ffff) == (0x15800000|(MSP_HW_REGNUM<<8)))     /* add */
 198    || ((insn & 0xff80ffff) == (0x81800000|(MSP_HW_REGNUM<<8))))    /* sll */
 199     {
 200       p += 4;
 201       if (mfp_used != NULL)
 202         *mfp_used = 1;
 203     }
 204
 205   /* Next comes a subtraction from msp to allocate a memory frame,
 206      but only if a memory frame is
 207      being used.  We don't check msize against the trace-back tag.
 208
 209      To allow for alternate register sets (gcc -mkernel-registers) the msp
 210      register number is a compile time constant.
 211
 212      Normally this is just
 213      sub msp,msp,<msize>
 214      */
 215   insn = read_memory_integer (p, 4);
 216   if ((insn & 0xffffff00) ==
 217                 (0x25000000|(MSP_HW_REGNUM<<16)|(MSP_HW_REGNUM<<8)))
 218     {
 219       p += 4;
 220       if (msize != NULL)
 221         *msize = insn & 0xff;
 222     }
 223   else
 224     {
 225       /* For large frames, instead of a single instruction it might
 226          be
 227
 228          const <reg>, <msize>
 229          consth <reg>, <msize>     ; optional
 230          sub msp,msp,<reg>
 231          */
 232       int reg;
 233       unsigned msize0;
 234       CORE_ADDR q = p;
 235
 236       if ((insn & 0xff000000) == 0x03000000)
 237         {
 238           reg = (insn >> 8) & 0xff;
 239           msize0 = ((insn >> 8) & 0xff00) | (insn & 0xff);
 240           q += 4;
 241           insn = read_memory_integer (q, 4);
 242           /* Check for consth.  */
 243           if ((insn & 0xff000000) == 0x02000000
 244               && (insn & 0x0000ff00) == reg)
 245             {
 246               msize0 |= (insn << 8) & 0xff000000;
 247               msize0 |= (insn << 16) & 0x00ff0000;
 248               q += 4;
 249               insn = read_memory_integer (q, 4);
 250             }
 251           /* Check for sub msp,msp,<reg>.  */
 252           if ((insn & 0xffffff00) ==
 253                 (0x24000000|(MSP_HW_REGNUM<<16)|(MSP_HW_REGNUM<<8))
 254               && (insn & 0xff) == reg)
 255             {
 256               p = q + 4;
 257               if (msize != NULL)
 258                 *msize = msize0;
 259             }
 260         }
 261     }
 262
 263  done:
 264   if (msymbol != NULL)
 265     {
 266       if (mi == 0)
 267         {
 268           /* Add a new cache entry.  */
 269           mi = (struct prologue_info *)xmalloc (sizeof (struct prologue_info));
 270           msymbol -> info = (char *)mi;
 271           mi->rsize_valid = 0;
 272           mi->msize_valid = 0;
 273           mi->mfp_valid = 0;
 274         }
 275       /* else, cache entry exists, but info is incomplete.  */
 276       mi->pc = p;
 277       if (rsize != NULL)
 278         {
 279           mi->rsize = *rsize;
 280           mi->rsize_valid = 1;
 281         }
 282       if (msize != NULL)
 283         {
 284           mi->msize = *msize;
 285           mi->msize_valid = 1;
 286         }
 287       if (mfp_used != NULL)
 288         {
 289           mi->mfp_used = *mfp_used;
 290           mi->mfp_valid = 1;
 291         }
 292     }
 293   return p;
 294 }
 295
 296 /* Advance PC across any function entry prologue instructions
 297    to reach some "real" code.  */
 298
 299 CORE_ADDR
 300 skip_prologue (pc)
 301      CORE_ADDR pc;
 302 {
 303   return examine_prologue (pc, (unsigned *)NULL, (unsigned *)NULL,
 304                            (int *)NULL);
 305 }
 306 /*
 307  * Examine the one or two word tag at the beginning of a function.
 308  * The tag word is expect to be at 'p', if it is not there, we fail
 309  * by returning 0.  The documentation for the tag word was taken from
 310  * page 7-15 of the 29050 User's Manual.  We are assuming that the
 311  * m bit is in bit 22 of the tag word, which seems to be the agreed upon
 312  * convention today (1/15/92).
 313  * msize is return in bytes.
 314  */
 315 static int      /* 0/1 - failure/success of finding the tag word  */
 316 examine_tag(p, is_trans, argcount, msize, mfp_used)
 317      CORE_ADDR p;
 318      int *is_trans;
 319      int   *argcount;
 320      unsigned *msize;
 321      int *mfp_used;
 322 {
 323   unsigned int tag1, tag2;
 324
 325   tag1 = read_memory_integer (p, 4);
 326   if ((tag1 & 0xff000000) != 0)         /* Not a tag word */
 327     return 0;
 328   if (tag1 & (1<<23))                   /* A two word tag */
 329     {
 330        tag2 = read_memory_integer (p+4, 4);
 331        if (msize)
 332          *msize = tag2;
 333     }
 334   else                                  /* A one word tag */
 335     {
 336        if (msize)
 337          *msize = tag1 & 0x7ff;
 338     }
 339   if (is_trans)
 340     *is_trans = ((tag1 & (1<<21)) ? 1 : 0);
 341   if (argcount)
 342     *argcount = (tag1 >> 16) & 0x1f;
 343   if (mfp_used)
 344     *mfp_used = ((tag1 & (1<<22)) ? 1 : 0);
 345   return(1);
 346 }
 347
 348 /* Initialize the frame.  In addition to setting "extra" frame info,
 349    we also set ->frame because we use it in a nonstandard way, and ->pc
 350    because we need to know it to get the other stuff.  See the diagram
 351    of stacks and the frame cache in tm-29k.h for more detail.  */
 352 static void
 353 init_frame_info (innermost_frame, fci)
 354      int innermost_frame;
 355      struct frame_info *fci;
 356 {
 357   CORE_ADDR p;
 358   long insn;
 359   unsigned rsize;
 360   unsigned msize;
 361   int mfp_used, trans;
 362   struct symbol *func;
 363
 364   p = fci->pc;
 365
 366   if (innermost_frame)
 367     fci->frame = read_register (GR1_REGNUM);
 368   else
 369     fci->frame = fci->next_frame + fci->next->rsize;
 370
 371 #if CALL_DUMMY_LOCATION == ON_STACK
 372   This wont work;
 373 #else
 374   if (PC_IN_CALL_DUMMY (p, 0, 0))
 375 #endif
 376     {
 377       fci->rsize = DUMMY_FRAME_RSIZE;
 378       /* This doesn't matter since we never try to get locals or args
 379          from a dummy frame.  */
 380       fci->msize = 0;
 381       /* Dummy frames always use a memory frame pointer.  */
 382       fci->saved_msp =
 383         read_register_stack_integer (fci->frame + DUMMY_FRAME_RSIZE - 4, 4);
 384       fci->flags |= (TRANSPARENT|MFP_USED);
 385       return;
 386     }
 387
 388   func = find_pc_function (p);
 389   if (func != NULL)
 390     p = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
 391   else
 392     {
 393       /* Search backward to find the trace-back tag.  However,
 394          do not trace back beyond the start of the text segment
 395          (just as a sanity check to avoid going into never-never land).  */
 396       while (p >= text_start
 397              && ((insn = read_memory_integer (p, 4)) & 0xff000000) != 0)
 398         p -= 4;
 399
 400       if (p < text_start)
 401         {
 402           /* Couldn't find the trace-back tag.
 403              Something strange is going on.  */
 404           fci->saved_msp = 0;
 405           fci->rsize = 0;
 406           fci->msize = 0;
 407           fci->flags = TRANSPARENT;
 408           return;
 409         }
 410       else
 411         /* Advance to the first word of the function, i.e. the word
 412            after the trace-back tag.  */
 413         p += 4;
 414     }
 415   /* We've found the start of the function.
 416    * Try looking for a tag word that indicates whether there is a
 417    * memory frame pointer and what the memory stack allocation is.
 418    * If one doesn't exist, try using a more exhaustive search of
 419    * the prologue.  For now we don't care about the argcount or
 420    * whether or not the routine is transparent.
 421    */
 422   if (examine_tag(p-4,&trans,NULL,&msize,&mfp_used)) /* Found a good tag */
 423       examine_prologue (p, &rsize, 0, 0);
 424   else                                          /* No tag try prologue */
 425       examine_prologue (p, &rsize, &msize, &mfp_used);
 426
 427   fci->rsize = rsize;
 428   fci->msize = msize;
 429   fci->flags = 0;
 430   if (mfp_used)
 431         fci->flags |= MFP_USED;
 432   if (trans)
 433         fci->flags |= TRANSPARENT;
 434   if (innermost_frame)
 435     {
 436       fci->saved_msp = read_register (MSP_REGNUM) + msize;
 437     }
 438   else
 439     {
 440       if (mfp_used)
 441          fci->saved_msp =
 442               read_register_stack_integer (fci->frame + rsize - 4, 4);
 443       else
 444             fci->saved_msp = fci->next->saved_msp + msize;
 445     }
 446 }
 447
 448 void
 449 init_extra_frame_info (fci)
 450      struct frame_info *fci;
 451 {
 452   if (fci->next == 0)
 453     /* Assume innermost frame.  May produce strange results for "info frame"
 454        but there isn't any way to tell the difference.  */
 455     init_frame_info (1, fci);
 456   else {
 457       /* We're in get_prev_frame_info.
 458          Take care of everything in init_frame_pc.  */
 459       ;
 460     }
 461 }
 462
 463 void
 464 init_frame_pc (fromleaf, fci)
 465      int fromleaf;
 466      struct frame_info *fci;
 467 {
 468   fci->pc = (fromleaf ? SAVED_PC_AFTER_CALL (fci->next) :
 469              fci->next ? FRAME_SAVED_PC (fci->next) : read_pc ());
 470   init_frame_info (fromleaf, fci);
 471 }
 472 \f
 473 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
 474    offsets being relative to the memory stack pointer (high C) or
 475    saved_msp (gcc).  */
 476
 477 CORE_ADDR
 478 frame_locals_address (fi)
 479      struct frame_info *fi;
 480 {
 481   if (fi->flags & MFP_USED)
 482     return fi->saved_msp;
 483   else
 484     return fi->saved_msp - fi->msize;
 485 }
 486 \f
 487 /* Routines for reading the register stack.  The caller gets to treat
 488    the register stack as a uniform stack in memory, from address $gr1
 489    straight through $rfb and beyond.  */
 490
 491 /* Analogous to read_memory except the length is understood to be 4.
 492    Also, myaddr can be NULL (meaning don't bother to read), and
 493    if actual_mem_addr is non-NULL, store there the address that it
 494    was fetched from (or if from a register the offset within
 495    registers).  Set *LVAL to lval_memory or lval_register, depending
 496    on where it came from.  */
 497 void
 498 read_register_stack (memaddr, myaddr, actual_mem_addr, lval)
 499      CORE_ADDR memaddr;
 500      char *myaddr;
 501      CORE_ADDR *actual_mem_addr;
 502      enum lval_type *lval;
 503 {
 504   long rfb = read_register (RFB_REGNUM);
 505   long rsp = read_register (RSP_REGNUM);
 506
 507 #ifdef RSTACK_HIGH_ADDR /* Highest allowed address in register stack */
 508   /* If we don't do this 'info register' stops in the middle. */
 509   if (memaddr >= RSTACK_HIGH_ADDR)
 510     {
 511       int val=-1;                       /* a bogus value */
 512       /* It's in a local register, but off the end of the stack.  */
 513       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 514       if (myaddr != NULL)
 515         *(int*)myaddr = val;            /* Provide bogusness */
 516       supply_register(regnum,&val);     /* More bogusness */
 517       if (lval != NULL)
 518         *lval = lval_register;
 519       if (actual_mem_addr != NULL)
 520         *actual_mem_addr = REGISTER_BYTE (regnum);
 521     }
 522   else
 523 #endif  /* RSTACK_HIGH_ADDR */
 524   if (memaddr < rfb)
 525     {
 526       /* It's in a register.  */
 527       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 528       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127)
 529         error ("Attempt to read register stack out of range.");
 530       if (myaddr != NULL)
 531         read_register_gen (regnum, myaddr);
 532       if (lval != NULL)
 533         *lval = lval_register;
 534       if (actual_mem_addr != NULL)
 535         *actual_mem_addr = REGISTER_BYTE (regnum);
 536     }
 537   else
 538     {
 539       /* It's in the memory portion of the register stack.  */
 540       if (myaddr != NULL)
 541            read_memory (memaddr, myaddr, 4);
 542       if (lval != NULL)
 543         *lval = lval_memory;
 544       if (actual_mem_addr != NULL)
 545         *actual_mem_addr = memaddr;
 546     }
 547 }
 548
 549 /* Analogous to read_memory_integer
 550    except the length is understood to be 4.  */
 551 long
 552 read_register_stack_integer (memaddr, len)
 553      CORE_ADDR memaddr;
 554      int len;
 555 {
 556   long buf;
 557   read_register_stack (memaddr, &buf, NULL, NULL);
 558   SWAP_TARGET_AND_HOST (&buf, 4);
 559   return buf;
 560 }
 561
 562 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
 563    at MEMADDR and put the actual address written into in
 564    *ACTUAL_MEM_ADDR.  */
 565 static void
 566 write_register_stack (memaddr, myaddr, actual_mem_addr)
 567      CORE_ADDR memaddr;
 568      char *myaddr;
 569      CORE_ADDR *actual_mem_addr;
 570 {
 571   long rfb = read_register (RFB_REGNUM);
 572   long rsp = read_register (RSP_REGNUM);
 573 #ifdef RSTACK_HIGH_ADDR /* Highest allowed address in register stack */
 574   /* If we don't do this 'info register' stops in the middle. */
 575   if (memaddr >= RSTACK_HIGH_ADDR)
 576     {
 577       /* It's in a register, but off the end of the stack.  */
 578       if (actual_mem_addr != NULL)
 579         *actual_mem_addr = NULL;
 580     }
 581   else
 582 #endif  /* RSTACK_HIGH_ADDR */
 583   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