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 "symtab.h"
  27 #include "inferior.h"
  28
  29 extern CORE_ADDR text_start;    /* FIXME, kludge... */
  30
  31 /* Structure to hold cached info about function prologues.  */
  32 struct prologue_info
  33 {
  34   CORE_ADDR pc;                 /* First addr after fn prologue */
  35   unsigned rsize, msize;        /* register stack frame size, mem stack ditto */
  36   unsigned mfp_used : 1;        /* memory frame pointer used */
  37   unsigned rsize_valid : 1;     /* Validity bits for the above */
  38   unsigned msize_valid : 1;
  39   unsigned mfp_valid : 1;
  40 };
  41
  42 /* Examine the prologue of a function which starts at PC.  Return
  43    the first addess past the prologue.  If MSIZE is non-NULL, then
  44    set *MSIZE to the memory stack frame size.  If RSIZE is non-NULL,
  45    then set *RSIZE to the register stack frame size (not including
  46    incoming arguments and the return address & frame pointer stored
  47    with them).  If no prologue is found, *RSIZE is set to zero.
  48    If no prologue is found, or a prologue which doesn't involve
  49    allocating a memory stack frame, then set *MSIZE to zero.
  50
  51    Note that both msize and rsize are in bytes.  This is not consistent
  52    with the _User's Manual_ with respect to rsize, but it is much more
  53    convenient.
  54
  55    If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory
  56    frame pointer is being used.  */
  57 CORE_ADDR
  58 examine_prologue (pc, rsize, msize, mfp_used)
  59      CORE_ADDR pc;
  60      unsigned *msize;
  61      unsigned *rsize;
  62      int *mfp_used;
  63 {
  64   long insn;
  65   CORE_ADDR p = pc;
  66   int misc_index = find_pc_misc_function (pc);
  67   struct prologue_info *mi = 0;
  68
  69   if (misc_index >= 0)
  70     mi = (struct prologue_info *)misc_function_vector[misc_index].misc_info;
  71
  72   if (mi != 0)
  73     {
  74       int valid = 1;
  75       if (rsize != NULL)
  76         {
  77           *rsize = mi->rsize;
  78           valid &= mi->rsize_valid;
  79         }
  80       if (msize != NULL)
  81         {
  82           *msize = mi->msize;
  83           valid &= mi->msize_valid;
  84         }
  85       if (mfp_used != NULL)
  86         {
  87           *mfp_used = mi->mfp_used;
  88           valid &= mi->mfp_valid;
  89         }
  90       if (valid)
  91         return mi->pc;
  92     }
  93
  94   if (rsize != NULL)
  95     *rsize = 0;
  96   if (msize != NULL)
  97     *msize = 0;
  98   if (mfp_used != NULL)
  99     *mfp_used = 0;
 100
 101   /* Prologue must start with subtracting a constant from gr1.
 102      Normally this is sub gr1,gr1,<rsize * 4>.  */
 103   insn = read_memory_integer (p, 4);
 104   if ((insn & 0xffffff00) != 0x25010100)
 105     {
 106       /* If the frame is large, instead of a single instruction it
 107          might be a pair of instructions:
 108          const <reg>, <rsize * 4>
 109          sub gr1,gr1,<reg>
 110          */
 111       int reg;
 112       /* Possible value for rsize.  */
 113       unsigned int rsize0;
 114
 115       if ((insn & 0xff000000) != 0x03000000)
 116         {
 117           p = pc;
 118           goto done;
 119         }
 120       reg = (insn >> 8) & 0xff;
 121       rsize0 = (((insn >> 8) & 0xff00) | (insn & 0xff));
 122       p += 4;
 123       insn = read_memory_integer (p, 4);
 124       if ((insn & 0xffffff00) != 0x24010100
 125           || (insn & 0xff) != reg)
 126         {
 127           p = pc;
 128           goto done;
 129         }
 130       if (rsize != NULL)
 131         *rsize = rsize0;
 132     }
 133   else
 134     {
 135       if (rsize != NULL)
 136         *rsize = (insn & 0xff);
 137     }
 138   p += 4;
 139
 140   /* Next instruction must be asgeu V_SPILL,gr1,rab.  */
 141   insn = read_memory_integer (p, 4);
 142   if (insn != 0x5e40017e)
 143     {
 144       p = pc;
 145       goto done;
 146     }
 147   p += 4;
 148
 149   /* Next instruction usually sets the frame pointer (lr1) by adding
 150      <size * 4> from gr1.  However, this can (and high C does) be
 151      deferred until anytime before the first function call.  So it is
 152      OK if we don't see anything which sets lr1.  */
 153   /* Normally this is just add lr1,gr1,<size * 4>.  */
 154   insn = read_memory_integer (p, 4);
 155   if ((insn & 0xffffff00) == 0x15810100)
 156     p += 4;
 157   else
 158     {
 159       /* However, for large frames it can be
 160          const <reg>, <size *4>
 161          add lr1,gr1,<reg>
 162          */
 163       int reg;
 164       CORE_ADDR q;
 165
 166       if ((insn & 0xff000000) == 0x03000000)
 167         {
 168           reg = (insn >> 8) & 0xff;
 169           q = p + 4;
 170           insn = read_memory_integer (q, 4);
 171           if ((insn & 0xffffff00) == 0x14810100
 172               && (insn & 0xff) == reg)
 173             p = q;
 174         }
 175     }
 176
 177   /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory
 178      frame pointer is in use.  We just check for add lr<anything>,msp,0;
 179      we don't check this rsize against the first instruction, and
 180      we don't check that the trace-back tag indicates a memory frame pointer
 181      is in use.
 182
 183      The recommended instruction is actually "sll lr<whatever>,msp,0".
 184      We check for that, too.  Originally Jim Kingdon's code seemed
 185      to be looking for a "sub" instruction here, but the mask was set
 186      up to lose all the time. */
 187   insn = read_memory_integer (p, 4);
 188   if (((insn & 0xff80ffff) == 0x15807d00)       /* add */
 189    || ((insn & 0xff80ffff) == 0x81807d00) )     /* sll */
 190     {
 191       p += 4;
 192       if (mfp_used != NULL)
 193         *mfp_used = 1;
 194     }
 195
 196   /* Next comes a subtraction from msp to allocate a memory frame,
 197      but only if a memory frame is
 198      being used.  We don't check msize against the trace-back tag.
 199
 200      Normally this is just
 201      sub msp,msp,<msize>
 202      */
 203   insn = read_memory_integer (p, 4);
 204   if ((insn & 0xffffff00) == 0x257d7d00)
 205     {
 206       p += 4;
 207       if (msize != NULL)
 208         *msize = insn & 0xff;
 209     }
 210   else
 211     {
 212       /* For large frames, instead of a single instruction it might
 213          be
 214
 215          const <reg>, <msize>
 216          consth <reg>, <msize>     ; optional
 217          sub msp,msp,<reg>
 218          */
 219       int reg;
 220       unsigned msize0;
 221       CORE_ADDR q = p;
 222
 223       if ((insn & 0xff000000) == 0x03000000)
 224         {
 225           reg = (insn >> 8) & 0xff;
 226           msize0 = ((insn >> 8) & 0xff00) | (insn & 0xff);
 227           q += 4;
 228           insn = read_memory_integer (q, 4);
 229           /* Check for consth.  */
 230           if ((insn & 0xff000000) == 0x02000000
 231               && (insn & 0x0000ff00) == reg)
 232             {
 233               msize0 |= (insn << 8) & 0xff000000;
 234               msize0 |= (insn << 16) & 0x00ff0000;
 235               q += 4;
 236               insn = read_memory_integer (q, 4);
 237             }
 238           /* Check for sub msp,msp,<reg>.  */
 239           if ((insn & 0xffffff00) == 0x247d7d00
 240               && (insn & 0xff) == reg)
 241             {
 242               p = q + 4;
 243               if (msize != NULL)
 244                 *msize = msize0;
 245             }
 246         }
 247     }
 248
 249  done:
 250   if (misc_index >= 0)
 251     {
 252       if (mi == 0)
 253         {
 254           /* Add a new cache entry.  */
 255           mi = (struct prologue_info *)xmalloc (sizeof (struct prologue_info));
 256           misc_function_vector[misc_index].misc_info = (char *)mi;
 257           mi->rsize_valid = 0;
 258           mi->msize_valid = 0;
 259           mi->mfp_valid = 0;
 260         }
 261       /* else, cache entry exists, but info is incomplete.  */
 262       mi->pc = p;
 263       if (rsize != NULL)
 264         {
 265           mi->rsize = *rsize;
 266           mi->rsize_valid = 1;
 267         }
 268       if (msize != NULL)
 269         {
 270           mi->msize = *msize;
 271           mi->msize_valid = 1;
 272         }
 273       if (mfp_used != NULL)
 274         {
 275           mi->mfp_used = *mfp_used;
 276           mi->mfp_valid = 1;
 277         }
 278     }
 279   return p;
 280 }
 281
 282 /* Advance PC across any function entry prologue instructions
 283    to reach some "real" code.  */
 284
 285 CORE_ADDR
 286 skip_prologue (pc)
 287      CORE_ADDR pc;
 288 {
 289   return examine_prologue (pc, (unsigned *)NULL, (unsigned *)NULL,
 290                            (int *)NULL);
 291 }
 292
 293 /* Initialize the frame.  In addition to setting "extra" frame info,
 294    we also set ->frame because we use it in a nonstandard way, and ->pc
 295    because we need to know it to get the other stuff.  See the diagram
 296    of stacks and the frame cache in tm-29k.h for more detail.  */
 297 static void
 298 init_frame_info (innermost_frame, fci)
 299      int innermost_frame;
 300      struct frame_info *fci;
 301 {
 302   CORE_ADDR p;
 303   long insn;
 304   unsigned rsize;
 305   unsigned msize;
 306   int mfp_used;
 307   struct symbol *func;
 308
 309   p = fci->pc;
 310
 311   if (innermost_frame)
 312     fci->frame = read_register (GR1_REGNUM);
 313   else
 314     fci->frame = fci->next_frame + fci->next->rsize;
 315
 316 #if CALL_DUMMY_LOCATION == ON_STACK
 317   This wont work;
 318 #else
 319   if (PC_IN_CALL_DUMMY (p, 0, 0))
 320 #endif
 321     {
 322       fci->rsize = DUMMY_FRAME_RSIZE;
 323       /* This doesn't matter since we never try to get locals or args
 324          from a dummy frame.  */
 325       fci->msize = 0;
 326       /* Dummy frames always use a memory frame pointer.  */
 327       fci->saved_msp =
 328         read_register_stack_integer (fci->frame + DUMMY_FRAME_RSIZE - 4, 4);
 329       return;
 330     }
 331
 332   func = find_pc_function (p);
 333   if (func != NULL)
 334     p = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
 335   else
 336     {
 337       /* Search backward to find the trace-back tag.  However,
 338          do not trace back beyond the start of the text segment
 339          (just as a sanity check to avoid going into never-never land).  */
 340       while (p >= text_start
 341              && ((insn = read_memory_integer (p, 4)) & 0xff000000) != 0)
 342         p -= 4;
 343
 344       if (p < text_start)
 345         {
 346           /* Couldn't find the trace-back tag.
 347              Something strange is going on.  */
 348           fci->saved_msp = 0;
 349           fci->rsize = 0;
 350           fci->msize = 0;
 351           return;
 352         }
 353       else
 354         /* Advance to the first word of the function, i.e. the word
 355            after the trace-back tag.  */
 356         p += 4;
 357     }
 358   /* We've found the start of the function.  Since High C interchanges
 359      the meanings of bits 23 and 22 (as of Jul 90), and we
 360      need to look at the prologue anyway to figure out
 361      what rsize is, ignore the contents of the trace-back tag.  */
 362   examine_prologue (p, &rsize, &msize, &mfp_used);
 363   fci->rsize = rsize;
 364   fci->msize = msize;
 365   if (innermost_frame)
 366     {
 367       fci->saved_msp = read_register (MSP_REGNUM) + msize;
 368     }
 369   else
 370     {
 371       if (mfp_used)
 372         fci->saved_msp =
 373           read_register_stack_integer (fci->frame + rsize - 1, 4);
 374       else
 375         fci->saved_msp = fci->next->saved_msp + msize;
 376     }
 377 }
 378
 379 void
 380 init_extra_frame_info (fci)
 381      struct frame_info *fci;
 382 {
 383   if (fci->next == 0)
 384     /* Assume innermost frame.  May produce strange results for "info frame"
 385        but there isn't any way to tell the difference.  */
 386     init_frame_info (1, fci);
 387   else {
 388       /* We're in get_prev_frame_info.
 389          Take care of everything in init_frame_pc.  */
 390       ;
 391     }
 392 }
 393
 394 void
 395 init_frame_pc (fromleaf, fci)
 396      int fromleaf;
 397      struct frame_info *fci;
 398 {
 399   fci->pc = (fromleaf ? SAVED_PC_AFTER_CALL (fci->next) :
 400              fci->next ? FRAME_SAVED_PC (fci->next) : read_pc ());
 401   init_frame_info (0, fci);
 402 }
 403 \f
 404 /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their
 405    offsets being relative to the memory stack pointer (high C) or
 406    saved_msp (gcc).  */
 407
 408 CORE_ADDR
 409 frame_locals_address (fi)
 410      struct frame_info *fi;
 411 {
 412   struct block *b = block_for_pc (fi->pc);
 413   /* If compiled without -g, assume GCC.  */
 414   if (b == NULL || BLOCK_GCC_COMPILED (b))
 415     return fi->saved_msp;
 416   else
 417     return fi->saved_msp - fi->msize;
 418 }
 419 \f
 420 /* Routines for reading the register stack.  The caller gets to treat
 421    the register stack as a uniform stack in memory, from address $gr1
 422    straight through $rfb and beyond.  */
 423
 424 /* Analogous to read_memory except the length is understood to be 4.
 425    Also, myaddr can be NULL (meaning don't bother to read), and
 426    if actual_mem_addr is non-NULL, store there the address that it
 427    was fetched from (or if from a register the offset within
 428    registers).  Set *LVAL to lval_memory or lval_register, depending
 429    on where it came from.  */
 430 void
 431 read_register_stack (memaddr, myaddr, actual_mem_addr, lval)
 432      CORE_ADDR memaddr;
 433      char *myaddr;
 434      CORE_ADDR *actual_mem_addr;
 435      enum lval_type *lval;
 436 {
 437   long rfb = read_register (RFB_REGNUM);
 438   long rsp = read_register (RSP_REGNUM);
 439   if (memaddr < rfb)
 440     {
 441       /* It's in a register.  */
 442       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 443       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127)
 444         error ("Attempt to read register stack out of range.");
 445       if (myaddr != NULL)
 446         read_register_gen (regnum, myaddr);
 447       if (lval != NULL)
 448         *lval = lval_register;
 449       if (actual_mem_addr != NULL)
 450         *actual_mem_addr = REGISTER_BYTE (regnum);
 451     }
 452   else
 453     {
 454       /* It's in the memory portion of the register stack.  */
 455       if (myaddr != NULL)
 456         read_memory (memaddr, myaddr, 4);
 457       if (lval != NULL)
 458         *lval = lval_memory;
 459       if (actual_mem_addr != NULL)
 460         *actual_mem_addr = memaddr;
 461     }
 462 }
 463
 464 /* Analogous to read_memory_integer
 465    except the length is understood to be 4.  */
 466 long
 467 read_register_stack_integer (memaddr, len)
 468      CORE_ADDR memaddr;
 469      int len;
 470 {
 471   long buf;
 472   read_register_stack (memaddr, &buf, NULL, NULL);
 473   SWAP_TARGET_AND_HOST (&buf, 4);
 474   return buf;
 475 }
 476
 477 /* Copy 4 bytes from GDB memory at MYADDR into inferior memory
 478    at MEMADDR and put the actual address written into in
 479    *ACTUAL_MEM_ADDR.  */
 480 static void
 481 write_register_stack (memaddr, myaddr, actual_mem_addr)
 482      CORE_ADDR memaddr;
 483      char *myaddr;
 484      CORE_ADDR *actual_mem_addr;
 485 {
 486   long rfb = read_register (RFB_REGNUM);
 487   long rsp = read_register (RSP_REGNUM);
 488   if (memaddr < rfb)
 489     {
 490       /* It's in a register.  */
 491       int regnum = (memaddr - rsp) / 4 + LR0_REGNUM;
 492       if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127)
 493         error ("Attempt to read register stack out of range.");
 494       if (myaddr != NULL)
 495         write_register (regnum, *(long *)myaddr);
 496       if (actual_mem_addr != NULL)
 497         *actual_mem_addr = NULL;
 498     }
 499   else
 500     {
 501       /* It's in the memory portion of the register stack.  */
 502       if (myaddr != NULL)
 503         write_memory (memaddr, myaddr, 4);
 504       if (actual_mem_addr != NULL)
 505         *actual_mem_addr = memaddr;
 506     }
 507 }
 508 \f
 509 /* Find register number REGNUM relative to FRAME and put its
 510    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
 511    was optimized out (and thus can't be fetched).  If the variable
 512    was fetched from memory, set *ADDRP to where it was fetched from,
 513    otherwise it was fetched from a register.
 514
 515    The argument RAW_BUFFER must point to aligned memory.  */
 516 void
 517 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lvalp)
 518      char *raw_buffer;
 519      int *optimized;
 520      CORE_ADDR *addrp;
 521      FRAME frame;
 522      int regnum;
 523      enum lval_type *lvalp;
 524 {
 525   struct frame_info *fi = get_frame_info (frame);
 526   CORE_ADDR addr;
 527   enum lval_type lval;
 528
 529   /* Once something has a register number, it doesn't get optimized out.  */
 530   if (optimized != NULL)
 531     *optimized = 0;
 532   if (regnum == RSP_REGNUM)
 533     {
 534       if (raw_buffer != NULL)
 535         *(CORE_ADDR *)raw_buffer = fi->frame;
 536       if (lvalp != NULL)
 537         *lvalp = not_lval;
 538       return;
 539     }
 540   else if (regnum == PC_REGNUM)
 541     {
 542       if (raw_buffer != NULL)
 543         *(CORE_ADDR *)raw_buffer = fi->pc;
 544
 545       /* Not sure we have to do this.  */
 546       if (lvalp != NULL)
 547         *lvalp = not_lval;
 548
 549       return;
 550     }
 551   else if (regnum == MSP_REGNUM)
 552     {
 553       if (raw_buffer != NULL)
 554         {
 555           if (fi->next != NULL)
 556             *(CORE_ADDR *)raw_buffer = fi->next->saved_msp;
 557           else
 558             *(CORE_ADDR *)raw_buffer = read_register (MSP_REGNUM);
 559         }
 560       /* The value may have been computed, not fetched.  */
 561       if (lvalp != NULL)
 562         *lvalp = not_lval;
 563       return;
 564     }
 565   else if (regnum < LR0_REGNUM || regnum >= LR0_REGNUM + 128)
 566     {
 567       /* These registers are not saved over procedure calls,
 568          so just print out the current values.  */
 569       if (raw_buffer != NULL)
 570         *(CORE_ADDR *)raw_buffer = read_register (regnum);
 571       if (lvalp != NULL)
 572         *lvalp = lval_register;
 573       if (addrp != NULL)
 574         *addrp = REGISTER_BYTE (regnum);
 575       return;
 576     }
 577
 578   addr = fi->frame + (regnum - LR0_REGNUM) * 4;
 579   if (raw_buffer != NULL)
 580     read_register_stack (addr, raw_buffer, &addr, &lval);
 581   if (lvalp != NULL)
 582     *lvalp = lval;
 583   if (addrp != NULL)
 584     *addrp = addr;
 585 }
 586 \f
 587 /* Discard from the stack the innermost frame,
 588    restoring all saved registers.  */
 589
 590 void
 591 pop_frame ()
 592 {
 593   FRAME frame = get_current_frame ();
 594   struct frame_info *fi = get_frame_info (frame);
 595   CORE_ADDR rfb = read_register (RFB_REGNUM);
 596   CORE_ADDR gr1 = fi->frame + fi->rsize;
 597   CORE_ADDR lr1;
 598   CORE_ADDR ret_addr;
 599   int i;
 600
 601   /* If popping a dummy frame, need to restore registers.  */
 602   if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM),
 603                         read_register (SP_REGNUM),
 604                         FRAME_FP (fi)))
 605     {
 606       for (i = 0; i < DUMMY_SAVE_SR128; ++i)
 607         write_register
 608           (SR_REGNUM (i + 128),
 609            read_register (LR0_REGNUM + DUMMY_ARG / 4 + i));
 610       for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
 611         write_register
 612           (RETURN_REGNUM + i,
 613            read_register (LR0_REGNUM + DUMMY_ARG / 4 + DUMMY_SAVE_SR128 + i));
 614     }
 615
 616   /* Restore the memory stack pointer.  */
 617   write_register (MSP_REGNUM, fi->saved_msp);
 618   /* Restore the register stack pointer.  */
 619   write_register (GR1_REGNUM, gr1);
 620   /* Check whether we need to fill registers.  */
 621   lr1 = read_register (LR0_REGNUM + 1);
 622   if (lr1 > rfb)
 623     {
 624       /* Fill.  */
 625       int num_bytes = lr1 - rfb;
 626       int i;
 627       long word;
 628       write_register (RAB_REGNUM, read_register (RAB_REGNUM) + num_bytes);
 629       write_register (RFB_REGNUM, lr1);
 630       for (i = 0; i < num_bytes; i += 4)
 631         {
 632           /* Note: word is in host byte order.  */
 633           word = read_memory_integer (rfb + i, 4);
 634           write_register (LR0_REGNUM + ((rfb - gr1) % 0x80) + i / 4, word);
 635         }
 636     }
 637   ret_addr = read_register (LR0_REGNUM);
 638   write_register (PC_REGNUM, ret_addr);
 639   write_register (NPC_REGNUM, ret_addr + 4);
 640   flush_cached_frames ();
 641   set_current_frame (create_new_frame (0, read_pc()));
 642 }
 643
 644 /* Push an empty stack frame, to record the current PC, etc.  */
 645
 646 void
 647 push_dummy_frame ()
 648 {
 649   long w;
 650   CORE_ADDR rab, gr1;
 651   CORE_ADDR msp = read_register (MSP_REGNUM);
 652   int i;
 653
 654   /* Save the PC.  */
 655   write_register (LR0_REGNUM, read_register (PC_REGNUM));
 656
 657   /* Allocate the new frame.  */
 658   gr1 = read_register (GR1_REGNUM) - DUMMY_FRAME_RSIZE;
 659   write_register (GR1_REGNUM, gr1);
 660
 661   rab = read_register (RAB_REGNUM);
 662   if (gr1 < rab)
 663     {
 664       /* We need to spill registers.  */
 665       int num_bytes = rab - gr1;
 666       CORE_ADDR rfb = read_register (RFB_REGNUM);
 667       int i;
 668       long word;
 669
 670       write_register (RFB_REGNUM, rfb - num_bytes);
 671       write_register (RAB_REGNUM, gr1);
 672       for (i = 0; i < num_bytes; i += 4)
 673         {
 674           /* Note:  word is in target byte order.  */
 675           read_register_gen (LR0_REGNUM + i / 4, &word, 4);
 676           write_memory (rfb - num_bytes + i, &word, 4);
 677         }
 678     }
 679
 680   /* There are no arguments in to the dummy frame, so we don't need
 681      more than rsize plus the return address and lr1.  */
 682   write_register (LR0_REGNUM + 1, gr1 + DUMMY_FRAME_RSIZE + 2 * 4);
 683
 684   /* Set the memory frame pointer.  */
 685   write_register (LR0_REGNUM + DUMMY_FRAME_RSIZE / 4 - 1, msp);
 686
 687   /* Allocate arg_slop.  */
 688   write_register (MSP_REGNUM, msp - 16 * 4);
 689
 690   /* Save registers.  */
 691   for (i = 0; i < DUMMY_SAVE_SR128; ++i)
 692     write_register (LR0_REGNUM + DUMMY_ARG / 4 + i,
 693                     read_register (SR_REGNUM (i + 128)));
 694   for (i = 0; i < DUMMY_SAVE_GREGS; ++i)
 695     write_register (LR0_REGNUM + DUMMY_ARG / 4 + DUMMY_SAVE_SR128 + i,
 696                     read_register (RETURN_REGNUM + i));
 697 }