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
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
);
75 struct type
*m68k_ps_type
;
77 /* Construct types for ISA-specific registers. */
79 m68k_init_types (void)
83 type
= init_flags_type ("builtin_type_m68k_ps", 4);
84 append_flags_type_flag (type
, 0, "C");
85 append_flags_type_flag (type
, 1, "V");
86 append_flags_type_flag (type
, 2, "Z");
87 append_flags_type_flag (type
, 3, "N");
88 append_flags_type_flag (type
, 4, "X");
89 append_flags_type_flag (type
, 8, "I0");
90 append_flags_type_flag (type
, 9, "I1");
91 append_flags_type_flag (type
, 10, "I2");
92 append_flags_type_flag (type
, 12, "M");
93 append_flags_type_flag (type
, 13, "S");
94 append_flags_type_flag (type
, 14, "T0");
95 append_flags_type_flag (type
, 15, "T1");
100 m68881_ext_type (struct gdbarch
*gdbarch
)
102 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
104 if (!tdep
->m68881_ext_type
)
105 tdep
->m68881_ext_type
106 = init_float_type (-1, "builtin_type_m68881_ext",
107 floatformats_m68881_ext
);
109 return tdep
->m68881_ext_type
;
112 /* Return the GDB type object for the "standard" data type of data in
113 register N. This should be int for D0-D7, SR, FPCONTROL and
114 FPSTATUS, long double for FP0-FP7, and void pointer for all others
115 (A0-A7, PC, FPIADDR). Note, for registers which contain
116 addresses return pointer to void, not pointer to char, because we
117 don't want to attempt to print the string after printing the
121 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
123 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
125 if (tdep
->fpregs_present
)
127 if (regnum
>= gdbarch_fp0_regnum (gdbarch
)
128 && regnum
<= gdbarch_fp0_regnum (gdbarch
) + 7)
130 if (tdep
->flavour
== m68k_coldfire_flavour
)
131 return builtin_type (gdbarch
)->builtin_double
;
133 return m68881_ext_type (gdbarch
);
136 if (regnum
== M68K_FPI_REGNUM
)
137 return builtin_type (gdbarch
)->builtin_func_ptr
;
139 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
)
140 return builtin_type (gdbarch
)->builtin_int32
;
144 if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
)
145 return builtin_type (gdbarch
)->builtin_int0
;
148 if (regnum
== gdbarch_pc_regnum (gdbarch
))
149 return builtin_type (gdbarch
)->builtin_func_ptr
;
151 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
152 return builtin_type (gdbarch
)->builtin_data_ptr
;
154 if (regnum
== M68K_PS_REGNUM
)
157 return builtin_type (gdbarch
)->builtin_int32
;
160 static const char *m68k_register_names
[] = {
161 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
162 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
164 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
165 "fpcontrol", "fpstatus", "fpiaddr"
168 /* Function: m68k_register_name
169 Returns the name of the standard m68k register regnum. */
172 m68k_register_name (struct gdbarch
*gdbarch
, int regnum
)
174 if (regnum
< 0 || regnum
>= ARRAY_SIZE (m68k_register_names
))
175 internal_error (__FILE__
, __LINE__
,
176 _("m68k_register_name: illegal register number %d"), regnum
);
178 return m68k_register_names
[regnum
];
181 /* Return nonzero if a value of type TYPE stored in register REGNUM
182 needs any special handling. */
185 m68k_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
187 if (!gdbarch_tdep (gdbarch
)->fpregs_present
)
189 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7
190 && type
!= m68881_ext_type (gdbarch
));
193 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
194 return its contents in TO. */
197 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
198 struct type
*type
, gdb_byte
*to
)
200 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
201 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
204 /* We only support floating-point values. */
205 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
207 warning (_("Cannot convert floating-point register value "
208 "to non-floating-point type."));
212 /* Convert to TYPE. */
213 get_frame_register (frame
, regnum
, from
);
214 convert_typed_floating (from
, fpreg_type
, to
, type
);
217 /* Write the contents FROM of a value of type TYPE into register
218 REGNUM in frame FRAME. */
221 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
222 struct type
*type
, const gdb_byte
*from
)
224 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
225 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
228 /* We only support floating-point values. */
229 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
231 warning (_("Cannot convert non-floating-point type "
232 "to floating-point register value."));
236 /* Convert from TYPE. */
237 convert_typed_floating (from
, type
, to
, fpreg_type
);
238 put_frame_register (frame
, regnum
, to
);
242 /* There is a fair number of calling conventions that are in somewhat
243 wide use. The 68000/08/10 don't support an FPU, not even as a
244 coprocessor. All function return values are stored in %d0/%d1.
245 Structures are returned in a static buffer, a pointer to which is
246 returned in %d0. This means that functions returning a structure
247 are not re-entrant. To avoid this problem some systems use a
248 convention where the caller passes a pointer to a buffer in %a1
249 where the return values is to be stored. This convention is the
250 default, and is implemented in the function m68k_return_value.
252 The 68020/030/040/060 do support an FPU, either as a coprocessor
253 (68881/2) or built-in (68040/68060). That's why System V release 4
254 (SVR4) instroduces a new calling convention specified by the SVR4
255 psABI. Integer values are returned in %d0/%d1, pointer return
256 values in %a0 and floating values in %fp0. When calling functions
257 returning a structure the caller should pass a pointer to a buffer
258 for the return value in %a0. This convention is implemented in the
259 function m68k_svr4_return_value, and by appropriately setting the
260 struct_value_regnum member of `struct gdbarch_tdep'.
262 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
263 for passing the structure return value buffer.
265 GCC can also generate code where small structures are returned in
266 %d0/%d1 instead of in memory by using -freg-struct-return. This is
267 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
268 embedded systems. This convention is implemented by setting the
269 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
271 /* Read a function return value of TYPE from REGCACHE, and copy that
275 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
278 int len
= TYPE_LENGTH (type
);
279 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
283 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
284 memcpy (valbuf
, buf
+ (4 - len
), len
);
288 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
289 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
290 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
293 internal_error (__FILE__
, __LINE__
,
294 _("Cannot extract return value of %d bytes long."), len
);
298 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
301 int len
= TYPE_LENGTH (type
);
302 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
303 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
304 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
306 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
308 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
309 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
310 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
312 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
313 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
315 m68k_extract_return_value (type
, regcache
, valbuf
);
318 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
321 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
322 const gdb_byte
*valbuf
)
324 int len
= TYPE_LENGTH (type
);
327 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
330 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
332 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
335 internal_error (__FILE__
, __LINE__
,
336 _("Cannot store return value of %d bytes long."), len
);
340 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
341 const gdb_byte
*valbuf
)
343 int len
= TYPE_LENGTH (type
);
344 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
345 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
347 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
349 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
350 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
351 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
352 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
354 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
356 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
357 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
360 m68k_store_return_value (type
, regcache
, valbuf
);
363 /* Return non-zero if TYPE, which is assumed to be a structure or
364 union type, should be returned in registers for architecture
368 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
370 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
371 enum type_code code
= TYPE_CODE (type
);
372 int len
= TYPE_LENGTH (type
);
374 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
376 if (tdep
->struct_return
== pcc_struct_return
)
379 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
382 /* Determine, for architecture GDBARCH, how a return value of TYPE
383 should be returned. If it is supposed to be returned in registers,
384 and READBUF is non-zero, read the appropriate value from REGCACHE,
385 and copy it into READBUF. If WRITEBUF is non-zero, write the value
386 from WRITEBUF into REGCACHE. */
388 static enum return_value_convention
389 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
390 struct type
*type
, struct regcache
*regcache
,
391 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
393 enum type_code code
= TYPE_CODE (type
);
395 /* GCC returns a `long double' in memory too. */
396 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
397 && !m68k_reg_struct_return_p (gdbarch
, type
))
398 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
400 /* The default on m68k is to return structures in static memory.
401 Consequently a function must return the address where we can
402 find the return value. */
408 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
409 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
412 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
416 m68k_extract_return_value (type
, regcache
, readbuf
);
418 m68k_store_return_value (type
, regcache
, writebuf
);
420 return RETURN_VALUE_REGISTER_CONVENTION
;
423 static enum return_value_convention
424 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
425 struct type
*type
, struct regcache
*regcache
,
426 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
428 enum type_code code
= TYPE_CODE (type
);
430 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
431 && !m68k_reg_struct_return_p (gdbarch
, type
))
433 /* The System V ABI says that:
435 "A function returning a structure or union also sets %a0 to
436 the value it finds in %a0. Thus when the caller receives
437 control again, the address of the returned object resides in
440 So the ABI guarantees that we can always find the return
441 value just after the function has returned. */
447 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
448 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
451 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
454 /* This special case is for structures consisting of a single
455 `float' or `double' member. These structures are returned in
456 %fp0. For these structures, we call ourselves recursively,
457 changing TYPE into the type of the first member of the structure.
458 Since that should work for all structures that have only one
459 member, we don't bother to check the member's type here. */
460 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
462 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
463 return m68k_svr4_return_value (gdbarch
, func_type
, type
, regcache
,
468 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
470 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
472 return RETURN_VALUE_REGISTER_CONVENTION
;
476 /* Always align the frame to a 4-byte boundary. This is required on
477 coldfire and harmless on the rest. */
480 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
482 /* Align the stack to four bytes. */
487 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
488 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
489 struct value
**args
, CORE_ADDR sp
, int struct_return
,
490 CORE_ADDR struct_addr
)
492 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
496 /* Push arguments in reverse order. */
497 for (i
= nargs
- 1; i
>= 0; i
--)
499 struct type
*value_type
= value_enclosing_type (args
[i
]);
500 int len
= TYPE_LENGTH (value_type
);
501 int container_len
= (len
+ 3) & ~3;
504 /* Non-scalars bigger than 4 bytes are left aligned, others are
506 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
507 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
508 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
512 offset
= container_len
- len
;
514 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
517 /* Store struct value address. */
520 store_unsigned_integer (buf
, 4, struct_addr
);
521 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
524 /* Store return address. */
526 store_unsigned_integer (buf
, 4, bp_addr
);
527 write_memory (sp
, buf
, 4);
529 /* Finally, update the stack pointer... */
530 store_unsigned_integer (buf
, 4, sp
);
531 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
533 /* ...and fake a frame pointer. */
534 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
536 /* DWARF2/GCC uses the stack address *before* the function call as a
541 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
544 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
548 return (num
- 0) + M68K_D0_REGNUM
;
551 return (num
- 8) + M68K_A0_REGNUM
;
552 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
554 return (num
- 16) + M68K_FP0_REGNUM
;
557 return M68K_PC_REGNUM
;
559 return gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
563 struct m68k_frame_cache
570 /* Saved registers. */
571 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
574 /* Stack space reserved for local variables. */
578 /* Allocate and initialize a frame cache. */
580 static struct m68k_frame_cache
*
581 m68k_alloc_frame_cache (void)
583 struct m68k_frame_cache
*cache
;
586 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
590 cache
->sp_offset
= -4;
593 /* Saved registers. We initialize these to -1 since zero is a valid
594 offset (that's where %fp is supposed to be stored). */
595 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
596 cache
->saved_regs
[i
] = -1;
598 /* Frameless until proven otherwise. */
604 /* Check whether PC points at a code that sets up a new stack frame.
605 If so, it updates CACHE and returns the address of the first
606 instruction after the sequence that sets removes the "hidden"
607 argument from the stack or CURRENT_PC, whichever is smaller.
608 Otherwise, return PC. */
611 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
612 struct m68k_frame_cache
*cache
)
616 if (pc
>= current_pc
)
619 op
= read_memory_unsigned_integer (pc
, 2);
621 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
623 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
624 cache
->sp_offset
+= 4;
625 if (op
== P_LINKW_FP
)
627 /* link.w %fp, #-N */
628 /* link.w %fp, #0; adda.l #-N, %sp */
629 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
631 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
633 op
= read_memory_unsigned_integer (pc
+ 4, 2);
634 if (op
== P_ADDAL_SP
)
636 cache
->locals
= read_memory_integer (pc
+ 6, 4);
643 else if (op
== P_LINKL_FP
)
645 /* link.l %fp, #-N */
646 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
651 /* pea (%fp); movea.l %sp, %fp */
654 if (pc
+ 2 < current_pc
)
656 op
= read_memory_unsigned_integer (pc
+ 2, 2);
658 if (op
== P_MOVEAL_SP_FP
)
660 /* move.l %sp, %fp */
668 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
670 /* subq.[wl] #N,%sp */
671 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
672 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
673 if (pc
+ 2 < current_pc
)
675 op
= read_memory_unsigned_integer (pc
+ 2, 2);
676 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
678 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
684 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
687 /* lea (-N,%sp),%sp */
688 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
691 else if (op
== P_ADDAL_SP
)
694 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
701 /* Check whether PC points at code that saves registers on the stack.
702 If so, it updates CACHE and returns the address of the first
703 instruction after the register saves or CURRENT_PC, whichever is
704 smaller. Otherwise, return PC. */
707 m68k_analyze_register_saves (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
708 CORE_ADDR current_pc
,
709 struct m68k_frame_cache
*cache
)
711 if (cache
->locals
>= 0)
717 offset
= -4 - cache
->locals
;
718 while (pc
< current_pc
)
720 op
= read_memory_unsigned_integer (pc
, 2);
721 if (op
== P_FMOVEMX_SP
722 && gdbarch_tdep (gdbarch
)->fpregs_present
)
724 /* fmovem.x REGS,-(%sp) */
725 op
= read_memory_unsigned_integer (pc
+ 2, 2);
726 if ((op
& 0xff00) == 0xe000)
729 for (i
= 0; i
< 16; i
++, mask
>>= 1)
733 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
742 else if ((op
& 0177760) == P_MOVEL_SP
)
744 /* move.l %R,-(%sp) */
746 cache
->saved_regs
[regno
] = offset
;
750 else if (op
== P_MOVEML_SP
)
752 /* movem.l REGS,-(%sp) */
753 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
754 for (i
= 0; i
< 16; i
++, mask
>>= 1)
758 cache
->saved_regs
[15 - i
] = offset
;
773 /* Do a full analysis of the prologue at PC and update CACHE
774 accordingly. Bail out early if CURRENT_PC is reached. Return the
775 address where the analysis stopped.
777 We handle all cases that can be generated by gcc.
779 For allocating a stack frame:
783 pea (%fp); move.l %sp,%fp
784 link.w %a6,#0; add.l #-N,%sp
787 subq.w #8,%sp; subq.w #N-8,%sp
792 For saving registers:
796 move.l R1,-(%sp); move.l R2,-(%sp)
799 For setting up the PIC register:
806 m68k_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
807 CORE_ADDR current_pc
, struct m68k_frame_cache
*cache
)
811 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
812 pc
= m68k_analyze_register_saves (gdbarch
, pc
, current_pc
, cache
);
813 if (pc
>= current_pc
)
816 /* Check for GOT setup. */
817 op
= read_memory_unsigned_integer (pc
, 4);
818 if (op
== P_LEA_PC_A5
)
820 /* lea (%pc,N),%a5 */
827 /* Return PC of first real instruction. */
830 m68k_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
832 struct m68k_frame_cache cache
;
837 pc
= m68k_analyze_prologue (gdbarch
, start_pc
, (CORE_ADDR
) -1, &cache
);
838 if (cache
.locals
< 0)
844 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
848 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
849 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
854 static struct m68k_frame_cache
*
855 m68k_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
857 struct m68k_frame_cache
*cache
;
864 cache
= m68k_alloc_frame_cache ();
867 /* In principle, for normal frames, %fp holds the frame pointer,
868 which holds the base address for the current stack frame.
869 However, for functions that don't need it, the frame pointer is
870 optional. For these "frameless" functions the frame pointer is
871 actually the frame pointer of the calling frame. Signal
872 trampolines are just a special case of a "frameless" function.
873 They (usually) share their frame pointer with the frame that was
874 in progress when the signal occurred. */
876 get_frame_register (this_frame
, M68K_FP_REGNUM
, buf
);
877 cache
->base
= extract_unsigned_integer (buf
, 4);
878 if (cache
->base
== 0)
881 /* For normal frames, %pc is stored at 4(%fp). */
882 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
884 cache
->pc
= get_frame_func (this_frame
);
886 m68k_analyze_prologue (get_frame_arch (this_frame
), cache
->pc
,
887 get_frame_pc (this_frame
), cache
);
889 if (cache
->locals
< 0)
891 /* We didn't find a valid frame, which means that CACHE->base
892 currently holds the frame pointer for our calling frame. If
893 we're at the start of a function, or somewhere half-way its
894 prologue, the function's frame probably hasn't been fully
895 setup yet. Try to reconstruct the base address for the stack
896 frame by looking at the stack pointer. For truly "frameless"
897 functions this might work too. */
899 get_frame_register (this_frame
, M68K_SP_REGNUM
, buf
);
900 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
903 /* Now that we have the base address for the stack frame we can
904 calculate the value of %sp in the calling frame. */
905 cache
->saved_sp
= cache
->base
+ 8;
907 /* Adjust all the saved registers such that they contain addresses
908 instead of offsets. */
909 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
910 if (cache
->saved_regs
[i
] != -1)
911 cache
->saved_regs
[i
] += cache
->base
;
917 m68k_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
918 struct frame_id
*this_id
)
920 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
922 /* This marks the outermost frame. */
923 if (cache
->base
== 0)
926 /* See the end of m68k_push_dummy_call. */
927 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
930 static struct value
*
931 m68k_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
934 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
936 gdb_assert (regnum
>= 0);
938 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
939 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
941 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
942 return frame_unwind_got_memory (this_frame
, regnum
,
943 cache
->saved_regs
[regnum
]);
945 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
948 static const struct frame_unwind m68k_frame_unwind
=
952 m68k_frame_prev_register
,
954 default_frame_sniffer
958 m68k_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
960 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
965 static const struct frame_base m68k_frame_base
=
968 m68k_frame_base_address
,
969 m68k_frame_base_address
,
970 m68k_frame_base_address
973 static struct frame_id
974 m68k_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
978 fp
= get_frame_register_unsigned (this_frame
, M68K_FP_REGNUM
);
980 /* See the end of m68k_push_dummy_call. */
981 return frame_id_build (fp
+ 8, get_frame_pc (this_frame
));
985 /* Figure out where the longjmp will land. Slurp the args out of the stack.
986 We expect the first arg to be a pointer to the jmp_buf structure from which
987 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
988 This routine returns true on success. */
991 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
994 CORE_ADDR sp
, jb_addr
;
995 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
996 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
1000 internal_error (__FILE__
, __LINE__
,
1001 _("m68k_get_longjmp_target: not implemented"));
1005 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1006 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1008 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1009 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1012 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1015 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1016 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1019 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1025 /* System V Release 4 (SVR4). */
1028 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1030 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1032 /* SVR4 uses a different calling convention. */
1033 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1035 /* SVR4 uses %a0 instead of %a1. */
1036 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1040 /* Function: m68k_gdbarch_init
1041 Initializer function for the m68k gdbarch vector.
1042 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1044 static struct gdbarch
*
1045 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1047 struct gdbarch_tdep
*tdep
= NULL
;
1048 struct gdbarch
*gdbarch
;
1049 struct gdbarch_list
*best_arch
;
1050 struct tdesc_arch_data
*tdesc_data
= NULL
;
1052 enum m68k_flavour flavour
= m68k_no_flavour
;
1054 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1056 /* Check any target description for validity. */
1057 if (tdesc_has_registers (info
.target_desc
))
1059 const struct tdesc_feature
*feature
;
1062 feature
= tdesc_find_feature (info
.target_desc
,
1063 "org.gnu.gdb.m68k.core");
1064 if (feature
!= NULL
)
1068 if (feature
== NULL
)
1070 feature
= tdesc_find_feature (info
.target_desc
,
1071 "org.gnu.gdb.coldfire.core");
1072 if (feature
!= NULL
)
1073 flavour
= m68k_coldfire_flavour
;
1076 if (feature
== NULL
)
1078 feature
= tdesc_find_feature (info
.target_desc
,
1079 "org.gnu.gdb.fido.core");
1080 if (feature
!= NULL
)
1081 flavour
= m68k_fido_flavour
;
1084 if (feature
== NULL
)
1087 tdesc_data
= tdesc_data_alloc ();
1090 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1091 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1092 m68k_register_names
[i
]);
1096 tdesc_data_cleanup (tdesc_data
);
1100 feature
= tdesc_find_feature (info
.target_desc
,
1101 "org.gnu.gdb.coldfire.fp");
1102 if (feature
!= NULL
)
1105 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1106 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1107 m68k_register_names
[i
]);
1110 tdesc_data_cleanup (tdesc_data
);
1118 /* The mechanism for returning floating values from function
1119 and the type of long double depend on whether we're
1120 on ColdFire or standard m68k. */
1122 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1124 const bfd_arch_info_type
*coldfire_arch
=
1125 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1128 && ((*info
.bfd_arch_info
->compatible
)
1129 (info
.bfd_arch_info
, coldfire_arch
)))
1130 flavour
= m68k_coldfire_flavour
;
1133 /* If there is already a candidate, use it. */
1134 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1136 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1138 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1141 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1147 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1148 gdbarch
= gdbarch_alloc (&info
, tdep
);
1149 tdep
->fpregs_present
= has_fp
;
1150 tdep
->flavour
= flavour
;
1152 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1153 long_double_format
= floatformats_ieee_double
;
1154 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1155 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1157 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1158 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1160 /* Stack grows down. */
1161 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1162 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1164 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1165 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1166 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1168 set_gdbarch_frame_args_skip (gdbarch
, 8);
1169 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1171 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1172 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1173 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1174 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1175 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1176 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1177 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1178 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1179 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1180 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1183 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1185 /* Try to figure out if the arch uses floating registers to return
1186 floating point values from functions. */
1189 /* On ColdFire, floating point values are returned in D0. */
1190 if (flavour
== m68k_coldfire_flavour
)
1191 tdep
->float_return
= 0;
1193 tdep
->float_return
= 1;
1197 /* No floating registers, so can't use them for returning values. */
1198 tdep
->float_return
= 0;
1201 /* Function call & return */
1202 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1203 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1207 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1209 #if defined JB_PC && defined JB_ELEMENT_SIZE
1210 tdep
->jb_pc
= JB_PC
;
1211 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1215 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1216 tdep
->struct_return
= reg_struct_return
;
1218 /* Frame unwinder. */
1219 set_gdbarch_dummy_id (gdbarch
, m68k_dummy_id
);
1220 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1222 /* Hook in the DWARF CFI frame unwinder. */
1223 dwarf2_append_unwinders (gdbarch
);
1225 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1227 /* Hook in ABI-specific overrides, if they have been registered. */
1228 gdbarch_init_osabi (info
, gdbarch
);
1230 /* Now we have tuned the configuration, set a few final things,
1231 based on what the OS ABI has told us. */
1233 if (tdep
->jb_pc
>= 0)
1234 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1236 frame_unwind_append_unwinder (gdbarch
, &m68k_frame_unwind
);
1239 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1246 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1248 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1254 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1257 _initialize_m68k_tdep (void)
1259 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1261 /* Initialize the m68k-specific register types. */