gdb/m68k-tdep.c

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