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