gdb/m68k-tdep.c

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