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