1 /* Target-dependent code for the Motorola 68000 series.
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.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "dwarf2-frame.h"
25 #include "frame-base.h"
26 #include "frame-unwind.h"
31 #include "gdb_string.h"
32 #include "gdb_assert.h"
35 #include "arch-utils.h"
38 #include "target-descriptions.h"
40 #include "m68k-tdep.h"
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
57 /* Offset from SP to first arg on stack at first instruction of a function. */
58 #define SP_ARG0 (1 * 4)
60 #if !defined (BPT_VECTOR)
61 #define BPT_VECTOR 0xf
64 static const gdb_byte
*
65 m68k_local_breakpoint_from_pc (struct gdbarch
*gdbarch
,
66 CORE_ADDR
*pcptr
, int *lenptr
)
68 static gdb_byte break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
69 *lenptr
= sizeof (break_insn
);
74 /* Construct types for ISA-specific registers. */
76 m68k_ps_type (struct gdbarch
*gdbarch
)
78 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
80 if (!tdep
->m68k_ps_type
)
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");
98 tdep
->m68k_ps_type
= type
;
101 return tdep
->m68k_ps_type
;
105 m68881_ext_type (struct gdbarch
*gdbarch
)
107 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
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
);
114 return tdep
->m68881_ext_type
;
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
126 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
128 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
130 if (tdep
->fpregs_present
)
132 if (regnum
>= gdbarch_fp0_regnum (gdbarch
)
133 && regnum
<= gdbarch_fp0_regnum (gdbarch
) + 7)
135 if (tdep
->flavour
== m68k_coldfire_flavour
)
136 return builtin_type (gdbarch
)->builtin_double
;
138 return m68881_ext_type (gdbarch
);
141 if (regnum
== M68K_FPI_REGNUM
)
142 return builtin_type (gdbarch
)->builtin_func_ptr
;
144 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
)
145 return builtin_type (gdbarch
)->builtin_int32
;
149 if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
)
150 return builtin_type (gdbarch
)->builtin_int0
;
153 if (regnum
== gdbarch_pc_regnum (gdbarch
))
154 return builtin_type (gdbarch
)->builtin_func_ptr
;
156 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
157 return builtin_type (gdbarch
)->builtin_data_ptr
;
159 if (regnum
== M68K_PS_REGNUM
)
160 return m68k_ps_type (gdbarch
);
162 return builtin_type (gdbarch
)->builtin_int32
;
165 static const char *m68k_register_names
[] = {
166 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
167 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
169 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
170 "fpcontrol", "fpstatus", "fpiaddr"
173 /* Function: m68k_register_name
174 Returns the name of the standard m68k register regnum. */
177 m68k_register_name (struct gdbarch
*gdbarch
, int regnum
)
179 if (regnum
< 0 || regnum
>= ARRAY_SIZE (m68k_register_names
))
180 internal_error (__FILE__
, __LINE__
,
181 _("m68k_register_name: illegal register number %d"),
183 else if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
184 && gdbarch_tdep (gdbarch
)->fpregs_present
== 0)
187 return m68k_register_names
[regnum
];
190 /* Return nonzero if a value of type TYPE stored in register REGNUM
191 needs any special handling. */
194 m68k_convert_register_p (struct gdbarch
*gdbarch
,
195 int regnum
, struct type
*type
)
197 if (!gdbarch_tdep (gdbarch
)->fpregs_present
)
199 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7
200 && type
!= register_type (gdbarch
, M68K_FP0_REGNUM
));
203 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
204 return its contents in TO. */
207 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
208 struct type
*type
, gdb_byte
*to
,
209 int *optimizedp
, int *unavailablep
)
211 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
212 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
215 /* We only support floating-point values. */
216 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
218 warning (_("Cannot convert floating-point register value "
219 "to non-floating-point type."));
220 *optimizedp
= *unavailablep
= 0;
224 /* Convert to TYPE. */
226 /* Convert to TYPE. */
227 if (!get_frame_register_bytes (frame
, regnum
, 0, TYPE_LENGTH (type
),
228 from
, optimizedp
, unavailablep
))
231 convert_typed_floating (from
, fpreg_type
, to
, type
);
232 *optimizedp
= *unavailablep
= 0;
236 /* Write the contents FROM of a value of type TYPE into register
237 REGNUM in frame FRAME. */
240 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
241 struct type
*type
, const gdb_byte
*from
)
243 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
244 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
247 /* We only support floating-point values. */
248 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
250 warning (_("Cannot convert non-floating-point type "
251 "to floating-point register value."));
255 /* Convert from TYPE. */
256 convert_typed_floating (from
, type
, to
, fpreg_type
);
257 put_frame_register (frame
, regnum
, to
);
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.
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'.
281 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
282 for passing the structure return value buffer.
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. */
290 /* Read a function return value of TYPE from REGCACHE, and copy that
294 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
297 int len
= TYPE_LENGTH (type
);
298 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
302 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
303 memcpy (valbuf
, buf
+ (4 - len
), len
);
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));
312 internal_error (__FILE__
, __LINE__
,
313 _("Cannot extract return value of %d bytes long."), len
);
317 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
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
);
325 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
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
);
331 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
332 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
334 m68k_extract_return_value (type
, regcache
, valbuf
);
337 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
340 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
341 const gdb_byte
*valbuf
)
343 int len
= TYPE_LENGTH (type
);
346 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
349 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
351 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
354 internal_error (__FILE__
, __LINE__
,
355 _("Cannot store return value of %d bytes long."), len
);
359 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
360 const gdb_byte
*valbuf
)
362 int len
= TYPE_LENGTH (type
);
363 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
364 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
366 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
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
);
373 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
375 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
376 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
379 m68k_store_return_value (type
, regcache
, valbuf
);
382 /* Return non-zero if TYPE, which is assumed to be a structure or
383 union type, should be returned in registers for architecture
387 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
389 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
390 enum type_code code
= TYPE_CODE (type
);
391 int len
= TYPE_LENGTH (type
);
393 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
395 if (tdep
->struct_return
== pcc_struct_return
)
398 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
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. */
407 static enum return_value_convention
408 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
409 struct type
*type
, struct regcache
*regcache
,
410 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
412 enum type_code code
= TYPE_CODE (type
);
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))
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. */
427 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
428 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
431 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
435 m68k_extract_return_value (type
, regcache
, readbuf
);
437 m68k_store_return_value (type
, regcache
, writebuf
);
439 return RETURN_VALUE_REGISTER_CONVENTION
;
442 static enum return_value_convention
443 m68k_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
)
447 enum type_code code
= TYPE_CODE (type
);
449 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
450 && !m68k_reg_struct_return_p (gdbarch
, type
))
452 /* The System V ABI says that:
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
459 So the ABI guarantees that we can always find the return
460 value just after the function has returned. */
466 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
467 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
470 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
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)
481 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
482 return m68k_svr4_return_value (gdbarch
, func_type
, type
, regcache
,
487 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
489 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
491 return RETURN_VALUE_REGISTER_CONVENTION
;
495 /* Always align the frame to a 4-byte boundary. This is required on
496 coldfire and harmless on the rest. */
499 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
501 /* Align the stack to four bytes. */
506 m68k_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
)
511 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
512 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
516 /* Push arguments in reverse order. */
517 for (i
= nargs
- 1; i
>= 0; i
--)
519 struct type
*value_type
= value_enclosing_type (args
[i
]);
520 int len
= TYPE_LENGTH (value_type
);
521 int container_len
= (len
+ 3) & ~3;
524 /* Non-scalars bigger than 4 bytes are left aligned, others are
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
)
532 offset
= container_len
- len
;
534 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
537 /* Store struct value address. */
540 store_unsigned_integer (buf
, 4, byte_order
, struct_addr
);
541 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
544 /* Store return address. */
546 store_unsigned_integer (buf
, 4, byte_order
, bp_addr
);
547 write_memory (sp
, buf
, 4);
549 /* Finally, update the stack pointer... */
550 store_unsigned_integer (buf
, 4, byte_order
, sp
);
551 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
553 /* ...and fake a frame pointer. */
554 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
556 /* DWARF2/GCC uses the stack address *before* the function call as a
561 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
564 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
568 return (num
- 0) + M68K_D0_REGNUM
;
571 return (num
- 8) + M68K_A0_REGNUM
;
572 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
574 return (num
- 16) + M68K_FP0_REGNUM
;
577 return M68K_PC_REGNUM
;
579 return gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
583 struct m68k_frame_cache
590 /* Saved registers. */
591 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
594 /* Stack space reserved for local variables. */
598 /* Allocate and initialize a frame cache. */
600 static struct m68k_frame_cache
*
601 m68k_alloc_frame_cache (void)
603 struct m68k_frame_cache
*cache
;
606 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
610 cache
->sp_offset
= -4;
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;
618 /* Frameless until proven otherwise. */
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. */
631 m68k_analyze_frame_setup (struct gdbarch
*gdbarch
,
632 CORE_ADDR pc
, CORE_ADDR current_pc
,
633 struct m68k_frame_cache
*cache
)
635 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
638 if (pc
>= current_pc
)
641 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
643 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
645 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
646 cache
->sp_offset
+= 4;
647 if (op
== P_LINKW_FP
)
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
);
653 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
655 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
656 if (op
== P_ADDAL_SP
)
658 cache
->locals
= read_memory_integer (pc
+ 6, 4, byte_order
);
665 else if (op
== P_LINKL_FP
)
667 /* link.l %fp, #-N */
668 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
673 /* pea (%fp); movea.l %sp, %fp */
676 if (pc
+ 2 < current_pc
)
678 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
680 if (op
== P_MOVEAL_SP_FP
)
682 /* move.l %sp, %fp */
690 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
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
)
697 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
698 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
700 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
706 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
709 /* lea (-N,%sp),%sp */
710 cache
->locals
= -read_memory_integer (pc
+ 2, 2, byte_order
);
713 else if (op
== P_ADDAL_SP
)
716 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
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. */
729 m68k_analyze_register_saves (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
730 CORE_ADDR current_pc
,
731 struct m68k_frame_cache
*cache
)
733 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
735 if (cache
->locals
>= 0)
741 offset
= -4 - cache
->locals
;
742 while (pc
< current_pc
)
744 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
745 if (op
== P_FMOVEMX_SP
746 && gdbarch_tdep (gdbarch
)->fpregs_present
)
748 /* fmovem.x REGS,-(%sp) */
749 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
750 if ((op
& 0xff00) == 0xe000)
753 for (i
= 0; i
< 16; i
++, mask
>>= 1)
757 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
766 else if ((op
& 0177760) == P_MOVEL_SP
)
768 /* move.l %R,-(%sp) */
770 cache
->saved_regs
[regno
] = offset
;
774 else if (op
== P_MOVEML_SP
)
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)
782 cache
->saved_regs
[15 - i
] = offset
;
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.
801 We handle all cases that can be generated by gcc.
803 For allocating a stack frame:
807 pea (%fp); move.l %sp,%fp
808 link.w %a6,#0; add.l #-N,%sp
811 subq.w #8,%sp; subq.w #N-8,%sp
816 For saving registers:
820 move.l R1,-(%sp); move.l R2,-(%sp)
823 For setting up the PIC register:
830 m68k_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
831 CORE_ADDR current_pc
, struct m68k_frame_cache
*cache
)
833 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
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
)
841 /* Check for GOT setup. */
842 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
843 if (op
== P_LEA_PC_A5
)
845 /* lea (%pc,N),%a5 */
852 /* Return PC of first real instruction. */
855 m68k_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
857 struct m68k_frame_cache cache
;
862 pc
= m68k_analyze_prologue (gdbarch
, start_pc
, (CORE_ADDR
) -1, &cache
);
863 if (cache
.locals
< 0)
869 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
873 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
874 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
879 static struct m68k_frame_cache
*
880 m68k_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
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
;
891 cache
= m68k_alloc_frame_cache ();
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. */
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)
908 /* For normal frames, %pc is stored at 4(%fp). */
909 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
911 cache
->pc
= get_frame_func (this_frame
);
913 m68k_analyze_prologue (get_frame_arch (this_frame
), cache
->pc
,
914 get_frame_pc (this_frame
), cache
);
916 if (cache
->locals
< 0)
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. */
926 get_frame_register (this_frame
, M68K_SP_REGNUM
, buf
);
927 cache
->base
= extract_unsigned_integer (buf
, 4, byte_order
)
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;
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
;
945 m68k_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
946 struct frame_id
*this_id
)
948 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
950 /* This marks the outermost frame. */
951 if (cache
->base
== 0)
954 /* See the end of m68k_push_dummy_call. */
955 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
958 static struct value
*
959 m68k_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
962 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
964 gdb_assert (regnum
>= 0);
966 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
967 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
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
]);
973 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
976 static const struct frame_unwind m68k_frame_unwind
=
979 default_frame_unwind_stop_reason
,
981 m68k_frame_prev_register
,
983 default_frame_sniffer
987 m68k_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
989 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
994 static const struct frame_base m68k_frame_base
=
997 m68k_frame_base_address
,
998 m68k_frame_base_address
,
999 m68k_frame_base_address
1002 static struct frame_id
1003 m68k_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1007 fp
= get_frame_register_unsigned (this_frame
, M68K_FP_REGNUM
);
1009 /* See the end of m68k_push_dummy_call. */
1010 return frame_id_build (fp
+ 8, get_frame_pc (this_frame
));
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. */
1020 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
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
);
1028 if (tdep
->jb_pc
< 0)
1030 internal_error (__FILE__
, __LINE__
,
1031 _("m68k_get_longjmp_target: not implemented"));
1035 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1036 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1038 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack. */
1039 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1042 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1043 / TARGET_CHAR_BIT
, byte_order
);
1045 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1046 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
),
1050 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1051 / TARGET_CHAR_BIT
, byte_order
);
1056 /* System V Release 4 (SVR4). */
1059 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1061 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1063 /* SVR4 uses a different calling convention. */
1064 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1066 /* SVR4 uses %a0 instead of %a1. */
1067 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
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. */
1075 static struct gdbarch
*
1076 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1078 struct gdbarch_tdep
*tdep
= NULL
;
1079 struct gdbarch
*gdbarch
;
1080 struct gdbarch_list
*best_arch
;
1081 struct tdesc_arch_data
*tdesc_data
= NULL
;
1083 enum m68k_flavour flavour
= m68k_no_flavour
;
1085 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1087 /* Check any target description for validity. */
1088 if (tdesc_has_registers (info
.target_desc
))
1090 const struct tdesc_feature
*feature
;
1093 feature
= tdesc_find_feature (info
.target_desc
,
1094 "org.gnu.gdb.m68k.core");
1095 if (feature
!= NULL
)
1099 if (feature
== NULL
)
1101 feature
= tdesc_find_feature (info
.target_desc
,
1102 "org.gnu.gdb.coldfire.core");
1103 if (feature
!= NULL
)
1104 flavour
= m68k_coldfire_flavour
;
1107 if (feature
== NULL
)
1109 feature
= tdesc_find_feature (info
.target_desc
,
1110 "org.gnu.gdb.fido.core");
1111 if (feature
!= NULL
)
1112 flavour
= m68k_fido_flavour
;
1115 if (feature
== NULL
)
1118 tdesc_data
= tdesc_data_alloc ();
1121 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1122 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1123 m68k_register_names
[i
]);
1127 tdesc_data_cleanup (tdesc_data
);
1131 feature
= tdesc_find_feature (info
.target_desc
,
1132 "org.gnu.gdb.coldfire.fp");
1133 if (feature
!= NULL
)
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
]);
1141 tdesc_data_cleanup (tdesc_data
);
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. */
1153 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1155 const bfd_arch_info_type
*coldfire_arch
=
1156 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1159 && ((*info
.bfd_arch_info
->compatible
)
1160 (info
.bfd_arch_info
, coldfire_arch
)))
1161 flavour
= m68k_coldfire_flavour
;
1164 /* If there is already a candidate, use it. */
1165 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1167 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1169 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1172 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1178 if (best_arch
!= NULL
)
1180 if (tdesc_data
!= NULL
)
1181 tdesc_data_cleanup (tdesc_data
);
1182 return best_arch
->gdbarch
;
1185 tdep
= xzalloc (sizeof (struct gdbarch_tdep
));
1186 gdbarch
= gdbarch_alloc (&info
, tdep
);
1187 tdep
->fpregs_present
= has_fp
;
1188 tdep
->flavour
= flavour
;
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
);
1195 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1196 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1198 /* Stack grows down. */
1199 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1200 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
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);
1206 set_gdbarch_frame_args_skip (gdbarch
, 8);
1207 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
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
);
1220 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1222 /* Try to figure out if the arch uses floating registers to return
1223 floating point values from functions. */
1226 /* On ColdFire, floating point values are returned in D0. */
1227 if (flavour
== m68k_coldfire_flavour
)
1228 tdep
->float_return
= 0;
1230 tdep
->float_return
= 1;
1234 /* No floating registers, so can't use them for returning values. */
1235 tdep
->float_return
= 0;
1238 /* Function call & return. */
1239 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1240 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1244 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1246 #if defined JB_PC && defined JB_ELEMENT_SIZE
1247 tdep
->jb_pc
= JB_PC
;
1248 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1252 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1253 tdep
->struct_return
= reg_struct_return
;
1255 /* Frame unwinder. */
1256 set_gdbarch_dummy_id (gdbarch
, m68k_dummy_id
);
1257 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1259 /* Hook in the DWARF CFI frame unwinder. */
1260 dwarf2_append_unwinders (gdbarch
);
1262 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1264 /* Hook in ABI-specific overrides, if they have been registered. */
1265 gdbarch_init_osabi (info
, gdbarch
);
1267 /* Now we have tuned the configuration, set a few final things,
1268 based on what the OS ABI has told us. */
1270 if (tdep
->jb_pc
>= 0)
1271 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1273 frame_unwind_append_unwinder (gdbarch
, &m68k_frame_unwind
);
1276 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1283 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1285 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1291 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1294 _initialize_m68k_tdep (void)
1296 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);