gdb/m68k-tdep.c

   1 /* Target-dependent code for the Motorola 68000 series.
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "dwarf2-frame.h"
  24 #include "frame.h"
  25 #include "frame-base.h"
  26 #include "frame-unwind.h"
  27 #include "gdbtypes.h"
  28 #include "symtab.h"
  29 #include "gdbcore.h"
  30 #include "value.h"
  31 #include "gdb_string.h"
  32 #include "gdb_assert.h"
  33 #include "inferior.h"
  34 #include "regcache.h"
  35 #include "arch-utils.h"
  36 #include "osabi.h"
  37 #include "dis-asm.h"
  38 #include "target-descriptions.h"
  39
  40 #include "m68k-tdep.h"
  41 \f
  42
  43 #define P_LINKL_FP      0x480e
  44 #define P_LINKW_FP      0x4e56
  45 #define P_PEA_FP        0x4856
  46 #define P_MOVEAL_SP_FP  0x2c4f
  47 #define P_ADDAW_SP      0xdefc
  48 #define P_ADDAL_SP      0xdffc
  49 #define P_SUBQW_SP      0x514f
  50 #define P_SUBQL_SP      0x518f
  51 #define P_LEA_SP_SP     0x4fef
  52 #define P_LEA_PC_A5     0x4bfb0170
  53 #define P_FMOVEMX_SP    0xf227
  54 #define P_MOVEL_SP      0x2f00
  55 #define P_MOVEML_SP     0x48e7
  56
  57 /* Offset from SP to first arg on stack at first instruction of a function */
  58 #define SP_ARG0 (1 * 4)
  59
  60 #if !defined (BPT_VECTOR)
  61 #define BPT_VECTOR 0xf
  62 #endif
  63
  64 static const gdb_byte *
  65 m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch,
  66                                CORE_ADDR *pcptr, int *lenptr)
  67 {
  68   static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
  69   *lenptr = sizeof (break_insn);
  70   return break_insn;
  71 }
  72 \f
  73
  74 /* Type for %ps.  */
  75 struct type *m68k_ps_type;
  76
  77 /* Construct types for ISA-specific registers.  */
  78 static void
  79 m68k_init_types (void)
  80 {
  81   struct type *type;
  82
  83   type = init_flags_type ("builtin_type_m68k_ps", 4);
  84   append_flags_type_flag (type, 0, "C");
  85   append_flags_type_flag (type, 1, "V");
  86   append_flags_type_flag (type, 2, "Z");
  87   append_flags_type_flag (type, 3, "N");
  88   append_flags_type_flag (type, 4, "X");
  89   append_flags_type_flag (type, 8, "I0");
  90   append_flags_type_flag (type, 9, "I1");
  91   append_flags_type_flag (type, 10, "I2");
  92   append_flags_type_flag (type, 12, "M");
  93   append_flags_type_flag (type, 13, "S");
  94   append_flags_type_flag (type, 14, "T0");
  95   append_flags_type_flag (type, 15, "T1");
  96   m68k_ps_type = type;
  97 }
  98
  99 /* Return the GDB type object for the "standard" data type of data in
 100    register N.  This should be int for D0-D7, SR, FPCONTROL and
 101    FPSTATUS, long double for FP0-FP7, and void pointer for all others
 102    (A0-A7, PC, FPIADDR).  Note, for registers which contain
 103    addresses return pointer to void, not pointer to char, because we
 104    don't want to attempt to print the string after printing the
 105    address.  */
 106
 107 static struct type *
 108 m68k_register_type (struct gdbarch *gdbarch, int regnum)
 109 {
 110   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 111
 112   if (tdep->fpregs_present)
 113     {
 114       if (regnum >= gdbarch_fp0_regnum (gdbarch)
 115           && regnum <= gdbarch_fp0_regnum (gdbarch) + 7)
 116         {
 117           if (tdep->flavour == m68k_coldfire_flavour)
 118             return builtin_type (gdbarch)->builtin_double;
 119           else
 120             return builtin_type_m68881_ext;
 121         }
 122
 123       if (regnum == M68K_FPI_REGNUM)
 124         return builtin_type (gdbarch)->builtin_func_ptr;
 125
 126       if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
 127         return builtin_type_int32;
 128     }
 129   else
 130     {
 131       if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
 132         return builtin_type_int0;
 133     }
 134
 135   if (regnum == gdbarch_pc_regnum (gdbarch))
 136     return builtin_type (gdbarch)->builtin_func_ptr;
 137
 138   if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
 139     return builtin_type (gdbarch)->builtin_data_ptr;
 140
 141   if (regnum == M68K_PS_REGNUM)
 142     return m68k_ps_type;
 143
 144   return builtin_type_int32;
 145 }
 146
 147 static const char *m68k_register_names[] = {
 148     "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
 149     "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
 150     "ps", "pc",
 151     "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
 152     "fpcontrol", "fpstatus", "fpiaddr"
 153   };
 154
 155 /* Function: m68k_register_name
 156    Returns the name of the standard m68k register regnum. */
 157
 158 static const char *
 159 m68k_register_name (struct gdbarch *gdbarch, int regnum)
 160 {
 161   if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
 162     internal_error (__FILE__, __LINE__,
 163                     _("m68k_register_name: illegal register number %d"), regnum);
 164   else
 165     return m68k_register_names[regnum];
 166 }
 167 \f
 168 /* Return nonzero if a value of type TYPE stored in register REGNUM
 169    needs any special handling.  */
 170
 171 static int
 172 m68k_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type)
 173 {
 174   if (!gdbarch_tdep (gdbarch)->fpregs_present)
 175     return 0;
 176   return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7
 177           && type != builtin_type_m68881_ext);
 178 }
 179
 180 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
 181    return its contents in TO.  */
 182
 183 static void
 184 m68k_register_to_value (struct frame_info *frame, int regnum,
 185                         struct type *type, gdb_byte *to)
 186 {
 187   gdb_byte from[M68K_MAX_REGISTER_SIZE];
 188   struct type *fpreg_type = register_type (get_frame_arch (frame),
 189                                            M68K_FP0_REGNUM);
 190
 191   /* We only support floating-point values.  */
 192   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 193     {
 194       warning (_("Cannot convert floating-point register value "
 195                "to non-floating-point type."));
 196       return;
 197     }
 198
 199   /* Convert to TYPE.  */
 200   get_frame_register (frame, regnum, from);
 201   convert_typed_floating (from, fpreg_type, to, type);
 202 }
 203
 204 /* Write the contents FROM of a value of type TYPE into register
 205    REGNUM in frame FRAME.  */
 206
 207 static void
 208 m68k_value_to_register (struct frame_info *frame, int regnum,
 209                         struct type *type, const gdb_byte *from)
 210 {
 211   gdb_byte to[M68K_MAX_REGISTER_SIZE];
 212   struct type *fpreg_type = register_type (get_frame_arch (frame),
 213                                            M68K_FP0_REGNUM);
 214
 215   /* We only support floating-point values.  */
 216   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 217     {
 218       warning (_("Cannot convert non-floating-point type "
 219                "to floating-point register value."));
 220       return;
 221     }
 222
 223   /* Convert from TYPE.  */
 224   convert_typed_floating (from, type, to, fpreg_type);
 225   put_frame_register (frame, regnum, to);
 226 }
 227
 228 \f
 229 /* There is a fair number of calling conventions that are in somewhat
 230    wide use.  The 68000/08/10 don't support an FPU, not even as a
 231    coprocessor.  All function return values are stored in %d0/%d1.
 232    Structures are returned in a static buffer, a pointer to which is
 233    returned in %d0.  This means that functions returning a structure
 234    are not re-entrant.  To avoid this problem some systems use a
 235    convention where the caller passes a pointer to a buffer in %a1
 236    where the return values is to be stored.  This convention is the
 237    default, and is implemented in the function m68k_return_value.
 238
 239    The 68020/030/040/060 do support an FPU, either as a coprocessor
 240    (68881/2) or built-in (68040/68060).  That's why System V release 4
 241    (SVR4) instroduces a new calling convention specified by the SVR4
 242    psABI.  Integer values are returned in %d0/%d1, pointer return
 243    values in %a0 and floating values in %fp0.  When calling functions
 244    returning a structure the caller should pass a pointer to a buffer
 245    for the return value in %a0.  This convention is implemented in the
 246    function m68k_svr4_return_value, and by appropriately setting the
 247    struct_value_regnum member of `struct gdbarch_tdep'.
 248
 249    GNU/Linux returns values in the same way as SVR4 does, but uses %a1
 250    for passing the structure return value buffer.
 251
 252    GCC can also generate code where small structures are returned in
 253    %d0/%d1 instead of in memory by using -freg-struct-return.  This is
 254    the default on NetBSD a.out, OpenBSD and GNU/Linux and several
 255    embedded systems.  This convention is implemented by setting the
 256    struct_return member of `struct gdbarch_tdep' to reg_struct_return.  */
 257
 258 /* Read a function return value of TYPE from REGCACHE, and copy that
 259    into VALBUF.  */
 260
 261 static void
 262 m68k_extract_return_value (struct type *type, struct regcache *regcache,
 263                            gdb_byte *valbuf)
 264 {
 265   int len = TYPE_LENGTH (type);
 266   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 267
 268   if (len <= 4)
 269     {
 270       regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
 271       memcpy (valbuf, buf + (4 - len), len);
 272     }
 273   else if (len <= 8)
 274     {
 275       regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
 276       memcpy (valbuf, buf + (8 - len), len - 4);
 277       regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
 278     }
 279   else
 280     internal_error (__FILE__, __LINE__,
 281                     _("Cannot extract return value of %d bytes long."), len);
 282 }
 283
 284 static void
 285 m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
 286                                 gdb_byte *valbuf)
 287 {
 288   int len = TYPE_LENGTH (type);
 289   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 290   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 291   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 292
 293   if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
 294     {
 295       struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
 296       regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
 297       convert_typed_floating (buf, fpreg_type, valbuf, type);
 298     }
 299   else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
 300     regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
 301   else
 302     m68k_extract_return_value (type, regcache, valbuf);
 303 }
 304
 305 /* Write a function return value of TYPE from VALBUF into REGCACHE.  */
 306
 307 static void
 308 m68k_store_return_value (struct type *type, struct regcache *regcache,
 309                          const gdb_byte *valbuf)
 310 {
 311   int len = TYPE_LENGTH (type);
 312
 313   if (len <= 4)
 314     regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
 315   else if (len <= 8)
 316     {
 317       regcache_raw_write_part (regcache, M68K_D0_REGNUM, 8 - len,
 318                                len - 4, valbuf);
 319       regcache_raw_write (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
 320     }
 321   else
 322     internal_error (__FILE__, __LINE__,
 323                     _("Cannot store return value of %d bytes long."), len);
 324 }
 325
 326 static void
 327 m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
 328                               const gdb_byte *valbuf)
 329 {
 330   int len = TYPE_LENGTH (type);
 331   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 332   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 333
 334   if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
 335     {
 336       struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
 337       gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 338       convert_typed_floating (valbuf, type, buf, fpreg_type);
 339       regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
 340     }
 341   else if (TYPE_CODE (type) == TYPE_CODE_PTR && len == 4)
 342     {
 343       regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
 344       regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
 345     }
 346   else
 347     m68k_store_return_value (type, regcache, valbuf);
 348 }
 349
 350 /* Return non-zero if TYPE, which is assumed to be a structure or
 351    union type, should be returned in registers for architecture
 352    GDBARCH.  */
 353
 354 static int
 355 m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
 356 {
 357   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 358   enum type_code code = TYPE_CODE (type);
 359   int len = TYPE_LENGTH (type);
 360
 361   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
 362
 363   if (tdep->struct_return == pcc_struct_return)
 364     return 0;
 365
 366   return (len == 1 || len == 2 || len == 4 || len == 8);
 367 }
 368
 369 /* Determine, for architecture GDBARCH, how a return value of TYPE
 370    should be returned.  If it is supposed to be returned in registers,
 371    and READBUF is non-zero, read the appropriate value from REGCACHE,
 372    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
 373    from WRITEBUF into REGCACHE.  */
 374
 375 static enum return_value_convention
 376 m68k_return_value (struct gdbarch *gdbarch, struct type *func_type,
 377                    struct type *type, struct regcache *regcache,
 378                    gdb_byte *readbuf, const gdb_byte *writebuf)
 379 {
 380   enum type_code code = TYPE_CODE (type);
 381
 382   /* GCC returns a `long double' in memory too.  */
 383   if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 384        && !m68k_reg_struct_return_p (gdbarch, type))
 385       || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
 386     {
 387       /* The default on m68k is to return structures in static memory.
 388          Consequently a function must return the address where we can
 389          find the return value.  */
 390
 391       if (readbuf)
 392         {
 393           ULONGEST addr;
 394
 395           regcache_raw_read_unsigned (regcache, M68K_D0_REGNUM, &addr);
 396           read_memory (addr, readbuf, TYPE_LENGTH (type));
 397         }
 398
 399       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 400     }
 401
 402   if (readbuf)
 403     m68k_extract_return_value (type, regcache, readbuf);
 404   if (writebuf)
 405     m68k_store_return_value (type, regcache, writebuf);
 406
 407   return RETURN_VALUE_REGISTER_CONVENTION;
 408 }
 409
 410 static enum return_value_convention
 411 m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *func_type,
 412                         struct type *type, struct regcache *regcache,
 413                         gdb_byte *readbuf, const gdb_byte *writebuf)
 414 {
 415   enum type_code code = TYPE_CODE (type);
 416
 417   if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
 418       && !m68k_reg_struct_return_p (gdbarch, type))
 419     {
 420       /* The System V ABI says that:
 421
 422          "A function returning a structure or union also sets %a0 to
 423          the value it finds in %a0.  Thus when the caller receives
 424          control again, the address of the returned object resides in
 425          register %a0."
 426
 427          So the ABI guarantees that we can always find the return
 428          value just after the function has returned.  */
 429
 430       if (readbuf)
 431         {
 432           ULONGEST addr;
 433
 434           regcache_raw_read_unsigned (regcache, M68K_A0_REGNUM, &addr);
 435           read_memory (addr, readbuf, TYPE_LENGTH (type));
 436         }
 437
 438       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 439     }
 440
 441   /* This special case is for structures consisting of a single
 442      `float' or `double' member.  These structures are returned in
 443      %fp0.  For these structures, we call ourselves recursively,
 444      changing TYPE into the type of the first member of the structure.
 445      Since that should work for all structures that have only one
 446      member, we don't bother to check the member's type here.  */
 447   if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
 448     {
 449       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
 450       return m68k_svr4_return_value (gdbarch, func_type, type, regcache,
 451                                      readbuf, writebuf);
 452     }
 453
 454   if (readbuf)
 455     m68k_svr4_extract_return_value (type, regcache, readbuf);
 456   if (writebuf)
 457     m68k_svr4_store_return_value (type, regcache, writebuf);
 458
 459   return RETURN_VALUE_REGISTER_CONVENTION;
 460 }
 461 \f
 462
 463 /* Always align the frame to a 4-byte boundary.  This is required on
 464    coldfire and harmless on the rest.  */
 465
 466 static CORE_ADDR
 467 m68k_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 468 {
 469   /* Align the stack to four bytes.  */
 470   return sp & ~3;
 471 }
 472
 473 static CORE_ADDR
 474 m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 475                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 476                       struct value **args, CORE_ADDR sp, int struct_return,
 477                       CORE_ADDR struct_addr)
 478 {
 479   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 480   gdb_byte buf[4];
 481   int i;
 482
 483   /* Push arguments in reverse order.  */
 484   for (i = nargs - 1; i >= 0; i--)
 485     {
 486       struct type *value_type = value_enclosing_type (args[i]);
 487       int len = TYPE_LENGTH (value_type);
 488       int container_len = (len + 3) & ~3;
 489       int offset;
 490
 491       /* Non-scalars bigger than 4 bytes are left aligned, others are
 492          right aligned.  */
 493       if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
 494            || TYPE_CODE (value_type) == TYPE_CODE_UNION
 495            || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
 496           && len > 4)
 497         offset = 0;
 498       else
 499         offset = container_len - len;
 500       sp -= container_len;
 501       write_memory (sp + offset, value_contents_all (args[i]), len);
 502     }
 503
 504   /* Store struct value address.  */
 505   if (struct_return)
 506     {
 507       store_unsigned_integer (buf, 4, struct_addr);
 508       regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);
 509     }
 510
 511   /* Store return address.  */
 512   sp -= 4;
 513   store_unsigned_integer (buf, 4, bp_addr);
 514   write_memory (sp, buf, 4);
 515
 516   /* Finally, update the stack pointer...  */
 517   store_unsigned_integer (buf, 4, sp);
 518   regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
 519
 520   /* ...and fake a frame pointer.  */
 521   regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
 522
 523   /* DWARF2/GCC uses the stack address *before* the function call as a
 524      frame's CFA.  */
 525   return sp + 8;
 526 }
 527
 528 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
 529
 530 static int
 531 m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num)
 532 {
 533   if (num < 8)
 534     /* d0..7 */
 535     return (num - 0) + M68K_D0_REGNUM;
 536   else if (num < 16)
 537     /* a0..7 */
 538     return (num - 8) + M68K_A0_REGNUM;
 539   else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present)
 540     /* fp0..7 */
 541     return (num - 16) + M68K_FP0_REGNUM;
 542   else if (num == 25)
 543     /* pc */
 544     return M68K_PC_REGNUM;
 545   else
 546     return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 547 }
 548
 549 \f
 550 struct m68k_frame_cache
 551 {
 552   /* Base address.  */
 553   CORE_ADDR base;
 554   CORE_ADDR sp_offset;
 555   CORE_ADDR pc;
 556
 557   /* Saved registers.  */
 558   CORE_ADDR saved_regs[M68K_NUM_REGS];
 559   CORE_ADDR saved_sp;
 560
 561   /* Stack space reserved for local variables.  */
 562   long locals;
 563 };
 564
 565 /* Allocate and initialize a frame cache.  */
 566
 567 static struct m68k_frame_cache *
 568 m68k_alloc_frame_cache (void)
 569 {
 570   struct m68k_frame_cache *cache;
 571   int i;
 572
 573   cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
 574
 575   /* Base address.  */
 576   cache->base = 0;
 577   cache->sp_offset = -4;
 578   cache->pc = 0;
 579
 580   /* Saved registers.  We initialize these to -1 since zero is a valid
 581      offset (that's where %fp is supposed to be stored).  */
 582   for (i = 0; i < M68K_NUM_REGS; i++)
 583     cache->saved_regs[i] = -1;
 584
 585   /* Frameless until proven otherwise.  */
 586   cache->locals = -1;
 587
 588   return cache;
 589 }
 590
 591 /* Check whether PC points at a code that sets up a new stack frame.
 592    If so, it updates CACHE and returns the address of the first
 593    instruction after the sequence that sets removes the "hidden"
 594    argument from the stack or CURRENT_PC, whichever is smaller.
 595    Otherwise, return PC.  */
 596
 597 static CORE_ADDR
 598 m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
 599                           struct m68k_frame_cache *cache)
 600 {
 601   int op;
 602
 603   if (pc >= current_pc)
 604     return current_pc;
 605
 606   op = read_memory_unsigned_integer (pc, 2);
 607
 608   if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
 609     {
 610       cache->saved_regs[M68K_FP_REGNUM] = 0;
 611       cache->sp_offset += 4;
 612       if (op == P_LINKW_FP)
 613         {
 614           /* link.w %fp, #-N */
 615           /* link.w %fp, #0; adda.l #-N, %sp */
 616           cache->locals = -read_memory_integer (pc + 2, 2);
 617
 618           if (pc + 4 < current_pc && cache->locals == 0)
 619             {
 620               op = read_memory_unsigned_integer (pc + 4, 2);
 621               if (op == P_ADDAL_SP)
 622                 {
 623                   cache->locals = read_memory_integer (pc + 6, 4);
 624                   return pc + 10;
 625                 }
 626             }
 627
 628           return pc + 4;
 629         }
 630       else if (op == P_LINKL_FP)
 631         {
 632           /* link.l %fp, #-N */
 633           cache->locals = -read_memory_integer (pc + 2, 4);
 634           return pc + 6;
 635         }
 636       else
 637         {
 638           /* pea (%fp); movea.l %sp, %fp */
 639           cache->locals = 0;
 640
 641           if (pc + 2 < current_pc)
 642             {
 643               op = read_memory_unsigned_integer (pc + 2, 2);
 644
 645               if (op == P_MOVEAL_SP_FP)
 646                 {
 647                   /* move.l %sp, %fp */
 648                   return pc + 4;
 649                 }
 650             }
 651
 652           return pc + 2;
 653         }
 654     }
 655   else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 656     {
 657       /* subq.[wl] #N,%sp */
 658       /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
 659       cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 660       if (pc + 2 < current_pc)
 661         {
 662           op = read_memory_unsigned_integer (pc + 2, 2);
 663           if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 664             {
 665               cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 666               return pc + 4;
 667             }
 668         }
 669       return pc + 2;
 670     }
 671   else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
 672     {
 673       /* adda.w #-N,%sp */
 674       /* lea (-N,%sp),%sp */
 675       cache->locals = -read_memory_integer (pc + 2, 2);
 676       return pc + 4;
 677     }
 678   else if (op == P_ADDAL_SP)
 679     {
 680       /* adda.l #-N,%sp */
 681       cache->locals = -read_memory_integer (pc + 2, 4);
 682       return pc + 6;
 683     }
 684
 685   return pc;
 686 }
 687
 688 /* Check whether PC points at code that saves registers on the stack.
 689    If so, it updates CACHE and returns the address of the first
 690    instruction after the register saves or CURRENT_PC, whichever is
 691    smaller.  Otherwise, return PC.  */
 692
 693 static CORE_ADDR
 694 m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc,
 695                              CORE_ADDR current_pc,
 696                              struct m68k_frame_cache *cache)
 697 {
 698   if (cache->locals >= 0)
 699     {
 700       CORE_ADDR offset;
 701       int op;
 702       int i, mask, regno;
 703
 704       offset = -4 - cache->locals;
 705       while (pc < current_pc)
 706         {
 707           op = read_memory_unsigned_integer (pc, 2);
 708           if (op == P_FMOVEMX_SP
 709               && gdbarch_tdep (gdbarch)->fpregs_present)
 710             {
 711               /* fmovem.x REGS,-(%sp) */
 712               op = read_memory_unsigned_integer (pc + 2, 2);
 713               if ((op & 0xff00) == 0xe000)
 714                 {
 715                   mask = op & 0xff;
 716                   for (i = 0; i < 16; i++, mask >>= 1)
 717                     {
 718                       if (mask & 1)
 719                         {
 720                           cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
 721                           offset -= 12;
 722                         }
 723                     }
 724                   pc += 4;
 725                 }
 726               else
 727                 break;
 728             }
 729           else if ((op & 0177760) == P_MOVEL_SP)
 730             {
 731               /* move.l %R,-(%sp) */
 732               regno = op & 017;
 733               cache->saved_regs[regno] = offset;
 734               offset -= 4;
 735               pc += 2;
 736             }
 737           else if (op == P_MOVEML_SP)
 738             {
 739               /* movem.l REGS,-(%sp) */
 740               mask = read_memory_unsigned_integer (pc + 2, 2);
 741               for (i = 0; i < 16; i++, mask >>= 1)
 742                 {
 743                   if (mask & 1)
 744                     {
 745                       cache->saved_regs[15 - i] = offset;
 746                       offset -= 4;
 747                     }
 748                 }
 749               pc += 4;
 750             }
 751           else
 752             break;
 753         }
 754     }
 755
 756   return pc;
 757 }
 758
 759
 760 /* Do a full analysis of the prologue at PC and update CACHE
 761    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
 762    address where the analysis stopped.
 763
 764    We handle all cases that can be generated by gcc.
 765
 766    For allocating a stack frame:
 767
 768    link.w %a6,#-N
 769    link.l %a6,#-N
 770    pea (%fp); move.l %sp,%fp
 771    link.w %a6,#0; add.l #-N,%sp
 772    subq.l #N,%sp
 773    subq.w #N,%sp
 774    subq.w #8,%sp; subq.w #N-8,%sp
 775    add.w #-N,%sp
 776    lea (-N,%sp),%sp
 777    add.l #-N,%sp
 778
 779    For saving registers:
 780
 781    fmovem.x REGS,-(%sp)
 782    move.l R1,-(%sp)
 783    move.l R1,-(%sp); move.l R2,-(%sp)
 784    movem.l REGS,-(%sp)
 785
 786    For setting up the PIC register:
 787
 788    lea (%pc,N),%a5
 789
 790    */
 791
 792 static CORE_ADDR
 793 m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
 794                        CORE_ADDR current_pc, struct m68k_frame_cache *cache)
 795 {
 796   unsigned int op;
 797
 798   pc = m68k_analyze_frame_setup (pc, current_pc, cache);
 799   pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache);
 800   if (pc >= current_pc)
 801     return current_pc;
 802
 803   /* Check for GOT setup.  */
 804   op = read_memory_unsigned_integer (pc, 4);
 805   if (op == P_LEA_PC_A5)
 806     {
 807       /* lea (%pc,N),%a5 */
 808       return pc + 8;
 809     }
 810
 811   return pc;
 812 }
 813
 814 /* Return PC of first real instruction.  */
 815
 816 static CORE_ADDR
 817 m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 818 {
 819   struct m68k_frame_cache cache;
 820   CORE_ADDR pc;
 821   int op;
 822
 823   cache.locals = -1;
 824   pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
 825   if (cache.locals < 0)
 826     return start_pc;
 827   return pc;
 828 }
 829
 830 static CORE_ADDR
 831 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 832 {
 833   gdb_byte buf[8];
 834
 835   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
 836   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 837 }
 838 \f
 839 /* Normal frames.  */
 840
 841 static struct m68k_frame_cache *
 842 m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
 843 {
 844   struct m68k_frame_cache *cache;
 845   gdb_byte buf[4];
 846   int i;
 847
 848   if (*this_cache)
 849     return *this_cache;
 850
 851   cache = m68k_alloc_frame_cache ();
 852   *this_cache = cache;
 853
 854   /* In principle, for normal frames, %fp holds the frame pointer,
 855      which holds the base address for the current stack frame.
 856      However, for functions that don't need it, the frame pointer is
 857      optional.  For these "frameless" functions the frame pointer is
 858      actually the frame pointer of the calling frame.  Signal
 859      trampolines are just a special case of a "frameless" function.
 860      They (usually) share their frame pointer with the frame that was
 861      in progress when the signal occurred.  */
 862
 863   get_frame_register (this_frame, M68K_FP_REGNUM, buf);
 864   cache->base = extract_unsigned_integer (buf, 4);
 865   if (cache->base == 0)
 866     return cache;
 867
 868   /* For normal frames, %pc is stored at 4(%fp).  */
 869   cache->saved_regs[M68K_PC_REGNUM] = 4;
 870
 871   cache->pc = get_frame_func (this_frame);
 872   if (cache->pc != 0)
 873     m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
 874                            get_frame_pc (this_frame), cache);
 875
 876   if (cache->locals < 0)
 877     {
 878       /* We didn't find a valid frame, which means that CACHE->base
 879          currently holds the frame pointer for our calling frame.  If
 880          we're at the start of a function, or somewhere half-way its
 881          prologue, the function's frame probably hasn't been fully
 882          setup yet.  Try to reconstruct the base address for the stack
 883          frame by looking at the stack pointer.  For truly "frameless"
 884          functions this might work too.  */
 885
 886       get_frame_register (this_frame, M68K_SP_REGNUM, buf);
 887       cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset;
 888     }
 889
 890   /* Now that we have the base address for the stack frame we can
 891      calculate the value of %sp in the calling frame.  */
 892   cache->saved_sp = cache->base + 8;
 893
 894   /* Adjust all the saved registers such that they contain addresses
 895      instead of offsets.  */
 896   for (i = 0; i < M68K_NUM_REGS; i++)
 897     if (cache->saved_regs[i] != -1)
 898       cache->saved_regs[i] += cache->base;
 899
 900   return cache;
 901 }
 902
 903 static void
 904 m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
 905                     struct frame_id *this_id)
 906 {
 907   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 908
 909   /* This marks the outermost frame.  */
 910   if (cache->base == 0)
 911     return;
 912
 913   /* See the end of m68k_push_dummy_call.  */
 914   *this_id = frame_id_build (cache->base + 8, cache->pc);
 915 }
 916
 917 static struct value *
 918 m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 919                           int regnum)
 920 {
 921   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 922
 923   gdb_assert (regnum >= 0);
 924
 925   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
 926     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 927
 928   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
 929     return frame_unwind_got_memory (this_frame, regnum,
 930                                     cache->saved_regs[regnum]);
 931
 932   return frame_unwind_got_register (this_frame, regnum, regnum);
 933 }
 934
 935 static const struct frame_unwind m68k_frame_unwind =
 936 {
 937   NORMAL_FRAME,
 938   m68k_frame_this_id,
 939   m68k_frame_prev_register,
 940   NULL,
 941   default_frame_sniffer
 942 };
 943 \f
 944 static CORE_ADDR
 945 m68k_frame_base_address (struct frame_info *this_frame, void **this_cache)
 946 {
 947   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 948
 949   return cache->base;
 950 }
 951
 952 static const struct frame_base m68k_frame_base =
 953 {
 954   &m68k_frame_unwind,
 955   m68k_frame_base_address,
 956   m68k_frame_base_address,
 957   m68k_frame_base_address
 958 };
 959
 960 static struct frame_id
 961 m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 962 {
 963   CORE_ADDR fp;
 964
 965   fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM);
 966
 967   /* See the end of m68k_push_dummy_call.  */
 968   return frame_id_build (fp + 8, get_frame_pc (this_frame));
 969 }
 970 \f
 971
 972 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
 973    We expect the first arg to be a pointer to the jmp_buf structure from which
 974    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 975    This routine returns true on success. */
 976
 977 static int
 978 m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
 979 {
 980   gdb_byte *buf;
 981   CORE_ADDR sp, jb_addr;
 982   struct gdbarch *gdbarch = get_frame_arch (frame);
 983   struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame));
 984
 985   if (tdep->jb_pc < 0)
 986     {
 987       internal_error (__FILE__, __LINE__,
 988                       _("m68k_get_longjmp_target: not implemented"));
 989       return 0;
 990     }
 991
 992   buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
 993   sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch));
 994
 995   if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
 996                           buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
 997     return 0;
 998
 999   jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1000                                              / TARGET_CHAR_BIT);
1001
1002   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1003                           gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
1004     return 0;
1005
1006   *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1007                                          / TARGET_CHAR_BIT);
1008   return 1;
1009 }
1010 \f
1011
1012 /* System V Release 4 (SVR4).  */
1013
1014 void
1015 m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1016 {
1017   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1018
1019   /* SVR4 uses a different calling convention.  */
1020   set_gdbarch_return_value (gdbarch, m68k_svr4_return_value);
1021
1022   /* SVR4 uses %a0 instead of %a1.  */
1023   tdep->struct_value_regnum = M68K_A0_REGNUM;
1024 }
1025 \f
1026
1027 /* Function: m68k_gdbarch_init
1028    Initializer function for the m68k gdbarch vector.
1029    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1030
1031 static struct gdbarch *
1032 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1033 {
1034   struct gdbarch_tdep *tdep = NULL;
1035   struct gdbarch *gdbarch;
1036   struct gdbarch_list *best_arch;
1037   struct tdesc_arch_data *tdesc_data = NULL;
1038   int i;
1039   enum m68k_flavour flavour = m68k_no_flavour;
1040   int has_fp = 1;
1041   const struct floatformat **long_double_format = floatformats_m68881_ext;
1042
1043   /* Check any target description for validity.  */
1044   if (tdesc_has_registers (info.target_desc))
1045     {
1046       const struct tdesc_feature *feature;
1047       int valid_p;
1048
1049       feature = tdesc_find_feature (info.target_desc,
1050                                     "org.gnu.gdb.m68k.core");
1051       if (feature != NULL)
1052         /* Do nothing.  */
1053         ;
1054
1055       if (feature == NULL)
1056         {
1057           feature = tdesc_find_feature (info.target_desc,
1058                                         "org.gnu.gdb.coldfire.core");
1059           if (feature != NULL)
1060             flavour = m68k_coldfire_flavour;
1061         }
1062
1063       if (feature == NULL)
1064         {
1065           feature = tdesc_find_feature (info.target_desc,
1066                                         "org.gnu.gdb.fido.core");
1067           if (feature != NULL)
1068             flavour = m68k_fido_flavour;
1069         }
1070
1071       if (feature == NULL)
1072         return NULL;
1073
1074       tdesc_data = tdesc_data_alloc ();
1075
1076       valid_p = 1;
1077       for (i = 0; i <= M68K_PC_REGNUM; i++)
1078         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1079                                             m68k_register_names[i]);
1080
1081       if (!valid_p)
1082         {
1083           tdesc_data_cleanup (tdesc_data);
1084           return NULL;
1085         }
1086
1087       feature = tdesc_find_feature (info.target_desc,
1088                                     "org.gnu.gdb.coldfire.fp");
1089       if (feature != NULL)
1090         {
1091           valid_p = 1;
1092           for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
1093             valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1094                                                 m68k_register_names[i]);
1095           if (!valid_p)
1096             {
1097               tdesc_data_cleanup (tdesc_data);
1098               return NULL;
1099             }
1100         }
1101       else
1102         has_fp = 0;
1103     }
1104
1105   /* The mechanism for returning floating values from function
1106      and the type of long double depend on whether we're
1107      on ColdFire or standard m68k. */
1108
1109   if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
1110     {
1111       const bfd_arch_info_type *coldfire_arch =
1112         bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
1113
1114       if (coldfire_arch
1115           && ((*info.bfd_arch_info->compatible)
1116               (info.bfd_arch_info, coldfire_arch)))
1117         flavour = m68k_coldfire_flavour;
1118     }
1119
1120   /* If there is already a candidate, use it.  */
1121   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1122        best_arch != NULL;
1123        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1124     {
1125       if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
1126         continue;
1127
1128       if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
1129         continue;
1130
1131       break;
1132     }
1133
1134   tdep = xmalloc (sizeof (struct gdbarch_tdep));
1135   gdbarch = gdbarch_alloc (&info, tdep);
1136   tdep->fpregs_present = has_fp;
1137   tdep->flavour = flavour;
1138
1139   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1140     long_double_format = floatformats_ieee_double;
1141   set_gdbarch_long_double_format (gdbarch, long_double_format);
1142   set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
1143
1144   set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
1145   set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
1146
1147   /* Stack grows down. */
1148   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1149   set_gdbarch_frame_align (gdbarch, m68k_frame_align);
1150
1151   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1152   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1153     set_gdbarch_decr_pc_after_break (gdbarch, 2);
1154
1155   set_gdbarch_frame_args_skip (gdbarch, 8);
1156   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1157
1158   set_gdbarch_register_type (gdbarch, m68k_register_type);
1159   set_gdbarch_register_name (gdbarch, m68k_register_name);
1160   set_gdbarch_num_regs (gdbarch, M68K_NUM_REGS);
1161   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1162   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1163   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1164   set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1165   set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p);
1166   set_gdbarch_register_to_value (gdbarch,  m68k_register_to_value);
1167   set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
1168
1169   if (has_fp)
1170     set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1171
1172   /* Try to figure out if the arch uses floating registers to return
1173      floating point values from functions.  */
1174   if (has_fp)
1175     {
1176       /* On ColdFire, floating point values are returned in D0.  */
1177       if (flavour == m68k_coldfire_flavour)
1178         tdep->float_return = 0;
1179       else
1180         tdep->float_return = 1;
1181     }
1182   else
1183     {
1184       /* No floating registers, so can't use them for returning values.  */
1185       tdep->float_return = 0;
1186     }
1187
1188   /* Function call & return */
1189   set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1190   set_gdbarch_return_value (gdbarch, m68k_return_value);
1191
1192
1193   /* Disassembler.  */
1194   set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1195
1196 #if defined JB_PC && defined JB_ELEMENT_SIZE
1197   tdep->jb_pc = JB_PC;
1198   tdep->jb_elt_size = JB_ELEMENT_SIZE;
1199 #else
1200   tdep->jb_pc = -1;
1201 #endif
1202   tdep->struct_value_regnum = M68K_A1_REGNUM;
1203   tdep->struct_return = reg_struct_return;
1204
1205   /* Frame unwinder.  */
1206   set_gdbarch_dummy_id (gdbarch, m68k_dummy_id);
1207   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1208
1209   /* Hook in the DWARF CFI frame unwinder.  */
1210   dwarf2_append_unwinders (gdbarch);
1211
1212   frame_base_set_default (gdbarch, &m68k_frame_base);
1213
1214   /* Hook in ABI-specific overrides, if they have been registered.  */
1215   gdbarch_init_osabi (info, gdbarch);
1216
1217   /* Now we have tuned the configuration, set a few final things,
1218      based on what the OS ABI has told us.  */
1219
1220   if (tdep->jb_pc >= 0)
1221     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1222
1223   frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
1224
1225   if (tdesc_data)
1226     tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
1227
1228   return gdbarch;
1229 }
1230
1231
1232 static void
1233 m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1234 {
1235   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1236
1237   if (tdep == NULL)
1238     return;
1239 }
1240
1241 extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1242
1243 void
1244 _initialize_m68k_tdep (void)
1245 {
1246   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1247
1248   /* Initialize the m68k-specific register types.  */
1249   m68k_init_types ();
1250 }