gdb/m88k-tdep.c

   1 /* Target-machine dependent code for Motorola 88000 series, for GDB.
   2    Copyright (C) 1988, 1990, 1991 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "value.h"
  24 #include "gdbcore.h"
  25
  26 #include "symtab.h"
  27 #include "setjmp.h"
  28 #include "value.h"
  29 #include "ieee-float.h" /* for ext_format & friends */
  30
  31 /* Size of an instruction */
  32 #define BYTES_PER_88K_INSN      4
  33
  34 void frame_find_saved_regs ();
  35
  36 /* is this target an m88110?  Otherwise assume m88100.  This has
  37    relevance for the ways in which we screw with instruction pointers.  */
  38 int target_is_m88110 = 0;
  39
  40 /* FIXME: this is really just a guess based on m88110 being big
  41    endian. */
  42 const struct ext_format ext_format_m88110 = {
  43 /* tot sbyte smask expbyte      manbyte */
  44    10, 0,    0x80, 0,1,         4,8             /* m88110 */
  45 };
  46
  47 /* Given a GDB frame, determine the address of the calling function's frame.
  48    This will be used to create a new GDB frame struct, and then
  49    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
  50
  51    For us, the frame address is its stack pointer value, so we look up
  52    the function prologue to determine the caller's sp value, and return it.  */
  53
  54 FRAME_ADDR
  55 frame_chain (thisframe)
  56      FRAME thisframe;
  57 {
  58
  59   frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0);
  60   /* NOTE:  this depends on frame_find_saved_regs returning the VALUE, not
  61             the ADDRESS, of SP_REGNUM.  It also depends on the cache of
  62             frame_find_saved_regs results.  */
  63   if (thisframe->fsr->regs[SP_REGNUM])
  64     return thisframe->fsr->regs[SP_REGNUM];
  65   else
  66     return thisframe->frame;    /* Leaf fn -- next frame up has same SP. */
  67 }
  68
  69 int
  70 frameless_function_invocation (frame)
  71      FRAME frame;
  72 {
  73
  74   frame_find_saved_regs (frame, (struct frame_saved_regs *) 0);
  75   /* NOTE:  this depends on frame_find_saved_regs returning the VALUE, not
  76             the ADDRESS, of SP_REGNUM.  It also depends on the cache of
  77             frame_find_saved_regs results.  */
  78   if (frame->fsr->regs[SP_REGNUM])
  79     return 0;                   /* Frameful -- return addr saved somewhere */
  80   else
  81     return 1;                   /* Frameless -- no saved return address */
  82 }
  83
  84 void
  85 init_extra_frame_info (fromleaf, fi)
  86      int fromleaf;
  87      struct frame_info *fi;
  88 {
  89   fi->fsr = 0;                  /* Not yet allocated */
  90   fi->args_pointer = 0;         /* Unknown */
  91   fi->locals_pointer = 0;       /* Unknown */
  92 }
  93 \f
  94 /* Examine an m88k function prologue, recording the addresses at which
  95    registers are saved explicitly by the prologue code, and returning
  96    the address of the first instruction after the prologue (but not
  97    after the instruction at address LIMIT, as explained below).
  98
  99    LIMIT places an upper bound on addresses of the instructions to be
 100    examined.  If the prologue code scan reaches LIMIT, the scan is
 101    aborted and LIMIT is returned.  This is used, when examining the
 102    prologue for the current frame, to keep examine_prologue () from
 103    claiming that a given register has been saved when in fact the
 104    instruction that saves it has not yet been executed.  LIMIT is used
 105    at other times to stop the scan when we hit code after the true
 106    function prologue (e.g. for the first source line) which might
 107    otherwise be mistaken for function prologue.
 108
 109    The format of the function prologue matched by this routine is
 110    derived from examination of the source to gcc 1.95, particularly
 111    the routine output_prologue () in config/out-m88k.c.
 112
 113    subu r31,r31,n                       # stack pointer update
 114
 115    (st rn,r31,offset)?                  # save incoming regs
 116    (st.d rn,r31,offset)?
 117
 118    (addu r30,r31,n)?                    # frame pointer update
 119
 120    (pic sequence)?                      # PIC code prologue
 121
 122    (or   rn,rm,0)?                      # Move parameters to other regs
 123 */
 124
 125 /* Macros for extracting fields from instructions.  */
 126
 127 #define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos))
 128 #define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width))
 129
 130 /* Prologue code that handles position-independent-code setup.  */
 131
 132 struct pic_prologue_code {
 133   unsigned long insn, mask;
 134 };
 135
 136 static struct pic_prologue_code pic_prologue_code [] = {
 137 /* FIXME -- until this is translated to hex, we won't match it... */
 138   { 0xffffffff, 0 },
 139                                         /* or r10,r1,0  (if not saved) */
 140                                         /* bsr.n LabN */
 141                                         /* or.u r25,r0,const */
 142                                         /*LabN: or r25,r25,const2 */
 143                                         /* addu r25,r25,1 */
 144                                         /* or r1,r10,0  (if not saved) */
 145 };
 146
 147 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
 148    is not the address of a valid instruction, the address of the next
 149    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
 150    of the instruction.  PWORD2 is ignored -- a remnant of the original
 151    i960 version.  */
 152
 153 #define NEXT_PROLOGUE_INSN(addr, lim, pword1) \
 154   (((addr) < (lim)) ? next_insn (addr, pword1) : 0)
 155
 156 /* Read the m88k instruction at 'memaddr' and return the address of
 157    the next instruction after that, or 0 if 'memaddr' is not the
 158    address of a valid instruction.  The instruction
 159    is stored at 'pword1'.  */
 160
 161 CORE_ADDR
 162 next_insn (memaddr, pword1)
 163      unsigned long *pword1;
 164      CORE_ADDR memaddr;
 165 {
 166   *pword1 = read_memory_integer (memaddr, BYTES_PER_88K_INSN);
 167   return memaddr + BYTES_PER_88K_INSN;
 168 }
 169
 170 /* Read a register from frames called by us (or from the hardware regs).  */
 171
 172 static int
 173 read_next_frame_reg(fi, regno)
 174      FRAME fi;
 175      int regno;
 176 {
 177   for (; fi; fi = fi->next) {
 178       if (regno == SP_REGNUM) return fi->frame;
 179       else if (fi->fsr->regs[regno])
 180         return read_memory_integer(fi->fsr->regs[regno], 4);
 181   }
 182   return read_register(regno);
 183 }
 184
 185 /* Examine the prologue of a function.  `ip' points to the first instruction.
 186    `limit' is the limit of the prologue (e.g. the addr of the first
 187    linenumber, or perhaps the program counter if we're stepping through).
 188    `frame_sp' is the stack pointer value in use in this frame.
 189    `fsr' is a pointer to a frame_saved_regs structure into which we put
 190    info about the registers saved by this frame.
 191    `fi' is a struct frame_info pointer; we fill in various fields in it
 192    to reflect the offsets of the arg pointer and the locals pointer.  */
 193
 194 static CORE_ADDR
 195 examine_prologue (ip, limit, frame_sp, fsr, fi)
 196      register CORE_ADDR ip;
 197      register CORE_ADDR limit;
 198      FRAME_ADDR frame_sp;
 199      struct frame_saved_regs *fsr;
 200      struct frame_info *fi;
 201 {
 202   register CORE_ADDR next_ip;
 203   register int src;
 204   register struct pic_prologue_code *pcode;
 205   unsigned int insn;
 206   int size, offset;
 207   char must_adjust[32];         /* If set, must adjust offsets in fsr */
 208   int sp_offset = -1;           /* -1 means not set (valid must be mult of 8) */
 209   int fp_offset = -1;           /* -1 means not set */
 210   CORE_ADDR frame_fp;
 211
 212   memset (must_adjust, '\0', sizeof (must_adjust));
 213   next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 214
 215   /* Accept move of incoming registers to other registers, using
 216      "or rd,rs,0" or "or.u rd,rs,0" or "or rd,r0,rs" or "or rd,rs,r0".
 217      We don't have to worry about walking into the first lines of code,
 218      since the first line number will stop us (assuming we have symbols).
 219      What we have actually seen is "or r10,r0,r12".  */
 220
 221 #define OR_MOVE_INSN    0x58000000              /* or/or.u with immed of 0 */
 222 #define OR_MOVE_MASK    0xF800FFFF
 223 #define OR_REG_MOVE1_INSN       0xF4005800      /* or rd,r0,rs */
 224 #define OR_REG_MOVE1_MASK       0xFC1FFFE0
 225 #define OR_REG_MOVE2_INSN       0xF4005800      /* or rd,rs,r0 */
 226 #define OR_REG_MOVE2_MASK       0xFC00FFFF
 227   while (next_ip &&
 228          ((insn & OR_MOVE_MASK) == OR_MOVE_INSN ||
 229           (insn & OR_REG_MOVE1_MASK) == OR_REG_MOVE1_INSN ||
 230           (insn & OR_REG_MOVE2_MASK) == OR_REG_MOVE2_INSN
 231          )
 232         )
 233     {
 234       /* We don't care what moves to where.  The result of the moves
 235          has already been reflected in what the compiler tells us is the
 236          location of these parameters.  */
 237       ip = next_ip;
 238       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 239     }
 240
 241   /* Accept an optional "subu sp,sp,n" to set up the stack pointer.  */
 242
 243 #define SUBU_SP_INSN    0x67ff0000
 244 #define SUBU_SP_MASK    0xffff0007      /* Note offset must be mult. of 8 */
 245 #define SUBU_OFFSET(x)  ((unsigned)(x & 0xFFFF))
 246   if (next_ip &&
 247       ((insn & SUBU_SP_MASK) == SUBU_SP_INSN))  /* subu r31, r31, N */
 248     {
 249       sp_offset = -SUBU_OFFSET (insn);
 250       ip = next_ip;
 251       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 252     }
 253
 254   /* The function must start with a stack-pointer adjustment, or
 255      we don't know WHAT'S going on... */
 256   if (sp_offset == -1)
 257     return ip;
 258
 259   /* Accept zero or more instances of "st rx,sp,n" or "st.d rx,sp,n".
 260      This may cause us to mistake the copying of a register
 261      parameter to the frame for the saving of a callee-saved
 262      register, but that can't be helped, since with the
 263      "-fcall-saved" flag, any register can be made callee-saved.
 264      This probably doesn't matter, since the ``saved'' caller's values of
 265      non-callee-saved registers are not relevant anyway.  */
 266
 267 #define STD_STACK_INSN  0x201f0000
 268 #define STD_STACK_MASK  0xfc1f0000
 269 #define ST_STACK_INSN   0x241f0000
 270 #define ST_STACK_MASK   0xfc1f0000
 271 #define ST_OFFSET(x)    ((unsigned)((x) & 0xFFFF))
 272 #define ST_SRC(x)       EXTRACT_FIELD ((x), 21, 5)
 273
 274   while (next_ip)
 275     {
 276            if ((insn & ST_STACK_MASK)  == ST_STACK_INSN)
 277         size = 1;
 278       else if ((insn & STD_STACK_MASK) == STD_STACK_INSN)
 279         size = 2;
 280       else
 281         break;
 282
 283       src = ST_SRC (insn);
 284       offset = ST_OFFSET (insn);
 285       while (size--)
 286         {
 287           must_adjust[src] = 1;
 288           fsr->regs[src++] = offset;            /* Will be adjusted later */
 289           offset += 4;
 290         }
 291       ip = next_ip;
 292       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 293     }
 294
 295   /* Accept an optional "addu r30,r31,n" to set up the frame pointer.  */
 296
 297 #define ADDU_FP_INSN    0x63df0000
 298 #define ADDU_FP_MASK    0xffff0000
 299 #define ADDU_OFFSET(x)  ((unsigned)(x & 0xFFFF))
 300   if (next_ip &&
 301       ((insn & ADDU_FP_MASK) == ADDU_FP_INSN))  /* addu r30, r31, N */
 302     {
 303       fp_offset = ADDU_OFFSET (insn);
 304       ip = next_ip;
 305       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 306     }
 307
 308   /* Accept the PIC prologue code if present.  */
 309
 310   pcode = pic_prologue_code;
 311   size = sizeof (pic_prologue_code) / sizeof (*pic_prologue_code);
 312   /* If return addr is saved, we don't use first or last insn of PICstuff.  */
 313   if (fsr->regs[SRP_REGNUM]) {
 314     pcode++;
 315     size-=2;
 316   }
 317
 318   while (size-- && next_ip && (pcode->insn == (pcode->mask & insn)))
 319     {
 320       pcode++;
 321       ip = next_ip;
 322       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 323     }
 324
 325   /* Accept moves of parameter registers to other registers, using
 326      "or rd,rs,0" or "or.u rd,rs,0" or "or rd,r0,rs" or "or rd,rs,r0".
 327      We don't have to worry about walking into the first lines of code,
 328      since the first line number will stop us (assuming we have symbols).
 329      What gcc actually seems to produce is "or rd,r0,rs".  */
 330
 331 #define OR_MOVE_INSN    0x58000000              /* or/or.u with immed of 0 */
 332 #define OR_MOVE_MASK    0xF800FFFF
 333 #define OR_REG_MOVE1_INSN       0xF4005800      /* or rd,r0,rs */
 334 #define OR_REG_MOVE1_MASK       0xFC1FFFE0
 335 #define OR_REG_MOVE2_INSN       0xF4005800      /* or rd,rs,r0 */
 336 #define OR_REG_MOVE2_MASK       0xFC00FFFF
 337   while (next_ip &&
 338          ((insn & OR_MOVE_MASK) == OR_MOVE_INSN ||
 339           (insn & OR_REG_MOVE1_MASK) == OR_REG_MOVE1_INSN ||
 340           (insn & OR_REG_MOVE2_MASK) == OR_REG_MOVE2_INSN
 341          )
 342         )
 343     {
 344       /* We don't care what moves to where.  The result of the moves
 345          has already been reflected in what the compiler tells us is the
 346          location of these parameters.  */
 347       ip = next_ip;
 348       next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn);
 349     }
 350
 351   /* We're done with the prologue.  If we don't care about the stack
 352      frame itself, just return.  (Note that fsr->regs has been trashed,
 353      but the one caller who calls with fi==0 passes a dummy there.)  */
 354
 355   if (fi == 0)
 356     return ip;
 357
 358   /*
 359      OK, now we have:
 360
 361         sp_offset       original (before any alloca calls) displacement of SP
 362                         (will be negative).
 363
 364         fp_offset       displacement from original SP to the FP for this frame
 365                         or -1.
 366
 367         fsr->regs[0..31]        displacement from original SP to the stack
 368                                 location where reg[0..31] is stored.
 369
 370         must_adjust[0..31]      set if corresponding offset was set.
 371
 372      If alloca has been called between the function prologue and the current
 373      IP, then the current SP (frame_sp) will not be the original SP as set by
 374      the function prologue.  If the current SP is not the original SP, then the
 375      compiler will have allocated an FP for this frame, fp_offset will be set,
 376      and we can use it to calculate the original SP.
 377
 378      Then, we figure out where the arguments and locals are, and relocate the
 379      offsets in fsr->regs to absolute addresses.  */
 380
 381   if (fp_offset != -1) {
 382     /* We have a frame pointer, so get it, and base our calc's on it.  */
 383     frame_fp = (CORE_ADDR) read_next_frame_reg (fi->next, ACTUAL_FP_REGNUM);
 384     frame_sp = frame_fp - fp_offset;
 385   } else {
 386     /* We have no frame pointer, therefore frame_sp is still the same value
 387        as set by prologue.  But where is the frame itself?  */
 388     if (must_adjust[SRP_REGNUM]) {
 389       /* Function header saved SRP (r1), the return address.  Frame starts
 390          4 bytes down from where it was saved.  */
 391       frame_fp = frame_sp + fsr->regs[SRP_REGNUM] - 4;
 392       fi->locals_pointer = frame_fp;
 393     } else {
 394       /* Function header didn't save SRP (r1), so we are in a leaf fn or
 395          are otherwise confused.  */
 396       frame_fp = -1;
 397     }
 398   }
 399
 400   /* The locals are relative to the FP (whether it exists as an allocated
 401      register, or just as an assumed offset from the SP) */
 402   fi->locals_pointer = frame_fp;
 403
 404   /* The arguments are just above the SP as it was before we adjusted it
 405      on entry.  */
 406   fi->args_pointer = frame_sp - sp_offset;
 407
 408   /* Now that we know the SP value used by the prologue, we know where
 409      it saved all the registers.  */
 410   for (src = 0; src < 32; src++)
 411     if (must_adjust[src])
 412       fsr->regs[src] += frame_sp;
 413
 414   /* The saved value of the SP is always known.  */
 415   /* (we hope...) */
 416   if (fsr->regs[SP_REGNUM] != 0
 417    && fsr->regs[SP_REGNUM] != frame_sp - sp_offset)
 418     fprintf_unfiltered(gdb_stderr, "Bad saved SP value %x != %x, offset %x!\n",
 419         fsr->regs[SP_REGNUM],
 420         frame_sp - sp_offset, sp_offset);
 421
 422   fsr->regs[SP_REGNUM] = frame_sp - sp_offset;
 423
 424   return (ip);
 425 }
 426
 427 /* Given an ip value corresponding to the start of a function,
 428    return the ip of the first instruction after the function
 429    prologue.  */
 430
 431 CORE_ADDR
 432 skip_prologue (ip)
 433      CORE_ADDR (ip);
 434 {
 435   struct frame_saved_regs saved_regs_dummy;
 436   struct symtab_and_line sal;
 437   CORE_ADDR limit;
 438
 439   sal = find_pc_line (ip, 0);
 440   limit = (sal.end) ? sal.end : 0xffffffff;
 441
 442   return (examine_prologue (ip, limit, (FRAME_ADDR) 0, &saved_regs_dummy,
 443                             (struct frame_info *)0 ));
 444 }
 445
 446 /* Put here the code to store, into a struct frame_saved_regs,
 447    the addresses of the saved registers of frame described by FRAME_INFO.
 448    This includes special registers such as pc and fp saved in special
 449    ways in the stack frame.  sp is even more special:
 450    the address we return for it IS the sp for the next frame.
 451
 452    We cache the result of doing this in the frame_cache_obstack, since
 453    it is fairly expensive.  */
 454
 455 void
 456 frame_find_saved_regs (fi, fsr)
 457      struct frame_info *fi;
 458      struct frame_saved_regs *fsr;
 459 {
 460   register struct frame_saved_regs *cache_fsr;
 461   extern struct obstack frame_cache_obstack;
 462   CORE_ADDR ip;
 463   struct symtab_and_line sal;
 464   CORE_ADDR limit;
 465
 466   if (!fi->fsr)
 467     {
 468       cache_fsr = (struct frame_saved_regs *)
 469                   obstack_alloc (&frame_cache_obstack,
 470                                  sizeof (struct frame_saved_regs));
 471       memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
 472       fi->fsr = cache_fsr;
 473
 474       /* Find the start and end of the function prologue.  If the PC
 475          is in the function prologue, we only consider the part that
 476          has executed already.  */
 477
 478       ip = get_pc_function_start (fi->pc);
 479       sal = find_pc_line (ip, 0);
 480       limit = (sal.end && sal.end < fi->pc) ? sal.end: fi->pc;
 481
 482       /* This will fill in fields in *fi as well as in cache_fsr.  */
 483 #ifdef SIGTRAMP_FRAME_FIXUP
 484       if (fi->signal_handler_caller)
 485         SIGTRAMP_FRAME_FIXUP(fi->frame);
 486 #endif
 487       examine_prologue (ip, limit, fi->frame, cache_fsr, fi);
 488 #ifdef SIGTRAMP_SP_FIXUP
 489       if (fi->signal_handler_caller && fi->fsr->regs[SP_REGNUM])
 490         SIGTRAMP_SP_FIXUP(fi->fsr->regs[SP_REGNUM]);
 491 #endif
 492     }
 493
 494   if (fsr)
 495     *fsr = *fi->fsr;
 496 }
 497
 498 /* Return the address of the locals block for the frame
 499    described by FI.  Returns 0 if the address is unknown.
 500    NOTE!  Frame locals are referred to by negative offsets from the
 501    argument pointer, so this is the same as frame_args_address().  */
 502
 503 CORE_ADDR
 504 frame_locals_address (fi)
 505      struct frame_info *fi;
 506 {
 507   struct frame_saved_regs fsr;
 508
 509   if (fi->args_pointer) /* Cached value is likely there.  */
 510     return fi->args_pointer;
 511
 512   /* Nope, generate it.  */
 513
 514   get_frame_saved_regs (fi, &fsr);
 515
 516   return fi->args_pointer;
 517 }
 518
 519 /* Return the address of the argument block for the frame
 520    described by FI.  Returns 0 if the address is unknown.  */
 521
 522 CORE_ADDR
 523 frame_args_address (fi)
 524      struct frame_info *fi;
 525 {
 526   struct frame_saved_regs fsr;
 527
 528   if (fi->args_pointer)         /* Cached value is likely there.  */
 529     return fi->args_pointer;
 530
 531   /* Nope, generate it.  */
 532
 533   get_frame_saved_regs (fi, &fsr);
 534
 535   return fi->args_pointer;
 536 }
 537
 538 /* Return the saved PC from this frame.
 539
 540    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
 541    just use the register SRP_REGNUM itself.  */
 542
 543 CORE_ADDR
 544 frame_saved_pc (frame)
 545      FRAME frame;
 546 {
 547   return read_next_frame_reg(frame, SRP_REGNUM);
 548 }
 549
 550 #if 0
 551 /* I believe this is all obsolete call dummy stuff.  */
 552 static int
 553 pushed_size (prev_words, v)
 554      int prev_words;
 555      struct value *v;
 556 {
 557   switch (TYPE_CODE (VALUE_TYPE (v)))
 558     {
 559       case TYPE_CODE_VOID:              /* Void type (values zero length) */
 560
 561         return 0;       /* That was easy! */
 562
 563       case TYPE_CODE_PTR:               /* Pointer type */
 564       case TYPE_CODE_ENUM:              /* Enumeration type */
 565       case TYPE_CODE_INT:               /* Integer type */
 566       case TYPE_CODE_REF:               /* C++ Reference types */
 567       case TYPE_CODE_ARRAY:             /* Array type, lower & upper bounds */
 568
 569         return 1;
 570
 571       case TYPE_CODE_FLT:               /* Floating type */
 572
 573         if (TYPE_LENGTH (VALUE_TYPE (v)) == 4)
 574           return 1;
 575         else
 576           /* Assume that it must be a double.  */
 577           if (prev_words & 1)           /* at an odd-word boundary */
 578             return 3;                   /* round to 8-byte boundary */
 579           else
 580             return 2;
 581
 582       case TYPE_CODE_STRUCT:            /* C struct or Pascal record */
 583       case TYPE_CODE_UNION:             /* C union or Pascal variant part */
 584
 585         return (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4);
 586
 587       case TYPE_CODE_FUNC:              /* Function type */
 588       case TYPE_CODE_SET:               /* Pascal sets */
 589       case TYPE_CODE_RANGE:             /* Range (integers within bounds) */
 590       case TYPE_CODE_STRING:            /* String type */
 591       case TYPE_CODE_MEMBER:            /* Member type */
 592       case TYPE_CODE_METHOD:            /* Method type */
 593         /* Don't know how to pass these yet.  */
 594
 595       case TYPE_CODE_UNDEF:             /* Not used; catches errors */
 596       default:
 597         abort ();
 598     }
 599 }
 600
 601 static void
 602 store_parm_word (address, val)
 603      CORE_ADDR address;
 604      int val;
 605 {
 606   write_memory (address, (char *)&val, 4);
 607 }
 608
 609 static int
 610 store_parm (prev_words, left_parm_addr, v)
 611      unsigned int prev_words;
 612      CORE_ADDR left_parm_addr;
 613      struct value *v;
 614 {
 615   CORE_ADDR start = left_parm_addr + (prev_words * 4);
 616   int *val_addr = (int *)VALUE_CONTENTS(v);
 617
 618   switch (TYPE_CODE (VALUE_TYPE (v)))
 619     {
 620       case TYPE_CODE_VOID:              /* Void type (values zero length) */
 621
 622         return 0;
 623
 624       case TYPE_CODE_PTR:               /* Pointer type */
 625       case TYPE_CODE_ENUM:              /* Enumeration type */
 626       case TYPE_CODE_INT:               /* Integer type */
 627       case TYPE_CODE_ARRAY:             /* Array type, lower & upper bounds */
 628       case TYPE_CODE_REF:               /* C++ Reference types */
 629
 630         store_parm_word (start, *val_addr);
 631         return 1;
 632
 633       case TYPE_CODE_FLT:               /* Floating type */
 634
 635         if (TYPE_LENGTH (VALUE_TYPE (v)) == 4)
 636           {
 637             store_parm_word (start, *val_addr);
 638             return 1;
 639           }
 640         else
 641           {
 642             store_parm_word (start + ((prev_words & 1) * 4), val_addr[0]);
 643             store_parm_word (start + ((prev_words & 1) * 4) + 4, val_addr[1]);
 644             return 2 + (prev_words & 1);
 645           }
 646
 647       case TYPE_CODE_STRUCT:            /* C struct or Pascal record */
 648       case TYPE_CODE_UNION:             /* C union or Pascal variant part */
 649
 650         {
 651           unsigned int words = (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4);
 652           unsigned int word;
 653
 654           for (word = 0; word < words; word++)
 655             store_parm_word (start + (word * 4), val_addr[word]);
 656           return words;
 657         }
 658
 659       default:
 660         abort ();
 661     }
 662 }
 663
 664  /* This routine sets up all of the parameter values needed to make a pseudo
 665     call.  The name "push_parameters" is a misnomer on some archs,
 666     because (on the m88k) most parameters generally end up being passed in
 667     registers rather than on the stack.  In this routine however, we do
 668     end up storing *all* parameter values onto the stack (even if we will
 669     realize later that some of these stores were unnecessary).  */
 670
 671 #define FIRST_PARM_REGNUM       2
 672
 673 void
 674 push_parameters (return_type, struct_conv, nargs, args)
 675       struct type *return_type;
 676       int struct_conv;
 677       int nargs;
 678       value *args;
 679 {
 680    int parm_num;
 681    unsigned int p_words = 0;
 682    CORE_ADDR left_parm_addr;
 683
 684    /* Start out by creating a space for the return value (if need be).  We
 685       only need to do this if the return value is a struct or union.  If we
 686       do make a space for a struct or union return value, then we must also
 687       arrange for the base address of that space to go into r12, which is the
 688       standard place to pass the address of the return value area to the
 689       callee.  Note that only structs and unions are returned in this fashion.
 690       Ints, enums, pointers, and floats are returned into r2.  Doubles are
 691       returned into the register pair {r2,r3}.  Note also that the space
 692       reserved for a struct or union return value only has to be word aligned
 693       (not double-word) but it is double-word aligned here anyway (just in
 694       case that becomes important someday).  */
 695
 696    switch (TYPE_CODE (return_type))
 697      {
 698        case TYPE_CODE_STRUCT:
 699        case TYPE_CODE_UNION:
 700          {
 701            int return_bytes = ((TYPE_LENGTH (return_type) + 7) / 8) * 8;
 702            CORE_ADDR rv_addr;
 703
 704            rv_addr = read_register (SP_REGNUM) - return_bytes;
 705
 706            write_register (SP_REGNUM, rv_addr); /* push space onto the stack */
 707            write_register (SRA_REGNUM, rv_addr);/* set return value register */
 708            break;
 709          }
 710        default: break;
 711      }
 712
 713    /* Here we make a pre-pass on the whole parameter list to figure out exactly
 714       how many words worth of stuff we are going to pass.  */
 715
 716    for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++)
 717      p_words += pushed_size (p_words, value_arg_coerce (args[parm_num]));
 718
 719    /* Now, check to see if we have to round up the number of parameter words
 720       to get up to the next 8-bytes boundary.  This may be necessary because
 721       of the software convention to always keep the stack aligned on an 8-byte
 722       boundary.  */
 723
 724    if (p_words & 1)
 725      p_words++;         /* round to 8-byte boundary */
 726
 727    /* Now figure out the absolute address of the leftmost parameter, and update
 728       the stack pointer to point at that address.  */
 729
 730    left_parm_addr = read_register (SP_REGNUM) - (p_words * 4);
 731    write_register (SP_REGNUM, left_parm_addr);
 732
 733    /* Now we can go through all of the parameters (in left-to-right order)
 734       and write them to their parameter stack slots.  Note that we are not
 735       really "pushing" the parameter values.  The stack space for these values
 736       was already allocated above.  Now we are just filling it up.  */
 737
 738    for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++)
 739      p_words +=
 740        store_parm (p_words, left_parm_addr, value_arg_coerce (args[parm_num]));
 741
 742    /* Now that we are all done storing the parameter values into the stack, we
 743       must go back and load up the parameter registers with the values from the
 744       corresponding stack slots.  Note that in the two cases of (a) gaps in the
 745       parameter word sequence causes by (otherwise) misaligned doubles, and (b)
 746       slots correcponding to structs or unions, the work we do here in loading
 747       some parameter registers may be unnecessary, but who cares?  */
 748
 749    for (p_words = 0; p_words < 8; p_words++)
 750      {
 751        write_register (FIRST_PARM_REGNUM + p_words,
 752          read_memory_integer (left_parm_addr + (p_words * 4), 4));
 753      }
 754 }
 755
 756 void
 757 collect_returned_value (rval, value_type, struct_return, nargs, args)
 758      value *rval;
 759      struct type *value_type;
 760      int struct_return;
 761      int nargs;
 762      value *args;
 763 {
 764   char retbuf[REGISTER_BYTES];
 765
 766   memcpy (retbuf, registers, REGISTER_BYTES);
 767   *rval = value_being_returned (value_type, retbuf, struct_return);
 768   return;
 769 }
 770 #endif /* 0 */
 771
 772 /*start of lines added by kev*/
 773
 774 #define DUMMY_FRAME_SIZE 192
 775
 776 static void
 777 write_word (sp, word)
 778      CORE_ADDR sp;
 779      unsigned LONGEST word;
 780 {
 781   register int len = REGISTER_SIZE;
 782   char buffer[MAX_REGISTER_RAW_SIZE];
 783
 784   store_unsigned_integer (buffer, len, word);
 785   write_memory (sp, buffer, len);
 786 }
 787
 788 void
 789 m88k_push_dummy_frame()
 790 {
 791   register CORE_ADDR sp = read_register (SP_REGNUM);
 792   register int rn;
 793   int offset;
 794
 795   sp -= DUMMY_FRAME_SIZE;       /* allocate a bunch of space */
 796
 797   for (rn = 0, offset = 0; rn <= SP_REGNUM; rn++, offset+=4)
 798     write_word (sp+offset, read_register(rn));
 799
 800   write_word (sp+offset, read_register (SXIP_REGNUM));
 801   offset += 4;
 802
 803   write_word (sp+offset, read_register (SNIP_REGNUM));
 804   offset += 4;
 805
 806   write_word (sp+offset, read_register (SFIP_REGNUM));
 807   offset += 4;
 808
 809   write_word (sp+offset, read_register (PSR_REGNUM));
 810   offset += 4;
 811
 812   write_word (sp+offset, read_register (FPSR_REGNUM));
 813   offset += 4;
 814
 815   write_word (sp+offset, read_register (FPCR_REGNUM));
 816   offset += 4;
 817
 818   write_register (SP_REGNUM, sp);
 819   write_register (ACTUAL_FP_REGNUM, sp);
 820 }
 821
 822 void
 823 pop_frame ()
 824 {
 825   register FRAME frame = get_current_frame ();
 826   register CORE_ADDR fp;
 827   register int regnum;
 828   struct frame_saved_regs fsr;
 829   struct frame_info *fi;
 830
 831   fi = get_frame_info (frame);
 832   fp = fi -> frame;
 833   get_frame_saved_regs (fi, &fsr);
 834
 835   if (PC_IN_CALL_DUMMY (read_pc(), read_register(SP_REGNUM), FRAME_FP(fi)))
 836     {
 837       /* FIXME: I think get_frame_saved_regs should be handling this so
 838          that we can deal with the saved registers properly (e.g. frame
 839          1 is a call dummy, the user types "frame 2" and then "print $ps").  */
 840       register CORE_ADDR sp = read_register (ACTUAL_FP_REGNUM);
 841       int offset;
 842
 843       for (regnum = 0, offset = 0; regnum <= SP_REGNUM; regnum++, offset+=4)
 844         (void) write_register (regnum, read_memory_integer (sp+offset, 4));
 845
 846       write_register (SXIP_REGNUM, read_memory_integer (sp+offset, 4));
 847       offset += 4;
 848
 849       write_register (SNIP_REGNUM, read_memory_integer (sp+offset, 4));
 850       offset += 4;
 851
 852       write_register (SFIP_REGNUM, read_memory_integer (sp+offset, 4));
 853       offset += 4;
 854
 855       write_register (PSR_REGNUM, read_memory_integer (sp+offset, 4));
 856       offset += 4;
 857
 858       write_register (FPSR_REGNUM, read_memory_integer (sp+offset, 4));
 859       offset += 4;
 860
 861       write_register (FPCR_REGNUM, read_memory_integer (sp+offset, 4));
 862       offset += 4;
 863
 864     }
 865   else
 866     {
 867       for (regnum = FP_REGNUM ; regnum > 0 ; regnum--)
 868           if (fsr.regs[regnum])
 869               write_register (regnum,
 870                               read_memory_integer (fsr.regs[regnum], 4));
 871       write_pc(frame_saved_pc(frame));
 872     }
 873   reinit_frame_cache ();
 874 }