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 != register_type (gdbarch, M68K_FP0_REGNUM));
 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   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 499   gdb_byte buf[4];
 500   int i;
 501
 502   /* Push arguments in reverse order.  */
 503   for (i = nargs - 1; i >= 0; i--)
 504     {
 505       struct type *value_type = value_enclosing_type (args[i]);
 506       int len = TYPE_LENGTH (value_type);
 507       int container_len = (len + 3) & ~3;
 508       int offset;
 509
 510       /* Non-scalars bigger than 4 bytes are left aligned, others are
 511          right aligned.  */
 512       if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
 513            || TYPE_CODE (value_type) == TYPE_CODE_UNION
 514            || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
 515           && len > 4)
 516         offset = 0;
 517       else
 518         offset = container_len - len;
 519       sp -= container_len;
 520       write_memory (sp + offset, value_contents_all (args[i]), len);
 521     }
 522
 523   /* Store struct value address.  */
 524   if (struct_return)
 525     {
 526       store_unsigned_integer (buf, 4, byte_order, struct_addr);
 527       regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);
 528     }
 529
 530   /* Store return address.  */
 531   sp -= 4;
 532   store_unsigned_integer (buf, 4, byte_order, bp_addr);
 533   write_memory (sp, buf, 4);
 534
 535   /* Finally, update the stack pointer...  */
 536   store_unsigned_integer (buf, 4, byte_order, sp);
 537   regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
 538
 539   /* ...and fake a frame pointer.  */
 540   regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
 541
 542   /* DWARF2/GCC uses the stack address *before* the function call as a
 543      frame's CFA.  */
 544   return sp + 8;
 545 }
 546
 547 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
 548
 549 static int
 550 m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num)
 551 {
 552   if (num < 8)
 553     /* d0..7 */
 554     return (num - 0) + M68K_D0_REGNUM;
 555   else if (num < 16)
 556     /* a0..7 */
 557     return (num - 8) + M68K_A0_REGNUM;
 558   else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present)
 559     /* fp0..7 */
 560     return (num - 16) + M68K_FP0_REGNUM;
 561   else if (num == 25)
 562     /* pc */
 563     return M68K_PC_REGNUM;
 564   else
 565     return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 566 }
 567
 568 \f
 569 struct m68k_frame_cache
 570 {
 571   /* Base address.  */
 572   CORE_ADDR base;
 573   CORE_ADDR sp_offset;
 574   CORE_ADDR pc;
 575
 576   /* Saved registers.  */
 577   CORE_ADDR saved_regs[M68K_NUM_REGS];
 578   CORE_ADDR saved_sp;
 579
 580   /* Stack space reserved for local variables.  */
 581   long locals;
 582 };
 583
 584 /* Allocate and initialize a frame cache.  */
 585
 586 static struct m68k_frame_cache *
 587 m68k_alloc_frame_cache (void)
 588 {
 589   struct m68k_frame_cache *cache;
 590   int i;
 591
 592   cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
 593
 594   /* Base address.  */
 595   cache->base = 0;
 596   cache->sp_offset = -4;
 597   cache->pc = 0;
 598
 599   /* Saved registers.  We initialize these to -1 since zero is a valid
 600      offset (that's where %fp is supposed to be stored).  */
 601   for (i = 0; i < M68K_NUM_REGS; i++)
 602     cache->saved_regs[i] = -1;
 603
 604   /* Frameless until proven otherwise.  */
 605   cache->locals = -1;
 606
 607   return cache;
 608 }
 609
 610 /* Check whether PC points at a code that sets up a new stack frame.
 611    If so, it updates CACHE and returns the address of the first
 612    instruction after the sequence that sets removes the "hidden"
 613    argument from the stack or CURRENT_PC, whichever is smaller.
 614    Otherwise, return PC.  */
 615
 616 static CORE_ADDR
 617 m68k_analyze_frame_setup (struct gdbarch *gdbarch,
 618                           CORE_ADDR pc, CORE_ADDR current_pc,
 619                           struct m68k_frame_cache *cache)
 620 {
 621   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 622   int op;
 623
 624   if (pc >= current_pc)
 625     return current_pc;
 626
 627   op = read_memory_unsigned_integer (pc, 2, byte_order);
 628
 629   if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
 630     {
 631       cache->saved_regs[M68K_FP_REGNUM] = 0;
 632       cache->sp_offset += 4;
 633       if (op == P_LINKW_FP)
 634         {
 635           /* link.w %fp, #-N */
 636           /* link.w %fp, #0; adda.l #-N, %sp */
 637           cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
 638
 639           if (pc + 4 < current_pc && cache->locals == 0)
 640             {
 641               op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
 642               if (op == P_ADDAL_SP)
 643                 {
 644                   cache->locals = read_memory_integer (pc + 6, 4, byte_order);
 645                   return pc + 10;
 646                 }
 647             }
 648
 649           return pc + 4;
 650         }
 651       else if (op == P_LINKL_FP)
 652         {
 653           /* link.l %fp, #-N */
 654           cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
 655           return pc + 6;
 656         }
 657       else
 658         {
 659           /* pea (%fp); movea.l %sp, %fp */
 660           cache->locals = 0;
 661
 662           if (pc + 2 < current_pc)
 663             {
 664               op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 665
 666               if (op == P_MOVEAL_SP_FP)
 667                 {
 668                   /* move.l %sp, %fp */
 669                   return pc + 4;
 670                 }
 671             }
 672
 673           return pc + 2;
 674         }
 675     }
 676   else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 677     {
 678       /* subq.[wl] #N,%sp */
 679       /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
 680       cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 681       if (pc + 2 < current_pc)
 682         {
 683           op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 684           if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 685             {
 686               cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 687               return pc + 4;
 688             }
 689         }
 690       return pc + 2;
 691     }
 692   else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
 693     {
 694       /* adda.w #-N,%sp */
 695       /* lea (-N,%sp),%sp */
 696       cache->locals = -read_memory_integer (pc + 2, 2, byte_order);
 697       return pc + 4;
 698     }
 699   else if (op == P_ADDAL_SP)
 700     {
 701       /* adda.l #-N,%sp */
 702       cache->locals = -read_memory_integer (pc + 2, 4, byte_order);
 703       return pc + 6;
 704     }
 705
 706   return pc;
 707 }
 708
 709 /* Check whether PC points at code that saves registers on the stack.
 710    If so, it updates CACHE and returns the address of the first
 711    instruction after the register saves or CURRENT_PC, whichever is
 712    smaller.  Otherwise, return PC.  */
 713
 714 static CORE_ADDR
 715 m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc,
 716                              CORE_ADDR current_pc,
 717                              struct m68k_frame_cache *cache)
 718 {
 719   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 720
 721   if (cache->locals >= 0)
 722     {
 723       CORE_ADDR offset;
 724       int op;
 725       int i, mask, regno;
 726
 727       offset = -4 - cache->locals;
 728       while (pc < current_pc)
 729         {
 730           op = read_memory_unsigned_integer (pc, 2, byte_order);
 731           if (op == P_FMOVEMX_SP
 732               && gdbarch_tdep (gdbarch)->fpregs_present)
 733             {
 734               /* fmovem.x REGS,-(%sp) */
 735               op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 736               if ((op & 0xff00) == 0xe000)
 737                 {
 738                   mask = op & 0xff;
 739                   for (i = 0; i < 16; i++, mask >>= 1)
 740                     {
 741                       if (mask & 1)
 742                         {
 743                           cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
 744                           offset -= 12;
 745                         }
 746                     }
 747                   pc += 4;
 748                 }
 749               else
 750                 break;
 751             }
 752           else if ((op & 0177760) == P_MOVEL_SP)
 753             {
 754               /* move.l %R,-(%sp) */
 755               regno = op & 017;
 756               cache->saved_regs[regno] = offset;
 757               offset -= 4;
 758               pc += 2;
 759             }
 760           else if (op == P_MOVEML_SP)
 761             {
 762               /* movem.l REGS,-(%sp) */
 763               mask = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 764               for (i = 0; i < 16; i++, mask >>= 1)
 765                 {
 766                   if (mask & 1)
 767                     {
 768                       cache->saved_regs[15 - i] = offset;
 769                       offset -= 4;
 770                     }
 771                 }
 772               pc += 4;
 773             }
 774           else
 775             break;
 776         }
 777     }
 778
 779   return pc;
 780 }
 781
 782
 783 /* Do a full analysis of the prologue at PC and update CACHE
 784    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
 785    address where the analysis stopped.
 786
 787    We handle all cases that can be generated by gcc.
 788
 789    For allocating a stack frame:
 790
 791    link.w %a6,#-N
 792    link.l %a6,#-N
 793    pea (%fp); move.l %sp,%fp
 794    link.w %a6,#0; add.l #-N,%sp
 795    subq.l #N,%sp
 796    subq.w #N,%sp
 797    subq.w #8,%sp; subq.w #N-8,%sp
 798    add.w #-N,%sp
 799    lea (-N,%sp),%sp
 800    add.l #-N,%sp
 801
 802    For saving registers:
 803
 804    fmovem.x REGS,-(%sp)
 805    move.l R1,-(%sp)
 806    move.l R1,-(%sp); move.l R2,-(%sp)
 807    movem.l REGS,-(%sp)
 808
 809    For setting up the PIC register:
 810
 811    lea (%pc,N),%a5
 812
 813    */
 814
 815 static CORE_ADDR
 816 m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
 817                        CORE_ADDR current_pc, struct m68k_frame_cache *cache)
 818 {
 819   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 820   unsigned int op;
 821
 822   pc = m68k_analyze_frame_setup (gdbarch, pc, current_pc, cache);
 823   pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache);
 824   if (pc >= current_pc)
 825     return current_pc;
 826
 827   /* Check for GOT setup.  */
 828   op = read_memory_unsigned_integer (pc, 4, byte_order);
 829   if (op == P_LEA_PC_A5)
 830     {
 831       /* lea (%pc,N),%a5 */
 832       return pc + 8;
 833     }
 834
 835   return pc;
 836 }
 837
 838 /* Return PC of first real instruction.  */
 839
 840 static CORE_ADDR
 841 m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 842 {
 843   struct m68k_frame_cache cache;
 844   CORE_ADDR pc;
 845   int op;
 846
 847   cache.locals = -1;
 848   pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
 849   if (cache.locals < 0)
 850     return start_pc;
 851   return pc;
 852 }
 853
 854 static CORE_ADDR
 855 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 856 {
 857   gdb_byte buf[8];
 858
 859   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
 860   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 861 }
 862 \f
 863 /* Normal frames.  */
 864
 865 static struct m68k_frame_cache *
 866 m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
 867 {
 868   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 869   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 870   struct m68k_frame_cache *cache;
 871   gdb_byte buf[4];
 872   int i;
 873
 874   if (*this_cache)
 875     return *this_cache;
 876
 877   cache = m68k_alloc_frame_cache ();
 878   *this_cache = cache;
 879
 880   /* In principle, for normal frames, %fp holds the frame pointer,
 881      which holds the base address for the current stack frame.
 882      However, for functions that don't need it, the frame pointer is
 883      optional.  For these "frameless" functions the frame pointer is
 884      actually the frame pointer of the calling frame.  Signal
 885      trampolines are just a special case of a "frameless" function.
 886      They (usually) share their frame pointer with the frame that was
 887      in progress when the signal occurred.  */
 888
 889   get_frame_register (this_frame, M68K_FP_REGNUM, buf);
 890   cache->base = extract_unsigned_integer (buf, 4, byte_order);
 891   if (cache->base == 0)
 892     return cache;
 893
 894   /* For normal frames, %pc is stored at 4(%fp).  */
 895   cache->saved_regs[M68K_PC_REGNUM] = 4;
 896
 897   cache->pc = get_frame_func (this_frame);
 898   if (cache->pc != 0)
 899     m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
 900                            get_frame_pc (this_frame), cache);
 901
 902   if (cache->locals < 0)
 903     {
 904       /* We didn't find a valid frame, which means that CACHE->base
 905          currently holds the frame pointer for our calling frame.  If
 906          we're at the start of a function, or somewhere half-way its
 907          prologue, the function's frame probably hasn't been fully
 908          setup yet.  Try to reconstruct the base address for the stack
 909          frame by looking at the stack pointer.  For truly "frameless"
 910          functions this might work too.  */
 911
 912       get_frame_register (this_frame, M68K_SP_REGNUM, buf);
 913       cache->base = extract_unsigned_integer (buf, 4, byte_order)
 914                     + cache->sp_offset;
 915     }
 916
 917   /* Now that we have the base address for the stack frame we can
 918      calculate the value of %sp in the calling frame.  */
 919   cache->saved_sp = cache->base + 8;
 920
 921   /* Adjust all the saved registers such that they contain addresses
 922      instead of offsets.  */
 923   for (i = 0; i < M68K_NUM_REGS; i++)
 924     if (cache->saved_regs[i] != -1)
 925       cache->saved_regs[i] += cache->base;
 926
 927   return cache;
 928 }
 929
 930 static void
 931 m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
 932                     struct frame_id *this_id)
 933 {
 934   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 935
 936   /* This marks the outermost frame.  */
 937   if (cache->base == 0)
 938     return;
 939
 940   /* See the end of m68k_push_dummy_call.  */
 941   *this_id = frame_id_build (cache->base + 8, cache->pc);
 942 }
 943
 944 static struct value *
 945 m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 946                           int regnum)
 947 {
 948   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 949
 950   gdb_assert (regnum >= 0);
 951
 952   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
 953     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 954
 955   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
 956     return frame_unwind_got_memory (this_frame, regnum,
 957                                     cache->saved_regs[regnum]);
 958
 959   return frame_unwind_got_register (this_frame, regnum, regnum);
 960 }
 961
 962 static const struct frame_unwind m68k_frame_unwind =
 963 {
 964   NORMAL_FRAME,
 965   m68k_frame_this_id,
 966   m68k_frame_prev_register,
 967   NULL,
 968   default_frame_sniffer
 969 };
 970 \f
 971 static CORE_ADDR
 972 m68k_frame_base_address (struct frame_info *this_frame, void **this_cache)
 973 {
 974   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 975
 976   return cache->base;
 977 }
 978
 979 static const struct frame_base m68k_frame_base =
 980 {
 981   &m68k_frame_unwind,
 982   m68k_frame_base_address,
 983   m68k_frame_base_address,
 984   m68k_frame_base_address
 985 };
 986
 987 static struct frame_id
 988 m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 989 {
 990   CORE_ADDR fp;
 991
 992   fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM);
 993
 994   /* See the end of m68k_push_dummy_call.  */
 995   return frame_id_build (fp + 8, get_frame_pc (this_frame));
 996 }
 997 \f
 998
 999 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
1000    We expect the first arg to be a pointer to the jmp_buf structure from which
1001    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
1002    This routine returns true on success. */
1003
1004 static int
1005 m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1006 {
1007   gdb_byte *buf;
1008   CORE_ADDR sp, jb_addr;
1009   struct gdbarch *gdbarch = get_frame_arch (frame);
1010   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1011   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1012
1013   if (tdep->jb_pc < 0)
1014     {
1015       internal_error (__FILE__, __LINE__,
1016                       _("m68k_get_longjmp_target: not implemented"));
1017       return 0;
1018     }
1019
1020   buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
1021   sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch));
1022
1023   if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
1024                           buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
1025     return 0;
1026
1027   jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1028                                              / TARGET_CHAR_BIT, byte_order);
1029
1030   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1031                           gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT),
1032                           byte_order)
1033     return 0;
1034
1035   *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch)
1036                                          / TARGET_CHAR_BIT, byte_order);
1037   return 1;
1038 }
1039 \f
1040
1041 /* System V Release 4 (SVR4).  */
1042
1043 void
1044 m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1045 {
1046   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1047
1048   /* SVR4 uses a different calling convention.  */
1049   set_gdbarch_return_value (gdbarch, m68k_svr4_return_value);
1050
1051   /* SVR4 uses %a0 instead of %a1.  */
1052   tdep->struct_value_regnum = M68K_A0_REGNUM;
1053 }
1054 \f
1055
1056 /* Function: m68k_gdbarch_init
1057    Initializer function for the m68k gdbarch vector.
1058    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1059
1060 static struct gdbarch *
1061 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1062 {
1063   struct gdbarch_tdep *tdep = NULL;
1064   struct gdbarch *gdbarch;
1065   struct gdbarch_list *best_arch;
1066   struct tdesc_arch_data *tdesc_data = NULL;
1067   int i;
1068   enum m68k_flavour flavour = m68k_no_flavour;
1069   int has_fp = 1;
1070   const struct floatformat **long_double_format = floatformats_m68881_ext;
1071
1072   /* Check any target description for validity.  */
1073   if (tdesc_has_registers (info.target_desc))
1074     {
1075       const struct tdesc_feature *feature;
1076       int valid_p;
1077
1078       feature = tdesc_find_feature (info.target_desc,
1079                                     "org.gnu.gdb.m68k.core");
1080       if (feature != NULL)
1081         /* Do nothing.  */
1082         ;
1083
1084       if (feature == NULL)
1085         {
1086           feature = tdesc_find_feature (info.target_desc,
1087                                         "org.gnu.gdb.coldfire.core");
1088           if (feature != NULL)
1089             flavour = m68k_coldfire_flavour;
1090         }
1091
1092       if (feature == NULL)
1093         {
1094           feature = tdesc_find_feature (info.target_desc,
1095                                         "org.gnu.gdb.fido.core");
1096           if (feature != NULL)
1097             flavour = m68k_fido_flavour;
1098         }
1099
1100       if (feature == NULL)
1101         return NULL;
1102
1103       tdesc_data = tdesc_data_alloc ();
1104
1105       valid_p = 1;
1106       for (i = 0; i <= M68K_PC_REGNUM; i++)
1107         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1108                                             m68k_register_names[i]);
1109
1110       if (!valid_p)
1111         {
1112           tdesc_data_cleanup (tdesc_data);
1113           return NULL;
1114         }
1115
1116       feature = tdesc_find_feature (info.target_desc,
1117                                     "org.gnu.gdb.coldfire.fp");
1118       if (feature != NULL)
1119         {
1120           valid_p = 1;
1121           for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
1122             valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1123                                                 m68k_register_names[i]);
1124           if (!valid_p)
1125             {
1126               tdesc_data_cleanup (tdesc_data);
1127               return NULL;
1128             }
1129         }
1130       else
1131         has_fp = 0;
1132     }
1133
1134   /* The mechanism for returning floating values from function
1135      and the type of long double depend on whether we're
1136      on ColdFire or standard m68k. */
1137
1138   if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
1139     {
1140       const bfd_arch_info_type *coldfire_arch =
1141         bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
1142
1143       if (coldfire_arch
1144           && ((*info.bfd_arch_info->compatible)
1145               (info.bfd_arch_info, coldfire_arch)))
1146         flavour = m68k_coldfire_flavour;
1147     }
1148
1149   /* If there is already a candidate, use it.  */
1150   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1151        best_arch != NULL;
1152        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1153     {
1154       if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
1155         continue;
1156
1157       if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
1158         continue;
1159
1160       break;
1161     }
1162
1163   tdep = xzalloc (sizeof (struct gdbarch_tdep));
1164   gdbarch = gdbarch_alloc (&info, tdep);
1165   tdep->fpregs_present = has_fp;
1166   tdep->flavour = flavour;
1167
1168   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1169     long_double_format = floatformats_ieee_double;
1170   set_gdbarch_long_double_format (gdbarch, long_double_format);
1171   set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
1172
1173   set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
1174   set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
1175
1176   /* Stack grows down. */
1177   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1178   set_gdbarch_frame_align (gdbarch, m68k_frame_align);
1179
1180   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1181   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1182     set_gdbarch_decr_pc_after_break (gdbarch, 2);
1183
1184   set_gdbarch_frame_args_skip (gdbarch, 8);
1185   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1186
1187   set_gdbarch_register_type (gdbarch, m68k_register_type);
1188   set_gdbarch_register_name (gdbarch, m68k_register_name);
1189   set_gdbarch_num_regs (gdbarch, M68K_NUM_REGS);
1190   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1191   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1192   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1193   set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1194   set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p);
1195   set_gdbarch_register_to_value (gdbarch,  m68k_register_to_value);
1196   set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
1197
1198   if (has_fp)
1199     set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1200
1201   /* Try to figure out if the arch uses floating registers to return
1202      floating point values from functions.  */
1203   if (has_fp)
1204     {
1205       /* On ColdFire, floating point values are returned in D0.  */
1206       if (flavour == m68k_coldfire_flavour)
1207         tdep->float_return = 0;
1208       else
1209         tdep->float_return = 1;
1210     }
1211   else
1212     {
1213       /* No floating registers, so can't use them for returning values.  */
1214       tdep->float_return = 0;
1215     }
1216
1217   /* Function call & return */
1218   set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1219   set_gdbarch_return_value (gdbarch, m68k_return_value);
1220
1221
1222   /* Disassembler.  */
1223   set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1224
1225 #if defined JB_PC && defined JB_ELEMENT_SIZE
1226   tdep->jb_pc = JB_PC;
1227   tdep->jb_elt_size = JB_ELEMENT_SIZE;
1228 #else
1229   tdep->jb_pc = -1;
1230 #endif
1231   tdep->struct_value_regnum = M68K_A1_REGNUM;
1232   tdep->struct_return = reg_struct_return;
1233
1234   /* Frame unwinder.  */
1235   set_gdbarch_dummy_id (gdbarch, m68k_dummy_id);
1236   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1237
1238   /* Hook in the DWARF CFI frame unwinder.  */
1239   dwarf2_append_unwinders (gdbarch);
1240
1241   frame_base_set_default (gdbarch, &m68k_frame_base);
1242
1243   /* Hook in ABI-specific overrides, if they have been registered.  */
1244   gdbarch_init_osabi (info, gdbarch);
1245
1246   /* Now we have tuned the configuration, set a few final things,
1247      based on what the OS ABI has told us.  */
1248
1249   if (tdep->jb_pc >= 0)
1250     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1251
1252   frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
1253
1254   if (tdesc_data)
1255     tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
1256
1257   return gdbarch;
1258 }
1259
1260
1261 static void
1262 m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1263 {
1264   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1265
1266   if (tdep == NULL)
1267     return;
1268 }
1269
1270 extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1271
1272 void
1273 _initialize_m68k_tdep (void)
1274 {
1275   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1276 }