gdb/m68k-tdep.c

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