gdb/am29k-tdep.c

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