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 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "dwarf2-frame.h"
24 #include "frame-base.h"
25 #include "frame-unwind.h"
30 #include "gdb_string.h"
31 #include "gdb_assert.h"
34 #include "arch-utils.h"
37 #include "target-descriptions.h"
39 #include "m68k-tdep.h"
42 #define P_LINKL_FP 0x480e
43 #define P_LINKW_FP 0x4e56
44 #define P_PEA_FP 0x4856
45 #define P_MOVEAL_SP_FP 0x2c4f
46 #define P_ADDAW_SP 0xdefc
47 #define P_ADDAL_SP 0xdffc
48 #define P_SUBQW_SP 0x514f
49 #define P_SUBQL_SP 0x518f
50 #define P_LEA_SP_SP 0x4fef
51 #define P_LEA_PC_A5 0x4bfb0170
52 #define P_FMOVEMX_SP 0xf227
53 #define P_MOVEL_SP 0x2f00
54 #define P_MOVEML_SP 0x48e7
56 /* Offset from SP to first arg on stack at first instruction of a function */
57 #define SP_ARG0 (1 * 4)
59 #if !defined (BPT_VECTOR)
60 #define BPT_VECTOR 0xf
63 static const gdb_byte
*
64 m68k_local_breakpoint_from_pc (struct gdbarch
*gdbarch
,
65 CORE_ADDR
*pcptr
, int *lenptr
)
67 static gdb_byte break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
68 *lenptr
= sizeof (break_insn
);
74 struct type
*m68k_ps_type
;
76 /* Construct types for ISA-specific registers. */
78 m68k_init_types (void)
82 type
= init_flags_type ("builtin_type_m68k_ps", 4);
83 append_flags_type_flag (type
, 0, "C");
84 append_flags_type_flag (type
, 1, "V");
85 append_flags_type_flag (type
, 2, "Z");
86 append_flags_type_flag (type
, 3, "N");
87 append_flags_type_flag (type
, 4, "X");
88 append_flags_type_flag (type
, 8, "I0");
89 append_flags_type_flag (type
, 9, "I1");
90 append_flags_type_flag (type
, 10, "I2");
91 append_flags_type_flag (type
, 12, "M");
92 append_flags_type_flag (type
, 13, "S");
93 append_flags_type_flag (type
, 14, "T0");
94 append_flags_type_flag (type
, 15, "T1");
98 /* Return the GDB type object for the "standard" data type of data in
99 register N. This should be int for D0-D7, SR, FPCONTROL and
100 FPSTATUS, long double for FP0-FP7, and void pointer for all others
101 (A0-A7, PC, FPIADDR). Note, for registers which contain
102 addresses return pointer to void, not pointer to char, because we
103 don't want to attempt to print the string after printing the
107 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
109 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
111 if (tdep
->fpregs_present
)
113 if (regnum
>= gdbarch_fp0_regnum (gdbarch
)
114 && regnum
<= gdbarch_fp0_regnum (gdbarch
) + 7)
116 if (tdep
->flavour
== m68k_coldfire_flavour
)
117 return builtin_type (gdbarch
)->builtin_double
;
119 return builtin_type_m68881_ext
;
122 if (regnum
== M68K_FPI_REGNUM
)
123 return builtin_type_void_func_ptr
;
125 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
)
126 return builtin_type_int32
;
130 if (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FPI_REGNUM
)
131 return builtin_type_int0
;
134 if (regnum
== gdbarch_pc_regnum (gdbarch
))
135 return builtin_type_void_func_ptr
;
137 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
138 return builtin_type_void_data_ptr
;
140 if (regnum
== M68K_PS_REGNUM
)
143 return builtin_type_int32
;
146 static const char *m68k_register_names
[] = {
147 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
148 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
150 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
151 "fpcontrol", "fpstatus", "fpiaddr"
154 /* Function: m68k_register_name
155 Returns the name of the standard m68k register regnum. */
158 m68k_register_name (struct gdbarch
*gdbarch
, int regnum
)
160 if (regnum
< 0 || regnum
>= ARRAY_SIZE (m68k_register_names
))
161 internal_error (__FILE__
, __LINE__
,
162 _("m68k_register_name: illegal register number %d"), regnum
);
164 return m68k_register_names
[regnum
];
167 /* Return nonzero if a value of type TYPE stored in register REGNUM
168 needs any special handling. */
171 m68k_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
173 if (!gdbarch_tdep (gdbarch
)->fpregs_present
)
175 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7
176 && type
!= builtin_type_m68881_ext
);
179 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
180 return its contents in TO. */
183 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
184 struct type
*type
, gdb_byte
*to
)
186 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
187 struct type
*fpreg_type
= register_type (get_frame_arch (frame
),
190 /* We only support floating-point values. */
191 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
193 warning (_("Cannot convert floating-point register value "
194 "to non-floating-point type."));
198 /* Convert to TYPE. */
199 get_frame_register (frame
, regnum
, from
);
200 convert_typed_floating (from
, fpreg_type
, to
, type
);
203 /* Write the contents FROM of a value of type TYPE into register
204 REGNUM in frame FRAME. */
207 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
208 struct type
*type
, const gdb_byte
*from
)
210 gdb_byte to
[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 non-floating-point type "
218 "to floating-point register value."));
222 /* Convert from TYPE. */
223 convert_typed_floating (from
, type
, to
, fpreg_type
);
224 put_frame_register (frame
, regnum
, to
);
228 /* There is a fair number of calling conventions that are in somewhat
229 wide use. The 68000/08/10 don't support an FPU, not even as a
230 coprocessor. All function return values are stored in %d0/%d1.
231 Structures are returned in a static buffer, a pointer to which is
232 returned in %d0. This means that functions returning a structure
233 are not re-entrant. To avoid this problem some systems use a
234 convention where the caller passes a pointer to a buffer in %a1
235 where the return values is to be stored. This convention is the
236 default, and is implemented in the function m68k_return_value.
238 The 68020/030/040/060 do support an FPU, either as a coprocessor
239 (68881/2) or built-in (68040/68060). That's why System V release 4
240 (SVR4) instroduces a new calling convention specified by the SVR4
241 psABI. Integer values are returned in %d0/%d1, pointer return
242 values in %a0 and floating values in %fp0. When calling functions
243 returning a structure the caller should pass a pointer to a buffer
244 for the return value in %a0. This convention is implemented in the
245 function m68k_svr4_return_value, and by appropriately setting the
246 struct_value_regnum member of `struct gdbarch_tdep'.
248 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
249 for passing the structure return value buffer.
251 GCC can also generate code where small structures are returned in
252 %d0/%d1 instead of in memory by using -freg-struct-return. This is
253 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
254 embedded systems. This convention is implemented by setting the
255 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
257 /* Read a function return value of TYPE from REGCACHE, and copy that
261 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
264 int len
= TYPE_LENGTH (type
);
265 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
269 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
270 memcpy (valbuf
, buf
+ (4 - len
), len
);
274 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
275 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
276 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
279 internal_error (__FILE__
, __LINE__
,
280 _("Cannot extract return value of %d bytes long."), len
);
284 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
287 int len
= TYPE_LENGTH (type
);
288 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
289 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
290 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
292 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
294 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
295 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
296 convert_typed_floating (buf
, fpreg_type
, valbuf
, type
);
298 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
299 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
301 m68k_extract_return_value (type
, regcache
, valbuf
);
304 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
307 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
308 const gdb_byte
*valbuf
)
310 int len
= TYPE_LENGTH (type
);
313 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
316 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
318 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
321 internal_error (__FILE__
, __LINE__
,
322 _("Cannot store return value of %d bytes long."), len
);
326 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
327 const gdb_byte
*valbuf
)
329 int len
= TYPE_LENGTH (type
);
330 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
331 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
333 if (tdep
->float_return
&& TYPE_CODE (type
) == TYPE_CODE_FLT
)
335 struct type
*fpreg_type
= register_type (gdbarch
, M68K_FP0_REGNUM
);
336 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
337 convert_typed_floating (valbuf
, type
, buf
, fpreg_type
);
338 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
340 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
342 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
343 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
346 m68k_store_return_value (type
, regcache
, valbuf
);
349 /* Return non-zero if TYPE, which is assumed to be a structure or
350 union type, should be returned in registers for architecture
354 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
356 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
357 enum type_code code
= TYPE_CODE (type
);
358 int len
= TYPE_LENGTH (type
);
360 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
362 if (tdep
->struct_return
== pcc_struct_return
)
365 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
368 /* Determine, for architecture GDBARCH, how a return value of TYPE
369 should be returned. If it is supposed to be returned in registers,
370 and READBUF is non-zero, read the appropriate value from REGCACHE,
371 and copy it into READBUF. If WRITEBUF is non-zero, write the value
372 from WRITEBUF into REGCACHE. */
374 static enum return_value_convention
375 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
376 struct regcache
*regcache
, gdb_byte
*readbuf
,
377 const gdb_byte
*writebuf
)
379 enum type_code code
= TYPE_CODE (type
);
381 /* GCC returns a `long double' in memory too. */
382 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
383 && !m68k_reg_struct_return_p (gdbarch
, type
))
384 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
386 /* The default on m68k is to return structures in static memory.
387 Consequently a function must return the address where we can
388 find the return value. */
394 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
395 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
398 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
402 m68k_extract_return_value (type
, regcache
, readbuf
);
404 m68k_store_return_value (type
, regcache
, writebuf
);
406 return RETURN_VALUE_REGISTER_CONVENTION
;
409 static enum return_value_convention
410 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
411 struct regcache
*regcache
, gdb_byte
*readbuf
,
412 const gdb_byte
*writebuf
)
414 enum type_code code
= TYPE_CODE (type
);
416 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
417 && !m68k_reg_struct_return_p (gdbarch
, type
))
419 /* The System V ABI says that:
421 "A function returning a structure or union also sets %a0 to
422 the value it finds in %a0. Thus when the caller receives
423 control again, the address of the returned object resides in
426 So the ABI guarantees that we can always find the return
427 value just after the function has returned. */
433 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
434 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
437 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
440 /* This special case is for structures consisting of a single
441 `float' or `double' member. These structures are returned in
442 %fp0. For these structures, we call ourselves recursively,
443 changing TYPE into the type of the first member of the structure.
444 Since that should work for all structures that have only one
445 member, we don't bother to check the member's type here. */
446 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
448 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
449 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
454 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
456 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
458 return RETURN_VALUE_REGISTER_CONVENTION
;
462 /* Always align the frame to a 4-byte boundary. This is required on
463 coldfire and harmless on the rest. */
466 m68k_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
468 /* Align the stack to four bytes. */
473 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
474 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
475 struct value
**args
, CORE_ADDR sp
, int struct_return
,
476 CORE_ADDR struct_addr
)
478 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
482 /* Push arguments in reverse order. */
483 for (i
= nargs
- 1; i
>= 0; i
--)
485 struct type
*value_type
= value_enclosing_type (args
[i
]);
486 int len
= TYPE_LENGTH (value_type
);
487 int container_len
= (len
+ 3) & ~3;
490 /* Non-scalars bigger than 4 bytes are left aligned, others are
492 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
493 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
494 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
498 offset
= container_len
- len
;
500 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
503 /* Store struct value address. */
506 store_unsigned_integer (buf
, 4, struct_addr
);
507 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
510 /* Store return address. */
512 store_unsigned_integer (buf
, 4, bp_addr
);
513 write_memory (sp
, buf
, 4);
515 /* Finally, update the stack pointer... */
516 store_unsigned_integer (buf
, 4, sp
);
517 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
519 /* ...and fake a frame pointer. */
520 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
522 /* DWARF2/GCC uses the stack address *before* the function call as a
527 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
530 m68k_dwarf_reg_to_regnum (struct gdbarch
*gdbarch
, int num
)
534 return (num
- 0) + M68K_D0_REGNUM
;
537 return (num
- 8) + M68K_A0_REGNUM
;
538 else if (num
< 24 && gdbarch_tdep (gdbarch
)->fpregs_present
)
540 return (num
- 16) + M68K_FP0_REGNUM
;
543 return M68K_PC_REGNUM
;
545 return gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
549 struct m68k_frame_cache
556 /* Saved registers. */
557 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
560 /* Stack space reserved for local variables. */
564 /* Allocate and initialize a frame cache. */
566 static struct m68k_frame_cache
*
567 m68k_alloc_frame_cache (void)
569 struct m68k_frame_cache
*cache
;
572 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
576 cache
->sp_offset
= -4;
579 /* Saved registers. We initialize these to -1 since zero is a valid
580 offset (that's where %fp is supposed to be stored). */
581 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
582 cache
->saved_regs
[i
] = -1;
584 /* Frameless until proven otherwise. */
590 /* Check whether PC points at a code that sets up a new stack frame.
591 If so, it updates CACHE and returns the address of the first
592 instruction after the sequence that sets removes the "hidden"
593 argument from the stack or CURRENT_PC, whichever is smaller.
594 Otherwise, return PC. */
597 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
598 struct m68k_frame_cache
*cache
)
602 if (pc
>= current_pc
)
605 op
= read_memory_unsigned_integer (pc
, 2);
607 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
609 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
610 cache
->sp_offset
+= 4;
611 if (op
== P_LINKW_FP
)
613 /* link.w %fp, #-N */
614 /* link.w %fp, #0; adda.l #-N, %sp */
615 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
617 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
619 op
= read_memory_unsigned_integer (pc
+ 4, 2);
620 if (op
== P_ADDAL_SP
)
622 cache
->locals
= read_memory_integer (pc
+ 6, 4);
629 else if (op
== P_LINKL_FP
)
631 /* link.l %fp, #-N */
632 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
637 /* pea (%fp); movea.l %sp, %fp */
640 if (pc
+ 2 < current_pc
)
642 op
= read_memory_unsigned_integer (pc
+ 2, 2);
644 if (op
== P_MOVEAL_SP_FP
)
646 /* move.l %sp, %fp */
654 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
656 /* subq.[wl] #N,%sp */
657 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
658 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
659 if (pc
+ 2 < current_pc
)
661 op
= read_memory_unsigned_integer (pc
+ 2, 2);
662 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
664 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
670 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
673 /* lea (-N,%sp),%sp */
674 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
677 else if (op
== P_ADDAL_SP
)
680 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
687 /* Check whether PC points at code that saves registers on the stack.
688 If so, it updates CACHE and returns the address of the first
689 instruction after the register saves or CURRENT_PC, whichever is
690 smaller. Otherwise, return PC. */
693 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
694 struct m68k_frame_cache
*cache
)
696 if (cache
->locals
>= 0)
702 offset
= -4 - cache
->locals
;
703 while (pc
< current_pc
)
705 op
= read_memory_unsigned_integer (pc
, 2);
706 if (op
== P_FMOVEMX_SP
707 && gdbarch_tdep (current_gdbarch
)->fpregs_present
)
709 /* fmovem.x REGS,-(%sp) */
710 op
= read_memory_unsigned_integer (pc
+ 2, 2);
711 if ((op
& 0xff00) == 0xe000)
714 for (i
= 0; i
< 16; i
++, mask
>>= 1)
718 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
727 else if ((op
& 0177760) == P_MOVEL_SP
)
729 /* move.l %R,-(%sp) */
731 cache
->saved_regs
[regno
] = offset
;
735 else if (op
== P_MOVEML_SP
)
737 /* movem.l REGS,-(%sp) */
738 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
739 for (i
= 0; i
< 16; i
++, mask
>>= 1)
743 cache
->saved_regs
[15 - i
] = offset
;
758 /* Do a full analysis of the prologue at PC and update CACHE
759 accordingly. Bail out early if CURRENT_PC is reached. Return the
760 address where the analysis stopped.
762 We handle all cases that can be generated by gcc.
764 For allocating a stack frame:
768 pea (%fp); move.l %sp,%fp
769 link.w %a6,#0; add.l #-N,%sp
772 subq.w #8,%sp; subq.w #N-8,%sp
777 For saving registers:
781 move.l R1,-(%sp); move.l R2,-(%sp)
784 For setting up the PIC register:
791 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
792 struct m68k_frame_cache
*cache
)
796 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
797 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
798 if (pc
>= current_pc
)
801 /* Check for GOT setup. */
802 op
= read_memory_unsigned_integer (pc
, 4);
803 if (op
== P_LEA_PC_A5
)
805 /* lea (%pc,N),%a5 */
812 /* Return PC of first real instruction. */
815 m68k_skip_prologue (CORE_ADDR start_pc
)
817 struct m68k_frame_cache cache
;
822 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
823 if (cache
.locals
< 0)
829 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
833 frame_unwind_register (next_frame
, gdbarch_pc_regnum (gdbarch
), buf
);
834 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
839 static struct m68k_frame_cache
*
840 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
842 struct m68k_frame_cache
*cache
;
849 cache
= m68k_alloc_frame_cache ();
852 /* In principle, for normal frames, %fp holds the frame pointer,
853 which holds the base address for the current stack frame.
854 However, for functions that don't need it, the frame pointer is
855 optional. For these "frameless" functions the frame pointer is
856 actually the frame pointer of the calling frame. Signal
857 trampolines are just a special case of a "frameless" function.
858 They (usually) share their frame pointer with the frame that was
859 in progress when the signal occurred. */
861 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
862 cache
->base
= extract_unsigned_integer (buf
, 4);
863 if (cache
->base
== 0)
866 /* For normal frames, %pc is stored at 4(%fp). */
867 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
869 cache
->pc
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
871 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
873 if (cache
->locals
< 0)
875 /* We didn't find a valid frame, which means that CACHE->base
876 currently holds the frame pointer for our calling frame. If
877 we're at the start of a function, or somewhere half-way its
878 prologue, the function's frame probably hasn't been fully
879 setup yet. Try to reconstruct the base address for the stack
880 frame by looking at the stack pointer. For truly "frameless"
881 functions this might work too. */
883 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
884 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
887 /* Now that we have the base address for the stack frame we can
888 calculate the value of %sp in the calling frame. */
889 cache
->saved_sp
= cache
->base
+ 8;
891 /* Adjust all the saved registers such that they contain addresses
892 instead of offsets. */
893 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
894 if (cache
->saved_regs
[i
] != -1)
895 cache
->saved_regs
[i
] += cache
->base
;
901 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
902 struct frame_id
*this_id
)
904 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
906 /* This marks the outermost frame. */
907 if (cache
->base
== 0)
910 /* See the end of m68k_push_dummy_call. */
911 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
915 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
916 int regnum
, int *optimizedp
,
917 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
918 int *realnump
, gdb_byte
*valuep
)
920 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
922 gdb_assert (regnum
>= 0);
924 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
932 /* Store the value. */
933 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
938 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
941 *lvalp
= lval_memory
;
942 *addrp
= cache
->saved_regs
[regnum
];
946 /* Read the value in from memory. */
947 read_memory (*addrp
, valuep
,
948 register_size (get_frame_arch (next_frame
), regnum
));
954 *lvalp
= lval_register
;
958 frame_unwind_register (next_frame
, (*realnump
), valuep
);
961 static const struct frame_unwind m68k_frame_unwind
=
965 m68k_frame_prev_register
968 static const struct frame_unwind
*
969 m68k_frame_sniffer (struct frame_info
*next_frame
)
971 return &m68k_frame_unwind
;
975 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
977 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
982 static const struct frame_base m68k_frame_base
=
985 m68k_frame_base_address
,
986 m68k_frame_base_address
,
987 m68k_frame_base_address
990 static struct frame_id
991 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
996 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
997 fp
= extract_unsigned_integer (buf
, 4);
999 /* See the end of m68k_push_dummy_call. */
1000 return frame_id_build (fp
+ 8, frame_pc_unwind (next_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 (get_frame_arch (frame
));
1017 if (tdep
->jb_pc
< 0)
1019 internal_error (__FILE__
, __LINE__
,
1020 _("m68k_get_longjmp_target: not implemented"));
1024 buf
= alloca (gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
);
1025 sp
= get_frame_register_unsigned (frame
, gdbarch_sp_regnum (gdbarch
));
1027 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1028 buf
, gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1031 jb_addr
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1034 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1035 gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
))
1038 *pc
= extract_unsigned_integer (buf
, gdbarch_ptr_bit (gdbarch
)
1044 /* System V Release 4 (SVR4). */
1047 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1049 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1051 /* SVR4 uses a different calling convention. */
1052 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1054 /* SVR4 uses %a0 instead of %a1. */
1055 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1059 /* Function: m68k_gdbarch_init
1060 Initializer function for the m68k gdbarch vector.
1061 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1063 static struct gdbarch
*
1064 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1066 struct gdbarch_tdep
*tdep
= NULL
;
1067 struct gdbarch
*gdbarch
;
1068 struct gdbarch_list
*best_arch
;
1069 struct tdesc_arch_data
*tdesc_data
= NULL
;
1071 enum m68k_flavour flavour
= m68k_no_flavour
;
1073 const struct floatformat
**long_double_format
= floatformats_m68881_ext
;
1075 /* Check any target description for validity. */
1076 if (tdesc_has_registers (info
.target_desc
))
1078 const struct tdesc_feature
*feature
;
1081 feature
= tdesc_find_feature (info
.target_desc
,
1082 "org.gnu.gdb.m68k.core");
1083 if (feature
!= NULL
)
1087 if (feature
== NULL
)
1089 feature
= tdesc_find_feature (info
.target_desc
,
1090 "org.gnu.gdb.coldfire.core");
1091 if (feature
!= NULL
)
1092 flavour
= m68k_coldfire_flavour
;
1095 if (feature
== NULL
)
1097 feature
= tdesc_find_feature (info
.target_desc
,
1098 "org.gnu.gdb.fido.core");
1099 if (feature
!= NULL
)
1100 flavour
= m68k_fido_flavour
;
1103 if (feature
== NULL
)
1106 tdesc_data
= tdesc_data_alloc ();
1109 for (i
= 0; i
<= M68K_PC_REGNUM
; i
++)
1110 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1111 m68k_register_names
[i
]);
1115 tdesc_data_cleanup (tdesc_data
);
1119 feature
= tdesc_find_feature (info
.target_desc
,
1120 "org.gnu.gdb.coldfire.fp");
1121 if (feature
!= NULL
)
1124 for (i
= M68K_FP0_REGNUM
; i
<= M68K_FPI_REGNUM
; i
++)
1125 valid_p
&= tdesc_numbered_register (feature
, tdesc_data
, i
,
1126 m68k_register_names
[i
]);
1129 tdesc_data_cleanup (tdesc_data
);
1137 /* The mechanism for returning floating values from function
1138 and the type of long double depend on whether we're
1139 on ColdFire or standard m68k. */
1141 if (info
.bfd_arch_info
&& info
.bfd_arch_info
->mach
!= 0)
1143 const bfd_arch_info_type
*coldfire_arch
=
1144 bfd_lookup_arch (bfd_arch_m68k
, bfd_mach_mcf_isa_a_nodiv
);
1147 && ((*info
.bfd_arch_info
->compatible
)
1148 (info
.bfd_arch_info
, coldfire_arch
)))
1149 flavour
= m68k_coldfire_flavour
;
1152 /* If there is already a candidate, use it. */
1153 for (best_arch
= gdbarch_list_lookup_by_info (arches
, &info
);
1155 best_arch
= gdbarch_list_lookup_by_info (best_arch
->next
, &info
))
1157 if (flavour
!= gdbarch_tdep (best_arch
->gdbarch
)->flavour
)
1160 if (has_fp
!= gdbarch_tdep (best_arch
->gdbarch
)->fpregs_present
)
1166 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1167 gdbarch
= gdbarch_alloc (&info
, tdep
);
1168 tdep
->fpregs_present
= has_fp
;
1169 tdep
->flavour
= flavour
;
1171 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1172 long_double_format
= floatformats_ieee_double
;
1173 set_gdbarch_long_double_format (gdbarch
, long_double_format
);
1174 set_gdbarch_long_double_bit (gdbarch
, long_double_format
[0]->totalsize
);
1176 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1177 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1179 /* Stack grows down. */
1180 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1181 set_gdbarch_frame_align (gdbarch
, m68k_frame_align
);
1183 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1184 if (flavour
== m68k_coldfire_flavour
|| flavour
== m68k_fido_flavour
)
1185 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1187 set_gdbarch_frame_args_skip (gdbarch
, 8);
1188 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1189 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1191 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1192 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1193 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1194 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1195 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1196 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1197 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1198 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1199 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1200 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1203 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1205 /* Try to figure out if the arch uses floating registers to return
1206 floating point values from functions. */
1209 /* On ColdFire, floating point values are returned in D0. */
1210 if (flavour
== m68k_coldfire_flavour
)
1211 tdep
->float_return
= 0;
1213 tdep
->float_return
= 1;
1217 /* No floating registers, so can't use them for returning values. */
1218 tdep
->float_return
= 0;
1221 /* Function call & return */
1222 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1223 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1227 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1229 #if defined JB_PC && defined JB_ELEMENT_SIZE
1230 tdep
->jb_pc
= JB_PC
;
1231 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1235 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1236 tdep
->struct_return
= reg_struct_return
;
1238 /* Frame unwinder. */
1239 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1240 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1242 /* Hook in the DWARF CFI frame unwinder. */
1243 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1245 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1247 /* Hook in ABI-specific overrides, if they have been registered. */
1248 gdbarch_init_osabi (info
, gdbarch
);
1250 /* Now we have tuned the configuration, set a few final things,
1251 based on what the OS ABI has told us. */
1253 if (tdep
->jb_pc
>= 0)
1254 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1256 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1259 tdesc_use_registers (gdbarch
, info
.target_desc
, tdesc_data
);
1266 m68k_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1268 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1274 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1277 _initialize_m68k_tdep (void)
1279 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1281 /* Initialize the m68k-specific register types. */