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 /* There is a fair number of calling conventions that are in somewhat
134 wide use. The 68000/08/10 don't support an FPU, not even as a
135 coprocessor. All function return values are stored in %d0/%d1.
136 Structures are returned in a static buffer, a pointer to which is
137 returned in %d0. This means that functions returning a structure
138 are not re-entrant. To avoid this problem some systems use a
139 convention where the caller passes a pointer to a buffer in %a1
140 where the return values is to be stored. This convention is the
141 default, and is implemented in the function m68k_return_value.
143 The 68020/030/040/060 do support an FPU, either as a coprocessor
144 (68881/2) or built-in (68040/68060). That's why System V release 4
145 (SVR4) instroduces a new calling convention specified by the SVR4
146 psABI. Integer values are returned in %d0/%d1, pointer return
147 values in %a0 and floating values in %fp0. When calling functions
148 returning a structure the caller should pass a pointer to a buffer
149 for the return value in %a0. This convention is implemented in the
150 function m68k_svr4_return_value, and by appropriately setting the
151 struct_value_regnum member of `struct gdbarch_tdep'.
153 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
154 for passing the structure return value buffer.
156 GCC can also generate code where small structures are returned in
157 %d0/%d1 instead of in memory by using -freg-struct-return. This is
158 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
159 embedded systems. This convention is implemented by setting the
160 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
162 /* Read a function return value of TYPE from REGCACHE, and copy that
166 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
169 int len
= TYPE_LENGTH (type
);
170 char buf
[M68K_MAX_REGISTER_SIZE
];
174 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
175 memcpy (valbuf
, buf
+ (4 - len
), len
);
179 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
180 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
181 regcache_raw_read (regcache
, M68K_D1_REGNUM
,
182 (char *) valbuf
+ (len
- 4));
185 internal_error (__FILE__
, __LINE__
,
186 "Cannot extract return value of %d bytes long.", len
);
190 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
193 int len
= TYPE_LENGTH (type
);
194 char buf
[M68K_MAX_REGISTER_SIZE
];
196 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
198 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
199 convert_typed_floating (buf
, builtin_type_m68881_ext
, valbuf
, type
);
201 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
202 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
204 m68k_extract_return_value (type
, regcache
, valbuf
);
207 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
210 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
213 int len
= TYPE_LENGTH (type
);
216 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
219 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
221 regcache_raw_write (regcache
, M68K_D1_REGNUM
,
222 (char *) valbuf
+ (len
- 4));
225 internal_error (__FILE__
, __LINE__
,
226 "Cannot store return value of %d bytes long.", len
);
230 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
233 int len
= TYPE_LENGTH (type
);
235 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
237 char buf
[M68K_MAX_REGISTER_SIZE
];
238 convert_typed_floating (valbuf
, type
, buf
, builtin_type_m68881_ext
);
239 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
241 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
243 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
244 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
247 m68k_store_return_value (type
, regcache
, valbuf
);
250 /* Return non-zero if TYPE, which is assumed to be a structure or
251 union type, should be returned in registers for architecture
255 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
257 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
258 enum type_code code
= TYPE_CODE (type
);
259 int len
= TYPE_LENGTH (type
);
261 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
263 if (tdep
->struct_return
== pcc_struct_return
)
266 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
269 /* Determine, for architecture GDBARCH, how a return value of TYPE
270 should be returned. If it is supposed to be returned in registers,
271 and READBUF is non-zero, read the appropriate value from REGCACHE,
272 and copy it into READBUF. If WRITEBUF is non-zero, write the value
273 from WRITEBUF into REGCACHE. */
275 static enum return_value_convention
276 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
277 struct regcache
*regcache
, void *readbuf
,
278 const void *writebuf
)
280 enum type_code code
= TYPE_CODE (type
);
282 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
283 && !m68k_reg_struct_return_p (gdbarch
, type
))
284 return RETURN_VALUE_STRUCT_CONVENTION
;
286 /* GCC returns a `long double' in memory. */
287 if (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12)
288 return RETURN_VALUE_STRUCT_CONVENTION
;
291 m68k_extract_return_value (type
, regcache
, readbuf
);
293 m68k_store_return_value (type
, regcache
, writebuf
);
295 return RETURN_VALUE_REGISTER_CONVENTION
;
298 static enum return_value_convention
299 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
300 struct regcache
*regcache
, void *readbuf
,
301 const void *writebuf
)
303 enum type_code code
= TYPE_CODE (type
);
305 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
306 && !m68k_reg_struct_return_p (gdbarch
, type
))
307 return RETURN_VALUE_STRUCT_CONVENTION
;
309 /* This special case is for structures consisting of a single
310 `float' or `double' member. These structures are returned in
311 %fp0. For these structures, we call ourselves recursively,
312 changing TYPE into the type of the first member of the structure.
313 Since that should work for all structures that have only one
314 member, we don't bother to check the member's type here. */
315 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
317 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
318 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
323 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
325 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
327 return RETURN_VALUE_REGISTER_CONVENTION
;
331 /* A function that tells us whether the function invocation represented
332 by fi does not have a frame on the stack associated with it. If it
333 does not, FRAMELESS is set to 1, else 0. */
336 m68k_frameless_function_invocation (struct frame_info
*fi
)
338 if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
341 return legacy_frameless_look_for_prologue (fi
);
345 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
348 return strcmp (name
, "_sigcode") == 0;
354 delta68_frame_args_address (struct frame_info
*frame_info
)
356 /* we assume here that the only frameless functions are the system calls
357 or other functions who do not put anything on the stack. */
358 if (get_frame_type (frame_info
) == SIGTRAMP_FRAME
)
359 return get_frame_base (frame_info
) + 12;
360 else if (legacy_frameless_look_for_prologue (frame_info
))
362 /* Check for an interrupted system call */
363 if (get_next_frame (frame_info
) && (get_frame_type (get_next_frame (frame_info
)) == SIGTRAMP_FRAME
))
364 return get_frame_base (get_next_frame (frame_info
)) + 16;
366 return get_frame_base (frame_info
) + 4;
369 return get_frame_base (frame_info
);
373 delta68_frame_saved_pc (struct frame_info
*frame_info
)
375 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info
)
380 delta68_frame_num_args (struct frame_info
*fi
)
383 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
384 int insn
= read_memory_unsigned_integer (pc
, 2);
386 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
387 val
= read_memory_integer (pc
+ 2, 2);
388 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
389 || (insn
& 0170777) == 0050117) /* addqw */
391 val
= (insn
>> 9) & 7;
395 else if (insn
== 0157774) /* addal #WW, sp */
396 val
= read_memory_integer (pc
+ 2, 4);
402 m68k_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
403 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
404 struct value
**args
, CORE_ADDR sp
, int struct_return
,
405 CORE_ADDR struct_addr
)
407 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
411 /* Push arguments in reverse order. */
412 for (i
= nargs
- 1; i
>= 0; i
--)
414 struct type
*value_type
= VALUE_ENCLOSING_TYPE (args
[i
]);
415 int len
= TYPE_LENGTH (value_type
);
416 int container_len
= (len
+ 3) & ~3;
419 /* Non-scalars bigger than 4 bytes are left aligned, others are
421 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
422 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
423 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
427 offset
= container_len
- len
;
429 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (args
[i
]), len
);
432 /* Store struct value address. */
435 store_unsigned_integer (buf
, 4, struct_addr
);
436 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
439 /* Store return address. */
441 store_unsigned_integer (buf
, 4, bp_addr
);
442 write_memory (sp
, buf
, 4);
444 /* Finally, update the stack pointer... */
445 store_unsigned_integer (buf
, 4, sp
);
446 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
448 /* ...and fake a frame pointer. */
449 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
451 /* DWARF2/GCC uses the stack address *before* the function call as a
456 struct m68k_frame_cache
463 /* Saved registers. */
464 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
467 /* Stack space reserved for local variables. */
471 /* Allocate and initialize a frame cache. */
473 static struct m68k_frame_cache
*
474 m68k_alloc_frame_cache (void)
476 struct m68k_frame_cache
*cache
;
479 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
483 cache
->sp_offset
= -4;
486 /* Saved registers. We initialize these to -1 since zero is a valid
487 offset (that's where %fp is supposed to be stored). */
488 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
489 cache
->saved_regs
[i
] = -1;
491 /* Frameless until proven otherwise. */
497 /* Check whether PC points at a code that sets up a new stack frame.
498 If so, it updates CACHE and returns the address of the first
499 instruction after the sequence that sets removes the "hidden"
500 argument from the stack or CURRENT_PC, whichever is smaller.
501 Otherwise, return PC. */
504 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
505 struct m68k_frame_cache
*cache
)
509 if (pc
>= current_pc
)
512 op
= read_memory_unsigned_integer (pc
, 2);
514 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
516 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
517 cache
->sp_offset
+= 4;
518 if (op
== P_LINKW_FP
)
520 /* link.w %fp, #-N */
521 /* link.w %fp, #0; adda.l #-N, %sp */
522 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
524 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
526 op
= read_memory_unsigned_integer (pc
+ 4, 2);
527 if (op
== P_ADDAL_SP
)
529 cache
->locals
= read_memory_integer (pc
+ 6, 4);
536 else if (op
== P_LINKL_FP
)
538 /* link.l %fp, #-N */
539 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
544 /* pea (%fp); movea.l %sp, %fp */
547 if (pc
+ 2 < current_pc
)
549 op
= read_memory_unsigned_integer (pc
+ 2, 2);
551 if (op
== P_MOVEAL_SP_FP
)
553 /* move.l %sp, %fp */
561 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
563 /* subq.[wl] #N,%sp */
564 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
565 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
566 if (pc
+ 2 < current_pc
)
568 op
= read_memory_unsigned_integer (pc
+ 2, 2);
569 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
571 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
577 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
580 /* lea (-N,%sp),%sp */
581 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
584 else if (op
== P_ADDAL_SP
)
587 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
594 /* Check whether PC points at code that saves registers on the stack.
595 If so, it updates CACHE and returns the address of the first
596 instruction after the register saves or CURRENT_PC, whichever is
597 smaller. Otherwise, return PC. */
600 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
601 struct m68k_frame_cache
*cache
)
603 if (cache
->locals
>= 0)
609 offset
= -4 - cache
->locals
;
610 while (pc
< current_pc
)
612 op
= read_memory_unsigned_integer (pc
, 2);
613 if (op
== P_FMOVEMX_SP
)
615 /* fmovem.x REGS,-(%sp) */
616 op
= read_memory_unsigned_integer (pc
+ 2, 2);
617 if ((op
& 0xff00) == 0xe000)
620 for (i
= 0; i
< 16; i
++, mask
>>= 1)
624 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
633 else if ((op
& 0170677) == P_MOVEL_SP
)
635 /* move.l %R,-(%sp) */
636 regno
= ((op
& 07000) >> 9) | ((op
& 0100) >> 3);
637 cache
->saved_regs
[regno
] = offset
;
641 else if (op
== P_MOVEML_SP
)
643 /* movem.l REGS,-(%sp) */
644 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
645 for (i
= 0; i
< 16; i
++, mask
>>= 1)
649 cache
->saved_regs
[15 - i
] = offset
;
664 /* Do a full analysis of the prologue at PC and update CACHE
665 accordingly. Bail out early if CURRENT_PC is reached. Return the
666 address where the analysis stopped.
668 We handle all cases that can be generated by gcc.
670 For allocating a stack frame:
674 pea (%fp); move.l %sp,%fp
675 link.w %a6,#0; add.l #-N,%sp
678 subq.w #8,%sp; subq.w #N-8,%sp
683 For saving registers:
687 move.l R1,-(%sp); move.l R2,-(%sp)
690 For setting up the PIC register:
697 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
698 struct m68k_frame_cache
*cache
)
702 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
703 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
704 if (pc
>= current_pc
)
707 /* Check for GOT setup. */
708 op
= read_memory_unsigned_integer (pc
, 4);
709 if (op
== P_LEA_PC_A5
)
711 /* lea (%pc,N),%a5 */
718 /* Return PC of first real instruction. */
721 m68k_skip_prologue (CORE_ADDR start_pc
)
723 struct m68k_frame_cache cache
;
728 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
729 if (cache
.locals
< 0)
735 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
739 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
740 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
745 static struct m68k_frame_cache
*
746 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
748 struct m68k_frame_cache
*cache
;
755 cache
= m68k_alloc_frame_cache ();
758 /* In principle, for normal frames, %fp holds the frame pointer,
759 which holds the base address for the current stack frame.
760 However, for functions that don't need it, the frame pointer is
761 optional. For these "frameless" functions the frame pointer is
762 actually the frame pointer of the calling frame. Signal
763 trampolines are just a special case of a "frameless" function.
764 They (usually) share their frame pointer with the frame that was
765 in progress when the signal occurred. */
767 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
768 cache
->base
= extract_unsigned_integer (buf
, 4);
769 if (cache
->base
== 0)
772 /* For normal frames, %pc is stored at 4(%fp). */
773 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
775 cache
->pc
= frame_func_unwind (next_frame
);
777 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
779 if (cache
->locals
< 0)
781 /* We didn't find a valid frame, which means that CACHE->base
782 currently holds the frame pointer for our calling frame. If
783 we're at the start of a function, or somewhere half-way its
784 prologue, the function's frame probably hasn't been fully
785 setup yet. Try to reconstruct the base address for the stack
786 frame by looking at the stack pointer. For truly "frameless"
787 functions this might work too. */
789 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
790 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
793 /* Now that we have the base address for the stack frame we can
794 calculate the value of %sp in the calling frame. */
795 cache
->saved_sp
= cache
->base
+ 8;
797 /* Adjust all the saved registers such that they contain addresses
798 instead of offsets. */
799 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
800 if (cache
->saved_regs
[i
] != -1)
801 cache
->saved_regs
[i
] += cache
->base
;
807 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
808 struct frame_id
*this_id
)
810 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
812 /* This marks the outermost frame. */
813 if (cache
->base
== 0)
816 /* See the end of m68k_push_dummy_call. */
817 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
821 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
822 int regnum
, int *optimizedp
,
823 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
824 int *realnump
, void *valuep
)
826 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
828 gdb_assert (regnum
>= 0);
830 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
838 /* Store the value. */
839 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
844 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
847 *lvalp
= lval_memory
;
848 *addrp
= cache
->saved_regs
[regnum
];
852 /* Read the value in from memory. */
853 read_memory (*addrp
, valuep
,
854 register_size (current_gdbarch
, regnum
));
859 frame_register_unwind (next_frame
, regnum
,
860 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
863 static const struct frame_unwind m68k_frame_unwind
=
867 m68k_frame_prev_register
870 static const struct frame_unwind
*
871 m68k_frame_sniffer (struct frame_info
*next_frame
)
873 return &m68k_frame_unwind
;
877 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
879 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
884 static const struct frame_base m68k_frame_base
=
887 m68k_frame_base_address
,
888 m68k_frame_base_address
,
889 m68k_frame_base_address
892 static struct frame_id
893 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
898 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
899 fp
= extract_unsigned_integer (buf
, 4);
901 /* See the end of m68k_push_dummy_call. */
902 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
905 #ifdef USE_PROC_FS /* Target dependent support for /proc */
907 #include <sys/procfs.h>
909 /* Prototypes for supply_gregset etc. */
912 /* The /proc interface divides the target machine's register set up into
913 two different sets, the general register set (gregset) and the floating
914 point register set (fpregset). For each set, there is an ioctl to get
915 the current register set and another ioctl to set the current values.
917 The actual structure passed through the ioctl interface is, of course,
918 naturally machine dependent, and is different for each set of registers.
919 For the m68k for example, the general register set is typically defined
922 typedef int gregset_t[18];
928 and the floating point set by:
930 typedef struct fpregset {
934 int f_fpregs[8][3]; (8 regs, 96 bits each)
937 These routines provide the packing and unpacking of gregset_t and
938 fpregset_t formatted data.
942 /* Atari SVR4 has R_SR but not R_PS */
944 #if !defined (R_PS) && defined (R_SR)
948 /* Given a pointer to a general register set in /proc format (gregset_t *),
949 unpack the register contents and supply them as gdb's idea of the current
953 supply_gregset (gregset_t
*gregsetp
)
956 greg_t
*regp
= (greg_t
*) gregsetp
;
958 for (regi
= 0; regi
< R_PC
; regi
++)
960 supply_register (regi
, (char *) (regp
+ regi
));
962 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
963 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
967 fill_gregset (gregset_t
*gregsetp
, int regno
)
970 greg_t
*regp
= (greg_t
*) gregsetp
;
972 for (regi
= 0; regi
< R_PC
; regi
++)
974 if (regno
== -1 || regno
== regi
)
975 regcache_collect (regi
, regp
+ regi
);
977 if (regno
== -1 || regno
== PS_REGNUM
)
978 regcache_collect (PS_REGNUM
, regp
+ R_PS
);
979 if (regno
== -1 || regno
== PC_REGNUM
)
980 regcache_collect (PC_REGNUM
, regp
+ R_PC
);
983 #if defined (FP0_REGNUM)
985 /* Given a pointer to a floating point register set in /proc format
986 (fpregset_t *), unpack the register contents and supply them as gdb's
987 idea of the current floating point register values. */
990 supply_fpregset (fpregset_t
*fpregsetp
)
995 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
997 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
998 supply_register (regi
, from
);
1000 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
1001 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
1002 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
1005 /* Given a pointer to a floating point register set in /proc format
1006 (fpregset_t *), update the register specified by REGNO from gdb's idea
1007 of the current floating point register set. If REGNO is -1, update
1011 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
1015 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
1017 if (regno
== -1 || regno
== regi
)
1018 regcache_collect (regi
, &fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
1020 if (regno
== -1 || regno
== M68K_FPC_REGNUM
)
1021 regcache_collect (M68K_FPC_REGNUM
, &fpregsetp
->f_pcr
);
1022 if (regno
== -1 || regno
== M68K_FPS_REGNUM
)
1023 regcache_collect (M68K_FPS_REGNUM
, &fpregsetp
->f_psr
);
1024 if (regno
== -1 || regno
== M68K_FPI_REGNUM
)
1025 regcache_collect (M68K_FPI_REGNUM
, &fpregsetp
->f_fpiaddr
);
1028 #endif /* defined (FP0_REGNUM) */
1030 #endif /* USE_PROC_FS */
1032 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1033 We expect the first arg to be a pointer to the jmp_buf structure from which
1034 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1035 This routine returns true on success. */
1038 m68k_get_longjmp_target (CORE_ADDR
*pc
)
1041 CORE_ADDR sp
, jb_addr
;
1042 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1044 if (tdep
->jb_pc
< 0)
1046 internal_error (__FILE__
, __LINE__
,
1047 "m68k_get_longjmp_target: not implemented");
1051 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1052 sp
= read_register (SP_REGNUM
);
1054 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1055 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1058 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1060 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1061 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1064 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1069 /* System V Release 4 (SVR4). */
1072 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1074 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1076 /* SVR4 uses a different calling convention. */
1077 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1079 /* SVR4 uses %a0 instead of %a1. */
1080 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1084 /* Function: m68k_gdbarch_init
1085 Initializer function for the m68k gdbarch vector.
1086 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1088 static struct gdbarch
*
1089 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1091 struct gdbarch_tdep
*tdep
= NULL
;
1092 struct gdbarch
*gdbarch
;
1094 /* find a candidate among the list of pre-declared architectures. */
1095 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1097 return (arches
->gdbarch
);
1099 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1100 gdbarch
= gdbarch_alloc (&info
, tdep
);
1102 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
1103 set_gdbarch_long_double_bit (gdbarch
, 96);
1105 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1106 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1108 /* Stack grows down. */
1109 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1111 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1112 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1114 set_gdbarch_deprecated_frameless_function_invocation (gdbarch
, m68k_frameless_function_invocation
);
1115 set_gdbarch_frame_args_skip (gdbarch
, 8);
1117 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1118 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1119 set_gdbarch_num_regs (gdbarch
, 29);
1120 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1121 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1122 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1123 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1124 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1126 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1127 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1130 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1132 #if defined JB_PC && defined JB_ELEMENT_SIZE
1133 tdep
->jb_pc
= JB_PC
;
1134 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1138 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1139 tdep
->struct_return
= reg_struct_return
;
1141 /* Frame unwinder. */
1142 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1143 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1145 /* Hook in the DWARF CFI frame unwinder. */
1146 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1148 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1150 /* Hook in ABI-specific overrides, if they have been registered. */
1151 gdbarch_init_osabi (info
, gdbarch
);
1153 /* Now we have tuned the configuration, set a few final things,
1154 based on what the OS ABI has told us. */
1156 if (tdep
->jb_pc
>= 0)
1157 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1159 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1166 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1168 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1174 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1177 _initialize_m68k_tdep (void)
1179 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);