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, 2001,
   4    2002, 2003, 2004, 2005, 2006, 2007 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 /* Always align the frame to a 4-byte boundary.  This is required on
 417    coldfire and harmless on the rest.  */
 418
 419 static CORE_ADDR
 420 m68k_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 421 {
 422   /* Align the stack to four bytes.  */
 423   return sp & ~3;
 424 }
 425
 426 static CORE_ADDR
 427 m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 428                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 429                       struct value **args, CORE_ADDR sp, int struct_return,
 430                       CORE_ADDR struct_addr)
 431 {
 432   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 433   gdb_byte buf[4];
 434   int i;
 435
 436   /* Push arguments in reverse order.  */
 437   for (i = nargs - 1; i >= 0; i--)
 438     {
 439       struct type *value_type = value_enclosing_type (args[i]);
 440       int len = TYPE_LENGTH (value_type);
 441       int container_len = (len + 3) & ~3;
 442       int offset;
 443
 444       /* Non-scalars bigger than 4 bytes are left aligned, others are
 445          right aligned.  */
 446       if ((TYPE_CODE (value_type) == TYPE_CODE_STRUCT
 447            || TYPE_CODE (value_type) == TYPE_CODE_UNION
 448            || TYPE_CODE (value_type) == TYPE_CODE_ARRAY)
 449           && len > 4)
 450         offset = 0;
 451       else
 452         offset = container_len - len;
 453       sp -= container_len;
 454       write_memory (sp + offset, value_contents_all (args[i]), len);
 455     }
 456
 457   /* Store struct value address.  */
 458   if (struct_return)
 459     {
 460       store_unsigned_integer (buf, 4, struct_addr);
 461       regcache_cooked_write (regcache, tdep->struct_value_regnum, buf);
 462     }
 463
 464   /* Store return address.  */
 465   sp -= 4;
 466   store_unsigned_integer (buf, 4, bp_addr);
 467   write_memory (sp, buf, 4);
 468
 469   /* Finally, update the stack pointer...  */
 470   store_unsigned_integer (buf, 4, sp);
 471   regcache_cooked_write (regcache, M68K_SP_REGNUM, buf);
 472
 473   /* ...and fake a frame pointer.  */
 474   regcache_cooked_write (regcache, M68K_FP_REGNUM, buf);
 475
 476   /* DWARF2/GCC uses the stack address *before* the function call as a
 477      frame's CFA.  */
 478   return sp + 8;
 479 }
 480
 481 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum.  */
 482
 483 static int
 484 m68k_dwarf_reg_to_regnum (int num)
 485 {
 486   if (num < 8)
 487     /* d0..7 */
 488     return (num - 0) + M68K_D0_REGNUM;
 489   else if (num < 16)
 490     /* a0..7 */
 491     return (num - 8) + M68K_A0_REGNUM;
 492   else if (num < 24)
 493     /* fp0..7 */
 494     return (num - 16) + M68K_FP0_REGNUM;
 495   else if (num == 25)
 496     /* pc */
 497     return M68K_PC_REGNUM;
 498   else
 499     return NUM_REGS + NUM_PSEUDO_REGS;
 500 }
 501
 502 \f
 503 struct m68k_frame_cache
 504 {
 505   /* Base address.  */
 506   CORE_ADDR base;
 507   CORE_ADDR sp_offset;
 508   CORE_ADDR pc;
 509
 510   /* Saved registers.  */
 511   CORE_ADDR saved_regs[M68K_NUM_REGS];
 512   CORE_ADDR saved_sp;
 513
 514   /* Stack space reserved for local variables.  */
 515   long locals;
 516 };
 517
 518 /* Allocate and initialize a frame cache.  */
 519
 520 static struct m68k_frame_cache *
 521 m68k_alloc_frame_cache (void)
 522 {
 523   struct m68k_frame_cache *cache;
 524   int i;
 525
 526   cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache);
 527
 528   /* Base address.  */
 529   cache->base = 0;
 530   cache->sp_offset = -4;
 531   cache->pc = 0;
 532
 533   /* Saved registers.  We initialize these to -1 since zero is a valid
 534      offset (that's where %fp is supposed to be stored).  */
 535   for (i = 0; i < M68K_NUM_REGS; i++)
 536     cache->saved_regs[i] = -1;
 537
 538   /* Frameless until proven otherwise.  */
 539   cache->locals = -1;
 540
 541   return cache;
 542 }
 543
 544 /* Check whether PC points at a code that sets up a new stack frame.
 545    If so, it updates CACHE and returns the address of the first
 546    instruction after the sequence that sets removes the "hidden"
 547    argument from the stack or CURRENT_PC, whichever is smaller.
 548    Otherwise, return PC.  */
 549
 550 static CORE_ADDR
 551 m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc,
 552                           struct m68k_frame_cache *cache)
 553 {
 554   int op;
 555
 556   if (pc >= current_pc)
 557     return current_pc;
 558
 559   op = read_memory_unsigned_integer (pc, 2);
 560
 561   if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP)
 562     {
 563       cache->saved_regs[M68K_FP_REGNUM] = 0;
 564       cache->sp_offset += 4;
 565       if (op == P_LINKW_FP)
 566         {
 567           /* link.w %fp, #-N */
 568           /* link.w %fp, #0; adda.l #-N, %sp */
 569           cache->locals = -read_memory_integer (pc + 2, 2);
 570
 571           if (pc + 4 < current_pc && cache->locals == 0)
 572             {
 573               op = read_memory_unsigned_integer (pc + 4, 2);
 574               if (op == P_ADDAL_SP)
 575                 {
 576                   cache->locals = read_memory_integer (pc + 6, 4);
 577                   return pc + 10;
 578                 }
 579             }
 580
 581           return pc + 4;
 582         }
 583       else if (op == P_LINKL_FP)
 584         {
 585           /* link.l %fp, #-N */
 586           cache->locals = -read_memory_integer (pc + 2, 4);
 587           return pc + 6;
 588         }
 589       else
 590         {
 591           /* pea (%fp); movea.l %sp, %fp */
 592           cache->locals = 0;
 593
 594           if (pc + 2 < current_pc)
 595             {
 596               op = read_memory_unsigned_integer (pc + 2, 2);
 597
 598               if (op == P_MOVEAL_SP_FP)
 599                 {
 600                   /* move.l %sp, %fp */
 601                   return pc + 4;
 602                 }
 603             }
 604
 605           return pc + 2;
 606         }
 607     }
 608   else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 609     {
 610       /* subq.[wl] #N,%sp */
 611       /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
 612       cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 613       if (pc + 2 < current_pc)
 614         {
 615           op = read_memory_unsigned_integer (pc + 2, 2);
 616           if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP)
 617             {
 618               cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9;
 619               return pc + 4;
 620             }
 621         }
 622       return pc + 2;
 623     }
 624   else if (op == P_ADDAW_SP || op == P_LEA_SP_SP)
 625     {
 626       /* adda.w #-N,%sp */
 627       /* lea (-N,%sp),%sp */
 628       cache->locals = -read_memory_integer (pc + 2, 2);
 629       return pc + 4;
 630     }
 631   else if (op == P_ADDAL_SP)
 632     {
 633       /* adda.l #-N,%sp */
 634       cache->locals = -read_memory_integer (pc + 2, 4);
 635       return pc + 6;
 636     }
 637
 638   return pc;
 639 }
 640
 641 /* Check whether PC points at code that saves registers on the stack.
 642    If so, it updates CACHE and returns the address of the first
 643    instruction after the register saves or CURRENT_PC, whichever is
 644    smaller.  Otherwise, return PC.  */
 645
 646 static CORE_ADDR
 647 m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc,
 648                              struct m68k_frame_cache *cache)
 649 {
 650   if (cache->locals >= 0)
 651     {
 652       CORE_ADDR offset;
 653       int op;
 654       int i, mask, regno;
 655
 656       offset = -4 - cache->locals;
 657       while (pc < current_pc)
 658         {
 659           op = read_memory_unsigned_integer (pc, 2);
 660           if (op == P_FMOVEMX_SP)
 661             {
 662               /* fmovem.x REGS,-(%sp) */
 663               op = read_memory_unsigned_integer (pc + 2, 2);
 664               if ((op & 0xff00) == 0xe000)
 665                 {
 666                   mask = op & 0xff;
 667                   for (i = 0; i < 16; i++, mask >>= 1)
 668                     {
 669                       if (mask & 1)
 670                         {
 671                           cache->saved_regs[i + M68K_FP0_REGNUM] = offset;
 672                           offset -= 12;
 673                         }
 674                     }
 675                   pc += 4;
 676                 }
 677               else
 678                 break;
 679             }
 680           else if ((op & 0177760) == P_MOVEL_SP)
 681             {
 682               /* move.l %R,-(%sp) */
 683               regno = op & 017;
 684               cache->saved_regs[regno] = offset;
 685               offset -= 4;
 686               pc += 2;
 687             }
 688           else if (op == P_MOVEML_SP)
 689             {
 690               /* movem.l REGS,-(%sp) */
 691               mask = read_memory_unsigned_integer (pc + 2, 2);
 692               for (i = 0; i < 16; i++, mask >>= 1)
 693                 {
 694                   if (mask & 1)
 695                     {
 696                       cache->saved_regs[15 - i] = offset;
 697                       offset -= 4;
 698                     }
 699                 }
 700               pc += 4;
 701             }
 702           else
 703             break;
 704         }
 705     }
 706
 707   return pc;
 708 }
 709
 710
 711 /* Do a full analysis of the prologue at PC and update CACHE
 712    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
 713    address where the analysis stopped.
 714
 715    We handle all cases that can be generated by gcc.
 716
 717    For allocating a stack frame:
 718
 719    link.w %a6,#-N
 720    link.l %a6,#-N
 721    pea (%fp); move.l %sp,%fp
 722    link.w %a6,#0; add.l #-N,%sp
 723    subq.l #N,%sp
 724    subq.w #N,%sp
 725    subq.w #8,%sp; subq.w #N-8,%sp
 726    add.w #-N,%sp
 727    lea (-N,%sp),%sp
 728    add.l #-N,%sp
 729
 730    For saving registers:
 731
 732    fmovem.x REGS,-(%sp)
 733    move.l R1,-(%sp)
 734    move.l R1,-(%sp); move.l R2,-(%sp)
 735    movem.l REGS,-(%sp)
 736
 737    For setting up the PIC register:
 738
 739    lea (%pc,N),%a5
 740
 741    */
 742
 743 static CORE_ADDR
 744 m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
 745                        struct m68k_frame_cache *cache)
 746 {
 747   unsigned int op;
 748
 749   pc = m68k_analyze_frame_setup (pc, current_pc, cache);
 750   pc = m68k_analyze_register_saves (pc, current_pc, cache);
 751   if (pc >= current_pc)
 752     return current_pc;
 753
 754   /* Check for GOT setup.  */
 755   op = read_memory_unsigned_integer (pc, 4);
 756   if (op == P_LEA_PC_A5)
 757     {
 758       /* lea (%pc,N),%a5 */
 759       return pc + 6;
 760     }
 761
 762   return pc;
 763 }
 764
 765 /* Return PC of first real instruction.  */
 766
 767 static CORE_ADDR
 768 m68k_skip_prologue (CORE_ADDR start_pc)
 769 {
 770   struct m68k_frame_cache cache;
 771   CORE_ADDR pc;
 772   int op;
 773
 774   cache.locals = -1;
 775   pc = m68k_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
 776   if (cache.locals < 0)
 777     return start_pc;
 778   return pc;
 779 }
 780
 781 static CORE_ADDR
 782 m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 783 {
 784   gdb_byte buf[8];
 785
 786   frame_unwind_register (next_frame, PC_REGNUM, buf);
 787   return extract_typed_address (buf, builtin_type_void_func_ptr);
 788 }
 789 \f
 790 /* Normal frames.  */
 791
 792 static struct m68k_frame_cache *
 793 m68k_frame_cache (struct frame_info *next_frame, void **this_cache)
 794 {
 795   struct m68k_frame_cache *cache;
 796   gdb_byte buf[4];
 797   int i;
 798
 799   if (*this_cache)
 800     return *this_cache;
 801
 802   cache = m68k_alloc_frame_cache ();
 803   *this_cache = cache;
 804
 805   /* In principle, for normal frames, %fp holds the frame pointer,
 806      which holds the base address for the current stack frame.
 807      However, for functions that don't need it, the frame pointer is
 808      optional.  For these "frameless" functions the frame pointer is
 809      actually the frame pointer of the calling frame.  Signal
 810      trampolines are just a special case of a "frameless" function.
 811      They (usually) share their frame pointer with the frame that was
 812      in progress when the signal occurred.  */
 813
 814   frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
 815   cache->base = extract_unsigned_integer (buf, 4);
 816   if (cache->base == 0)
 817     return cache;
 818
 819   /* For normal frames, %pc is stored at 4(%fp).  */
 820   cache->saved_regs[M68K_PC_REGNUM] = 4;
 821
 822   cache->pc = frame_func_unwind (next_frame);
 823   if (cache->pc != 0)
 824     m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache);
 825
 826   if (cache->locals < 0)
 827     {
 828       /* We didn't find a valid frame, which means that CACHE->base
 829          currently holds the frame pointer for our calling frame.  If
 830          we're at the start of a function, or somewhere half-way its
 831          prologue, the function's frame probably hasn't been fully
 832          setup yet.  Try to reconstruct the base address for the stack
 833          frame by looking at the stack pointer.  For truly "frameless"
 834          functions this might work too.  */
 835
 836       frame_unwind_register (next_frame, M68K_SP_REGNUM, buf);
 837       cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset;
 838     }
 839
 840   /* Now that we have the base address for the stack frame we can
 841      calculate the value of %sp in the calling frame.  */
 842   cache->saved_sp = cache->base + 8;
 843
 844   /* Adjust all the saved registers such that they contain addresses
 845      instead of offsets.  */
 846   for (i = 0; i < M68K_NUM_REGS; i++)
 847     if (cache->saved_regs[i] != -1)
 848       cache->saved_regs[i] += cache->base;
 849
 850   return cache;
 851 }
 852
 853 static void
 854 m68k_frame_this_id (struct frame_info *next_frame, void **this_cache,
 855                     struct frame_id *this_id)
 856 {
 857   struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
 858
 859   /* This marks the outermost frame.  */
 860   if (cache->base == 0)
 861     return;
 862
 863   /* See the end of m68k_push_dummy_call.  */
 864   *this_id = frame_id_build (cache->base + 8, cache->pc);
 865 }
 866
 867 static void
 868 m68k_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 869                           int regnum, int *optimizedp,
 870                           enum lval_type *lvalp, CORE_ADDR *addrp,
 871                           int *realnump, gdb_byte *valuep)
 872 {
 873   struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
 874
 875   gdb_assert (regnum >= 0);
 876
 877   if (regnum == M68K_SP_REGNUM && cache->saved_sp)
 878     {
 879       *optimizedp = 0;
 880       *lvalp = not_lval;
 881       *addrp = 0;
 882       *realnump = -1;
 883       if (valuep)
 884         {
 885           /* Store the value.  */
 886           store_unsigned_integer (valuep, 4, cache->saved_sp);
 887         }
 888       return;
 889     }
 890
 891   if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1)
 892     {
 893       *optimizedp = 0;
 894       *lvalp = lval_memory;
 895       *addrp = cache->saved_regs[regnum];
 896       *realnump = -1;
 897       if (valuep)
 898         {
 899           /* Read the value in from memory.  */
 900           read_memory (*addrp, valuep,
 901                        register_size (current_gdbarch, regnum));
 902         }
 903       return;
 904     }
 905
 906   *optimizedp = 0;
 907   *lvalp = lval_register;
 908   *addrp = 0;
 909   *realnump = regnum;
 910   if (valuep)
 911     frame_unwind_register (next_frame, (*realnump), valuep);
 912 }
 913
 914 static const struct frame_unwind m68k_frame_unwind =
 915 {
 916   NORMAL_FRAME,
 917   m68k_frame_this_id,
 918   m68k_frame_prev_register
 919 };
 920
 921 static const struct frame_unwind *
 922 m68k_frame_sniffer (struct frame_info *next_frame)
 923 {
 924   return &m68k_frame_unwind;
 925 }
 926 \f
 927 static CORE_ADDR
 928 m68k_frame_base_address (struct frame_info *next_frame, void **this_cache)
 929 {
 930   struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache);
 931
 932   return cache->base;
 933 }
 934
 935 static const struct frame_base m68k_frame_base =
 936 {
 937   &m68k_frame_unwind,
 938   m68k_frame_base_address,
 939   m68k_frame_base_address,
 940   m68k_frame_base_address
 941 };
 942
 943 static struct frame_id
 944 m68k_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 945 {
 946   gdb_byte buf[4];
 947   CORE_ADDR fp;
 948
 949   frame_unwind_register (next_frame, M68K_FP_REGNUM, buf);
 950   fp = extract_unsigned_integer (buf, 4);
 951
 952   /* See the end of m68k_push_dummy_call.  */
 953   return frame_id_build (fp + 8, frame_pc_unwind (next_frame));
 954 }
 955 \f
 956 #ifdef USE_PROC_FS              /* Target dependent support for /proc */
 957
 958 #include <sys/procfs.h>
 959
 960 /* Prototypes for supply_gregset etc. */
 961 #include "gregset.h"
 962
 963 /*  The /proc interface divides the target machine's register set up into
 964    two different sets, the general register set (gregset) and the floating
 965    point register set (fpregset).  For each set, there is an ioctl to get
 966    the current register set and another ioctl to set the current values.
 967
 968    The actual structure passed through the ioctl interface is, of course,
 969    naturally machine dependent, and is different for each set of registers.
 970    For the m68k for example, the general register set is typically defined
 971    by:
 972
 973    typedef int gregset_t[18];
 974
 975    #define      R_D0    0
 976    ...
 977    #define      R_PS    17
 978
 979    and the floating point set by:
 980
 981    typedef      struct fpregset {
 982    int  f_pcr;
 983    int  f_psr;
 984    int  f_fpiaddr;
 985    int  f_fpregs[8][3];         (8 regs, 96 bits each)
 986    } fpregset_t;
 987
 988    These routines provide the packing and unpacking of gregset_t and
 989    fpregset_t formatted data.
 990
 991  */
 992
 993 /* Atari SVR4 has R_SR but not R_PS */
 994
 995 #if !defined (R_PS) && defined (R_SR)
 996 #define R_PS R_SR
 997 #endif
 998
 999 /*  Given a pointer to a general register set in /proc format (gregset_t *),
1000    unpack the register contents and supply them as gdb's idea of the current
1001    register values. */
1002
1003 void
1004 supply_gregset (gregset_t *gregsetp)
1005 {
1006   int regi;
1007   greg_t *regp = (greg_t *) gregsetp;
1008
1009   for (regi = 0; regi < R_PC; regi++)
1010     {
1011       regcache_raw_supply (current_regcache, regi, (char *) (regp + regi));
1012     }
1013   regcache_raw_supply (current_regcache, PS_REGNUM, (char *) (regp + R_PS));
1014   regcache_raw_supply (current_regcache, PC_REGNUM, (char *) (regp + R_PC));
1015 }
1016
1017 void
1018 fill_gregset (gregset_t *gregsetp, int regno)
1019 {
1020   int regi;
1021   greg_t *regp = (greg_t *) gregsetp;
1022
1023   for (regi = 0; regi < R_PC; regi++)
1024     {
1025       if (regno == -1 || regno == regi)
1026         regcache_raw_collect (current_regcache, regi, regp + regi);
1027     }
1028   if (regno == -1 || regno == PS_REGNUM)
1029     regcache_raw_collect (current_regcache, PS_REGNUM, regp + R_PS);
1030   if (regno == -1 || regno == PC_REGNUM)
1031     regcache_raw_collect (current_regcache, PC_REGNUM, regp + R_PC);
1032 }
1033
1034 #if defined (FP0_REGNUM)
1035
1036 /*  Given a pointer to a floating point register set in /proc format
1037    (fpregset_t *), unpack the register contents and supply them as gdb's
1038    idea of the current floating point register values. */
1039
1040 void
1041 supply_fpregset (fpregset_t *fpregsetp)
1042 {
1043   int regi;
1044   char *from;
1045
1046   for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
1047     {
1048       from = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
1049       regcache_raw_supply (current_regcache, regi, from);
1050     }
1051   regcache_raw_supply (current_regcache, M68K_FPC_REGNUM,
1052                        (char *) &(fpregsetp->f_pcr));
1053   regcache_raw_supply (current_regcache, M68K_FPS_REGNUM,
1054                        (char *) &(fpregsetp->f_psr));
1055   regcache_raw_supply (current_regcache, M68K_FPI_REGNUM,
1056                        (char *) &(fpregsetp->f_fpiaddr));
1057 }
1058
1059 /*  Given a pointer to a floating point register set in /proc format
1060    (fpregset_t *), update the register specified by REGNO from gdb's idea
1061    of the current floating point register set.  If REGNO is -1, update
1062    them all. */
1063
1064 void
1065 fill_fpregset (fpregset_t *fpregsetp, int regno)
1066 {
1067   int regi;
1068
1069   for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
1070     {
1071       if (regno == -1 || regno == regi)
1072         regcache_raw_collect (current_regcache, regi,
1073                               &fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
1074     }
1075   if (regno == -1 || regno == M68K_FPC_REGNUM)
1076     regcache_raw_collect (current_regcache, M68K_FPC_REGNUM,
1077                           &fpregsetp->f_pcr);
1078   if (regno == -1 || regno == M68K_FPS_REGNUM)
1079     regcache_raw_collect (current_regcache, M68K_FPS_REGNUM,
1080                           &fpregsetp->f_psr);
1081   if (regno == -1 || regno == M68K_FPI_REGNUM)
1082     regcache_raw_collect (current_regcache, M68K_FPI_REGNUM,
1083                           &fpregsetp->f_fpiaddr);
1084 }
1085
1086 #endif /* defined (FP0_REGNUM) */
1087
1088 #endif /* USE_PROC_FS */
1089
1090 /* Figure out where the longjmp will land.  Slurp the args out of the stack.
1091    We expect the first arg to be a pointer to the jmp_buf structure from which
1092    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
1093    This routine returns true on success. */
1094
1095 static int
1096 m68k_get_longjmp_target (CORE_ADDR *pc)
1097 {
1098   gdb_byte *buf;
1099   CORE_ADDR sp, jb_addr;
1100   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1101
1102   if (tdep->jb_pc < 0)
1103     {
1104       internal_error (__FILE__, __LINE__,
1105                       _("m68k_get_longjmp_target: not implemented"));
1106       return 0;
1107     }
1108
1109   buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
1110   sp = read_register (SP_REGNUM);
1111
1112   if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */
1113                           buf, TARGET_PTR_BIT / TARGET_CHAR_BIT))
1114     return 0;
1115
1116   jb_addr = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1117
1118   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1119                           TARGET_PTR_BIT / TARGET_CHAR_BIT))
1120     return 0;
1121
1122   *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1123   return 1;
1124 }
1125 \f
1126
1127 /* System V Release 4 (SVR4).  */
1128
1129 void
1130 m68k_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1131 {
1132   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1133
1134   /* SVR4 uses a different calling convention.  */
1135   set_gdbarch_return_value (gdbarch, m68k_svr4_return_value);
1136
1137   /* SVR4 uses %a0 instead of %a1.  */
1138   tdep->struct_value_regnum = M68K_A0_REGNUM;
1139 }
1140 \f
1141
1142 /* Function: m68k_gdbarch_init
1143    Initializer function for the m68k gdbarch vector.
1144    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1145
1146 static struct gdbarch *
1147 m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1148 {
1149   struct gdbarch_tdep *tdep = NULL;
1150   struct gdbarch *gdbarch;
1151
1152   /* find a candidate among the list of pre-declared architectures. */
1153   arches = gdbarch_list_lookup_by_info (arches, &info);
1154   if (arches != NULL)
1155     return (arches->gdbarch);
1156
1157   tdep = xmalloc (sizeof (struct gdbarch_tdep));
1158   gdbarch = gdbarch_alloc (&info, tdep);
1159
1160   set_gdbarch_long_double_format (gdbarch, floatformats_m68881_ext);
1161   set_gdbarch_long_double_bit (gdbarch, 96);
1162
1163   set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
1164   set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
1165
1166   /* Stack grows down. */
1167   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1168   set_gdbarch_frame_align (gdbarch, m68k_frame_align);
1169
1170   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1171   set_gdbarch_decr_pc_after_break (gdbarch, 2);
1172
1173   set_gdbarch_frame_args_skip (gdbarch, 8);
1174   set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1175   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum);
1176
1177   set_gdbarch_register_type (gdbarch, m68k_register_type);
1178   set_gdbarch_register_name (gdbarch, m68k_register_name);
1179   set_gdbarch_num_regs (gdbarch, M68K_NUM_REGS);
1180   set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
1181   set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
1182   set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
1183   set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
1184   set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
1185   set_gdbarch_convert_register_p (gdbarch, m68k_convert_register_p);
1186   set_gdbarch_register_to_value (gdbarch,  m68k_register_to_value);
1187   set_gdbarch_value_to_register (gdbarch, m68k_value_to_register);
1188
1189   set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call);
1190   set_gdbarch_return_value (gdbarch, m68k_return_value);
1191
1192   /* Disassembler.  */
1193   set_gdbarch_print_insn (gdbarch, print_insn_m68k);
1194
1195 #if defined JB_PC && defined JB_ELEMENT_SIZE
1196   tdep->jb_pc = JB_PC;
1197   tdep->jb_elt_size = JB_ELEMENT_SIZE;
1198 #else
1199   tdep->jb_pc = -1;
1200 #endif
1201   tdep->struct_value_regnum = M68K_A1_REGNUM;
1202   tdep->struct_return = reg_struct_return;
1203
1204   /* Frame unwinder.  */
1205   set_gdbarch_unwind_dummy_id (gdbarch, m68k_unwind_dummy_id);
1206   set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc);
1207
1208   /* Hook in the DWARF CFI frame unwinder.  */
1209   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1210
1211   frame_base_set_default (gdbarch, &m68k_frame_base);
1212
1213   /* Hook in ABI-specific overrides, if they have been registered.  */
1214   gdbarch_init_osabi (info, gdbarch);
1215
1216   /* Now we have tuned the configuration, set a few final things,
1217      based on what the OS ABI has told us.  */
1218
1219   if (tdep->jb_pc >= 0)
1220     set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
1221
1222   frame_unwind_append_sniffer (gdbarch, m68k_frame_sniffer);
1223
1224   return gdbarch;
1225 }
1226
1227
1228 static void
1229 m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1230 {
1231   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1232
1233   if (tdep == NULL)
1234     return;
1235 }
1236
1237 extern initialize_file_ftype _initialize_m68k_tdep; /* -Wmissing-prototypes */
1238
1239 void
1240 _initialize_m68k_tdep (void)
1241 {
1242   gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
1243 }