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