gdb/m68k-tdep.c

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