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