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