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
)
210 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
211 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
214 /* We only support floating-point values. */
215 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
217 warning (_("Cannot convert floating-point register value "
218 "to non-floating-point type."));
222 /* Convert to TYPE. */
223 get_frame_register (frame
, regnum
, from
);
224 convert_typed_floating (from
, fpreg_type
, to
, type
);
227 /* Write the contents FROM of a value of type TYPE into register
228 REGNUM in frame FRAME. */
231 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
232 struct type
*type
, const gdb_byte
*from
)
234 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
235 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
238 /* We only support floating-point values. */
239 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
241 warning (_("Cannot convert non-floating-point type "
242 "to floating-point register value."));
246 /* Convert from TYPE. */
247 convert_typed_floating (from
, type
, to
, fpreg_type
);
248 put_frame_register (frame
, regnum
, to
);
252 /* There is a fair number of calling conventions that are in somewhat
253 wide use. The 68000/08/10 don't support an FPU, not even as a
254 coprocessor. All function return values are stored in %d0/%d1.
255 Structures are returned in a static buffer, a pointer to which is
256 returned in %d0. This means that functions returning a structure
257 are not re-entrant. To avoid this problem some systems use a
258 convention where the caller passes a pointer to a buffer in %a1
259 where the return values is to be stored. This convention is the
260 default, and is implemented in the function m68k_return_value.
262 The 68020/030/040/060 do support an FPU, either as a coprocessor
263 (68881/2) or built-in (68040/68060). That's why System V release 4
264 (SVR4) instroduces a new calling convention specified by the SVR4
265 psABI. Integer values are returned in %d0/%d1, pointer return
266 values in %a0 and floating values in %fp0. When calling functions
267 returning a structure the caller should pass a pointer to a buffer
268 for the return value in %a0. This convention is implemented in the
269 function m68k_svr4_return_value, and by appropriately setting the
270 struct_value_regnum member of `struct gdbarch_tdep'.
272 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
273 for passing the structure return value buffer.
275 GCC can also generate code where small structures are returned in
276 %d0/%d1 instead of in memory by using -freg-struct-return. This is
277 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
278 embedded systems. This convention is implemented by setting the
279 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
281 /* Read a function return value of TYPE from REGCACHE, and copy that
285 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
288 int len
= TYPE_LENGTH (type
);
289 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
293 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
294 memcpy (valbuf
, buf
+ (4 - len
), len
);
298 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
299 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
300 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
303 internal_error (__FILE__
, __LINE__
,
304 _("Cannot extract return value of %d bytes long."), len
);
308 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
311 int len
= TYPE_LENGTH (type
);
312 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
313 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
314 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
316 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
318 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
319 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
320 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
322 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
323 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
325 m68k_extract_return_value (type
, regcache
, valbuf
);
328 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
331 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
332 const gdb_byte
*valbuf
)
334 int len
= TYPE_LENGTH (type
);
337 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
340 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
342 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
345 internal_error (__FILE__
, __LINE__
,
346 _("Cannot store return value of %d bytes long."), len
);
350 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
351 const gdb_byte
*valbuf
)
353 int len
= TYPE_LENGTH (type
);
354 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
355 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
357 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
359 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
360 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
361 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
362 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
364 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
366 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
367 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
370 m68k_store_return_value (type
, regcache
, valbuf
);
373 /* Return non-zero if TYPE, which is assumed to be a structure or
374 union type, should be returned in registers for architecture
378 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
380 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
381 enum type_code code
= TYPE_CODE (type
);
382 int len
= TYPE_LENGTH (type
);
384 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
386 if (tdep
->struct_return
== pcc_struct_return
)
389 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
392 /* Determine, for architecture GDBARCH, how a return value of TYPE
393 should be returned. If it is supposed to be returned in registers,
394 and READBUF is non-zero, read the appropriate value from REGCACHE,
395 and copy it into READBUF. If WRITEBUF is non-zero, write the value
396 from WRITEBUF into REGCACHE. */
398 static enum return_value_convention
399 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
400 struct type
*type
, struct regcache
*regcache
,
401 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
403 enum type_code code
= TYPE_CODE (type
);
405 /* GCC returns a `long double' in memory too. */
406 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
407 && !m68k_reg_struct_return_p (gdbarch
, type
))
408 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
410 /* The default on m68k is to return structures in static memory.
411 Consequently a function must return the address where we can
412 find the return value. */
418 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
419 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
422 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
426 m68k_extract_return_value (type
, regcache
, readbuf
);
428 m68k_store_return_value (type
, regcache
, writebuf
);
430 return RETURN_VALUE_REGISTER_CONVENTION
;
433 static enum return_value_convention
434 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
435 struct type
*type
, struct regcache
*regcache
,
436 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
438 enum type_code code
= TYPE_CODE (type
);
440 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
441 && !m68k_reg_struct_return_p (gdbarch
, type
))
443 /* The System V ABI says that:
445 "A function returning a structure or union also sets %a0 to
446 the value it finds in %a0. Thus when the caller receives
447 control again, the address of the returned object resides in
450 So the ABI guarantees that we can always find the return
451 value just after the function has returned. */
457 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
458 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
461 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
464 /* This special case is for structures consisting of a single
465 `float' or `double' member. These structures are returned in
466 %fp0. For these structures, we call ourselves recursively,
467 changing TYPE into the type of the first member of the structure.
468 Since that should work for all structures that have only one
469 member, we don't bother to check the member's type here. */
470 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
472 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
473 return m68k_svr4_return_value (gdbarch
, func_type
, type
, regcache
,
478 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
480 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
482 return RETURN_VALUE_REGISTER_CONVENTION
;
486 /* Always align the frame to a 4-byte boundary. This is required on
487 coldfire and harmless on the rest. */
490 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
492 /* Align the stack to four bytes. */
497 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
498 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
499 struct value
**args
, CORE_ADDR sp
, int struct_return
,
500 CORE_ADDR struct_addr
)
502 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
503 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
507 /* Push arguments in reverse order. */
508 for (i
= nargs
- 1; i
>= 0; i
--)
510 struct type
*value_type
= value_enclosing_type (args
[i
]);
511 int len
= TYPE_LENGTH (value_type
);
512 int container_len
= (len
+ 3) & ~3;
515 /* Non-scalars bigger than 4 bytes are left aligned, others are
517 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
518 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
519 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
523 offset
= container_len
- len
;
525 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
528 /* Store struct value address. */
531 store_unsigned_integer (buf
, 4, byte_order
, struct_addr
);
532 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
535 /* Store return address. */
537 store_unsigned_integer (buf
, 4, byte_order
, bp_addr
);
538 write_memory (sp
, buf
, 4);
540 /* Finally, update the stack pointer... */
541 store_unsigned_integer (buf
, 4, byte_order
, sp
);
542 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
544 /* ...and fake a frame pointer. */
545 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
547 /* DWARF2/GCC uses the stack address *before* the function call as a
552 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
555 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
559 return (num
- 0) + M68K_D0_REGNUM
;
562 return (num
- 8) + M68K_A0_REGNUM
;
563 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
565 return (num
- 16) + M68K_FP0_REGNUM
;
568 return M68K_PC_REGNUM
;
570 return gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
574 struct m68k_frame_cache
581 /* Saved registers. */
582 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
585 /* Stack space reserved for local variables. */
589 /* Allocate and initialize a frame cache. */
591 static struct m68k_frame_cache
*
592 m68k_alloc_frame_cache (void)
594 struct m68k_frame_cache
*cache
;
597 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
601 cache
->sp_offset
= -4;
604 /* Saved registers. We initialize these to -1 since zero is a valid
605 offset (that's where %fp is supposed to be stored). */
606 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
607 cache
->saved_regs
[i
] = -1;
609 /* Frameless until proven otherwise. */
615 /* Check whether PC points at a code that sets up a new stack frame.
616 If so, it updates CACHE and returns the address of the first
617 instruction after the sequence that sets removes the "hidden"
618 argument from the stack or CURRENT_PC, whichever is smaller.
619 Otherwise, return PC. */
622 m68k_analyze_frame_setup (struct gdbarch
*gdbarch
,
623 CORE_ADDR pc
, CORE_ADDR current_pc
,
624 struct m68k_frame_cache
*cache
)
626 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
629 if (pc
>= current_pc
)
632 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
634 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
636 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
637 cache
->sp_offset
+= 4;
638 if (op
== P_LINKW_FP
)
640 /* link.w %fp, #-N */
641 /* link.w %fp, #0; adda.l #-N, %sp */
642 cache
->locals
= -read_memory_integer (pc
+ 2, 2, byte_order
);
644 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
646 op
= read_memory_unsigned_integer (pc
+ 4, 2, byte_order
);
647 if (op
== P_ADDAL_SP
)
649 cache
->locals
= read_memory_integer (pc
+ 6, 4, byte_order
);
656 else if (op
== P_LINKL_FP
)
658 /* link.l %fp, #-N */
659 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
664 /* pea (%fp); movea.l %sp, %fp */
667 if (pc
+ 2 < current_pc
)
669 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
671 if (op
== P_MOVEAL_SP_FP
)
673 /* move.l %sp, %fp */
681 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
683 /* subq.[wl] #N,%sp */
684 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
685 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
686 if (pc
+ 2 < current_pc
)
688 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
689 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
691 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
697 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
700 /* lea (-N,%sp),%sp */
701 cache
->locals
= -read_memory_integer (pc
+ 2, 2, byte_order
);
704 else if (op
== P_ADDAL_SP
)
707 cache
->locals
= -read_memory_integer (pc
+ 2, 4, byte_order
);
714 /* Check whether PC points at code that saves registers on the stack.
715 If so, it updates CACHE and returns the address of the first
716 instruction after the register saves or CURRENT_PC, whichever is
717 smaller. Otherwise, return PC. */
720 m68k_analyze_register_saves (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
721 CORE_ADDR current_pc
,
722 struct m68k_frame_cache
*cache
)
724 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
726 if (cache
->locals
>= 0)
732 offset
= -4 - cache
->locals
;
733 while (pc
< current_pc
)
735 op
= read_memory_unsigned_integer (pc
, 2, byte_order
);
736 if (op
== P_FMOVEMX_SP
737 && gdbarch_tdep (gdbarch
)->fpregs_present
)
739 /* fmovem.x REGS,-(%sp) */
740 op
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
741 if ((op
& 0xff00) == 0xe000)
744 for (i
= 0; i
< 16; i
++, mask
>>= 1)
748 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
757 else if ((op
& 0177760) == P_MOVEL_SP
)
759 /* move.l %R,-(%sp) */
761 cache
->saved_regs
[regno
] = offset
;
765 else if (op
== P_MOVEML_SP
)
767 /* movem.l REGS,-(%sp) */
768 mask
= read_memory_unsigned_integer (pc
+ 2, 2, byte_order
);
769 for (i
= 0; i
< 16; i
++, mask
>>= 1)
773 cache
->saved_regs
[15 - i
] = offset
;
788 /* Do a full analysis of the prologue at PC and update CACHE
789 accordingly. Bail out early if CURRENT_PC is reached. Return the
790 address where the analysis stopped.
792 We handle all cases that can be generated by gcc.
794 For allocating a stack frame:
798 pea (%fp); move.l %sp,%fp
799 link.w %a6,#0; add.l #-N,%sp
802 subq.w #8,%sp; subq.w #N-8,%sp
807 For saving registers:
811 move.l R1,-(%sp); move.l R2,-(%sp)
814 For setting up the PIC register:
821 m68k_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
822 CORE_ADDR current_pc
, struct m68k_frame_cache
*cache
)
824 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
827 pc
= m68k_analyze_frame_setup (gdbarch
, pc
, current_pc
, cache
);
828 pc
= m68k_analyze_register_saves (gdbarch
, pc
, current_pc
, cache
);
829 if (pc
>= current_pc
)
832 /* Check for GOT setup. */
833 op
= read_memory_unsigned_integer (pc
, 4, byte_order
);
834 if (op
== P_LEA_PC_A5
)
836 /* lea (%pc,N),%a5 */
843 /* Return PC of first real instruction. */
846 m68k_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
848 struct m68k_frame_cache cache
;
853 pc
= m68k_analyze_prologue (gdbarch
, start_pc
, (CORE_ADDR
) -1, &cache
);
854 if (cache
.locals
< 0)
860 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
864 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
865 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
870 static struct m68k_frame_cache
*
871 m68k_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
873 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
874 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
875 struct m68k_frame_cache
*cache
;
882 cache
= m68k_alloc_frame_cache ();
885 /* In principle, for normal frames, %fp holds the frame pointer,
886 which holds the base address for the current stack frame.
887 However, for functions that don't need it, the frame pointer is
888 optional. For these "frameless" functions the frame pointer is
889 actually the frame pointer of the calling frame. Signal
890 trampolines are just a special case of a "frameless" function.
891 They (usually) share their frame pointer with the frame that was
892 in progress when the signal occurred. */
894 get_frame_register (this_frame
, M68K_FP_REGNUM
, buf
);
895 cache
->base
= extract_unsigned_integer (buf
, 4, byte_order
);
896 if (cache
->base
== 0)
899 /* For normal frames, %pc is stored at 4(%fp). */
900 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
902 cache
->pc
= get_frame_func (this_frame
);
904 m68k_analyze_prologue (get_frame_arch (this_frame
), cache
->pc
,
905 get_frame_pc (this_frame
), cache
);
907 if (cache
->locals
< 0)
909 /* We didn't find a valid frame, which means that CACHE->base
910 currently holds the frame pointer for our calling frame. If
911 we're at the start of a function, or somewhere half-way its
912 prologue, the function's frame probably hasn't been fully
913 setup yet. Try to reconstruct the base address for the stack
914 frame by looking at the stack pointer. For truly "frameless"
915 functions this might work too. */
917 get_frame_register (this_frame
, M68K_SP_REGNUM
, buf
);
918 cache
->base
= extract_unsigned_integer (buf
, 4, byte_order
)
922 /* Now that we have the base address for the stack frame we can
923 calculate the value of %sp in the calling frame. */
924 cache
->saved_sp
= cache
->base
+ 8;
926 /* Adjust all the saved registers such that they contain addresses
927 instead of offsets. */
928 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
929 if (cache
->saved_regs
[i
] != -1)
930 cache
->saved_regs
[i
] += cache
->base
;
936 m68k_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
937 struct frame_id
*this_id
)
939 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
941 /* This marks the outermost frame. */
942 if (cache
->base
== 0)
945 /* See the end of m68k_push_dummy_call. */
946 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
949 static struct value
*
950 m68k_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
953 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
955 gdb_assert (regnum
>= 0);
957 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
958 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
960 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
961 return frame_unwind_got_memory (this_frame
, regnum
,
962 cache
->saved_regs
[regnum
]);
964 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
967 static const struct frame_unwind m68k_frame_unwind
=
971 m68k_frame_prev_register
,
973 default_frame_sniffer
977 m68k_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
979 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
984 static const struct frame_base m68k_frame_base
=
987 m68k_frame_base_address
,
988 m68k_frame_base_address
,
989 m68k_frame_base_address
992 static struct frame_id
993 m68k_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
997 fp
= get_frame_register_unsigned (this_frame
, M68K_FP_REGNUM
);
999 /* See the end of m68k_push_dummy_call. */
1000 return frame_id_build (fp
+ 8, get_frame_pc (this_frame
));
1004 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1005 We expect the first arg to be a pointer to the jmp_buf structure from which
1006 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1007 This routine returns true on success. */
1010 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
1013 CORE_ADDR sp
, jb_addr
;
1014 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1015 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1016 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1018 if (tdep
->jb_pc
< 0)
1020 internal_error (__FILE__
, __LINE__
,
1021 _("m68k_get_longjmp_target: not implemented"));
1025 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1026 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1028 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack. */
1029 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1032 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1033 / TARGET_CHAR_BIT
, byte_order
);
1035 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1036 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
),
1040 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1041 / TARGET_CHAR_BIT
, byte_order
);
1046 /* System V Release 4 (SVR4). */
1049 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1051 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1053 /* SVR4 uses a different calling convention. */
1054 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1056 /* SVR4 uses %a0 instead of %a1. */
1057 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1061 /* Function: m68k_gdbarch_init
1062 Initializer function for the m68k gdbarch vector.
1063 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1065 static struct gdbarch
*
1066 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1068 struct gdbarch_tdep
*tdep
= NULL
;
1069 struct gdbarch
*gdbarch
;
1070 struct gdbarch_list
*best_arch
;
1071 struct tdesc_arch_data
*tdesc_data
= NULL
;
1073 enum m68k_flavour flavour
= m68k_no_flavour
;
1075 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1077 /* Check any target description for validity. */
1078 if (tdesc_has_registers (info
.target_desc
))
1080 const struct tdesc_feature
*feature
;
1083 feature
= tdesc_find_feature (info
.target_desc
,
1084 "org.gnu.gdb.m68k.core");
1085 if (feature
!= NULL
)
1089 if (feature
== NULL
)
1091 feature
= tdesc_find_feature (info
.target_desc
,
1092 "org.gnu.gdb.coldfire.core");
1093 if (feature
!= NULL
)
1094 flavour
= m68k_coldfire_flavour
;
1097 if (feature
== NULL
)
1099 feature
= tdesc_find_feature (info
.target_desc
,
1100 "org.gnu.gdb.fido.core");
1101 if (feature
!= NULL
)
1102 flavour
= m68k_fido_flavour
;
1105 if (feature
== NULL
)
1108 tdesc_data
= tdesc_data_alloc ();
1111 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1112 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1113 m68k_register_names
[i
]);
1117 tdesc_data_cleanup (tdesc_data
);
1121 feature
= tdesc_find_feature (info
.target_desc
,
1122 "org.gnu.gdb.coldfire.fp");
1123 if (feature
!= NULL
)
1126 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1127 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1128 m68k_register_names
[i
]);
1131 tdesc_data_cleanup (tdesc_data
);
1139 /* The mechanism for returning floating values from function
1140 and the type of long double depend on whether we're
1141 on ColdFire or standard m68k. */
1143 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1145 const bfd_arch_info_type
*coldfire_arch
=
1146 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1149 && ((*info
.bfd_arch_info
->compatible
)
1150 (info
.bfd_arch_info
, coldfire_arch
)))
1151 flavour
= m68k_coldfire_flavour
;
1154 /* If there is already a candidate, use it. */
1155 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1157 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1159 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1162 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1168 if (best_arch
!= NULL
)
1170 if (tdesc_data
!= NULL
)
1171 tdesc_data_cleanup (tdesc_data
);
1172 return best_arch
->gdbarch
;
1175 tdep
= xzalloc (sizeof (struct gdbarch_tdep
));
1176 gdbarch
= gdbarch_alloc (&info
, tdep
);
1177 tdep
->fpregs_present
= has_fp
;
1178 tdep
->flavour
= flavour
;
1180 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1181 long_double_format
= floatformats_ieee_double
;
1182 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1183 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1185 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1186 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1188 /* Stack grows down. */
1189 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1190 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1192 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1193 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1194 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1196 set_gdbarch_frame_args_skip (gdbarch
, 8);
1197 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1199 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1200 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1201 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1202 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1203 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1204 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1205 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1206 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1207 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1210 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1212 /* Try to figure out if the arch uses floating registers to return
1213 floating point values from functions. */
1216 /* On ColdFire, floating point values are returned in D0. */
1217 if (flavour
== m68k_coldfire_flavour
)
1218 tdep
->float_return
= 0;
1220 tdep
->float_return
= 1;
1224 /* No floating registers, so can't use them for returning values. */
1225 tdep
->float_return
= 0;
1228 /* Function call & return. */
1229 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1230 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1234 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1236 #if defined JB_PC && defined JB_ELEMENT_SIZE
1237 tdep
->jb_pc
= JB_PC
;
1238 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1242 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1243 tdep
->struct_return
= reg_struct_return
;
1245 /* Frame unwinder. */
1246 set_gdbarch_dummy_id (gdbarch
, m68k_dummy_id
);
1247 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1249 /* Hook in the DWARF CFI frame unwinder. */
1250 dwarf2_append_unwinders (gdbarch
);
1252 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1254 /* Hook in ABI-specific overrides, if they have been registered. */
1255 gdbarch_init_osabi (info
, gdbarch
);
1257 /* Now we have tuned the configuration, set a few final things,
1258 based on what the OS ABI has told us. */
1260 if (tdep
->jb_pc
>= 0)
1261 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1263 frame_unwind_append_unwinder (gdbarch
, &m68k_frame_unwind
);
1266 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1273 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1275 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1281 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1284 _initialize_m68k_tdep (void)
1286 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);