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