1 /* Target-dependent code for the Motorola 68000 series.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000,
4 2001, 2002, 2003, 2004, 2005 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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 gdb_byte
*
69 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
71 static gdb_byte 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"
125 if (regnum
< 0 || regnum
>= ARRAY_SIZE (register_names
))
126 internal_error (__FILE__
, __LINE__
,
127 _("m68k_register_name: illegal register number %d"), regnum
);
129 return register_names
[regnum
];
132 /* Return nonzero if a value of type TYPE stored in register REGNUM
133 needs any special handling. */
136 m68k_convert_register_p (int regnum
, struct type
*type
)
138 return (regnum
>= M68K_FP0_REGNUM
&& regnum
<= M68K_FP0_REGNUM
+ 7);
141 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
142 return its contents in TO. */
145 m68k_register_to_value (struct frame_info
*frame
, int regnum
,
146 struct type
*type
, gdb_byte
*to
)
148 gdb_byte from
[M68K_MAX_REGISTER_SIZE
];
150 /* We only support floating-point values. */
151 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
153 warning (_("Cannot convert floating-point register value "
154 "to non-floating-point type."));
158 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
159 the extended floating-point format used by the FPU. */
160 get_frame_register (frame
, regnum
, from
);
161 convert_typed_floating (from
, builtin_type_m68881_ext
, to
, type
);
164 /* Write the contents FROM of a value of type TYPE into register
165 REGNUM in frame FRAME. */
168 m68k_value_to_register (struct frame_info
*frame
, int regnum
,
169 struct type
*type
, const gdb_byte
*from
)
171 gdb_byte to
[M68K_MAX_REGISTER_SIZE
];
173 /* We only support floating-point values. */
174 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
176 warning (_("Cannot convert non-floating-point type "
177 "to floating-point register value."));
181 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
182 to the extended floating-point format used by the FPU. */
183 convert_typed_floating (from
, type
, to
, builtin_type_m68881_ext
);
184 put_frame_register (frame
, regnum
, to
);
188 /* There is a fair number of calling conventions that are in somewhat
189 wide use. The 68000/08/10 don't support an FPU, not even as a
190 coprocessor. All function return values are stored in %d0/%d1.
191 Structures are returned in a static buffer, a pointer to which is
192 returned in %d0. This means that functions returning a structure
193 are not re-entrant. To avoid this problem some systems use a
194 convention where the caller passes a pointer to a buffer in %a1
195 where the return values is to be stored. This convention is the
196 default, and is implemented in the function m68k_return_value.
198 The 68020/030/040/060 do support an FPU, either as a coprocessor
199 (68881/2) or built-in (68040/68060). That's why System V release 4
200 (SVR4) instroduces a new calling convention specified by the SVR4
201 psABI. Integer values are returned in %d0/%d1, pointer return
202 values in %a0 and floating values in %fp0. When calling functions
203 returning a structure the caller should pass a pointer to a buffer
204 for the return value in %a0. This convention is implemented in the
205 function m68k_svr4_return_value, and by appropriately setting the
206 struct_value_regnum member of `struct gdbarch_tdep'.
208 GNU/Linux returns values in the same way as SVR4 does, but uses %a1
209 for passing the structure return value buffer.
211 GCC can also generate code where small structures are returned in
212 %d0/%d1 instead of in memory by using -freg-struct-return. This is
213 the default on NetBSD a.out, OpenBSD and GNU/Linux and several
214 embedded systems. This convention is implemented by setting the
215 struct_return member of `struct gdbarch_tdep' to reg_struct_return. */
217 /* Read a function return value of TYPE from REGCACHE, and copy that
221 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
224 int len
= TYPE_LENGTH (type
);
225 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
229 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
230 memcpy (valbuf
, buf
+ (4 - len
), len
);
234 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
235 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
236 regcache_raw_read (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
239 internal_error (__FILE__
, __LINE__
,
240 _("Cannot extract return value of %d bytes long."), len
);
244 m68k_svr4_extract_return_value (struct type
*type
, struct regcache
*regcache
,
247 int len
= TYPE_LENGTH (type
);
248 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
250 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
252 regcache_raw_read (regcache
, M68K_FP0_REGNUM
, buf
);
253 convert_typed_floating (buf
, builtin_type_m68881_ext
, valbuf
, type
);
255 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
256 regcache_raw_read (regcache
, M68K_A0_REGNUM
, valbuf
);
258 m68k_extract_return_value (type
, regcache
, valbuf
);
261 /* Write a function return value of TYPE from VALBUF into REGCACHE. */
264 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
265 const gdb_byte
*valbuf
)
267 int len
= TYPE_LENGTH (type
);
270 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
273 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 8 - len
,
275 regcache_raw_write (regcache
, M68K_D1_REGNUM
, valbuf
+ (len
- 4));
278 internal_error (__FILE__
, __LINE__
,
279 _("Cannot store return value of %d bytes long."), len
);
283 m68k_svr4_store_return_value (struct type
*type
, struct regcache
*regcache
,
284 const gdb_byte
*valbuf
)
286 int len
= TYPE_LENGTH (type
);
288 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
290 gdb_byte buf
[M68K_MAX_REGISTER_SIZE
];
291 convert_typed_floating (valbuf
, type
, buf
, builtin_type_m68881_ext
);
292 regcache_raw_write (regcache
, M68K_FP0_REGNUM
, buf
);
294 else if (TYPE_CODE (type
) == TYPE_CODE_PTR
&& len
== 4)
296 regcache_raw_write (regcache
, M68K_A0_REGNUM
, valbuf
);
297 regcache_raw_write (regcache
, M68K_D0_REGNUM
, valbuf
);
300 m68k_store_return_value (type
, regcache
, valbuf
);
303 /* Return non-zero if TYPE, which is assumed to be a structure or
304 union type, should be returned in registers for architecture
308 m68k_reg_struct_return_p (struct gdbarch
*gdbarch
, struct type
*type
)
310 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
311 enum type_code code
= TYPE_CODE (type
);
312 int len
= TYPE_LENGTH (type
);
314 gdb_assert (code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
);
316 if (tdep
->struct_return
== pcc_struct_return
)
319 return (len
== 1 || len
== 2 || len
== 4 || len
== 8);
322 /* Determine, for architecture GDBARCH, how a return value of TYPE
323 should be returned. If it is supposed to be returned in registers,
324 and READBUF is non-zero, read the appropriate value from REGCACHE,
325 and copy it into READBUF. If WRITEBUF is non-zero, write the value
326 from WRITEBUF into REGCACHE. */
328 static enum return_value_convention
329 m68k_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
330 struct regcache
*regcache
, gdb_byte
*readbuf
,
331 const gdb_byte
*writebuf
)
333 enum type_code code
= TYPE_CODE (type
);
335 /* GCC returns a `long double' in memory too. */
336 if (((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
337 && !m68k_reg_struct_return_p (gdbarch
, type
))
338 || (code
== TYPE_CODE_FLT
&& TYPE_LENGTH (type
) == 12))
340 /* The default on m68k is to return structures in static memory.
341 Consequently a function must return the address where we can
342 find the return value. */
348 regcache_raw_read_unsigned (regcache
, M68K_D0_REGNUM
, &addr
);
349 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
352 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
356 m68k_extract_return_value (type
, regcache
, readbuf
);
358 m68k_store_return_value (type
, regcache
, writebuf
);
360 return RETURN_VALUE_REGISTER_CONVENTION
;
363 static enum return_value_convention
364 m68k_svr4_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
365 struct regcache
*regcache
, gdb_byte
*readbuf
,
366 const gdb_byte
*writebuf
)
368 enum type_code code
= TYPE_CODE (type
);
370 if ((code
== TYPE_CODE_STRUCT
|| code
== TYPE_CODE_UNION
)
371 && !m68k_reg_struct_return_p (gdbarch
, type
))
373 /* The System V ABI says that:
375 "A function returning a structure or union also sets %a0 to
376 the value it finds in %a0. Thus when the caller receives
377 control again, the address of the returned object resides in
380 So the ABI guarantees that we can always find the return
381 value just after the function has returned. */
387 regcache_raw_read_unsigned (regcache
, M68K_A0_REGNUM
, &addr
);
388 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
391 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
394 /* This special case is for structures consisting of a single
395 `float' or `double' member. These structures are returned in
396 %fp0. For these structures, we call ourselves recursively,
397 changing TYPE into the type of the first member of the structure.
398 Since that should work for all structures that have only one
399 member, we don't bother to check the member's type here. */
400 if (code
== TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type
) == 1)
402 type
= check_typedef (TYPE_FIELD_TYPE (type
, 0));
403 return m68k_svr4_return_value (gdbarch
, type
, regcache
,
408 m68k_svr4_extract_return_value (type
, regcache
, readbuf
);
410 m68k_svr4_store_return_value (type
, regcache
, writebuf
);
412 return RETURN_VALUE_REGISTER_CONVENTION
;
417 m68k_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
418 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
419 struct value
**args
, CORE_ADDR sp
, int struct_return
,
420 CORE_ADDR struct_addr
)
422 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
426 /* Push arguments in reverse order. */
427 for (i
= nargs
- 1; i
>= 0; i
--)
429 struct type
*value_type
= value_enclosing_type (args
[i
]);
430 int len
= TYPE_LENGTH (value_type
);
431 int container_len
= (len
+ 3) & ~3;
434 /* Non-scalars bigger than 4 bytes are left aligned, others are
436 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
437 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
438 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
442 offset
= container_len
- len
;
444 write_memory (sp
+ offset
, value_contents_all (args
[i
]), len
);
447 /* Store struct value address. */
450 store_unsigned_integer (buf
, 4, struct_addr
);
451 regcache_cooked_write (regcache
, tdep
->struct_value_regnum
, buf
);
454 /* Store return address. */
456 store_unsigned_integer (buf
, 4, bp_addr
);
457 write_memory (sp
, buf
, 4);
459 /* Finally, update the stack pointer... */
460 store_unsigned_integer (buf
, 4, sp
);
461 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
463 /* ...and fake a frame pointer. */
464 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
466 /* DWARF2/GCC uses the stack address *before* the function call as a
471 /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */
474 m68k_dwarf_reg_to_regnum (int num
)
478 return (num
- 0) + M68K_D0_REGNUM
;
481 return (num
- 8) + M68K_A0_REGNUM
;
484 return (num
- 16) + M68K_FP0_REGNUM
;
487 return M68K_PC_REGNUM
;
489 return NUM_REGS
+ NUM_PSEUDO_REGS
;
493 struct m68k_frame_cache
500 /* Saved registers. */
501 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
504 /* Stack space reserved for local variables. */
508 /* Allocate and initialize a frame cache. */
510 static struct m68k_frame_cache
*
511 m68k_alloc_frame_cache (void)
513 struct m68k_frame_cache
*cache
;
516 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
520 cache
->sp_offset
= -4;
523 /* Saved registers. We initialize these to -1 since zero is a valid
524 offset (that's where %fp is supposed to be stored). */
525 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
526 cache
->saved_regs
[i
] = -1;
528 /* Frameless until proven otherwise. */
534 /* Check whether PC points at a code that sets up a new stack frame.
535 If so, it updates CACHE and returns the address of the first
536 instruction after the sequence that sets removes the "hidden"
537 argument from the stack or CURRENT_PC, whichever is smaller.
538 Otherwise, return PC. */
541 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
542 struct m68k_frame_cache
*cache
)
546 if (pc
>= current_pc
)
549 op
= read_memory_unsigned_integer (pc
, 2);
551 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
553 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
554 cache
->sp_offset
+= 4;
555 if (op
== P_LINKW_FP
)
557 /* link.w %fp, #-N */
558 /* link.w %fp, #0; adda.l #-N, %sp */
559 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
561 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
563 op
= read_memory_unsigned_integer (pc
+ 4, 2);
564 if (op
== P_ADDAL_SP
)
566 cache
->locals
= read_memory_integer (pc
+ 6, 4);
573 else if (op
== P_LINKL_FP
)
575 /* link.l %fp, #-N */
576 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
581 /* pea (%fp); movea.l %sp, %fp */
584 if (pc
+ 2 < current_pc
)
586 op
= read_memory_unsigned_integer (pc
+ 2, 2);
588 if (op
== P_MOVEAL_SP_FP
)
590 /* move.l %sp, %fp */
598 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
600 /* subq.[wl] #N,%sp */
601 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
602 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
603 if (pc
+ 2 < current_pc
)
605 op
= read_memory_unsigned_integer (pc
+ 2, 2);
606 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
608 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
614 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
617 /* lea (-N,%sp),%sp */
618 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
621 else if (op
== P_ADDAL_SP
)
624 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
631 /* Check whether PC points at code that saves registers on the stack.
632 If so, it updates CACHE and returns the address of the first
633 instruction after the register saves or CURRENT_PC, whichever is
634 smaller. Otherwise, return PC. */
637 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
638 struct m68k_frame_cache
*cache
)
640 if (cache
->locals
>= 0)
646 offset
= -4 - cache
->locals
;
647 while (pc
< current_pc
)
649 op
= read_memory_unsigned_integer (pc
, 2);
650 if (op
== P_FMOVEMX_SP
)
652 /* fmovem.x REGS,-(%sp) */
653 op
= read_memory_unsigned_integer (pc
+ 2, 2);
654 if ((op
& 0xff00) == 0xe000)
657 for (i
= 0; i
< 16; i
++, mask
>>= 1)
661 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
670 else if ((op
& 0170677) == P_MOVEL_SP
)
672 /* move.l %R,-(%sp) */
673 regno
= ((op
& 07000) >> 9) | ((op
& 0100) >> 3);
674 cache
->saved_regs
[regno
] = offset
;
678 else if (op
== P_MOVEML_SP
)
680 /* movem.l REGS,-(%sp) */
681 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
682 for (i
= 0; i
< 16; i
++, mask
>>= 1)
686 cache
->saved_regs
[15 - i
] = offset
;
701 /* Do a full analysis of the prologue at PC and update CACHE
702 accordingly. Bail out early if CURRENT_PC is reached. Return the
703 address where the analysis stopped.
705 We handle all cases that can be generated by gcc.
707 For allocating a stack frame:
711 pea (%fp); move.l %sp,%fp
712 link.w %a6,#0; add.l #-N,%sp
715 subq.w #8,%sp; subq.w #N-8,%sp
720 For saving registers:
724 move.l R1,-(%sp); move.l R2,-(%sp)
727 For setting up the PIC register:
734 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
735 struct m68k_frame_cache
*cache
)
739 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
740 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
741 if (pc
>= current_pc
)
744 /* Check for GOT setup. */
745 op
= read_memory_unsigned_integer (pc
, 4);
746 if (op
== P_LEA_PC_A5
)
748 /* lea (%pc,N),%a5 */
755 /* Return PC of first real instruction. */
758 m68k_skip_prologue (CORE_ADDR start_pc
)
760 struct m68k_frame_cache cache
;
765 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
766 if (cache
.locals
< 0)
772 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
776 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
777 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
782 static struct m68k_frame_cache
*
783 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
785 struct m68k_frame_cache
*cache
;
792 cache
= m68k_alloc_frame_cache ();
795 /* In principle, for normal frames, %fp holds the frame pointer,
796 which holds the base address for the current stack frame.
797 However, for functions that don't need it, the frame pointer is
798 optional. For these "frameless" functions the frame pointer is
799 actually the frame pointer of the calling frame. Signal
800 trampolines are just a special case of a "frameless" function.
801 They (usually) share their frame pointer with the frame that was
802 in progress when the signal occurred. */
804 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
805 cache
->base
= extract_unsigned_integer (buf
, 4);
806 if (cache
->base
== 0)
809 /* For normal frames, %pc is stored at 4(%fp). */
810 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
812 cache
->pc
= frame_func_unwind (next_frame
);
814 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
816 if (cache
->locals
< 0)
818 /* We didn't find a valid frame, which means that CACHE->base
819 currently holds the frame pointer for our calling frame. If
820 we're at the start of a function, or somewhere half-way its
821 prologue, the function's frame probably hasn't been fully
822 setup yet. Try to reconstruct the base address for the stack
823 frame by looking at the stack pointer. For truly "frameless"
824 functions this might work too. */
826 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
827 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
830 /* Now that we have the base address for the stack frame we can
831 calculate the value of %sp in the calling frame. */
832 cache
->saved_sp
= cache
->base
+ 8;
834 /* Adjust all the saved registers such that they contain addresses
835 instead of offsets. */
836 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
837 if (cache
->saved_regs
[i
] != -1)
838 cache
->saved_regs
[i
] += cache
->base
;
844 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
845 struct frame_id
*this_id
)
847 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
849 /* This marks the outermost frame. */
850 if (cache
->base
== 0)
853 /* See the end of m68k_push_dummy_call. */
854 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
858 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
859 int regnum
, int *optimizedp
,
860 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
861 int *realnump
, gdb_byte
*valuep
)
863 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
865 gdb_assert (regnum
>= 0);
867 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
875 /* Store the value. */
876 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
881 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
884 *lvalp
= lval_memory
;
885 *addrp
= cache
->saved_regs
[regnum
];
889 /* Read the value in from memory. */
890 read_memory (*addrp
, valuep
,
891 register_size (current_gdbarch
, regnum
));
897 *lvalp
= lval_register
;
901 frame_unwind_register (next_frame
, (*realnump
), valuep
);
904 static const struct frame_unwind m68k_frame_unwind
=
908 m68k_frame_prev_register
911 static const struct frame_unwind
*
912 m68k_frame_sniffer (struct frame_info
*next_frame
)
914 return &m68k_frame_unwind
;
918 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
920 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
925 static const struct frame_base m68k_frame_base
=
928 m68k_frame_base_address
,
929 m68k_frame_base_address
,
930 m68k_frame_base_address
933 static struct frame_id
934 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
939 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
940 fp
= extract_unsigned_integer (buf
, 4);
942 /* See the end of m68k_push_dummy_call. */
943 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
946 #ifdef USE_PROC_FS /* Target dependent support for /proc */
948 #include <sys/procfs.h>
950 /* Prototypes for supply_gregset etc. */
953 /* The /proc interface divides the target machine's register set up into
954 two different sets, the general register set (gregset) and the floating
955 point register set (fpregset). For each set, there is an ioctl to get
956 the current register set and another ioctl to set the current values.
958 The actual structure passed through the ioctl interface is, of course,
959 naturally machine dependent, and is different for each set of registers.
960 For the m68k for example, the general register set is typically defined
963 typedef int gregset_t[18];
969 and the floating point set by:
971 typedef struct fpregset {
975 int f_fpregs[8][3]; (8 regs, 96 bits each)
978 These routines provide the packing and unpacking of gregset_t and
979 fpregset_t formatted data.
983 /* Atari SVR4 has R_SR but not R_PS */
985 #if !defined (R_PS) && defined (R_SR)
989 /* Given a pointer to a general register set in /proc format (gregset_t *),
990 unpack the register contents and supply them as gdb's idea of the current
994 supply_gregset (gregset_t
*gregsetp
)
997 greg_t
*regp
= (greg_t
*) gregsetp
;
999 for (regi
= 0; regi
< R_PC
; regi
++)
1001 regcache_raw_supply (current_regcache
, regi
, (char *) (regp
+ regi
));
1003 regcache_raw_supply (current_regcache
, PS_REGNUM
, (char *) (regp
+ R_PS
));
1004 regcache_raw_supply (current_regcache
, PC_REGNUM
, (char *) (regp
+ R_PC
));
1008 fill_gregset (gregset_t
*gregsetp
, int regno
)
1011 greg_t
*regp
= (greg_t
*) gregsetp
;
1013 for (regi
= 0; regi
< R_PC
; regi
++)
1015 if (regno
== -1 || regno
== regi
)
1016 regcache_raw_collect (current_regcache
, regi
, regp
+ regi
);
1018 if (regno
== -1 || regno
== PS_REGNUM
)
1019 regcache_raw_collect (current_regcache
, PS_REGNUM
, regp
+ R_PS
);
1020 if (regno
== -1 || regno
== PC_REGNUM
)
1021 regcache_raw_collect (current_regcache
, PC_REGNUM
, regp
+ R_PC
);
1024 #if defined (FP0_REGNUM)
1026 /* Given a pointer to a floating point register set in /proc format
1027 (fpregset_t *), unpack the register contents and supply them as gdb's
1028 idea of the current floating point register values. */
1031 supply_fpregset (fpregset_t
*fpregsetp
)
1036 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
1038 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
1039 regcache_raw_supply (current_regcache
, regi
, from
);
1041 regcache_raw_supply (current_regcache
, M68K_FPC_REGNUM
,
1042 (char *) &(fpregsetp
->f_pcr
));
1043 regcache_raw_supply (current_regcache
, M68K_FPS_REGNUM
,
1044 (char *) &(fpregsetp
->f_psr
));
1045 regcache_raw_supply (current_regcache
, M68K_FPI_REGNUM
,
1046 (char *) &(fpregsetp
->f_fpiaddr
));
1049 /* Given a pointer to a floating point register set in /proc format
1050 (fpregset_t *), update the register specified by REGNO from gdb's idea
1051 of the current floating point register set. If REGNO is -1, update
1055 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
1059 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
1061 if (regno
== -1 || regno
== regi
)
1062 regcache_raw_collect (current_regcache
, regi
,
1063 &fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
1065 if (regno
== -1 || regno
== M68K_FPC_REGNUM
)
1066 regcache_raw_collect (current_regcache
, M68K_FPC_REGNUM
,
1068 if (regno
== -1 || regno
== M68K_FPS_REGNUM
)
1069 regcache_raw_collect (current_regcache
, M68K_FPS_REGNUM
,
1071 if (regno
== -1 || regno
== M68K_FPI_REGNUM
)
1072 regcache_raw_collect (current_regcache
, M68K_FPI_REGNUM
,
1073 &fpregsetp
->f_fpiaddr
);
1076 #endif /* defined (FP0_REGNUM) */
1078 #endif /* USE_PROC_FS */
1080 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1081 We expect the first arg to be a pointer to the jmp_buf structure from which
1082 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1083 This routine returns true on success. */
1086 m68k_get_longjmp_target (CORE_ADDR
*pc
)
1089 CORE_ADDR sp
, jb_addr
;
1090 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1092 if (tdep
->jb_pc
< 0)
1094 internal_error (__FILE__
, __LINE__
,
1095 _("m68k_get_longjmp_target: not implemented"));
1099 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1100 sp
= read_register (SP_REGNUM
);
1102 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1103 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1106 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1108 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1109 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1112 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1117 /* System V Release 4 (SVR4). */
1120 m68k_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1122 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1124 /* SVR4 uses a different calling convention. */
1125 set_gdbarch_return_value (gdbarch
, m68k_svr4_return_value
);
1127 /* SVR4 uses %a0 instead of %a1. */
1128 tdep
->struct_value_regnum
= M68K_A0_REGNUM
;
1132 /* Function: m68k_gdbarch_init
1133 Initializer function for the m68k gdbarch vector.
1134 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1136 static struct gdbarch
*
1137 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1139 struct gdbarch_tdep
*tdep
= NULL
;
1140 struct gdbarch
*gdbarch
;
1142 /* find a candidate among the list of pre-declared architectures. */
1143 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1145 return (arches
->gdbarch
);
1147 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1148 gdbarch
= gdbarch_alloc (&info
, tdep
);
1150 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
1151 set_gdbarch_long_double_bit (gdbarch
, 96);
1153 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1154 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1156 /* Stack grows down. */
1157 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1159 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1160 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1162 set_gdbarch_frame_args_skip (gdbarch
, 8);
1163 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1164 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, m68k_dwarf_reg_to_regnum
);
1166 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1167 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1168 set_gdbarch_num_regs (gdbarch
, M68K_NUM_REGS
);
1169 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1170 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1171 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1172 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1173 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1174 set_gdbarch_convert_register_p (gdbarch
, m68k_convert_register_p
);
1175 set_gdbarch_register_to_value (gdbarch
, m68k_register_to_value
);
1176 set_gdbarch_value_to_register (gdbarch
, m68k_value_to_register
);
1178 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1179 set_gdbarch_return_value (gdbarch
, m68k_return_value
);
1182 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1184 #if defined JB_PC && defined JB_ELEMENT_SIZE
1185 tdep
->jb_pc
= JB_PC
;
1186 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1190 tdep
->struct_value_regnum
= M68K_A1_REGNUM
;
1191 tdep
->struct_return
= reg_struct_return
;
1193 /* Frame unwinder. */
1194 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1195 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1197 /* Hook in the DWARF CFI frame unwinder. */
1198 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
1200 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1202 /* Hook in ABI-specific overrides, if they have been registered. */
1203 gdbarch_init_osabi (info
, gdbarch
);
1205 /* Now we have tuned the configuration, set a few final things,
1206 based on what the OS ABI has told us. */
1208 if (tdep
->jb_pc
>= 0)
1209 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1211 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1218 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1220 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1226 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1229 _initialize_m68k_tdep (void)
1231 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);