gdb/m68k-tdep.c

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