1 /* Target-dependent code for the Motorola 68000 series.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000,
4 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "dwarf2-frame.h"
26 #include "frame-base.h"
27 #include "frame-unwind.h"
28 #include "floatformat.h"
32 #include "gdb_string.h"
33 #include "gdb_assert.h"
36 #include "arch-utils.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
58 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
59 #define REGISTER_BYTES_NOFP (16*4 + 8)
61 /* Offset from SP to first arg on stack at first instruction of a function */
62 #define SP_ARG0 (1 * 4)
64 #if !defined (BPT_VECTOR)
65 #define BPT_VECTOR 0xf
68 static const unsigned char *
69 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
71 static unsigned char break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
72 *lenptr
= sizeof (break_insn
);
78 m68k_register_bytes_ok (long numbytes
)
80 return ((numbytes
== REGISTER_BYTES_FP
)
81 || (numbytes
== REGISTER_BYTES_NOFP
));
84 /* Return the GDB type object for the "standard" data type of data in
85 register N. This should be int for D0-D7, SR, FPCONTROL and
86 FPSTATUS, long double for FP0-FP7, and void pointer for all others
87 (A0-A7, PC, FPIADDR). Note, for registers which contain
88 addresses return pointer to void, not pointer to char, because we
89 don't want to attempt to print the string after printing the
93 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
95 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
96 return builtin_type_m68881_ext
;
98 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
99 return builtin_type_void_func_ptr
;
101 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
102 || regnum
== PS_REGNUM
)
103 return builtin_type_int32
;
105 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
106 return builtin_type_void_data_ptr
;
108 return builtin_type_int32
;
111 /* Function: m68k_register_name
112 Returns the name of the standard m68k register regnum. */
115 m68k_register_name (int regnum
)
117 static char *register_names
[] = {
118 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
119 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
121 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
122 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
126 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
127 internal_error (__FILE__
, __LINE__
,
128 "m68k_register_name: illegal register number %d", regnum
);
130 return register_names
[regnum
];
133 /* Return nonzero if a value of type TYPE stored in register REGNUM
134 needs any special handling. */
137 m68k_convert_register_p (int regnum
, struct type
*type
)
139 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7);
142 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
143 return its contents in TO. */
146 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
147 struct type
*type
, void *to
)
149 char from
[M68K_MAX_REGISTER_SIZE
];
151 /* We only support floating-point values. */
152 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
154 warning ("Cannot convert floating-point register value "
155 "to non-floating-point type.");
159 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
160 the extended floating-point format used by the FPU. */
161 get_frame_register (frame
, regnum
, from
);
162 convert_typed_floating (from
, builtin_type_m68881_ext
, to
, type
);
165 /* Write the contents FROM of a value of type TYPE into register
166 REGNUM in frame FRAME. */
169 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
170 struct type
*type
, const void *from
)
172 char to
[M68K_MAX_REGISTER_SIZE
];
174 /* We only support floating-point values. */
175 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
177 warning ("Cannot convert non-floating-point type "
178 "to floating-point register value.");
182 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
183 to the extended floating-point format used by the FPU. */
184 convert_typed_floating (from
, type
, to
, builtin_type_m68881_ext
);
185 put_frame_register (frame
, regnum
, to
);
189 /* There is a fair number of calling conventions that are in somewhat
190 wide use. The 68000/08/10 don't support an FPU, not even as a
191 coprocessor. All function return values are stored in %d0/%d1.
192 Structures are returned in a static buffer, a pointer to which is
193 returned in %d0. This means that functions returning a structure
194 are not re-entrant. To avoid this problem some systems use a
195 convention where the caller passes a pointer to a buffer in %a1
196 where the return values is to be stored. This convention is the
197 default, and is implemented in the function m68k_return_value.
199 The 68020/030/040/060 do support an FPU, either as a coprocessor
200 (68881/2) or built-in (68040/68060). That's why System V release 4
201 (SVR4) instroduces a new calling convention specified by the SVR4
202 psABI. Integer values are returned in %d0/%d1, pointer return
203 values in %a0 and floating values in %fp0. When calling functions
204 returning a structure the caller should pass a pointer to a buffer
205 for the return value in %a0. This convention is implemented in the
206 function m68k_svr4_return_value, and by appropriately setting the
207 struct_value_regnum member of `struct gdbarch_tdep'.
209 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
210 for passing the structure return value buffer.
212 GCC can also generate code where small structures are returned in
213 %d0/%d1 instead of in memory by using -freg-struct-return. This is
214 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
215 embedded systems. This convention is implemented by setting the
216 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
218 /* Read a function return value of TYPE from REGCACHE, and copy that
222 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
225 int len
= TYPE_LENGTH (type
);
226 char buf
[M68K_MAX_REGISTER_SIZE
];
230 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
231 memcpy (valbuf
, buf
+ (4 - len
), len
);
235 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
236 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
237 regcache_raw_read (regcache
, M68K_D1_REGNUM
,
238 (char *) valbuf
+ (len
- 4));
241 internal_error (__FILE__
, __LINE__
,
242 "Cannot extract return value of %d bytes long.", len
);
246 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
249 int len
= TYPE_LENGTH (type
);
250 char buf
[M68K_MAX_REGISTER_SIZE
];
252 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
254 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
255 convert_typed_floating (buf
, builtin_type_m68881_ext
, valbuf
, type
);
257 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
258 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
260 m68k_extract_return_value (type
, regcache
, valbuf
);
263 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
266 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
269 int len
= TYPE_LENGTH (type
);
272 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
275 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
277 regcache_raw_write (regcache
, M68K_D1_REGNUM
,
278 (char *) valbuf
+ (len
- 4));
281 internal_error (__FILE__
, __LINE__
,
282 "Cannot store return value of %d bytes long.", len
);
286 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
289 int len
= TYPE_LENGTH (type
);
291 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
293 char buf
[M68K_MAX_REGISTER_SIZE
];
294 convert_typed_floating (valbuf
, type
, buf
, builtin_type_m68881_ext
);
295 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
297 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
299 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
300 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
303 m68k_store_return_value (type
, regcache
, valbuf
);
306 /* Return non-zero if TYPE, which is assumed to be a structure or
307 union type, should be returned in registers for architecture
311 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
313 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
314 enum type_code code
= TYPE_CODE (type
);
315 int len
= TYPE_LENGTH (type
);
317 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
319 if (tdep
->struct_return
== pcc_struct_return
)
322 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
325 /* Determine, for architecture GDBARCH, how a return value of TYPE
326 should be returned. If it is supposed to be returned in registers,
327 and READBUF is non-zero, read the appropriate value from REGCACHE,
328 and copy it into READBUF. If WRITEBUF is non-zero, write the value
329 from WRITEBUF into REGCACHE. */
331 static enum return_value_convention
332 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
333 struct regcache
*regcache
, void *readbuf
,
334 const void *writebuf
)
336 enum type_code code
= TYPE_CODE (type
);
338 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
339 && !m68k_reg_struct_return_p (gdbarch
, type
))
340 return RETURN_VALUE_STRUCT_CONVENTION
;
342 /* GCC returns a `long double' in memory. */
343 if (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12)
344 return RETURN_VALUE_STRUCT_CONVENTION
;
347 m68k_extract_return_value (type
, regcache
, readbuf
);
349 m68k_store_return_value (type
, regcache
, writebuf
);
351 return RETURN_VALUE_REGISTER_CONVENTION
;
354 static enum return_value_convention
355 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
356 struct regcache
*regcache
, void *readbuf
,
357 const void *writebuf
)
359 enum type_code code
= TYPE_CODE (type
);
361 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
362 && !m68k_reg_struct_return_p (gdbarch
, type
))
363 return RETURN_VALUE_STRUCT_CONVENTION
;
365 /* This special case is for structures consisting of a single
366 `float' or `double' member. These structures are returned in
367 %fp0. For these structures, we call ourselves recursively,
368 changing TYPE into the type of the first member of the structure.
369 Since that should work for all structures that have only one
370 member, we don't bother to check the member's type here. */
371 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
373 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
374 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
379 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
381 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
383 return RETURN_VALUE_REGISTER_CONVENTION
;
388 m68k_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
389 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
390 struct value
**args
, CORE_ADDR sp
, int struct_return
,
391 CORE_ADDR struct_addr
)
393 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
397 /* Push arguments in reverse order. */
398 for (i
= nargs
- 1; i
>= 0; i
--)
400 struct type
*value_type
= VALUE_ENCLOSING_TYPE (args
[i
]);
401 int len
= TYPE_LENGTH (value_type
);
402 int container_len
= (len
+ 3) & ~3;
405 /* Non-scalars bigger than 4 bytes are left aligned, others are
407 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
408 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
409 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
413 offset
= container_len
- len
;
415 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (args
[i
]), len
);
418 /* Store struct value address. */
421 store_unsigned_integer (buf
, 4, struct_addr
);
422 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
425 /* Store return address. */
427 store_unsigned_integer (buf
, 4, bp_addr
);
428 write_memory (sp
, buf
, 4);
430 /* Finally, update the stack pointer... */
431 store_unsigned_integer (buf
, 4, sp
);
432 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
434 /* ...and fake a frame pointer. */
435 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
437 /* DWARF2/GCC uses the stack address *before* the function call as a
442 struct m68k_frame_cache
449 /* Saved registers. */
450 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
453 /* Stack space reserved for local variables. */
457 /* Allocate and initialize a frame cache. */
459 static struct m68k_frame_cache
*
460 m68k_alloc_frame_cache (void)
462 struct m68k_frame_cache
*cache
;
465 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
469 cache
->sp_offset
= -4;
472 /* Saved registers. We initialize these to -1 since zero is a valid
473 offset (that's where %fp is supposed to be stored). */
474 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
475 cache
->saved_regs
[i
] = -1;
477 /* Frameless until proven otherwise. */
483 /* Check whether PC points at a code that sets up a new stack frame.
484 If so, it updates CACHE and returns the address of the first
485 instruction after the sequence that sets removes the "hidden"
486 argument from the stack or CURRENT_PC, whichever is smaller.
487 Otherwise, return PC. */
490 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
491 struct m68k_frame_cache
*cache
)
495 if (pc
>= current_pc
)
498 op
= read_memory_unsigned_integer (pc
, 2);
500 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
502 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
503 cache
->sp_offset
+= 4;
504 if (op
== P_LINKW_FP
)
506 /* link.w %fp, #-N */
507 /* link.w %fp, #0; adda.l #-N, %sp */
508 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
510 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
512 op
= read_memory_unsigned_integer (pc
+ 4, 2);
513 if (op
== P_ADDAL_SP
)
515 cache
->locals
= read_memory_integer (pc
+ 6, 4);
522 else if (op
== P_LINKL_FP
)
524 /* link.l %fp, #-N */
525 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
530 /* pea (%fp); movea.l %sp, %fp */
533 if (pc
+ 2 < current_pc
)
535 op
= read_memory_unsigned_integer (pc
+ 2, 2);
537 if (op
== P_MOVEAL_SP_FP
)
539 /* move.l %sp, %fp */
547 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
549 /* subq.[wl] #N,%sp */
550 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
551 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
552 if (pc
+ 2 < current_pc
)
554 op
= read_memory_unsigned_integer (pc
+ 2, 2);
555 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
557 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
563 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
566 /* lea (-N,%sp),%sp */
567 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
570 else if (op
== P_ADDAL_SP
)
573 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
580 /* Check whether PC points at code that saves registers on the stack.
581 If so, it updates CACHE and returns the address of the first
582 instruction after the register saves or CURRENT_PC, whichever is
583 smaller. Otherwise, return PC. */
586 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
587 struct m68k_frame_cache
*cache
)
589 if (cache
->locals
>= 0)
595 offset
= -4 - cache
->locals
;
596 while (pc
< current_pc
)
598 op
= read_memory_unsigned_integer (pc
, 2);
599 if (op
== P_FMOVEMX_SP
)
601 /* fmovem.x REGS,-(%sp) */
602 op
= read_memory_unsigned_integer (pc
+ 2, 2);
603 if ((op
& 0xff00) == 0xe000)
606 for (i
= 0; i
< 16; i
++, mask
>>= 1)
610 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
619 else if ((op
& 0170677) == P_MOVEL_SP
)
621 /* move.l %R,-(%sp) */
622 regno
= ((op
& 07000) >> 9) | ((op
& 0100) >> 3);
623 cache
->saved_regs
[regno
] = offset
;
627 else if (op
== P_MOVEML_SP
)
629 /* movem.l REGS,-(%sp) */
630 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
631 for (i
= 0; i
< 16; i
++, mask
>>= 1)
635 cache
->saved_regs
[15 - i
] = offset
;
650 /* Do a full analysis of the prologue at PC and update CACHE
651 accordingly. Bail out early if CURRENT_PC is reached. Return the
652 address where the analysis stopped.
654 We handle all cases that can be generated by gcc.
656 For allocating a stack frame:
660 pea (%fp); move.l %sp,%fp
661 link.w %a6,#0; add.l #-N,%sp
664 subq.w #8,%sp; subq.w #N-8,%sp
669 For saving registers:
673 move.l R1,-(%sp); move.l R2,-(%sp)
676 For setting up the PIC register:
683 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
684 struct m68k_frame_cache
*cache
)
688 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
689 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
690 if (pc
>= current_pc
)
693 /* Check for GOT setup. */
694 op
= read_memory_unsigned_integer (pc
, 4);
695 if (op
== P_LEA_PC_A5
)
697 /* lea (%pc,N),%a5 */
704 /* Return PC of first real instruction. */
707 m68k_skip_prologue (CORE_ADDR start_pc
)
709 struct m68k_frame_cache cache
;
714 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
715 if (cache
.locals
< 0)
721 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
725 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
726 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
731 static struct m68k_frame_cache
*
732 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
734 struct m68k_frame_cache
*cache
;
741 cache
= m68k_alloc_frame_cache ();
744 /* In principle, for normal frames, %fp holds the frame pointer,
745 which holds the base address for the current stack frame.
746 However, for functions that don't need it, the frame pointer is
747 optional. For these "frameless" functions the frame pointer is
748 actually the frame pointer of the calling frame. Signal
749 trampolines are just a special case of a "frameless" function.
750 They (usually) share their frame pointer with the frame that was
751 in progress when the signal occurred. */
753 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
754 cache
->base
= extract_unsigned_integer (buf
, 4);
755 if (cache
->base
== 0)
758 /* For normal frames, %pc is stored at 4(%fp). */
759 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
761 cache
->pc
= frame_func_unwind (next_frame
);
763 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
765 if (cache
->locals
< 0)
767 /* We didn't find a valid frame, which means that CACHE->base
768 currently holds the frame pointer for our calling frame. If
769 we're at the start of a function, or somewhere half-way its
770 prologue, the function's frame probably hasn't been fully
771 setup yet. Try to reconstruct the base address for the stack
772 frame by looking at the stack pointer. For truly "frameless"
773 functions this might work too. */
775 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
776 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
779 /* Now that we have the base address for the stack frame we can
780 calculate the value of %sp in the calling frame. */
781 cache
->saved_sp
= cache
->base
+ 8;
783 /* Adjust all the saved registers such that they contain addresses
784 instead of offsets. */
785 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
786 if (cache
->saved_regs
[i
] != -1)
787 cache
->saved_regs
[i
] += cache
->base
;
793 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
794 struct frame_id
*this_id
)
796 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
798 /* This marks the outermost frame. */
799 if (cache
->base
== 0)
802 /* See the end of m68k_push_dummy_call. */
803 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
807 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
808 int regnum
, int *optimizedp
,
809 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
810 int *realnump
, void *valuep
)
812 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
814 gdb_assert (regnum
>= 0);
816 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
824 /* Store the value. */
825 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
830 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
833 *lvalp
= lval_memory
;
834 *addrp
= cache
->saved_regs
[regnum
];
838 /* Read the value in from memory. */
839 read_memory (*addrp
, valuep
,
840 register_size (current_gdbarch
, regnum
));
845 frame_register_unwind (next_frame
, regnum
,
846 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
849 static const struct frame_unwind m68k_frame_unwind
=
853 m68k_frame_prev_register
856 static const struct frame_unwind
*
857 m68k_frame_sniffer (struct frame_info
*next_frame
)
859 return &m68k_frame_unwind
;
863 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
865 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
870 static const struct frame_base m68k_frame_base
=
873 m68k_frame_base_address
,
874 m68k_frame_base_address
,
875 m68k_frame_base_address
878 static struct frame_id
879 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
884 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
885 fp
= extract_unsigned_integer (buf
, 4);
887 /* See the end of m68k_push_dummy_call. */
888 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
891 #ifdef USE_PROC_FS /* Target dependent support for /proc */
893 #include <sys/procfs.h>
895 /* Prototypes for supply_gregset etc. */
898 /* The /proc interface divides the target machine's register set up into
899 two different sets, the general register set (gregset) and the floating
900 point register set (fpregset). For each set, there is an ioctl to get
901 the current register set and another ioctl to set the current values.
903 The actual structure passed through the ioctl interface is, of course,
904 naturally machine dependent, and is different for each set of registers.
905 For the m68k for example, the general register set is typically defined
908 typedef int gregset_t[18];
914 and the floating point set by:
916 typedef struct fpregset {
920 int f_fpregs[8][3]; (8 regs, 96 bits each)
923 These routines provide the packing and unpacking of gregset_t and
924 fpregset_t formatted data.
928 /* Atari SVR4 has R_SR but not R_PS */
930 #if !defined (R_PS) && defined (R_SR)
934 /* Given a pointer to a general register set in /proc format (gregset_t *),
935 unpack the register contents and supply them as gdb's idea of the current
939 supply_gregset (gregset_t
*gregsetp
)
942 greg_t
*regp
= (greg_t
*) gregsetp
;
944 for (regi
= 0; regi
< R_PC
; regi
++)
946 supply_register (regi
, (char *) (regp
+ regi
));
948 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
949 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
953 fill_gregset (gregset_t
*gregsetp
, int regno
)
956 greg_t
*regp
= (greg_t
*) gregsetp
;
958 for (regi
= 0; regi
< R_PC
; regi
++)
960 if (regno
== -1 || regno
== regi
)
961 regcache_collect (regi
, regp
+ regi
);
963 if (regno
== -1 || regno
== PS_REGNUM
)
964 regcache_collect (PS_REGNUM
, regp
+ R_PS
);
965 if (regno
== -1 || regno
== PC_REGNUM
)
966 regcache_collect (PC_REGNUM
, regp
+ R_PC
);
969 #if defined (FP0_REGNUM)
971 /* Given a pointer to a floating point register set in /proc format
972 (fpregset_t *), unpack the register contents and supply them as gdb's
973 idea of the current floating point register values. */
976 supply_fpregset (fpregset_t
*fpregsetp
)
981 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
983 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
984 supply_register (regi
, from
);
986 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
987 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
988 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
991 /* Given a pointer to a floating point register set in /proc format
992 (fpregset_t *), update the register specified by REGNO from gdb's idea
993 of the current floating point register set. If REGNO is -1, update
997 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
1001 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
1003 if (regno
== -1 || regno
== regi
)
1004 regcache_collect (regi
, &fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
1006 if (regno
== -1 || regno
== M68K_FPC_REGNUM
)
1007 regcache_collect (M68K_FPC_REGNUM
, &fpregsetp
->f_pcr
);
1008 if (regno
== -1 || regno
== M68K_FPS_REGNUM
)
1009 regcache_collect (M68K_FPS_REGNUM
, &fpregsetp
->f_psr
);
1010 if (regno
== -1 || regno
== M68K_FPI_REGNUM
)
1011 regcache_collect (M68K_FPI_REGNUM
, &fpregsetp
->f_fpiaddr
);
1014 #endif /* defined (FP0_REGNUM) */
1016 #endif /* USE_PROC_FS */
1018 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1019 We expect the first arg to be a pointer to the jmp_buf structure from which
1020 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1021 This routine returns true on success. */
1024 m68k_get_longjmp_target (CORE_ADDR
*pc
)
1027 CORE_ADDR sp
, jb_addr
;
1028 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1030 if (tdep
->jb_pc
< 0)
1032 internal_error (__FILE__
, __LINE__
,
1033 "m68k_get_longjmp_target: not implemented");
1037 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1038 sp
= read_register (SP_REGNUM
);
1040 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1041 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1044 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1046 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1047 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1050 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1055 /* System V Release 4 (SVR4). */
1058 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1060 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1062 /* SVR4 uses a different calling convention. */
1063 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1065 /* SVR4 uses %a0 instead of %a1. */
1066 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1070 /* Function: m68k_gdbarch_init
1071 Initializer function for the m68k gdbarch vector.
1072 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1074 static struct gdbarch
*
1075 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1077 struct gdbarch_tdep
*tdep
= NULL
;
1078 struct gdbarch
*gdbarch
;
1080 /* find a candidate among the list of pre-declared architectures. */
1081 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1083 return (arches
->gdbarch
);
1085 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1086 gdbarch
= gdbarch_alloc (&info
, tdep
);
1088 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
1089 set_gdbarch_long_double_bit (gdbarch
, 96);
1091 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1092 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1094 /* Stack grows down. */
1095 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1097 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1098 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1100 set_gdbarch_frame_args_skip (gdbarch
, 8);
1102 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1103 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1104 set_gdbarch_num_regs (gdbarch
, 29);
1105 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1106 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1107 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1108 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1109 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1110 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1111 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1112 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1114 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1115 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1118 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1120 #if defined JB_PC && defined JB_ELEMENT_SIZE
1121 tdep
->jb_pc
= JB_PC
;
1122 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1126 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1127 tdep
->struct_return
= reg_struct_return
;
1129 /* Frame unwinder. */
1130 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1131 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1133 /* Hook in the DWARF CFI frame unwinder. */
1134 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1136 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1138 /* Hook in ABI-specific overrides, if they have been registered. */
1139 gdbarch_init_osabi (info
, gdbarch
);
1141 /* Now we have tuned the configuration, set a few final things,
1142 based on what the OS ABI has told us. */
1144 if (tdep
->jb_pc
>= 0)
1145 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1147 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1154 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1156 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1162 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1165 _initialize_m68k_tdep (void)
1167 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);