gdb/m68k-tdep.c

   1 /* Target dependent code for the Motorola 68000 series.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
   3    2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "symtab.h"
  26 #include "gdbcore.h"
  27 #include "value.h"
  28 #include "gdb_string.h"
  29 #include "inferior.h"
  30 #include "regcache.h"
  31 #include "arch-utils.h"
  32
  33 #include "m68k-tdep.h"
  34 \f
  35
  36 #define P_LINKL_FP      0x480e
  37 #define P_LINKW_FP      0x4e56
  38 #define P_PEA_FP        0x4856
  39 #define P_MOVL_SP_FP    0x2c4f
  40 #define P_MOVL          0x207c
  41 #define P_JSR           0x4eb9
  42 #define P_BSR           0x61ff
  43 #define P_LEAL          0x43fb
  44 #define P_MOVML         0x48ef
  45 #define P_FMOVM         0xf237
  46 #define P_TRAP          0x4e40
  47
  48
  49 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
  50 #define REGISTER_BYTES_NOFP (16*4 + 8)
  51
  52 #define NUM_FREGS (NUM_REGS-24)
  53
  54 /* Offset from SP to first arg on stack at first instruction of a function */
  55
  56 #define SP_ARG0 (1 * 4)
  57
  58 /* This was determined by experimentation on hp300 BSD 4.3.  Perhaps
  59    it corresponds to some offset in /usr/include/sys/user.h or
  60    something like that.  Using some system include file would
  61    have the advantage of probably being more robust in the face
  62    of OS upgrades, but the disadvantage of being wrong for
  63    cross-debugging.  */
  64
  65 #define SIG_PC_FP_OFFSET 530
  66
  67 #define TARGET_M68K
  68
  69
  70 #if !defined (BPT_VECTOR)
  71 #define BPT_VECTOR 0xf
  72 #endif
  73
  74 #if !defined (REMOTE_BPT_VECTOR)
  75 #define REMOTE_BPT_VECTOR 1
  76 #endif
  77
  78
  79 void m68k_frame_init_saved_regs (struct frame_info *frame_info);
  80
  81
  82 /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
  83    so m68k_remote_breakpoint_from_pc is currently not used.  */
  84
  85 const static unsigned char *
  86 m68k_remote_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
  87 {
  88   static unsigned char break_insn[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR)};
  89   *lenptr = sizeof (break_insn);
  90   return break_insn;
  91 }
  92
  93 const static unsigned char *
  94 m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
  95 {
  96   static unsigned char break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
  97   *lenptr = sizeof (break_insn);
  98   return break_insn;
  99 }
 100
 101
 102 static int
 103 m68k_register_bytes_ok (long numbytes)
 104 {
 105   return ((numbytes == REGISTER_BYTES_FP)
 106           || (numbytes == REGISTER_BYTES_NOFP));
 107 }
 108
 109 /* Number of bytes of storage in the actual machine representation
 110    for register regnum.  On the 68000, all regs are 4 bytes
 111    except the floating point regs which are 12 bytes.  */
 112 /* Note that the unsigned cast here forces the result of the
 113    subtraction to very high positive values if regnum < FP0_REGNUM */
 114
 115 static int
 116 m68k_register_raw_size (int regnum)
 117 {
 118   return (((unsigned) (regnum) - FP0_REGNUM) < 8 ? 12 : 4);
 119 }
 120
 121 /* Number of bytes of storage in the program's representation
 122    for register regnum.  On the 68000, all regs are 4 bytes
 123    except the floating point regs which are 12-byte long doubles.  */
 124
 125 static int
 126 m68k_register_virtual_size (int regnum)
 127 {
 128   return (((unsigned) (regnum) - FP0_REGNUM) < 8 ? 12 : 4);
 129 }
 130
 131 /* Return the GDB type object for the "standard" data type of data in
 132    register N.  This should be int for D0-D7, SR, FPCONTROL and
 133    FPSTATUS, long double for FP0-FP7, and void pointer for all others
 134    (A0-A7, PC, FPIADDR).  Note, for registers which contain
 135    addresses return pointer to void, not pointer to char, because we
 136    don't want to attempt to print the string after printing the
 137    address.  */
 138
 139 static struct type *
 140 m68k_register_virtual_type (int regnum)
 141 {
 142   if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
 143     return builtin_type_m68881_ext;
 144
 145   if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
 146     return builtin_type_void_func_ptr;
 147
 148   if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
 149       || regnum == PS_REGNUM)
 150     return builtin_type_int32;
 151
 152   if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
 153     return builtin_type_void_data_ptr;
 154
 155   return builtin_type_int32;
 156 }
 157
 158 /* Function: m68k_register_name
 159    Returns the name of the standard m68k register regnum. */
 160
 161 static const char *
 162 m68k_register_name (int regnum)
 163 {
 164   static char *register_names[] = {
 165     "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
 166     "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
 167     "ps", "pc",
 168     "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
 169     "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
 170   };
 171
 172   if (regnum < 0 ||
 173       regnum >= sizeof (register_names) / sizeof (register_names[0]))
 174     internal_error (__FILE__, __LINE__,
 175                     "m68k_register_name: illegal register number %d", regnum);
 176   else
 177     return register_names[regnum];
 178 }
 179
 180 /* Stack must be kept short aligned when doing function calls.  */
 181
 182 static CORE_ADDR
 183 m68k_stack_align (CORE_ADDR addr)
 184 {
 185   return ((addr + 1) & ~1);
 186 }
 187
 188 /* Index within `registers' of the first byte of the space for
 189    register regnum.  */
 190
 191 static int
 192 m68k_register_byte (int regnum)
 193 {
 194   if (regnum >= M68K_FPC_REGNUM)
 195     return (((regnum - M68K_FPC_REGNUM) * 4) + 168);
 196   else if (regnum >= FP0_REGNUM)
 197     return (((regnum - FP0_REGNUM) * 12) + 72);
 198   else
 199     return (regnum * 4);
 200 }
 201
 202 /* Store the address of the place in which to copy the structure the
 203    subroutine will return.  This is called from call_function. */
 204
 205 static void
 206 m68k_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 207 {
 208   write_register (M68K_A1_REGNUM, addr);
 209 }
 210
 211 /* Extract from an array regbuf containing the (raw) register state
 212    a function return value of type type, and copy that, in virtual format,
 213    into valbuf.  This is assuming that floating point values are returned
 214    as doubles in d0/d1.  */
 215
 216 static void
 217 m68k_deprecated_extract_return_value (struct type *type, char *regbuf,
 218                                       char *valbuf)
 219 {
 220   int offset = 0;
 221   int typeLength = TYPE_LENGTH (type);
 222
 223   if (typeLength < 4)
 224     offset = 4 - typeLength;
 225
 226   memcpy (valbuf, regbuf + offset, typeLength);
 227 }
 228
 229 static CORE_ADDR
 230 m68k_deprecated_extract_struct_value_address (char *regbuf)
 231 {
 232   return (*(CORE_ADDR *) (regbuf));
 233 }
 234
 235 /* Write into appropriate registers a function return value
 236    of type TYPE, given in virtual format.  Assumes floats are passed
 237    in d0/d1.  */
 238
 239 static void
 240 m68k_store_return_value (struct type *type, char *valbuf)
 241 {
 242   deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (type));
 243 }
 244
 245 /* Describe the pointer in each stack frame to the previous stack frame
 246    (its caller).  */
 247
 248 /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
 249    the frame's chain-pointer.  In the case of the 68000, the frame's
 250    nominal address is the address of a 4-byte word containing the
 251    calling frame's address.  */
 252
 253 /* If we are chaining from sigtramp, then manufacture a sigtramp frame
 254    (which isn't really on the stack.  I'm not sure this is right for anything
 255    but BSD4.3 on an hp300.  */
 256
 257 static CORE_ADDR
 258 m68k_frame_chain (struct frame_info *thisframe)
 259 {
 260   if (get_frame_type (thisframe) == SIGTRAMP_FRAME)
 261     return get_frame_base (thisframe);
 262   else if (!inside_entry_file (get_frame_pc (thisframe)))
 263     return read_memory_unsigned_integer (get_frame_base (thisframe), 4);
 264   else
 265     return 0;
 266 }
 267
 268 /* A function that tells us whether the function invocation represented
 269    by fi does not have a frame on the stack associated with it.  If it
 270    does not, FRAMELESS is set to 1, else 0.  */
 271
 272 static int
 273 m68k_frameless_function_invocation (struct frame_info *fi)
 274 {
 275   if (get_frame_type (fi) == SIGTRAMP_FRAME)
 276     return 0;
 277   else
 278     return frameless_look_for_prologue (fi);
 279 }
 280
 281 static CORE_ADDR
 282 m68k_frame_saved_pc (struct frame_info *frame)
 283 {
 284   if (get_frame_type (frame) == SIGTRAMP_FRAME)
 285     {
 286       if (get_next_frame (frame))
 287         return read_memory_unsigned_integer (get_frame_base (get_next_frame (frame))
 288                                              + SIG_PC_FP_OFFSET, 4);
 289       else
 290         return read_memory_unsigned_integer (read_register (SP_REGNUM)
 291                                              + SIG_PC_FP_OFFSET - 8, 4);
 292     }
 293   else
 294     return read_memory_unsigned_integer (get_frame_base (frame) + 4, 4);
 295 }
 296
 297
 298 /* The only reason this is here is the tm-altos.h reference below.  It
 299    was moved back here from tm-m68k.h.  FIXME? */
 300
 301 extern CORE_ADDR
 302 altos_skip_prologue (CORE_ADDR pc)
 303 {
 304   register int op = read_memory_unsigned_integer (pc, 2);
 305   if (op == P_LINKW_FP)
 306     pc += 4;                    /* Skip link #word */
 307   else if (op == P_LINKL_FP)
 308     pc += 6;                    /* Skip link #long */
 309   /* Not sure why branches are here.  */
 310   /* From tm-altos.h */
 311   else if (op == 0060000)
 312     pc += 4;                    /* Skip bra #word */
 313   else if (op == 00600377)
 314     pc += 6;                    /* skip bra #long */
 315   else if ((op & 0177400) == 0060000)
 316     pc += 2;                    /* skip bra #char */
 317   return pc;
 318 }
 319
 320 int
 321 delta68_in_sigtramp (CORE_ADDR pc, char *name)
 322 {
 323   if (name != NULL)
 324     return strcmp (name, "_sigcode") == 0;
 325   else
 326     return 0;
 327 }
 328
 329 CORE_ADDR
 330 delta68_frame_args_address (struct frame_info *frame_info)
 331 {
 332   /* we assume here that the only frameless functions are the system calls
 333      or other functions who do not put anything on the stack. */
 334   if (get_frame_type (frame_info) == SIGTRAMP_FRAME)
 335     return get_frame_base (frame_info) + 12;
 336   else if (frameless_look_for_prologue (frame_info))
 337     {
 338       /* Check for an interrupted system call */
 339       if (get_next_frame (frame_info) && (get_frame_type (get_next_frame (frame_info)) == SIGTRAMP_FRAME))
 340         return get_frame_base (get_next_frame (frame_info)) + 16;
 341       else
 342         return get_frame_base (frame_info) + 4;
 343     }
 344   else
 345     return get_frame_base (frame_info);
 346 }
 347
 348 CORE_ADDR
 349 delta68_frame_saved_pc (struct frame_info *frame_info)
 350 {
 351   return read_memory_unsigned_integer (delta68_frame_args_address (frame_info)
 352                                        + 4, 4);
 353 }
 354
 355 /* Return number of args passed to a frame.
 356    Can return -1, meaning no way to tell.  */
 357
 358 int
 359 isi_frame_num_args (struct frame_info *fi)
 360 {
 361   int val;
 362   CORE_ADDR pc = DEPRECATED_FRAME_SAVED_PC (fi);
 363   int insn = read_memory_unsigned_integer (pc, 2);
 364   val = 0;
 365   if (insn == 0047757 || insn == 0157374)       /* lea W(sp),sp or addaw #W,sp */
 366     val = read_memory_integer (pc + 2, 2);
 367   else if ((insn & 0170777) == 0050217  /* addql #N, sp */
 368            || (insn & 0170777) == 0050117)      /* addqw */
 369     {
 370       val = (insn >> 9) & 7;
 371       if (val == 0)
 372         val = 8;
 373     }
 374   else if (insn == 0157774)     /* addal #WW, sp */
 375     val = read_memory_integer (pc + 2, 4);
 376   val >>= 2;
 377   return val;
 378 }
 379
 380 int
 381 delta68_frame_num_args (struct frame_info *fi)
 382 {
 383   int val;
 384   CORE_ADDR pc = DEPRECATED_FRAME_SAVED_PC (fi);
 385   int insn = read_memory_unsigned_integer (pc, 2);
 386   val = 0;
 387   if (insn == 0047757 || insn == 0157374)       /* lea W(sp),sp or addaw #W,sp */
 388     val = read_memory_integer (pc + 2, 2);
 389   else if ((insn & 0170777) == 0050217  /* addql #N, sp */
 390            || (insn & 0170777) == 0050117)      /* addqw */
 391     {
 392       val = (insn >> 9) & 7;
 393       if (val == 0)
 394         val = 8;
 395     }
 396   else if (insn == 0157774)     /* addal #WW, sp */
 397     val = read_memory_integer (pc + 2, 4);
 398   val >>= 2;
 399   return val;
 400 }
 401
 402 int
 403 news_frame_num_args (struct frame_info *fi)
 404 {
 405   int val;
 406   CORE_ADDR pc = DEPRECATED_FRAME_SAVED_PC (fi);
 407   int insn = read_memory_unsigned_integer (pc, 2);
 408   val = 0;
 409   if (insn == 0047757 || insn == 0157374)       /* lea W(sp),sp or addaw #W,sp */
 410     val = read_memory_integer (pc + 2, 2);
 411   else if ((insn & 0170777) == 0050217  /* addql #N, sp */
 412            || (insn & 0170777) == 0050117)      /* addqw */
 413     {
 414       val = (insn >> 9) & 7;
 415       if (val == 0)
 416         val = 8;
 417     }
 418   else if (insn == 0157774)     /* addal #WW, sp */
 419     val = read_memory_integer (pc + 2, 4);
 420   val >>= 2;
 421   return val;
 422 }
 423
 424 /* Insert the specified number of args and function address
 425    into a call sequence of the above form stored at DUMMYNAME.
 426    We use the BFD routines to store a big-endian value of known size.  */
 427
 428 void
 429 m68k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 430                      struct value **args, struct type *type, int gcc_p)
 431 {
 432   bfd_putb32 (fun, (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 2);
 433   bfd_putb32 (nargs * 4,
 434               (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 8);
 435 }
 436
 437
 438 /* Push an empty stack frame, to record the current PC, etc.  */
 439
 440 void
 441 m68k_push_dummy_frame (void)
 442 {
 443   register CORE_ADDR sp = read_register (SP_REGNUM);
 444   register int regnum;
 445   char raw_buffer[12];
 446
 447   sp = push_word (sp, read_register (PC_REGNUM));
 448   sp = push_word (sp, read_register (FP_REGNUM));
 449   write_register (FP_REGNUM, sp);
 450
 451   /* Always save the floating-point registers, whether they exist on
 452      this target or not.  */
 453   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
 454     {
 455       deprecated_read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
 456       sp = push_bytes (sp, raw_buffer, 12);
 457     }
 458
 459   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
 460     {
 461       sp = push_word (sp, read_register (regnum));
 462     }
 463   sp = push_word (sp, read_register (PS_REGNUM));
 464   write_register (SP_REGNUM, sp);
 465 }
 466
 467 /* Discard from the stack the innermost frame,
 468    restoring all saved registers.  */
 469
 470 void
 471 m68k_pop_frame (void)
 472 {
 473   register struct frame_info *frame = get_current_frame ();
 474   register CORE_ADDR fp;
 475   register int regnum;
 476   char raw_buffer[12];
 477
 478   fp = get_frame_base (frame);
 479   m68k_frame_init_saved_regs (frame);
 480   for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
 481     {
 482       if (get_frame_saved_regs (frame)[regnum])
 483         {
 484           read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, 12);
 485           deprecated_write_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
 486                                            12);
 487         }
 488     }
 489   for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
 490     {
 491       if (get_frame_saved_regs (frame)[regnum])
 492         {
 493           write_register (regnum,
 494                           read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
 495         }
 496     }
 497   if (get_frame_saved_regs (frame)[PS_REGNUM])
 498     {
 499       write_register (PS_REGNUM,
 500                       read_memory_integer (get_frame_saved_regs (frame)[PS_REGNUM], 4));
 501     }
 502   write_register (FP_REGNUM, read_memory_integer (fp, 4));
 503   write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
 504   write_register (SP_REGNUM, fp + 8);
 505   flush_cached_frames ();
 506 }
 507 \f
 508
 509 /* Given an ip value corresponding to the start of a function,
 510    return the ip of the first instruction after the function
 511    prologue.  This is the generic m68k support.  Machines which
 512    require something different can override the SKIP_PROLOGUE
 513    macro to point elsewhere.
 514
 515    Some instructions which typically may appear in a function
 516    prologue include:
 517
 518    A link instruction, word form:
 519
 520    link.w       %a6,&0                  4e56  XXXX
 521
 522    A link instruction, long form:
 523
 524    link.l  %fp,&F%1             480e  XXXX  XXXX
 525
 526    A movm instruction to preserve integer regs:
 527
 528    movm.l  &M%1,(4,%sp)         48ef  XXXX  XXXX
 529
 530    A fmovm instruction to preserve float regs:
 531
 532    fmovm   &FPM%1,(FPO%1,%sp)   f237  XXXX  XXXX  XXXX  XXXX
 533
 534    Some profiling setup code (FIXME, not recognized yet):
 535
 536    lea.l   (.L3,%pc),%a1                43fb  XXXX  XXXX  XXXX
 537    bsr     _mcount                      61ff  XXXX  XXXX
 538
 539  */
 540
 541 CORE_ADDR
 542 m68k_skip_prologue (CORE_ADDR ip)
 543 {
 544   register CORE_ADDR limit;
 545   struct symtab_and_line sal;
 546   register int op;
 547
 548   /* Find out if there is a known limit for the extent of the prologue.
 549      If so, ensure we don't go past it.  If not, assume "infinity". */
 550
 551   sal = find_pc_line (ip, 0);
 552   limit = (sal.end) ? sal.end : (CORE_ADDR) ~0;
 553
 554   while (ip < limit)
 555     {
 556       op = read_memory_unsigned_integer (ip, 2);
 557
 558       if (op == P_LINKW_FP)
 559         ip += 4;                /* Skip link.w */
 560       else if (op == P_PEA_FP)
 561         ip += 2;                /* Skip pea %fp */
 562       else if (op == P_MOVL_SP_FP)
 563         ip += 2;                /* Skip move.l %sp, %fp */
 564       else if (op == P_LINKL_FP)
 565         ip += 6;                /* Skip link.l */
 566       else if (op == P_MOVML)
 567         ip += 6;                /* Skip movm.l */
 568       else if (op == P_FMOVM)
 569         ip += 10;               /* Skip fmovm */
 570       else
 571         break;                  /* Found unknown code, bail out. */
 572     }
 573   return (ip);
 574 }
 575
 576 /* Store the addresses of the saved registers of the frame described by
 577    FRAME_INFO in its saved_regs field.
 578    This includes special registers such as pc and fp saved in special
 579    ways in the stack frame.  sp is even more special:
 580    the address we return for it IS the sp for the next frame.  */
 581
 582 void
 583 m68k_frame_init_saved_regs (struct frame_info *frame_info)
 584 {
 585   register int regnum;
 586   register int regmask;
 587   register CORE_ADDR next_addr;
 588   register CORE_ADDR pc;
 589
 590   /* First possible address for a pc in a call dummy for this frame.  */
 591   CORE_ADDR possible_call_dummy_start =
 592     get_frame_base (frame_info) - 28 - FP_REGNUM * 4 - 4 - 8 * 12;
 593
 594   int nextinsn;
 595
 596   if (get_frame_saved_regs (frame_info))
 597     return;
 598
 599   frame_saved_regs_zalloc (frame_info);
 600
 601   memset (get_frame_saved_regs (frame_info), 0, SIZEOF_FRAME_SAVED_REGS);
 602
 603   if (get_frame_pc (frame_info) >= possible_call_dummy_start
 604       && get_frame_pc (frame_info) <= get_frame_base (frame_info))
 605     {
 606
 607       /* It is a call dummy.  We could just stop now, since we know
 608          what the call dummy saves and where.  But this code proceeds
 609          to parse the "prologue" which is part of the call dummy.
 610          This is needlessly complex and confusing.  FIXME.  */
 611
 612       next_addr = get_frame_base (frame_info);
 613       pc = possible_call_dummy_start;
 614     }
 615   else
 616     {
 617       pc = get_pc_function_start (get_frame_pc (frame_info));
 618
 619       nextinsn = read_memory_unsigned_integer (pc, 2);
 620       if (P_PEA_FP == nextinsn
 621           && P_MOVL_SP_FP == read_memory_unsigned_integer (pc + 2, 2))
 622         {
 623           /* pea %fp
 624              move.l %sp, %fp */
 625           next_addr = get_frame_base (frame_info);
 626           pc += 4;
 627         }
 628       else if (P_LINKL_FP == nextinsn)
 629         /* link.l %fp */
 630         /* Find the address above the saved
 631            regs using the amount of storage from the link instruction.  */
 632         {
 633           next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 4);
 634           pc += 6;
 635         }
 636       else if (P_LINKW_FP == nextinsn)
 637         /* link.w %fp */
 638         /* Find the address above the saved
 639            regs using the amount of storage from the link instruction.  */
 640         {
 641           next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 2);
 642           pc += 4;
 643         }
 644       else
 645         goto lose;
 646
 647       /* If have an addal #-n, sp next, adjust next_addr.  */
 648       if (read_memory_unsigned_integer (pc, 2) == 0157774)
 649         next_addr += read_memory_integer (pc += 2, 4), pc += 4;
 650     }
 651
 652   for (;;)
 653     {
 654       nextinsn = read_memory_unsigned_integer (pc, 2);
 655       regmask = read_memory_unsigned_integer (pc + 2, 2);
 656       /* fmovemx to -(sp) */
 657       if (0xf227 == nextinsn && (regmask & 0xff00) == 0xe000)
 658         {
 659           /* Regmask's low bit is for register fp7, the first pushed */
 660           for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
 661             if (regmask & 1)
 662               get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 12);
 663           pc += 4;
 664         }
 665       /* fmovemx to (fp + displacement) */
 666       else if (0171056 == nextinsn && (regmask & 0xff00) == 0xf000)
 667         {
 668           register CORE_ADDR addr;
 669
 670           addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2);
 671           /* Regmask's low bit is for register fp7, the first pushed */
 672           for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
 673             if (regmask & 1)
 674               {
 675                 get_frame_saved_regs (frame_info)[regnum] = addr;
 676                 addr += 12;
 677               }
 678           pc += 6;
 679         }
 680       /* moveml to (sp) */
 681       else if (0044327 == nextinsn)
 682         {
 683           /* Regmask's low bit is for register 0, the first written */
 684           for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
 685             if (regmask & 1)
 686               {
 687                 get_frame_saved_regs (frame_info)[regnum] = next_addr;
 688                 next_addr += 4;
 689               }
 690           pc += 4;
 691         }
 692       /* moveml to (fp + displacement) */
 693       else if (0044356 == nextinsn)
 694         {
 695           register CORE_ADDR addr;
 696
 697           addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2);
 698           /* Regmask's low bit is for register 0, the first written */
 699           for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
 700             if (regmask & 1)
 701               {
 702                 get_frame_saved_regs (frame_info)[regnum] = addr;
 703                 addr += 4;
 704               }
 705           pc += 6;
 706         }
 707       /* moveml to -(sp) */
 708       else if (0044347 == nextinsn)
 709         {
 710           /* Regmask's low bit is for register 15, the first pushed */
 711           for (regnum = 16; --regnum >= 0; regmask >>= 1)
 712             if (regmask & 1)
 713               get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
 714           pc += 4;
 715         }
 716       /* movl r,-(sp) */
 717       else if (0x2f00 == (0xfff0 & nextinsn))
 718         {
 719           regnum = 0xf & nextinsn;
 720           get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
 721           pc += 2;
 722         }
 723       /* fmovemx to index of sp */
 724       else if (0xf236 == nextinsn && (regmask & 0xff00) == 0xf000)
 725         {
 726           /* Regmask's low bit is for register fp0, the first written */
 727           for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
 728             if (regmask & 1)
 729               {
 730                 get_frame_saved_regs (frame_info)[regnum] = next_addr;
 731                 next_addr += 12;
 732               }
 733           pc += 10;
 734         }
 735       /* clrw -(sp); movw ccr,-(sp) */
 736       else if (0x4267 == nextinsn && 0x42e7 == regmask)
 737         {
 738           get_frame_saved_regs (frame_info)[PS_REGNUM] = (next_addr -= 4);
 739           pc += 4;
 740         }
 741       else
 742         break;
 743     }
 744 lose:;
 745   get_frame_saved_regs (frame_info)[SP_REGNUM] = get_frame_base (frame_info) + 8;
 746   get_frame_saved_regs (frame_info)[FP_REGNUM] = get_frame_base (frame_info);
 747   get_frame_saved_regs (frame_info)[PC_REGNUM] = get_frame_base (frame_info) + 4;
 748 #ifdef SIG_SP_FP_OFFSET
 749   /* Adjust saved SP_REGNUM for fake _sigtramp frames.  */
 750   if ((get_frame_type (frame_info) == SIGTRAMP_FRAME) && frame_info->next)
 751     frame_info->saved_regs[SP_REGNUM] =
 752       frame_info->next->frame + SIG_SP_FP_OFFSET;
 753 #endif
 754 }
 755
 756
 757 #ifdef USE_PROC_FS              /* Target dependent support for /proc */
 758
 759 #include <sys/procfs.h>
 760
 761 /* Prototypes for supply_gregset etc. */
 762 #include "gregset.h"
 763
 764 /*  The /proc interface divides the target machine's register set up into
 765    two different sets, the general register set (gregset) and the floating
 766    point register set (fpregset).  For each set, there is an ioctl to get
 767    the current register set and another ioctl to set the current values.
 768
 769    The actual structure passed through the ioctl interface is, of course,
 770    naturally machine dependent, and is different for each set of registers.
 771    For the m68k for example, the general register set is typically defined
 772    by:
 773
 774    typedef int gregset_t[18];
 775
 776    #define      R_D0    0
 777    ...
 778    #define      R_PS    17
 779
 780    and the floating point set by:
 781
 782    typedef      struct fpregset {
 783    int  f_pcr;
 784    int  f_psr;
 785    int  f_fpiaddr;
 786    int  f_fpregs[8][3];         (8 regs, 96 bits each)
 787    } fpregset_t;
 788
 789    These routines provide the packing and unpacking of gregset_t and
 790    fpregset_t formatted data.
 791
 792  */
 793
 794 /* Atari SVR4 has R_SR but not R_PS */
 795
 796 #if !defined (R_PS) && defined (R_SR)
 797 #define R_PS R_SR
 798 #endif
 799
 800 /*  Given a pointer to a general register set in /proc format (gregset_t *),
 801    unpack the register contents and supply them as gdb's idea of the current
 802    register values. */
 803
 804 void
 805 supply_gregset (gregset_t *gregsetp)
 806 {
 807   register int regi;
 808   register greg_t *regp = (greg_t *) gregsetp;
 809
 810   for (regi = 0; regi < R_PC; regi++)
 811     {
 812       supply_register (regi, (char *) (regp + regi));
 813     }
 814   supply_register (PS_REGNUM, (char *) (regp + R_PS));
 815   supply_register (PC_REGNUM, (char *) (regp + R_PC));
 816 }
 817
 818 void
 819 fill_gregset (gregset_t *gregsetp, int regno)
 820 {
 821   register int regi;
 822   register greg_t *regp = (greg_t *) gregsetp;
 823
 824   for (regi = 0; regi < R_PC; regi++)
 825     {
 826       if ((regno == -1) || (regno == regi))
 827         {
 828           *(regp + regi) = *(int *) &deprecated_registers[REGISTER_BYTE (regi)];
 829         }
 830     }
 831   if ((regno == -1) || (regno == PS_REGNUM))
 832     {
 833       *(regp + R_PS) = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
 834     }
 835   if ((regno == -1) || (regno == PC_REGNUM))
 836     {
 837       *(regp + R_PC) = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
 838     }
 839 }
 840
 841 #if defined (FP0_REGNUM)
 842
 843 /*  Given a pointer to a floating point register set in /proc format
 844    (fpregset_t *), unpack the register contents and supply them as gdb's
 845    idea of the current floating point register values. */
 846
 847 void
 848 supply_fpregset (fpregset_t *fpregsetp)
 849 {
 850   register int regi;
 851   char *from;
 852
 853   for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
 854     {
 855       from = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
 856       supply_register (regi, from);
 857     }
 858   supply_register (M68K_FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
 859   supply_register (M68K_FPS_REGNUM, (char *) &(fpregsetp->f_psr));
 860   supply_register (M68K_FPI_REGNUM, (char *) &(fpregsetp->f_fpiaddr));
 861 }
 862
 863 /*  Given a pointer to a floating point register set in /proc format
 864    (fpregset_t *), update the register specified by REGNO from gdb's idea
 865    of the current floating point register set.  If REGNO is -1, update
 866    them all. */
 867
 868 void
 869 fill_fpregset (fpregset_t *fpregsetp, int regno)
 870 {
 871   int regi;
 872   char *to;
 873   char *from;
 874
 875   for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
 876     {
 877       if ((regno == -1) || (regno == regi))
 878         {
 879           from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
 880           to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
 881           memcpy (to, from, REGISTER_RAW_SIZE (regi));
 882         }
 883     }
 884   if ((regno == -1) || (regno == M68K_FPC_REGNUM))
 885     {
 886       fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPC_REGNUM)];
 887     }
 888   if ((regno == -1) || (regno == M68K_FPS_REGNUM))
 889     {
 890       fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPS_REGNUM)];
 891     }
 892   if ((regno == -1) || (regno == M68K_FPI_REGNUM))
 893     {
 894       fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPI_REGNUM)];
 895     }
 896 }
 897
 898 #endif /* defined (FP0_REGNUM) */
 899
 900 #endif /* USE_PROC_FS */
 901
 902 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
 903    We expect the first arg to be a pointer to the jmp_buf structure from which
 904    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 905    This routine returns true on success. */
 906
 907 /* NOTE: cagney/2000-11-08: For this function to be fully multi-arched
 908    the macro's JB_PC and JB_ELEMENT_SIZE would need to be moved into
 909    the ``struct gdbarch_tdep'' object and then set on a target ISA/ABI
 910    dependant basis. */
 911
 912 int
 913 m68k_get_longjmp_target (CORE_ADDR *pc)
 914 {
 915 #if defined (JB_PC) && defined (JB_ELEMENT_SIZE)
 916   char *buf;
 917   CORE_ADDR sp, jb_addr;
 918
 919   buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
 920   sp = read_register (SP_REGNUM);
 921
 922   if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
 923                           buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
 924     return 0;
 925
 926   jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 927
 928   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
 929                           TARGET_PTR_BIT / TARGET_CHAR_BIT))
 930     return 0;
 931
 932   *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 933
 934   return 1;
 935 #else
 936   internal_error (__FILE__, __LINE__,
 937                   "m68k_get_longjmp_target: not implemented");
 938   return 0;
 939 #endif
 940 }
 941
 942 /* Immediately after a function call, return the saved pc before the frame
 943    is setup.  For sun3's, we check for the common case of being inside of a
 944    system call, and if so, we know that Sun pushes the call # on the stack
 945    prior to doing the trap. */
 946
 947 CORE_ADDR
 948 m68k_saved_pc_after_call (struct frame_info *frame)
 949 {
 950 #ifdef SYSCALL_TRAP
 951   int op;
 952
 953   op = read_memory_unsigned_integer (frame->pc - SYSCALL_TRAP_OFFSET, 2);
 954
 955   if (op == SYSCALL_TRAP)
 956     return read_memory_unsigned_integer (read_register (SP_REGNUM) + 4, 4);
 957   else
 958 #endif /* SYSCALL_TRAP */
 959     return read_memory_unsigned_integer (read_register (SP_REGNUM), 4);
 960 }
 961
 962 /* Function: m68k_gdbarch_init
 963    Initializer function for the m68k gdbarch vector.
 964    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
 965
 966 static struct gdbarch *
 967 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 968 {
 969   static LONGEST call_dummy_words[7] = { 0xf227e0ff, 0x48e7fffc, 0x426742e7,
 970     0x4eb93232, 0x3232dffc, 0x69696969,
 971     (0x4e404e71 | (BPT_VECTOR << 16))
 972   };
 973   struct gdbarch_tdep *tdep = NULL;
 974   struct gdbarch *gdbarch;
 975
 976   /* find a candidate among the list of pre-declared architectures. */
 977   arches = gdbarch_list_lookup_by_info (arches, &info);
 978   if (arches != NULL)
 979     return (arches->gdbarch);
 980
 981 #if 0
 982   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
 983 #endif
 984
 985   gdbarch = gdbarch_alloc (&info, 0);
 986
 987   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
 988      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
 989   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
 990
 991   set_gdbarch_long_double_format (gdbarch, &floatformat_m68881_ext);
 992   set_gdbarch_long_double_bit (gdbarch, 96);
 993
 994   set_gdbarch_function_start_offset (gdbarch, 0);
 995
 996   set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
 997   set_gdbarch_saved_pc_after_call (gdbarch, m68k_saved_pc_after_call);
 998   set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
 999
1000   /* Stack grows down. */
1001   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1002   set_gdbarch_stack_align (gdbarch, m68k_stack_align);
1003   set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
1004
1005   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1006   set_gdbarch_decr_pc_after_break (gdbarch, 2);
1007
1008   set_gdbarch_deprecated_store_struct_return (gdbarch, m68k_store_struct_return);
1009   set_gdbarch_deprecated_extract_return_value (gdbarch,
1010                                                m68k_deprecated_extract_return_value);
1011   set_gdbarch_deprecated_store_return_value (gdbarch, m68k_store_return_value);
1012
1013   set_gdbarch_deprecated_frame_chain (gdbarch, m68k_frame_chain);
1014   set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68k_frame_saved_pc);
1015   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, m68k_frame_init_saved_regs);
1016   set_gdbarch_frameless_function_invocation (gdbarch,
1017                                              m68k_frameless_function_invocation);
1018   /* OK to default this value to 'unknown'. */
1019   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1020   set_gdbarch_frame_args_skip (gdbarch, 8);
1021
1022   set_gdbarch_register_raw_size (gdbarch, m68k_register_raw_size);
1023   set_gdbarch_register_virtual_size (gdbarch, m68k_register_virtual_size);
1024   set_gdbarch_deprecated_max_register_raw_size (gdbarch, 12);
1025   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 12);
1026   set_gdbarch_register_virtual_type (gdbarch, m68k_register_virtual_type);
1027   set_gdbarch_register_name (gdbarch, m68k_register_name);
1028   set_gdbarch_register_size (gdbarch, 4);
1029   set_gdbarch_register_byte (gdbarch, m68k_register_byte);
1030   set_gdbarch_num_regs (gdbarch, 29);
1031   set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
1032   set_gdbarch_register_bytes (gdbarch, (16 * 4 + 8 + 8 * 12 + 3 * 4));
1033   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1034   set_gdbarch_fp_regnum (gdbarch, M68K_FP_REGNUM);
1035   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1036   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1037   set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1038
1039   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
1040   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1041   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1042   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 24);
1043   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
1044   set_gdbarch_call_dummy_length (gdbarch, 28);
1045   set_gdbarch_call_dummy_start_offset (gdbarch, 12);
1046
1047   set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
1048   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
1049   set_gdbarch_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
1050   set_gdbarch_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
1051   set_gdbarch_deprecated_pop_frame (gdbarch, m68k_pop_frame);
1052
1053   /* Should be using push_dummy_call.  */
1054   set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
1055
1056   return gdbarch;
1057 }
1058
1059
1060 static void
1061 m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1062 {
1063
1064 }
1065
1066 void
1067 _initialize_m68k_tdep (void)
1068 {
1069   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1070   tm_print_insn = print_insn_m68k;
1071 }