gdb/m88k-tdep.c

   1 /* Target-machine dependent code for Motorola 88000 series, for GDB.
   2    Copyright 1988, 1990, 1991, 1994, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "value.h"
  24 #include "gdbcore.h"
  25 #include "symtab.h"
  26 #include "setjmp.h"
  27 #include "value.h"
  28
  29 /* Size of an instruction */
  30 #define BYTES_PER_88K_INSN      4
  31
  32 void frame_find_saved_regs ();
  33
  34 /* Is this target an m88110?  Otherwise assume m88100.  This has
  35    relevance for the ways in which we screw with instruction pointers.  */
  36
  37 int target_is_m88110 = 0;
  38
  39 /* The m88k kernel aligns all instructions on 4-byte boundaries.  The
  40    kernel also uses the least significant two bits for its own hocus
  41    pocus.  When gdb receives an address from the kernel, it needs to
  42    preserve those right-most two bits, but gdb also needs to be careful
  43    to realize that those two bits are not really a part of the address
  44    of an instruction.  Shrug.  */
  45
  46 CORE_ADDR
  47 m88k_addr_bits_remove (addr)
  48      CORE_ADDR addr;
  49 {
  50   return ((addr) & ~3);
  51 }
  52
  53
  54 /* Given a GDB frame, determine the address of the calling function's frame.
  55    This will be used to create a new GDB frame struct, and then
  56    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
  57
  58    For us, the frame address is its stack pointer value, so we look up
  59    the function prologue to determine the caller's sp value, and return it.  */
  60
  61 CORE_ADDR
  62 frame_chain (thisframe)
  63      struct frame_info *thisframe;
  64 {
  65
  66   frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
  67   /* NOTE:  this depends on frame_find_saved_regs returning the VALUE, not
  68             the ADDRESS, of SP_REGNUM.  It also depends on the cache of
  69             frame_find_saved_regs results.  */
  70   if (thisframe->fsr->regs[SP_REGNUM])
  71     return thisframe->fsr->regs[SP_REGNUM];
  72   else
  73     return thisframe->frame;    /* Leaf fn -- next frame up has same SP. */
  74 }
  75
  76 int
  77 frameless_function_invocation (frame)
  78      struct frame_info *frame;
  79 {
  80
  81   frame_find_saved_regs (frame, (struct frame_saved_regs *) 0);
  82   /* NOTE:  this depends on frame_find_saved_regs returning the VALUE, not
  83             the ADDRESS, of SP_REGNUM.  It also depends on the cache of
  84             frame_find_saved_regs results.  */
  85   if (frame->fsr->regs[SP_REGNUM])
  86     return 0;                   /* Frameful -- return addr saved somewhere */
  87   else
  88     return 1;                   /* Frameless -- no saved return address */
  89 }
  90
  91 void
  92 init_extra_frame_info (fromleaf, frame)
  93      int fromleaf;
  94      struct frame_info *frame;
  95 {
  96   frame->fsr = 0;                       /* Not yet allocated */
  97   frame->args_pointer = 0;              /* Unknown */
  98   frame->locals_pointer = 0;    /* Unknown */
  99 }
 100 \f
 101 /* Examine an m88k function prologue, recording the addresses at which
 102    registers are saved explicitly by the prologue code, and returning
 103    the address of the first instruction after the prologue (but not
 104    after the instruction at address LIMIT, as explained below).
 105
 106    LIMIT places an upper bound on addresses of the instructions to be
 107    examined.  If the prologue code scan reaches LIMIT, the scan is
 108    aborted and LIMIT is returned.  This is used, when examining the
 109    prologue for the current frame, to keep examine_prologue () from
 110    claiming that a given register has been saved when in fact the
 111    instruction that saves it has not yet been executed.  LIMIT is used
 112    at other times to stop the scan when we hit code after the true
 113    function prologue (e.g. for the first source line) which might
 114    otherwise be mistaken for function prologue.
 115
 116    The format of the function prologue matched by this routine is
 117    derived from examination of the source to gcc 1.95, particularly
 118    the routine output_prologue () in config/out-m88k.c.
 119
 120    subu r31,r31,n                       # stack pointer update
 121
 122    (st rn,r31,offset)?                  # save incoming regs
 123    (st.d rn,r31,offset)?
 124
 125    (addu r30,r31,n)?                    # frame pointer update
 126
 127    (pic sequence)?                      # PIC code prologue
 128
 129    (or   rn,rm,0)?                      # Move parameters to other regs
 130 */
 131
 132 /* Macros for extracting fields from instructions.  */
 133
 134 #define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos))
 135 #define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width))
 136 #define SUBU_OFFSET(x)  ((unsigned)(x & 0xFFFF))
 137 #define ST_OFFSET(x)    ((unsigned)((x) & 0xFFFF))
 138 #define ST_SRC(x)       EXTRACT_FIELD ((x), 21, 5)
 139 #define ADDU_OFFSET(x)  ((unsigned)(x & 0xFFFF))
 140
 141 /*
 142  * prologue_insn_tbl is a table of instructions which may comprise a
 143  * function prologue.  Associated with each table entry (corresponding
 144  * to a single instruction or group of instructions), is an action.
 145  * This action is used by examine_prologue (below) to determine
 146  * the state of certain machine registers and where the stack frame lives.
 147  */
 148
 149 enum prologue_insn_action {
 150   PIA_SKIP,                     /* don't care what the instruction does */
 151   PIA_NOTE_ST,                  /* note register stored and where */
 152   PIA_NOTE_STD,                 /* note pair of registers stored and where */
 153   PIA_NOTE_SP_ADJUSTMENT,       /* note stack pointer adjustment */
 154   PIA_NOTE_FP_ASSIGNMENT,       /* note frame pointer assignment */
 155   PIA_NOTE_PROLOGUE_END,        /* no more prologue */
 156 };
 157
 158 struct prologue_insns {
 159     unsigned long insn;
 160     unsigned long mask;
 161     enum prologue_insn_action action;
 162 };
 163
 164 struct prologue_insns prologue_insn_tbl[] = {
 165   /* Various register move instructions */
 166   { 0x58000000, 0xf800ffff, PIA_SKIP },         /* or/or.u with immed of 0 */
 167   { 0xf4005800, 0xfc1fffe0, PIA_SKIP },         /* or rd, r0, rs */
 168   { 0xf4005800, 0xfc00ffff, PIA_SKIP },         /* or rd, rs, r0 */
 169
 170   /* Stack pointer setup: "subu sp, sp, n" where n is a multiple of 8 */
 171   { 0x67ff0000, 0xffff0007, PIA_NOTE_SP_ADJUSTMENT },
 172
 173   /* Frame pointer assignment: "addu r30, r31, n" */
 174   { 0x63df0000, 0xffff0000, PIA_NOTE_FP_ASSIGNMENT },
 175
 176   /* Store to stack instructions; either "st rx, sp, n" or "st.d rx, sp, n" */
 177   { 0x241f0000, 0xfc1f0000, PIA_NOTE_ST },      /* st rx, sp, n */
 178   { 0x201f0000, 0xfc1f0000, PIA_NOTE_STD },     /* st.d rs, sp, n */
 179
 180   /* Instructions needed for setting up r25 for pic code. */
 181   { 0x5f200000, 0xffff0000, PIA_SKIP },         /* or.u r25, r0, offset_high */
 182   { 0xcc000002, 0xffffffff, PIA_SKIP },         /* bsr.n Lab */
 183   { 0x5b390000, 0xffff0000, PIA_SKIP },         /* or r25, r25, offset_low */
 184   { 0xf7396001, 0xffffffff, PIA_SKIP },         /* Lab: addu r25, r25, r1 */
 185
 186   /* Various branch or jump instructions which have a delay slot -- these
 187      do not form part of the prologue, but the instruction in the delay
 188      slot might be a store instruction which should be noted. */
 189   { 0xc4000000, 0xe4000000, PIA_NOTE_PROLOGUE_END },
 190                                         /* br.n, bsr.n, bb0.n, or bb1.n */
 191   { 0xec000000, 0xfc000000, PIA_NOTE_PROLOGUE_END }, /* bcnd.n */
 192   { 0xf400c400, 0xfffff7e0, PIA_NOTE_PROLOGUE_END } /* jmp.n or jsr.n */
 193
 194 };
 195
 196
 197 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
 198    is not the address of a valid instruction, the address of the next
 199    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
 200    of the instruction. */
 201
 202 #define NEXT_PROLOGUE_INSN(addr, lim, pword1) \
 203   (((addr) < (lim)) ? next_insn (addr, pword1) : 0)
 204
 205 /* Read the m88k instruction at 'memaddr' and return the address of
 206    the next instruction after that, or 0 if 'memaddr' is not the
 207    address of a valid instruction.  The instruction
 208    is stored at 'pword1'.  */
 209
 210 CORE_ADDR
 211 next_insn (memaddr, pword1)
 212      unsigned long *pword1;
 213      CORE_ADDR memaddr;
 214 {
 215   *pword1 = read_memory_integer (memaddr, BYTES_PER_88K_INSN);
 216   return memaddr + BYTES_PER_88K_INSN;
 217 }
 218
 219 /* Read a register from frames called by us (or from the hardware regs).  */
 220
 221 static int
 222 read_next_frame_reg(frame, regno)
 223      struct frame_info *frame;
 224      int regno;
 225 {
 226   for (; frame; frame = frame->next) {
 227       if (regno == SP_REGNUM)
 228         return FRAME_FP (frame);
 229       else if (frame->fsr->regs[regno])
 230         return read_memory_integer(frame->fsr->regs[regno], 4);
 231   }
 232   return read_register(regno);
 233 }
 234
 235 /* Examine the prologue of a function.  `ip' points to the first instruction.
 236    `limit' is the limit of the prologue (e.g. the addr of the first
 237    linenumber, or perhaps the program counter if we're stepping through).
 238    `frame_sp' is the stack pointer value in use in this frame.
 239    `fsr' is a pointer to a frame_saved_regs structure into which we put
 240    info about the registers saved by this frame.
 241    `fi' is a struct frame_info pointer; we fill in various fields in it
 242    to reflect the offsets of the arg pointer and the locals pointer.  */
 243
 244 static CORE_ADDR
 245 examine_prologue (ip, limit, frame_sp, fsr, fi)
 246      register CORE_ADDR ip;
 247      register CORE_ADDR limit;
 248      CORE_ADDR frame_sp;
 249      struct frame_saved_regs *fsr;
 250      struct frame_info *fi;
 251 {
 252   register CORE_ADDR next_ip;
 253   register int src;
 254   unsigned int insn;
 255   int size, offset;
 256   char must_adjust[32];         /* If set, must adjust offsets in fsr */
 257   int sp_offset = -1;           /* -1 means not set (valid must be mult of 8) */
 258   int fp_offset = -1;           /* -1 means not set */
 259   CORE_ADDR frame_fp;
 260   CORE_ADDR prologue_end = 0;
 261
 262   memset (must_adjust, '\0', sizeof (must_adjust));
 263   next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 264
 265   while (next_ip)
 266     {
 267       struct prologue_insns *pip;
 268
 269       for (pip=prologue_insn_tbl; (insn & pip->mask) != pip->insn; )
 270           if (++pip >= prologue_insn_tbl + sizeof prologue_insn_tbl)
 271               goto end_of_prologue_found;       /* not a prologue insn */
 272
 273       switch (pip->action)
 274         {
 275           case PIA_NOTE_ST:
 276           case PIA_NOTE_STD:
 277             if (sp_offset != -1) {
 278                 src = ST_SRC (insn);
 279                 offset = ST_OFFSET (insn);
 280                 must_adjust[src] = 1;
 281                 fsr->regs[src++] = offset;      /* Will be adjusted later */
 282                 if (pip->action == PIA_NOTE_STD && src < 32)
 283                   {
 284                     offset += 4;
 285                     must_adjust[src] = 1;
 286                     fsr->regs[src++] = offset;
 287                   }
 288             }
 289             else
 290                 goto end_of_prologue_found;
 291             break;
 292           case PIA_NOTE_SP_ADJUSTMENT:
 293             if (sp_offset == -1)
 294                 sp_offset = -SUBU_OFFSET (insn);
 295             else
 296                 goto end_of_prologue_found;
 297             break;
 298           case PIA_NOTE_FP_ASSIGNMENT:
 299             if (fp_offset == -1)
 300                 fp_offset = ADDU_OFFSET (insn);
 301             else
 302                 goto end_of_prologue_found;
 303             break;
 304           case PIA_NOTE_PROLOGUE_END:
 305             if (!prologue_end)
 306                 prologue_end = ip;
 307             break;
 308           case PIA_SKIP:
 309           default :
 310             /* Do nothing */
 311             break;
 312         }
 313
 314       ip = next_ip;
 315       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 316     }
 317
 318 end_of_prologue_found:
 319
 320     if (prologue_end)
 321         ip = prologue_end;
 322
 323   /* We're done with the prologue.  If we don't care about the stack
 324      frame itself, just return.  (Note that fsr->regs has been trashed,
 325      but the one caller who calls with fi==0 passes a dummy there.)  */
 326
 327   if (fi == 0)
 328     return ip;
 329
 330   /*
 331      OK, now we have:
 332
 333         sp_offset       original (before any alloca calls) displacement of SP
 334                         (will be negative).
 335
 336         fp_offset       displacement from original SP to the FP for this frame
 337                         or -1.
 338
 339         fsr->regs[0..31]        displacement from original SP to the stack
 340                                 location where reg[0..31] is stored.
 341
 342         must_adjust[0..31]      set if corresponding offset was set.
 343
 344      If alloca has been called between the function prologue and the current
 345      IP, then the current SP (frame_sp) will not be the original SP as set by
 346      the function prologue.  If the current SP is not the original SP, then the
 347      compiler will have allocated an FP for this frame, fp_offset will be set,
 348      and we can use it to calculate the original SP.
 349
 350      Then, we figure out where the arguments and locals are, and relocate the
 351      offsets in fsr->regs to absolute addresses.  */
 352
 353   if (fp_offset != -1) {
 354     /* We have a frame pointer, so get it, and base our calc's on it.  */
 355     frame_fp = (CORE_ADDR) read_next_frame_reg (fi->next, ACTUAL_FP_REGNUM);
 356     frame_sp = frame_fp - fp_offset;
 357   } else {
 358     /* We have no frame pointer, therefore frame_sp is still the same value
 359        as set by prologue.  But where is the frame itself?  */
 360     if (must_adjust[SRP_REGNUM]) {
 361       /* Function header saved SRP (r1), the return address.  Frame starts
 362          4 bytes down from where it was saved.  */
 363       frame_fp = frame_sp + fsr->regs[SRP_REGNUM] - 4;
 364       fi->locals_pointer = frame_fp;
 365     } else {
 366       /* Function header didn't save SRP (r1), so we are in a leaf fn or
 367          are otherwise confused.  */
 368       frame_fp = -1;
 369     }
 370   }
 371
 372   /* The locals are relative to the FP (whether it exists as an allocated
 373      register, or just as an assumed offset from the SP) */
 374   fi->locals_pointer = frame_fp;
 375
 376   /* The arguments are just above the SP as it was before we adjusted it
 377      on entry.  */
 378   fi->args_pointer = frame_sp - sp_offset;
 379
 380   /* Now that we know the SP value used by the prologue, we know where
 381      it saved all the registers.  */
 382   for (src = 0; src < 32; src++)
 383     if (must_adjust[src])
 384       fsr->regs[src] += frame_sp;
 385
 386   /* The saved value of the SP is always known.  */
 387   /* (we hope...) */
 388   if (fsr->regs[SP_REGNUM] != 0
 389    && fsr->regs[SP_REGNUM] != frame_sp - sp_offset)
 390     fprintf_unfiltered(gdb_stderr, "Bad saved SP value %x != %x, offset %x!\n",
 391         fsr->regs[SP_REGNUM],
 392         frame_sp - sp_offset, sp_offset);
 393
 394   fsr->regs[SP_REGNUM] = frame_sp - sp_offset;
 395
 396   return (ip);
 397 }
 398
 399 /* Given an ip value corresponding to the start of a function,
 400    return the ip of the first instruction after the function
 401    prologue.  */
 402
 403 CORE_ADDR
 404 skip_prologue (ip)
 405      CORE_ADDR (ip);
 406 {
 407   struct frame_saved_regs saved_regs_dummy;
 408   struct symtab_and_line sal;
 409   CORE_ADDR limit;
 410
 411   sal = find_pc_line (ip, 0);
 412   limit = (sal.end) ? sal.end : 0xffffffff;
 413
 414   return (examine_prologue (ip, limit, (CORE_ADDR) 0, &saved_regs_dummy,
 415                             (struct frame_info *)0 ));
 416 }
 417
 418 /* Put here the code to store, into a struct frame_saved_regs,
 419    the addresses of the saved registers of frame described by FRAME_INFO.
 420    This includes special registers such as pc and fp saved in special
 421    ways in the stack frame.  sp is even more special:
 422    the address we return for it IS the sp for the next frame.
 423
 424    We cache the result of doing this in the frame_cache_obstack, since
 425    it is fairly expensive.  */
 426
 427 void
 428 frame_find_saved_regs (fi, fsr)
 429      struct frame_info *fi;
 430      struct frame_saved_regs *fsr;
 431 {
 432   register struct frame_saved_regs *cache_fsr;
 433   extern struct obstack frame_cache_obstack;
 434   CORE_ADDR ip;
 435   struct symtab_and_line sal;
 436   CORE_ADDR limit;
 437
 438   if (!fi->fsr)
 439     {
 440       cache_fsr = (struct frame_saved_regs *)
 441                   obstack_alloc (&frame_cache_obstack,
 442                                  sizeof (struct frame_saved_regs));
 443       memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
 444       fi->fsr = cache_fsr;
 445
 446       /* Find the start and end of the function prologue.  If the PC
 447          is in the function prologue, we only consider the part that
 448          has executed already.  In the case where the PC is not in
 449          the function prologue, we set limit to two instructions beyond
 450          where the prologue ends in case if any of the prologue instructions
 451          were moved into a delay slot of a branch instruction. */
 452
 453       ip = get_pc_function_start (fi->pc);
 454       sal = find_pc_line (ip, 0);
 455       limit = (sal.end && sal.end < fi->pc) ? sal.end + 2 * BYTES_PER_88K_INSN
 456                                             : fi->pc;
 457
 458       /* This will fill in fields in *fi as well as in cache_fsr.  */
 459 #ifdef SIGTRAMP_FRAME_FIXUP
 460       if (fi->signal_handler_caller)
 461         SIGTRAMP_FRAME_FIXUP(fi->frame);
 462 #endif
 463       examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
 464 #ifdef SIGTRAMP_SP_FIXUP
 465       if (fi->signal_handler_caller && fi->fsr->regs[SP_REGNUM])
 466         SIGTRAMP_SP_FIXUP(fi->fsr->regs[SP_REGNUM]);
 467 #endif
 468     }
 469
 470   if (fsr)
 471     *fsr = *fi->fsr;
 472 }
 473
 474 /* Return the address of the locals block for the frame
 475    described by FI.  Returns 0 if the address is unknown.
 476    NOTE!  Frame locals are referred to by negative offsets from the
 477    argument pointer, so this is the same as frame_args_address().  */
 478
 479 CORE_ADDR
 480 frame_locals_address (fi)
 481      struct frame_info *fi;
 482 {
 483   struct frame_saved_regs fsr;
 484
 485   if (fi->args_pointer) /* Cached value is likely there.  */
 486     return fi->args_pointer;
 487
 488   /* Nope, generate it.  */
 489
 490   get_frame_saved_regs (fi, &fsr);
 491
 492   return fi->args_pointer;
 493 }
 494
 495 /* Return the address of the argument block for the frame
 496    described by FI.  Returns 0 if the address is unknown.  */
 497
 498 CORE_ADDR
 499 frame_args_address (fi)
 500      struct frame_info *fi;
 501 {
 502   struct frame_saved_regs fsr;
 503
 504   if (fi->args_pointer)         /* Cached value is likely there.  */
 505     return fi->args_pointer;
 506
 507   /* Nope, generate it.  */
 508
 509   get_frame_saved_regs (fi, &fsr);
 510
 511   return fi->args_pointer;
 512 }
 513
 514 /* Return the saved PC from this frame.
 515
 516    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
 517    just use the register SRP_REGNUM itself.  */
 518
 519 CORE_ADDR
 520 frame_saved_pc (frame)
 521      struct frame_info *frame;
 522 {
 523   return read_next_frame_reg(frame, SRP_REGNUM);
 524 }
 525
 526
 527 #define DUMMY_FRAME_SIZE 192
 528
 529 static void
 530 write_word (sp, word)
 531      CORE_ADDR sp;
 532      ULONGEST word;
 533 {
 534   register int len = REGISTER_SIZE;
 535   char buffer[MAX_REGISTER_RAW_SIZE];
 536
 537   store_unsigned_integer (buffer, len, word);
 538   write_memory (sp, buffer, len);
 539 }
 540
 541 void
 542 m88k_push_dummy_frame()
 543 {
 544   register CORE_ADDR sp = read_register (SP_REGNUM);
 545   register int rn;
 546   int offset;
 547
 548   sp -= DUMMY_FRAME_SIZE;       /* allocate a bunch of space */
 549
 550   for (rn = 0, offset = 0; rn <= SP_REGNUM; rn++, offset+=4)
 551     write_word (sp+offset, read_register(rn));
 552
 553   write_word (sp+offset, read_register (SXIP_REGNUM));
 554   offset += 4;
 555
 556   write_word (sp+offset, read_register (SNIP_REGNUM));
 557   offset += 4;
 558
 559   write_word (sp+offset, read_register (SFIP_REGNUM));
 560   offset += 4;
 561
 562   write_word (sp+offset, read_register (PSR_REGNUM));
 563   offset += 4;
 564
 565   write_word (sp+offset, read_register (FPSR_REGNUM));
 566   offset += 4;
 567
 568   write_word (sp+offset, read_register (FPCR_REGNUM));
 569   offset += 4;
 570
 571   write_register (SP_REGNUM, sp);
 572   write_register (ACTUAL_FP_REGNUM, sp);
 573 }
 574
 575 void
 576 pop_frame ()
 577 {
 578   register struct frame_info *frame = get_current_frame ();
 579   register CORE_ADDR fp;
 580   register int regnum;
 581   struct frame_saved_regs fsr;
 582
 583   fp = FRAME_FP (frame);
 584   get_frame_saved_regs (frame, &fsr);
 585
 586   if (PC_IN_CALL_DUMMY (read_pc (), read_register (SP_REGNUM), FRAME_FP (fi)))
 587     {
 588       /* FIXME: I think get_frame_saved_regs should be handling this so
 589          that we can deal with the saved registers properly (e.g. frame
 590          1 is a call dummy, the user types "frame 2" and then "print $ps").  */
 591       register CORE_ADDR sp = read_register (ACTUAL_FP_REGNUM);
 592       int offset;
 593
 594       for (regnum = 0, offset = 0; regnum <= SP_REGNUM; regnum++, offset+=4)
 595         (void) write_register (regnum, read_memory_integer (sp+offset, 4));
 596
 597       write_register (SXIP_REGNUM, read_memory_integer (sp+offset, 4));
 598       offset += 4;
 599
 600       write_register (SNIP_REGNUM, read_memory_integer (sp+offset, 4));
 601       offset += 4;
 602
 603       write_register (SFIP_REGNUM, read_memory_integer (sp+offset, 4));
 604       offset += 4;
 605
 606       write_register (PSR_REGNUM, read_memory_integer (sp+offset, 4));
 607       offset += 4;
 608
 609       write_register (FPSR_REGNUM, read_memory_integer (sp+offset, 4));
 610       offset += 4;
 611
 612       write_register (FPCR_REGNUM, read_memory_integer (sp+offset, 4));
 613       offset += 4;
 614
 615     }
 616   else
 617     {
 618       for (regnum = FP_REGNUM ; regnum > 0 ; regnum--)
 619           if (fsr.regs[regnum])
 620               write_register (regnum,
 621                               read_memory_integer (fsr.regs[regnum], 4));
 622       write_pc (frame_saved_pc (frame));
 623     }
 624   reinit_frame_cache ();
 625 }
 626
 627 void
 628 _initialize_m88k_tdep ()
 629 {
 630   tm_print_insn = print_insn_m88k;
 631 }