gdb/m68k-tdep.c

   1 /* Target dependent code for the Motorola 68000 series.
   2    Copyright (C) 1990, 1992 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 "ieee-float.h"
  22 #include "frame.h"
  23 #include "symtab.h"
  24
  25 const struct ext_format ext_format_68881 = {
  26 /* tot sbyte smask expbyte manbyte */
  27    12, 0,    0x80, 0,1,    4,8          /* mc68881 */
  28 };
  29
  30 \f
  31 /* Things needed for making the inferior call functions.
  32    It seems like every m68k based machine has almost identical definitions
  33    in the individual machine's configuration files.  Most other cpu types
  34    (mips, i386, etc) have routines in their *-tdep.c files to handle this
  35    for most configurations.  The m68k family should be able to do this as
  36    well.  These macros can still be overridden when necessary.  */
  37
  38 /* Push an empty stack frame, to record the current PC, etc.  */
  39
  40 void
  41 m68k_push_dummy_frame ()
  42 {
  43   register CORE_ADDR sp = read_register (SP_REGNUM);
  44   register int regnum;
  45   char raw_buffer[12];
  46
  47   sp = push_word (sp, read_register (PC_REGNUM));
  48   sp = push_word (sp, read_register (FP_REGNUM));
  49   write_register (FP_REGNUM, sp);
  50 #if defined (HAVE_68881)
  51   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
  52     {
  53       read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
  54       sp = push_bytes (sp, raw_buffer, 12);
  55     }
  56 #endif
  57   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
  58     {
  59       sp = push_word (sp, read_register (regnum));
  60     }
  61   sp = push_word (sp, read_register (PS_REGNUM));
  62   write_register (SP_REGNUM, sp);
  63 }
  64
  65 /* Discard from the stack the innermost frame,
  66    restoring all saved registers.  */
  67
  68 void
  69 m68k_pop_frame ()
  70 {
  71   register FRAME frame = get_current_frame ();
  72   register CORE_ADDR fp;
  73   register int regnum;
  74   struct frame_saved_regs fsr;
  75   struct frame_info *fi;
  76   char raw_buffer[12];
  77
  78   fi = get_frame_info (frame);
  79   fp = fi -> frame;
  80   get_frame_saved_regs (fi, &fsr);
  81 #if defined (HAVE_68881)
  82   for (regnum = FP0_REGNUM + 7 ; regnum >= FP0_REGNUM ; regnum--)
  83     {
  84       if (fsr.regs[regnum])
  85         {
  86           read_memory (fsr.regs[regnum], raw_buffer, 12);
  87           write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
  88         }
  89     }
  90 #endif
  91   for (regnum = FP_REGNUM - 1 ; regnum >= 0 ; regnum--)
  92     {
  93       if (fsr.regs[regnum])
  94         {
  95           write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
  96         }
  97     }
  98   if (fsr.regs[PS_REGNUM])
  99     {
 100       write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4));
 101     }
 102   write_register (FP_REGNUM, read_memory_integer (fp, 4));
 103   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
 104   write_register (SP_REGNUM, fp + 8);
 105   flush_cached_frames ();
 106   set_current_frame (create_new_frame (read_register (FP_REGNUM),
 107                                        read_pc ()));
 108 }
 109
 110 \f
 111 /* Given an ip value corresponding to the start of a function,
 112    return the ip of the first instruction after the function
 113    prologue.  This is the generic m68k support.  Machines which
 114    require something different can override the SKIP_PROLOGUE
 115    macro to point elsewhere.
 116
 117    Some instructions which typically may appear in a function
 118    prologue include:
 119
 120    A link instruction, word form:
 121
 122         link.w  %a6,&0                  4e56  XXXX
 123
 124    A link instruction, long form:
 125
 126         link.l  %fp,&F%1                480e  XXXX  XXXX
 127
 128    A movm instruction to preserve integer regs:
 129
 130         movm.l  &M%1,(4,%sp)            48ef  XXXX  XXXX
 131
 132    A fmovm instruction to preserve float regs:
 133
 134         fmovm   &FPM%1,(FPO%1,%sp)      f237  XXXX  XXXX  XXXX  XXXX
 135
 136    Some profiling setup code (FIXME, not recognized yet):
 137
 138         lea.l   (.L3,%pc),%a1           43fb  XXXX  XXXX  XXXX
 139         bsr     _mcount                 61ff  XXXX  XXXX
 140
 141   */
 142
 143 #define P_LINK_L        0x480e
 144 #define P_LINK_W        0x4e56
 145 #define P_MOV_L         0x207c
 146 #define P_JSR           0x4eb9
 147 #define P_BSR           0x61ff
 148 #define P_LEA_L         0x43fb
 149 #define P_MOVM_L        0x48ef
 150 #define P_FMOVM         0xf237
 151 #define P_TRAP          0x4e40
 152
 153 CORE_ADDR
 154 m68k_skip_prologue (ip)
 155 CORE_ADDR ip;
 156 {
 157   register CORE_ADDR limit;
 158   struct symtab_and_line sal;
 159   register int op;
 160
 161   /* Find out if there is a known limit for the extent of the prologue.
 162      If so, ensure we don't go past it.  If not, assume "infinity". */
 163
 164   sal = find_pc_line (ip, 0);
 165   limit = (sal.end) ? sal.end : (CORE_ADDR) ~0;
 166
 167   while (ip < limit)
 168     {
 169       op = read_memory_integer (ip, 2);
 170       op &= 0xFFFF;
 171
 172       if (op == P_LINK_W)
 173         {
 174           ip += 4;      /* Skip link.w */
 175         }
 176       else if (op == P_LINK_L)
 177         {
 178           ip += 6;      /* Skip link.l */
 179         }
 180       else if (op == P_MOVM_L)
 181         {
 182           ip += 6;      /* Skip movm.l */
 183         }
 184       else if (op == P_FMOVM)
 185         {
 186           ip += 10;     /* Skip fmovm */
 187         }
 188       else
 189         {
 190           break;        /* Found unknown code, bail out. */
 191         }
 192     }
 193   return (ip);
 194 }
 195
 196 #ifdef USE_PROC_FS      /* Target dependent support for /proc */
 197
 198 #include <sys/procfs.h>
 199
 200 /*  The /proc interface divides the target machine's register set up into
 201     two different sets, the general register set (gregset) and the floating
 202     point register set (fpregset).  For each set, there is an ioctl to get
 203     the current register set and another ioctl to set the current values.
 204
 205     The actual structure passed through the ioctl interface is, of course,
 206     naturally machine dependent, and is different for each set of registers.
 207     For the m68k for example, the general register set is typically defined
 208     by:
 209
 210         typedef int gregset_t[18];
 211
 212         #define R_D0    0
 213         ...
 214         #define R_PS    17
 215
 216     and the floating point set by:
 217
 218         typedef struct fpregset {
 219           int   f_pcr;
 220           int   f_psr;
 221           int   f_fpiaddr;
 222           int   f_fpregs[8][3];         (8 regs, 96 bits each)
 223         } fpregset_t;
 224
 225     These routines provide the packing and unpacking of gregset_t and
 226     fpregset_t formatted data.
 227
 228  */
 229
 230
 231 /*  Given a pointer to a general register set in /proc format (gregset_t *),
 232     unpack the register contents and supply them as gdb's idea of the current
 233     register values. */
 234
 235 void
 236 supply_gregset (gregsetp)
 237 gregset_t *gregsetp;
 238 {
 239   register int regi;
 240   register greg_t *regp = (greg_t *) gregsetp;
 241
 242   for (regi = 0 ; regi < R_PC ; regi++)
 243     {
 244       supply_register (regi, (char *) (regp + regi));
 245     }
 246   supply_register (PS_REGNUM, (char *) (regp + R_PS));
 247   supply_register (PC_REGNUM, (char *) (regp + R_PC));
 248 }
 249
 250 void
 251 fill_gregset (gregsetp, regno)
 252 gregset_t *gregsetp;
 253 int regno;
 254 {
 255   register int regi;
 256   register greg_t *regp = (greg_t *) gregsetp;
 257   extern char registers[];
 258
 259   for (regi = 0 ; regi < R_PC ; regi++)
 260     {
 261       if ((regno == -1) || (regno == regi))
 262         {
 263           *(regp + regi) = *(int *) &registers[REGISTER_BYTE (regi)];
 264         }
 265     }
 266   if ((regno == -1) || (regno == PS_REGNUM))
 267     {
 268       *(regp + R_PS) = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)];
 269     }
 270   if ((regno == -1) || (regno == PC_REGNUM))
 271     {
 272       *(regp + R_PC) = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
 273     }
 274 }
 275
 276 #if defined (FP0_REGNUM)
 277
 278 /*  Given a pointer to a floating point register set in /proc format
 279     (fpregset_t *), unpack the register contents and supply them as gdb's
 280     idea of the current floating point register values. */
 281
 282 void
 283 supply_fpregset (fpregsetp)
 284 fpregset_t *fpregsetp;
 285 {
 286   register int regi;
 287   char *from;
 288
 289   for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
 290     {
 291       from = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
 292       supply_register (regi, from);
 293     }
 294   supply_register (FPC_REGNUM, (char *) &(fpregsetp -> f_pcr));
 295   supply_register (FPS_REGNUM, (char *) &(fpregsetp -> f_psr));
 296   supply_register (FPI_REGNUM, (char *) &(fpregsetp -> f_fpiaddr));
 297 }
 298
 299 /*  Given a pointer to a floating point register set in /proc format
 300     (fpregset_t *), update the register specified by REGNO from gdb's idea
 301     of the current floating point register set.  If REGNO is -1, update
 302     them all. */
 303
 304 void
 305 fill_fpregset (fpregsetp, regno)
 306 fpregset_t *fpregsetp;
 307 int regno;
 308 {
 309   int regi;
 310   char *to;
 311   char *from;
 312   extern char registers[];
 313
 314   for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
 315     {
 316       if ((regno == -1) || (regno == regi))
 317         {
 318           from = (char *) &registers[REGISTER_BYTE (regi)];
 319           to = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
 320           bcopy (from, to, REGISTER_RAW_SIZE (regi));
 321         }
 322     }
 323   if ((regno == -1) || (regno == FPC_REGNUM))
 324     {
 325       fpregsetp -> f_pcr = *(int *) &registers[REGISTER_BYTE (FPC_REGNUM)];
 326     }
 327   if ((regno == -1) || (regno == FPS_REGNUM))
 328     {
 329       fpregsetp -> f_psr = *(int *) &registers[REGISTER_BYTE (FPS_REGNUM)];
 330     }
 331   if ((regno == -1) || (regno == FPI_REGNUM))
 332     {
 333       fpregsetp -> f_fpiaddr = *(int *) &registers[REGISTER_BYTE (FPI_REGNUM)];
 334     }
 335 }
 336
 337 #endif  /* defined (FP0_REGNUM) */
 338
 339 #endif  /* USE_PROC_FS */
 340
 341 #ifdef GET_LONGJMP_TARGET
 342 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
 343    We expect the first arg to be a pointer to the jmp_buf structure from which
 344    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 345    This routine returns true on success. */
 346
 347 int
 348 get_longjmp_target(pc)
 349      CORE_ADDR *pc;
 350 {
 351   CORE_ADDR sp, jb_addr;
 352
 353   sp = read_register(SP_REGNUM);
 354
 355   if (target_read_memory(sp + SP_ARG0, /* Offset of first arg on stack */
 356                          &jb_addr,
 357                          sizeof(CORE_ADDR)))
 358     return 0;
 359
 360
 361   SWAP_TARGET_AND_HOST(&jb_addr, sizeof(CORE_ADDR));
 362
 363   if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, pc,
 364                          sizeof(CORE_ADDR)))
 365     return 0;
 366
 367   SWAP_TARGET_AND_HOST(pc, sizeof(CORE_ADDR));
 368
 369   return 1;
 370 }
 371 #endif /* GET_LONGJMP_TARGET */
 372
 373 /* Immediately after a function call, return the saved pc before the frame
 374    is setup.  We check for the common case of being inside of a system call,
 375    and if so, we know that Sun pushes the call # on the stack prior to doing
 376    the trap. */
 377
 378 CORE_ADDR
 379 m68k_saved_pc_after_call(frame)
 380      struct frame_info *frame;
 381 {
 382 #ifdef sun
 383   int op;
 384
 385   op = read_memory_integer (frame->pc, 2);
 386   op &= 0xFFFF;
 387
 388   if (op == P_TRAP)
 389     return read_memory_integer (read_register (SP_REGNUM) + 4, 4);
 390   else
 391 #endif /* sun */
 392     return read_memory_integer (read_register (SP_REGNUM), 4);
 393 }