gdb/m68k-tdep.c

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