gdb/m68k-tdep.c

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