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
);
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"), regnum
);
183 return m68k_register_names
[regnum
];
186 /* Return nonzero if a value of type TYPE stored in register REGNUM
187 needs any special handling. */
190 m68k_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
192 if (!gdbarch_tdep (gdbarch
)->fpregs_present
)
194 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7
195 && type
!= m68881_ext_type (gdbarch
));
198 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
199 return its contents in TO. */
202 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
203 struct type
*type
, gdb_byte
*to
)
205 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
206 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
209 /* We only support floating-point values. */
210 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
212 warning (_("Cannot convert floating-point register value "
213 "to non-floating-point type."));
217 /* Convert to TYPE. */
218 get_frame_register (frame
, regnum
, from
);
219 convert_typed_floating (from
, fpreg_type
, to
, type
);
222 /* Write the contents FROM of a value of type TYPE into register
223 REGNUM in frame FRAME. */
226 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
227 struct type
*type
, const gdb_byte
*from
)
229 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
230 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
233 /* We only support floating-point values. */
234 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
236 warning (_("Cannot convert non-floating-point type "
237 "to floating-point register value."));
241 /* Convert from TYPE. */
242 convert_typed_floating (from
, type
, to
, fpreg_type
);
243 put_frame_register (frame
, regnum
, to
);
247 /* There is a fair number of calling conventions that are in somewhat
248 wide use. The 68000/08/10 don't support an FPU, not even as a
249 coprocessor. All function return values are stored in %d0/%d1.
250 Structures are returned in a static buffer, a pointer to which is
251 returned in %d0. This means that functions returning a structure
252 are not re-entrant. To avoid this problem some systems use a
253 convention where the caller passes a pointer to a buffer in %a1
254 where the return values is to be stored. This convention is the
255 default, and is implemented in the function m68k_return_value.
257 The 68020/030/040/060 do support an FPU, either as a coprocessor
258 (68881/2) or built-in (68040/68060). That's why System V release 4
259 (SVR4) instroduces a new calling convention specified by the SVR4
260 psABI. Integer values are returned in %d0/%d1, pointer return
261 values in %a0 and floating values in %fp0. When calling functions
262 returning a structure the caller should pass a pointer to a buffer
263 for the return value in %a0. This convention is implemented in the
264 function m68k_svr4_return_value, and by appropriately setting the
265 struct_value_regnum member of `struct gdbarch_tdep'.
267 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
268 for passing the structure return value buffer.
270 GCC can also generate code where small structures are returned in
271 %d0/%d1 instead of in memory by using -freg-struct-return. This is
272 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
273 embedded systems. This convention is implemented by setting the
274 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
276 /* Read a function return value of TYPE from REGCACHE, and copy that
280 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
283 int len
= TYPE_LENGTH (type
);
284 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
288 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
289 memcpy (valbuf
, buf
+ (4 - len
), len
);
293 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
294 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
295 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
298 internal_error (__FILE__
, __LINE__
,
299 _("Cannot extract return value of %d bytes long."), len
);
303 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
306 int len
= TYPE_LENGTH (type
);
307 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
308 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
309 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
311 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
313 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
314 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
315 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
317 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
318 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
320 m68k_extract_return_value (type
, regcache
, valbuf
);
323 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
326 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
327 const gdb_byte
*valbuf
)
329 int len
= TYPE_LENGTH (type
);
332 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
335 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
337 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
340 internal_error (__FILE__
, __LINE__
,
341 _("Cannot store return value of %d bytes long."), len
);
345 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
346 const gdb_byte
*valbuf
)
348 int len
= TYPE_LENGTH (type
);
349 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
350 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
352 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
354 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
355 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
356 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
357 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
359 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
361 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
362 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
365 m68k_store_return_value (type
, regcache
, valbuf
);
368 /* Return non-zero if TYPE, which is assumed to be a structure or
369 union type, should be returned in registers for architecture
373 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
375 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
376 enum type_code code
= TYPE_CODE (type
);
377 int len
= TYPE_LENGTH (type
);
379 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
381 if (tdep
->struct_return
== pcc_struct_return
)
384 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
387 /* Determine, for architecture GDBARCH, how a return value of TYPE
388 should be returned. If it is supposed to be returned in registers,
389 and READBUF is non-zero, read the appropriate value from REGCACHE,
390 and copy it into READBUF. If WRITEBUF is non-zero, write the value
391 from WRITEBUF into REGCACHE. */
393 static enum return_value_convention
394 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
395 struct type
*type
, struct regcache
*regcache
,
396 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
398 enum type_code code
= TYPE_CODE (type
);
400 /* GCC returns a `long double' in memory too. */
401 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
402 && !m68k_reg_struct_return_p (gdbarch
, type
))
403 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
405 /* The default on m68k is to return structures in static memory.
406 Consequently a function must return the address where we can
407 find the return value. */
413 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
414 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
417 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
421 m68k_extract_return_value (type
, regcache
, readbuf
);
423 m68k_store_return_value (type
, regcache
, writebuf
);
425 return RETURN_VALUE_REGISTER_CONVENTION
;
428 static enum return_value_convention
429 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
430 struct type
*type
, struct regcache
*regcache
,
431 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
433 enum type_code code
= TYPE_CODE (type
);
435 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
436 && !m68k_reg_struct_return_p (gdbarch
, type
))
438 /* The System V ABI says that:
440 "A function returning a structure or union also sets %a0 to
441 the value it finds in %a0. Thus when the caller receives
442 control again, the address of the returned object resides in
445 So the ABI guarantees that we can always find the return
446 value just after the function has returned. */
452 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
453 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
456 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
459 /* This special case is for structures consisting of a single
460 `float' or `double' member. These structures are returned in
461 %fp0. For these structures, we call ourselves recursively,
462 changing TYPE into the type of the first member of the structure.
463 Since that should work for all structures that have only one
464 member, we don't bother to check the member's type here. */
465 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
467 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
468 return m68k_svr4_return_value (gdbarch
, func_type
, type
, regcache
,
473 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
475 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
477 return RETURN_VALUE_REGISTER_CONVENTION
;
481 /* Always align the frame to a 4-byte boundary. This is required on
482 coldfire and harmless on the rest. */
485 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
487 /* Align the stack to four bytes. */
492 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
493 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
494 struct value
**args
, CORE_ADDR sp
, int struct_return
,
495 CORE_ADDR struct_addr
)
497 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
501 /* Push arguments in reverse order. */
502 for (i
= nargs
- 1; i
>= 0; i
--)
504 struct type
*value_type
= value_enclosing_type (args
[i
]);
505 int len
= TYPE_LENGTH (value_type
);
506 int container_len
= (len
+ 3) & ~3;
509 /* Non-scalars bigger than 4 bytes are left aligned, others are
511 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
512 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
513 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
517 offset
= container_len
- len
;
519 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
522 /* Store struct value address. */
525 store_unsigned_integer (buf
, 4, struct_addr
);
526 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
529 /* Store return address. */
531 store_unsigned_integer (buf
, 4, bp_addr
);
532 write_memory (sp
, buf
, 4);
534 /* Finally, update the stack pointer... */
535 store_unsigned_integer (buf
, 4, sp
);
536 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
538 /* ...and fake a frame pointer. */
539 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
541 /* DWARF2/GCC uses the stack address *before* the function call as a
546 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
549 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
553 return (num
- 0) + M68K_D0_REGNUM
;
556 return (num
- 8) + M68K_A0_REGNUM
;
557 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
559 return (num
- 16) + M68K_FP0_REGNUM
;
562 return M68K_PC_REGNUM
;
564 return gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
568 struct m68k_frame_cache
575 /* Saved registers. */
576 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
579 /* Stack space reserved for local variables. */
583 /* Allocate and initialize a frame cache. */
585 static struct m68k_frame_cache
*
586 m68k_alloc_frame_cache (void)
588 struct m68k_frame_cache
*cache
;
591 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
595 cache
->sp_offset
= -4;
598 /* Saved registers. We initialize these to -1 since zero is a valid
599 offset (that's where %fp is supposed to be stored). */
600 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
601 cache
->saved_regs
[i
] = -1;
603 /* Frameless until proven otherwise. */
609 /* Check whether PC points at a code that sets up a new stack frame.
610 If so, it updates CACHE and returns the address of the first
611 instruction after the sequence that sets removes the "hidden"
612 argument from the stack or CURRENT_PC, whichever is smaller.
613 Otherwise, return PC. */
616 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
617 struct m68k_frame_cache
*cache
)
621 if (pc
>= current_pc
)
624 op
= read_memory_unsigned_integer (pc
, 2);
626 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
628 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
629 cache
->sp_offset
+= 4;
630 if (op
== P_LINKW_FP
)
632 /* link.w %fp, #-N */
633 /* link.w %fp, #0; adda.l #-N, %sp */
634 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
636 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
638 op
= read_memory_unsigned_integer (pc
+ 4, 2);
639 if (op
== P_ADDAL_SP
)
641 cache
->locals
= read_memory_integer (pc
+ 6, 4);
648 else if (op
== P_LINKL_FP
)
650 /* link.l %fp, #-N */
651 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
656 /* pea (%fp); movea.l %sp, %fp */
659 if (pc
+ 2 < current_pc
)
661 op
= read_memory_unsigned_integer (pc
+ 2, 2);
663 if (op
== P_MOVEAL_SP_FP
)
665 /* move.l %sp, %fp */
673 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
675 /* subq.[wl] #N,%sp */
676 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
677 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
678 if (pc
+ 2 < current_pc
)
680 op
= read_memory_unsigned_integer (pc
+ 2, 2);
681 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
683 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
689 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
692 /* lea (-N,%sp),%sp */
693 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
696 else if (op
== P_ADDAL_SP
)
699 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
706 /* Check whether PC points at code that saves registers on the stack.
707 If so, it updates CACHE and returns the address of the first
708 instruction after the register saves or CURRENT_PC, whichever is
709 smaller. Otherwise, return PC. */
712 m68k_analyze_register_saves (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
713 CORE_ADDR current_pc
,
714 struct m68k_frame_cache
*cache
)
716 if (cache
->locals
>= 0)
722 offset
= -4 - cache
->locals
;
723 while (pc
< current_pc
)
725 op
= read_memory_unsigned_integer (pc
, 2);
726 if (op
== P_FMOVEMX_SP
727 && gdbarch_tdep (gdbarch
)->fpregs_present
)
729 /* fmovem.x REGS,-(%sp) */
730 op
= read_memory_unsigned_integer (pc
+ 2, 2);
731 if ((op
& 0xff00) == 0xe000)
734 for (i
= 0; i
< 16; i
++, mask
>>= 1)
738 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
747 else if ((op
& 0177760) == P_MOVEL_SP
)
749 /* move.l %R,-(%sp) */
751 cache
->saved_regs
[regno
] = offset
;
755 else if (op
== P_MOVEML_SP
)
757 /* movem.l REGS,-(%sp) */
758 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
759 for (i
= 0; i
< 16; i
++, mask
>>= 1)
763 cache
->saved_regs
[15 - i
] = offset
;
778 /* Do a full analysis of the prologue at PC and update CACHE
779 accordingly. Bail out early if CURRENT_PC is reached. Return the
780 address where the analysis stopped.
782 We handle all cases that can be generated by gcc.
784 For allocating a stack frame:
788 pea (%fp); move.l %sp,%fp
789 link.w %a6,#0; add.l #-N,%sp
792 subq.w #8,%sp; subq.w #N-8,%sp
797 For saving registers:
801 move.l R1,-(%sp); move.l R2,-(%sp)
804 For setting up the PIC register:
811 m68k_analyze_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
812 CORE_ADDR current_pc
, struct m68k_frame_cache
*cache
)
816 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
817 pc
= m68k_analyze_register_saves (gdbarch
, pc
, current_pc
, cache
);
818 if (pc
>= current_pc
)
821 /* Check for GOT setup. */
822 op
= read_memory_unsigned_integer (pc
, 4);
823 if (op
== P_LEA_PC_A5
)
825 /* lea (%pc,N),%a5 */
832 /* Return PC of first real instruction. */
835 m68k_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR start_pc
)
837 struct m68k_frame_cache cache
;
842 pc
= m68k_analyze_prologue (gdbarch
, start_pc
, (CORE_ADDR
) -1, &cache
);
843 if (cache
.locals
< 0)
849 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
853 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
854 return extract_typed_address (buf
, builtin_type (gdbarch
)->builtin_func_ptr
);
859 static struct m68k_frame_cache
*
860 m68k_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
862 struct m68k_frame_cache
*cache
;
869 cache
= m68k_alloc_frame_cache ();
872 /* In principle, for normal frames, %fp holds the frame pointer,
873 which holds the base address for the current stack frame.
874 However, for functions that don't need it, the frame pointer is
875 optional. For these "frameless" functions the frame pointer is
876 actually the frame pointer of the calling frame. Signal
877 trampolines are just a special case of a "frameless" function.
878 They (usually) share their frame pointer with the frame that was
879 in progress when the signal occurred. */
881 get_frame_register (this_frame
, M68K_FP_REGNUM
, buf
);
882 cache
->base
= extract_unsigned_integer (buf
, 4);
883 if (cache
->base
== 0)
886 /* For normal frames, %pc is stored at 4(%fp). */
887 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
889 cache
->pc
= get_frame_func (this_frame
);
891 m68k_analyze_prologue (get_frame_arch (this_frame
), cache
->pc
,
892 get_frame_pc (this_frame
), cache
);
894 if (cache
->locals
< 0)
896 /* We didn't find a valid frame, which means that CACHE->base
897 currently holds the frame pointer for our calling frame. If
898 we're at the start of a function, or somewhere half-way its
899 prologue, the function's frame probably hasn't been fully
900 setup yet. Try to reconstruct the base address for the stack
901 frame by looking at the stack pointer. For truly "frameless"
902 functions this might work too. */
904 get_frame_register (this_frame
, M68K_SP_REGNUM
, buf
);
905 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
908 /* Now that we have the base address for the stack frame we can
909 calculate the value of %sp in the calling frame. */
910 cache
->saved_sp
= cache
->base
+ 8;
912 /* Adjust all the saved registers such that they contain addresses
913 instead of offsets. */
914 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
915 if (cache
->saved_regs
[i
] != -1)
916 cache
->saved_regs
[i
] += cache
->base
;
922 m68k_frame_this_id (struct frame_info
*this_frame
, void **this_cache
,
923 struct frame_id
*this_id
)
925 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
927 /* This marks the outermost frame. */
928 if (cache
->base
== 0)
931 /* See the end of m68k_push_dummy_call. */
932 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
935 static struct value
*
936 m68k_frame_prev_register (struct frame_info
*this_frame
, void **this_cache
,
939 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
941 gdb_assert (regnum
>= 0);
943 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
944 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
946 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
947 return frame_unwind_got_memory (this_frame
, regnum
,
948 cache
->saved_regs
[regnum
]);
950 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
953 static const struct frame_unwind m68k_frame_unwind
=
957 m68k_frame_prev_register
,
959 default_frame_sniffer
963 m68k_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
965 struct m68k_frame_cache
*cache
= m68k_frame_cache (this_frame
, this_cache
);
970 static const struct frame_base m68k_frame_base
=
973 m68k_frame_base_address
,
974 m68k_frame_base_address
,
975 m68k_frame_base_address
978 static struct frame_id
979 m68k_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
983 fp
= get_frame_register_unsigned (this_frame
, M68K_FP_REGNUM
);
985 /* See the end of m68k_push_dummy_call. */
986 return frame_id_build (fp
+ 8, get_frame_pc (this_frame
));
990 /* Figure out where the longjmp will land. Slurp the args out of the stack.
991 We expect the first arg to be a pointer to the jmp_buf structure from which
992 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
993 This routine returns true on success. */
996 m68k_get_longjmp_target (struct frame_info
*frame
, CORE_ADDR
*pc
)
999 CORE_ADDR sp
, jb_addr
;
1000 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1001 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
1003 if (tdep
->jb_pc
< 0)
1005 internal_error (__FILE__
, __LINE__
,
1006 _("m68k_get_longjmp_target: not implemented"));
1010 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1011 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1013 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1014 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1017 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1020 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1021 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1024 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1030 /* System V Release 4 (SVR4). */
1033 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1035 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1037 /* SVR4 uses a different calling convention. */
1038 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1040 /* SVR4 uses %a0 instead of %a1. */
1041 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1045 /* Function: m68k_gdbarch_init
1046 Initializer function for the m68k gdbarch vector.
1047 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1049 static struct gdbarch
*
1050 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1052 struct gdbarch_tdep
*tdep
= NULL
;
1053 struct gdbarch
*gdbarch
;
1054 struct gdbarch_list
*best_arch
;
1055 struct tdesc_arch_data
*tdesc_data
= NULL
;
1057 enum m68k_flavour flavour
= m68k_no_flavour
;
1059 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1061 /* Check any target description for validity. */
1062 if (tdesc_has_registers (info
.target_desc
))
1064 const struct tdesc_feature
*feature
;
1067 feature
= tdesc_find_feature (info
.target_desc
,
1068 "org.gnu.gdb.m68k.core");
1069 if (feature
!= NULL
)
1073 if (feature
== NULL
)
1075 feature
= tdesc_find_feature (info
.target_desc
,
1076 "org.gnu.gdb.coldfire.core");
1077 if (feature
!= NULL
)
1078 flavour
= m68k_coldfire_flavour
;
1081 if (feature
== NULL
)
1083 feature
= tdesc_find_feature (info
.target_desc
,
1084 "org.gnu.gdb.fido.core");
1085 if (feature
!= NULL
)
1086 flavour
= m68k_fido_flavour
;
1089 if (feature
== NULL
)
1092 tdesc_data
= tdesc_data_alloc ();
1095 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1096 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1097 m68k_register_names
[i
]);
1101 tdesc_data_cleanup (tdesc_data
);
1105 feature
= tdesc_find_feature (info
.target_desc
,
1106 "org.gnu.gdb.coldfire.fp");
1107 if (feature
!= NULL
)
1110 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1111 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1112 m68k_register_names
[i
]);
1115 tdesc_data_cleanup (tdesc_data
);
1123 /* The mechanism for returning floating values from function
1124 and the type of long double depend on whether we're
1125 on ColdFire or standard m68k. */
1127 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1129 const bfd_arch_info_type
*coldfire_arch
=
1130 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1133 && ((*info
.bfd_arch_info
->compatible
)
1134 (info
.bfd_arch_info
, coldfire_arch
)))
1135 flavour
= m68k_coldfire_flavour
;
1138 /* If there is already a candidate, use it. */
1139 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1141 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1143 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1146 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1152 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1153 gdbarch
= gdbarch_alloc (&info
, tdep
);
1154 tdep
->fpregs_present
= has_fp
;
1155 tdep
->flavour
= flavour
;
1157 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1158 long_double_format
= floatformats_ieee_double
;
1159 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1160 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1162 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1163 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1165 /* Stack grows down. */
1166 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1167 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1169 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1170 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1171 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1173 set_gdbarch_frame_args_skip (gdbarch
, 8);
1174 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1176 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1177 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1178 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1179 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1180 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1181 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1182 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1183 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1184 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1185 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1188 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1190 /* Try to figure out if the arch uses floating registers to return
1191 floating point values from functions. */
1194 /* On ColdFire, floating point values are returned in D0. */
1195 if (flavour
== m68k_coldfire_flavour
)
1196 tdep
->float_return
= 0;
1198 tdep
->float_return
= 1;
1202 /* No floating registers, so can't use them for returning values. */
1203 tdep
->float_return
= 0;
1206 /* Function call & return */
1207 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1208 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1212 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1214 #if defined JB_PC && defined JB_ELEMENT_SIZE
1215 tdep
->jb_pc
= JB_PC
;
1216 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1220 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1221 tdep
->struct_return
= reg_struct_return
;
1223 /* Frame unwinder. */
1224 set_gdbarch_dummy_id (gdbarch
, m68k_dummy_id
);
1225 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1227 /* Hook in the DWARF CFI frame unwinder. */
1228 dwarf2_append_unwinders (gdbarch
);
1230 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1232 /* Hook in ABI-specific overrides, if they have been registered. */
1233 gdbarch_init_osabi (info
, gdbarch
);
1235 /* Now we have tuned the configuration, set a few final things,
1236 based on what the OS ABI has told us. */
1238 if (tdep
->jb_pc
>= 0)
1239 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1241 frame_unwind_append_unwinder (gdbarch
, &m68k_frame_unwind
);
1244 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1251 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1253 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1259 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1262 _initialize_m68k_tdep (void)
1264 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);