gdb/m68k-tdep.c

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