gdb/m68k-tdep.c

   1 /* Target-dependent code for the Motorola 68000 series.
   2
   3    Copyright (C) 1990-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "dwarf2-frame.h"
  22 #include "frame.h"
  23 #include "frame-base.h"
  24 #include "frame-unwind.h"
  25 #include "gdbtypes.h"
  26 #include "symtab.h"
  27 #include "gdbcore.h"
  28 #include "value.h"
  29 #include "inferior.h"
  30 #include "regcache.h"
  31 #include "arch-utils.h"
  32 #include "osabi.h"
  33 #include "dis-asm.h"
  34 #include "target-descriptions.h"
  35 #include "floatformat.h"
  36
  37 #include "m68k-tdep.h"
  38 \f
  39
  40 #define P_LINKL_FP      0x480e
  41 #define P_LINKW_FP      0x4e56
  42 #define P_PEA_FP        0x4856
  43 #define P_MOVEAL_SP_FP  0x2c4f
  44 #define P_ADDAW_SP      0xdefc
  45 #define P_ADDAL_SP      0xdffc
  46 #define P_SUBQW_SP      0x514f
  47 #define P_SUBQL_SP      0x518f
  48 #define P_LEA_SP_SP     0x4fef
  49 #define P_LEA_PC_A5     0x4bfb0170
  50 #define P_FMOVEMX_SP    0xf227
  51 #define P_MOVEL_SP      0x2f00
  52 #define P_MOVEML_SP     0x48e7
  53
  54 /* Offset from SP to first arg on stack at first instruction of a function.  */
  55 #define SP_ARG0 (1 * 4)
  56
  57 #if !defined (BPT_VECTOR)
  58 #define BPT_VECTOR 0xf
  59 #endif
  60
  61 constexpr gdb_byte m68k_break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
  62
  63 typedef BP_MANIPULATION (m68k_break_insn) m68k_breakpoint;
  64 \f
  65
  66 /* Construct types for ISA-specific registers.  */
  67 static struct type *
  68 m68k_ps_type (struct gdbarch *gdbarch)
  69 {
  70   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  71
  72   if (!tdep->m68k_ps_type)
  73     {
  74       struct type *type;
  75
  76       type = arch_flags_type (gdbarch, "builtin_type_m68k_ps", 32);
  77       append_flags_type_flag (type, 0, "C");
  78       append_flags_type_flag (type, 1, "V");
  79       append_flags_type_flag (type, 2, "Z");
  80       append_flags_type_flag (type, 3, "N");
  81       append_flags_type_flag (type, 4, "X");
  82       append_flags_type_flag (type, 8, "I0");
  83       append_flags_type_flag (type, 9, "I1");
  84       append_flags_type_flag (type, 10, "I2");
  85       append_flags_type_flag (type, 12, "M");
  86       append_flags_type_flag (type, 13, "S");
  87       append_flags_type_flag (type, 14, "T0");
  88       append_flags_type_flag (type, 15, "T1");
  89
  90       tdep->m68k_ps_type = type;
  91     }
  92
  93   return tdep->m68k_ps_type;
  94 }
  95
  96 static struct type *
  97 m68881_ext_type (struct gdbarch *gdbarch)
  98 {
  99   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 100
 101   if (!tdep->m68881_ext_type)
 102     tdep->m68881_ext_type
 103       = arch_float_type (gdbarch, -1, "builtin_type_m68881_ext",
 104                          floatformats_m68881_ext);
 105
 106   return tdep->m68881_ext_type;
 107 }
 108
 109 /* Return the GDB type object for the "standard" data type of data in
 110    register N.  This should be int for D0-D7, SR, FPCONTROL and
 111    FPSTATUS, long double for FP0-FP7, and void pointer for all others
 112    (A0-A7, PC, FPIADDR).  Note, for registers which contain
 113    addresses return pointer to void, not pointer to char, because we
 114    don't want to attempt to print the string after printing the
 115    address.  */
 116
 117 static struct type *
 118 m68k_register_type (struct gdbarch *gdbarch, int regnum)
 119 {
 120   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 121
 122   if (tdep->fpregs_present)
 123     {
 124       if (regnum >= gdbarch_fp0_regnum (gdbarch)
 125           && regnum <= gdbarch_fp0_regnum (gdbarch) + 7)
 126         {
 127           if (tdep->flavour == m68k_coldfire_flavour)
 128             return builtin_type (gdbarch)->builtin_double;
 129           else
 130             return m68881_ext_type (gdbarch);
 131         }
 132
 133       if (regnum == M68K_FPI_REGNUM)
 134         return builtin_type (gdbarch)->builtin_func_ptr;
 135
 136       if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM)
 137         return builtin_type (gdbarch)->builtin_int32;
 138     }
 139   else
 140     {
 141       if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM)
 142         return builtin_type (gdbarch)->builtin_int0;
 143     }
 144
 145   if (regnum == gdbarch_pc_regnum (gdbarch))
 146     return builtin_type (gdbarch)->builtin_func_ptr;
 147
 148   if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
 149     return builtin_type (gdbarch)->builtin_data_ptr;
 150
 151   if (regnum == M68K_PS_REGNUM)
 152     return m68k_ps_type (gdbarch);
 153
 154   return builtin_type (gdbarch)->builtin_int32;
 155 }
 156
 157 static const char *m68k_register_names[] = {
 158     "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
 159     "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
 160     "ps", "pc",
 161     "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
 162     "fpcontrol", "fpstatus", "fpiaddr"
 163   };
 164
 165 /* Function: m68k_register_name
 166    Returns the name of the standard m68k register regnum.  */
 167
 168 static const char *
 169 m68k_register_name (struct gdbarch *gdbarch, int regnum)
 170 {
 171   if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names))
 172     internal_error (__FILE__, __LINE__,
 173                     _("m68k_register_name: illegal register number %d"),
 174                     regnum);
 175   else if (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FPI_REGNUM
 176            && gdbarch_tdep (gdbarch)->fpregs_present == 0)
 177     return "";
 178   else
 179     return m68k_register_names[regnum];
 180 }
 181 \f
 182 /* Return nonzero if a value of type TYPE stored in register REGNUM
 183    needs any special handling.  */
 184
 185 static int
 186 m68k_convert_register_p (struct gdbarch *gdbarch,
 187                          int regnum, struct type *type)
 188 {
 189   if (!gdbarch_tdep (gdbarch)->fpregs_present)
 190     return 0;
 191   return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7
 192           /* We only support floating-point values.  */
 193           && TYPE_CODE (type) == TYPE_CODE_FLT
 194           && type != register_type (gdbarch, M68K_FP0_REGNUM));
 195 }
 196
 197 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
 198    return its contents in TO.  */
 199
 200 static int
 201 m68k_register_to_value (struct frame_info *frame, int regnum,
 202                         struct type *type, gdb_byte *to,
 203                         int *optimizedp, int *unavailablep)
 204 {
 205   struct gdbarch *gdbarch = get_frame_arch (frame);
 206   gdb_byte from[M68K_MAX_REGISTER_SIZE];
 207   struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
 208
 209   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
 210
 211   /* Convert to TYPE.  */
 212   if (!get_frame_register_bytes (frame, regnum, 0,
 213                                  register_size (gdbarch, regnum),
 214                                  from, optimizedp, unavailablep))
 215     return 0;
 216
 217   convert_typed_floating (from, fpreg_type, to, type);
 218   *optimizedp = *unavailablep = 0;
 219   return 1;
 220 }
 221
 222 /* Write the contents FROM of a value of type TYPE into register
 223    REGNUM in frame FRAME.  */
 224
 225 static void
 226 m68k_value_to_register (struct frame_info *frame, int regnum,
 227                         struct type *type, const gdb_byte *from)
 228 {
 229   gdb_byte to[M68K_MAX_REGISTER_SIZE];
 230   struct type *fpreg_type = register_type (get_frame_arch (frame),
 231                                            M68K_FP0_REGNUM);
 232
 233   /* We only support floating-point values.  */
 234   if (TYPE_CODE (type) != TYPE_CODE_FLT)
 235     {
 236       warning (_("Cannot convert non-floating-point type "
 237                "to floating-point register value."));
 238       return;
 239     }
 240
 241   /* Convert from TYPE.  */
 242   convert_typed_floating (from, type, to, fpreg_type);
 243   put_frame_register (frame, regnum, to);
 244 }
 245
 246 \f
 247 /* There is a fair number of calling conventions that are in somewhat
 248    wide use.  The 68000/08/10 don't support an FPU, not even as a
 249    coprocessor.  All function return values are stored in %d0/%d1.
 250    Structures are returned in a static buffer, a pointer to which is
 251    returned in %d0.  This means that functions returning a structure
 252    are not re-entrant.  To avoid this problem some systems use a
 253    convention where the caller passes a pointer to a buffer in %a1
 254    where the return values is to be stored.  This convention is the
 255    default, and is implemented in the function m68k_return_value.
 256
 257    The 68020/030/040/060 do support an FPU, either as a coprocessor
 258    (68881/2) or built-in (68040/68060).  That's why System V release 4
 259    (SVR4) instroduces a new calling convention specified by the SVR4
 260    psABI.  Integer values are returned in %d0/%d1, pointer return
 261    values in %a0 and floating values in %fp0.  When calling functions
 262    returning a structure the caller should pass a pointer to a buffer
 263    for the return value in %a0.  This convention is implemented in the
 264    function m68k_svr4_return_value, and by appropriately setting the
 265    struct_value_regnum member of `struct gdbarch_tdep'.
 266
 267    GNU/Linux returns values in the same way as SVR4 does, but uses %a1
 268    for passing the structure return value buffer.
 269
 270    GCC can also generate code where small structures are returned in
 271    %d0/%d1 instead of in memory by using -freg-struct-return.  This is
 272    the default on NetBSD a.out, OpenBSD and GNU/Linux and several
 273    embedded systems.  This convention is implemented by setting the
 274    struct_return member of `struct gdbarch_tdep' to reg_struct_return.  */
 275
 276 /* Read a function return value of TYPE from REGCACHE, and copy that
 277    into VALBUF.  */
 278
 279 static void
 280 m68k_extract_return_value (struct type *type, struct regcache *regcache,
 281                            gdb_byte *valbuf)
 282 {
 283   int len = TYPE_LENGTH (type);
 284   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 285
 286   if (len <= 4)
 287     {
 288       regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
 289       memcpy (valbuf, buf + (4 - len), len);
 290     }
 291   else if (len <= 8)
 292     {
 293       regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
 294       memcpy (valbuf, buf + (8 - len), len - 4);
 295       regcache_raw_read (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
 296     }
 297   else
 298     internal_error (__FILE__, __LINE__,
 299                     _("Cannot extract return value of %d bytes long."), len);
 300 }
 301
 302 static void
 303 m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache,
 304                                 gdb_byte *valbuf)
 305 {
 306   gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 307   struct gdbarch *gdbarch = regcache->arch ();
 308   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 309
 310   if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
 311     {
 312       struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
 313       regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
 314       convert_typed_floating (buf, fpreg_type, valbuf, type);
 315     }
 316   else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
 317     regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
 318   else
 319     m68k_extract_return_value (type, regcache, valbuf);
 320 }
 321
 322 /* Write a function return value of TYPE from VALBUF into REGCACHE.  */
 323
 324 static void
 325 m68k_store_return_value (struct type *type, struct regcache *regcache,
 326                          const gdb_byte *valbuf)
 327 {
 328   int len = TYPE_LENGTH (type);
 329
 330   if (len <= 4)
 331     regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf);
 332   else if (len <= 8)
 333     {
 334       regcache_raw_write_part (regcache, M68K_D0_REGNUM, 8 - len,
 335                                len - 4, valbuf);
 336       regcache_raw_write (regcache, M68K_D1_REGNUM, valbuf + (len - 4));
 337     }
 338   else
 339     internal_error (__FILE__, __LINE__,
 340                     _("Cannot store return value of %d bytes long."), len);
 341 }
 342
 343 static void
 344 m68k_svr4_store_return_value (struct type *type, struct regcache *regcache,
 345                               const gdb_byte *valbuf)
 346 {
 347   struct gdbarch *gdbarch = regcache->arch ();
 348   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 349
 350   if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT)
 351     {
 352       struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM);
 353       gdb_byte buf[M68K_MAX_REGISTER_SIZE];
 354       convert_typed_floating (valbuf, type, buf, fpreg_type);
 355       regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
 356     }
 357   else if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_LENGTH (type) == 4)
 358     {
 359       regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
 360       regcache_raw_write (regcache, M68K_D0_REGNUM, valbuf);
 361     }
 362   else
 363     m68k_store_return_value (type, regcache, valbuf);
 364 }
 365
 366 /* Return non-zero if TYPE, which is assumed to be a structure, union or
 367    complex type, should be returned in registers for architecture
 368    GDBARCH.  */
 369
 370 static int
 371 m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
 372 {
 373   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 374   enum type_code code = TYPE_CODE (type);
 375   int len = TYPE_LENGTH (type);
 376
 377   gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
 378               || code == TYPE_CODE_COMPLEX);
 379
 380   if (tdep->struct_return == pcc_struct_return)
 381     return 0;
 382
 383   return (len == 1 || len == 2 || len == 4 || len == 8);
 384 }
 385
 386 /* Determine, for architecture GDBARCH, how a return value of TYPE
 387    should be returned.  If it is supposed to be returned in registers,
 388    and READBUF is non-zero, read the appropriate value from REGCACHE,
 389    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
 390    from WRITEBUF into REGCACHE.  */
 391
 392 static enum return_value_convention
 393 m68k_return_value (struct gdbarch *gdbarch, struct value *function,
 394                    struct type *type, struct regcache *regcache,
 395                    gdb_byte *readbuf, const gdb_byte *writebuf)
 396 {
 397   enum type_code code = TYPE_CODE (type);
 398
 399   /* GCC returns a `long double' in memory too.  */
 400   if (((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
 401         || code == TYPE_CODE_COMPLEX)
 402        && !m68k_reg_struct_return_p (gdbarch, type))
 403       || (code == TYPE_CODE_FLT && TYPE_LENGTH (type) == 12))
 404     {
 405       /* The default on m68k is to return structures in static memory.
 406          Consequently a function must return the address where we can
 407          find the return value.  */
 408
 409       if (readbuf)
 410         {
 411           ULONGEST addr;
 412
 413           regcache_raw_read_unsigned (regcache, M68K_D0_REGNUM, &addr);
 414           read_memory (addr, readbuf, TYPE_LENGTH (type));
 415         }
 416
 417       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 418     }
 419
 420   if (readbuf)
 421     m68k_extract_return_value (type, regcache, readbuf);
 422   if (writebuf)
 423     m68k_store_return_value (type, regcache, writebuf);
 424
 425   return RETURN_VALUE_REGISTER_CONVENTION;
 426 }
 427
 428 static enum return_value_convention
 429 m68k_svr4_return_value (struct gdbarch *gdbarch, struct value *function,
 430                         struct type *type, struct regcache *regcache,
 431                         gdb_byte *readbuf, const gdb_byte *writebuf)
 432 {
 433   enum type_code code = TYPE_CODE (type);
 434
 435   if ((code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION
 436        || code == TYPE_CODE_COMPLEX)
 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, function, 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 -1;
 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
 847   cache.locals = -1;
 848   pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache);
 849   if (cache.locals < 0)
 850     return start_pc;
 851   return pc;
 852 }
 853
 854 static CORE_ADDR
 855 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 856 {
 857   gdb_byte buf[8];
 858
 859   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
 860   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 861 }
 862 \f
 863 /* Normal frames.  */
 864
 865 static struct m68k_frame_cache *
 866 m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
 867 {
 868   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 869   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 870   struct m68k_frame_cache *cache;
 871   gdb_byte buf[4];
 872   int i;
 873
 874   if (*this_cache)
 875     return (struct m68k_frame_cache *) *this_cache;
 876
 877   cache = m68k_alloc_frame_cache ();
 878   *this_cache = cache;
 879
 880   /* In principle, for normal frames, %fp holds the frame pointer,
 881      which holds the base address for the current stack frame.
 882      However, for functions that don't need it, the frame pointer is
 883      optional.  For these "frameless" functions the frame pointer is
 884      actually the frame pointer of the calling frame.  Signal
 885      trampolines are just a special case of a "frameless" function.
 886      They (usually) share their frame pointer with the frame that was
 887      in progress when the signal occurred.  */
 888
 889   get_frame_register (this_frame, M68K_FP_REGNUM, buf);
 890   cache->base = extract_unsigned_integer (buf, 4, byte_order);
 891   if (cache->base == 0)
 892     return cache;
 893
 894   /* For normal frames, %pc is stored at 4(%fp).  */
 895   cache->saved_regs[M68K_PC_REGNUM] = 4;
 896
 897   cache->pc = get_frame_func (this_frame);
 898   if (cache->pc != 0)
 899     m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc,
 900                            get_frame_pc (this_frame), cache);
 901
 902   if (cache->locals < 0)
 903     {
 904       /* We didn't find a valid frame, which means that CACHE->base
 905          currently holds the frame pointer for our calling frame.  If
 906          we're at the start of a function, or somewhere half-way its
 907          prologue, the function's frame probably hasn't been fully
 908          setup yet.  Try to reconstruct the base address for the stack
 909          frame by looking at the stack pointer.  For truly "frameless"
 910          functions this might work too.  */
 911
 912       get_frame_register (this_frame, M68K_SP_REGNUM, buf);
 913       cache->base = extract_unsigned_integer (buf, 4, byte_order)
 914                     + cache->sp_offset;
 915     }
 916
 917   /* Now that we have the base address for the stack frame we can
 918      calculate the value of %sp in the calling frame.  */
 919   cache->saved_sp = cache->base + 8;
 920
 921   /* Adjust all the saved registers such that they contain addresses
 922      instead of offsets.  */
 923   for (i = 0; i < M68K_NUM_REGS; i++)
 924     if (cache->saved_regs[i] != -1)
 925       cache->saved_regs[i] += cache->base;
 926
 927   return cache;
 928 }
 929
 930 static void
 931 m68k_frame_this_id (struct frame_info *this_frame, void **this_cache,
 932                     struct frame_id *this_id)
 933 {
 934   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 935
 936   /* This marks the outermost frame.  */
 937   if (cache->base == 0)
 938     return;
 939
 940   /* See the end of m68k_push_dummy_call.  */
 941   *this_id = frame_id_build (cache->base + 8, cache->pc);
 942 }
 943
 944 static struct value *
 945 m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 946                           int regnum)
 947 {
 948   struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache);
 949
 950   gdb_assert (regnum >= 0);
 951
 952   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
 953     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 954
 955   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
 956     return frame_unwind_got_memory (this_frame, regnum,
 957                                     cache->saved_regs[regnum]);
 958
 959   return frame_unwind_got_register (this_frame, regnum, regnum);
 960 }
 961
 962 static const struct frame_unwind m68k_frame_unwind =
 963 {
 964   NORMAL_FRAME,
 965   default_frame_unwind_stop_reason,
 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 = (gdb_byte *) 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 /* This is the implementation of gdbarch method
1043    return_in_first_hidden_param_p.  */
1044
1045 static int
1046 m68k_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
1047                                      struct type *type)
1048 {
1049   return 0;
1050 }
1051
1052 /* System V Release 4 (SVR4).  */
1053
1054 void
1055 m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1056 {
1057   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1058
1059   /* SVR4 uses a different calling convention.  */
1060   set_gdbarch_return_value (gdbarch, m68k_svr4_return_value);
1061
1062   /* SVR4 uses %a0 instead of %a1.  */
1063   tdep->struct_value_regnum = M68K_A0_REGNUM;
1064 }
1065 \f
1066
1067 /* Function: m68k_gdbarch_init
1068    Initializer function for the m68k gdbarch vector.
1069    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
1070
1071 static struct gdbarch *
1072 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1073 {
1074   struct gdbarch_tdep *tdep = NULL;
1075   struct gdbarch *gdbarch;
1076   struct gdbarch_list *best_arch;
1077   struct tdesc_arch_data *tdesc_data = NULL;
1078   int i;
1079   enum m68k_flavour flavour = m68k_no_flavour;
1080   int has_fp = 1;
1081   const struct floatformat **long_double_format = floatformats_m68881_ext;
1082
1083   /* Check any target description for validity.  */
1084   if (tdesc_has_registers (info.target_desc))
1085     {
1086       const struct tdesc_feature *feature;
1087       int valid_p;
1088
1089       feature = tdesc_find_feature (info.target_desc,
1090                                     "org.gnu.gdb.m68k.core");
1091
1092       if (feature == NULL)
1093         {
1094           feature = tdesc_find_feature (info.target_desc,
1095                                         "org.gnu.gdb.coldfire.core");
1096           if (feature != NULL)
1097             flavour = m68k_coldfire_flavour;
1098         }
1099
1100       if (feature == NULL)
1101         {
1102           feature = tdesc_find_feature (info.target_desc,
1103                                         "org.gnu.gdb.fido.core");
1104           if (feature != NULL)
1105             flavour = m68k_fido_flavour;
1106         }
1107
1108       if (feature == NULL)
1109         return NULL;
1110
1111       tdesc_data = tdesc_data_alloc ();
1112
1113       valid_p = 1;
1114       for (i = 0; i <= M68K_PC_REGNUM; i++)
1115         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1116                                             m68k_register_names[i]);
1117
1118       if (!valid_p)
1119         {
1120           tdesc_data_cleanup (tdesc_data);
1121           return NULL;
1122         }
1123
1124       feature = tdesc_find_feature (info.target_desc,
1125                                     "org.gnu.gdb.coldfire.fp");
1126       if (feature != NULL)
1127         {
1128           valid_p = 1;
1129           for (i = M68K_FP0_REGNUM; i <= M68K_FPI_REGNUM; i++)
1130             valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1131                                                 m68k_register_names[i]);
1132           if (!valid_p)
1133             {
1134               tdesc_data_cleanup (tdesc_data);
1135               return NULL;
1136             }
1137         }
1138       else
1139         has_fp = 0;
1140     }
1141
1142   /* The mechanism for returning floating values from function
1143      and the type of long double depend on whether we're
1144      on ColdFire or standard m68k.  */
1145
1146   if (info.bfd_arch_info && info.bfd_arch_info->mach != 0)
1147     {
1148       const bfd_arch_info_type *coldfire_arch =
1149         bfd_lookup_arch (bfd_arch_m68k, bfd_mach_mcf_isa_a_nodiv);
1150
1151       if (coldfire_arch
1152           && ((*info.bfd_arch_info->compatible)
1153               (info.bfd_arch_info, coldfire_arch)))
1154         flavour = m68k_coldfire_flavour;
1155     }
1156
1157   /* If there is already a candidate, use it.  */
1158   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1159        best_arch != NULL;
1160        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1161     {
1162       if (flavour != gdbarch_tdep (best_arch->gdbarch)->flavour)
1163         continue;
1164
1165       if (has_fp != gdbarch_tdep (best_arch->gdbarch)->fpregs_present)
1166         continue;
1167
1168       break;
1169     }
1170
1171   if (best_arch != NULL)
1172     {
1173       if (tdesc_data != NULL)
1174         tdesc_data_cleanup (tdesc_data);
1175       return best_arch->gdbarch;
1176     }
1177
1178   tdep = XCNEW (struct gdbarch_tdep);
1179   gdbarch = gdbarch_alloc (&info, tdep);
1180   tdep->fpregs_present = has_fp;
1181   tdep->flavour = flavour;
1182
1183   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1184     long_double_format = floatformats_ieee_double;
1185   set_gdbarch_long_double_format (gdbarch, long_double_format);
1186   set_gdbarch_long_double_bit (gdbarch, long_double_format[0]->totalsize);
1187
1188   set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
1189   set_gdbarch_breakpoint_kind_from_pc (gdbarch, m68k_breakpoint::kind_from_pc);
1190   set_gdbarch_sw_breakpoint_from_kind (gdbarch, m68k_breakpoint::bp_from_kind);
1191
1192   /* Stack grows down.  */
1193   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1194   set_gdbarch_frame_align (gdbarch, m68k_frame_align);
1195
1196   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1197   if (flavour == m68k_coldfire_flavour || flavour == m68k_fido_flavour)
1198     set_gdbarch_decr_pc_after_break (gdbarch, 2);
1199
1200   set_gdbarch_frame_args_skip (gdbarch, 8);
1201   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1202
1203   set_gdbarch_register_type (gdbarch, m68k_register_type);
1204   set_gdbarch_register_name (gdbarch, m68k_register_name);
1205   set_gdbarch_num_regs (gdbarch, M68K_NUM_REGS);
1206   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1207   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1208   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1209   set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p);
1210   set_gdbarch_register_to_value (gdbarch,  m68k_register_to_value);
1211   set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
1212
1213   if (has_fp)
1214     set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1215
1216   /* Try to figure out if the arch uses floating registers to return
1217      floating point values from functions.  */
1218   if (has_fp)
1219     {
1220       /* On ColdFire, floating point values are returned in D0.  */
1221       if (flavour == m68k_coldfire_flavour)
1222         tdep->float_return = 0;
1223       else
1224         tdep->float_return = 1;
1225     }
1226   else
1227     {
1228       /* No floating registers, so can't use them for returning values.  */
1229       tdep->float_return = 0;
1230     }
1231
1232   /* Function call & return.  */
1233   set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1234   set_gdbarch_return_value (gdbarch, m68k_return_value);
1235   set_gdbarch_return_in_first_hidden_param_p (gdbarch,
1236                                               m68k_return_in_first_hidden_param_p);
1237
1238 #if defined JB_PC && defined JB_ELEMENT_SIZE
1239   tdep->jb_pc = JB_PC;
1240   tdep->jb_elt_size = JB_ELEMENT_SIZE;
1241 #else
1242   tdep->jb_pc = -1;
1243 #endif
1244   tdep->struct_value_regnum = M68K_A1_REGNUM;
1245   tdep->struct_return = reg_struct_return;
1246
1247   /* Frame unwinder.  */
1248   set_gdbarch_dummy_id (gdbarch, m68k_dummy_id);
1249   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1250
1251   /* Hook in the DWARF CFI frame unwinder.  */
1252   dwarf2_append_unwinders (gdbarch);
1253
1254   frame_base_set_default (gdbarch, &m68k_frame_base);
1255
1256   /* Hook in ABI-specific overrides, if they have been registered.  */
1257   gdbarch_init_osabi (info, gdbarch);
1258
1259   /* Now we have tuned the configuration, set a few final things,
1260      based on what the OS ABI has told us.  */
1261
1262   if (tdep->jb_pc >= 0)
1263     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1264
1265   frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind);
1266
1267   if (tdesc_data)
1268     tdesc_use_registers (gdbarch, info.target_desc, tdesc_data);
1269
1270   return gdbarch;
1271 }
1272
1273
1274 static void
1275 m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
1276 {
1277   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1278
1279   if (tdep == NULL)
1280     return;
1281 }
1282
1283 void
1284 _initialize_m68k_tdep (void)
1285 {
1286   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1287 }