1 /* Target dependent code for the Motorola 68000 series.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
4 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. */
25 #include "frame-base.h"
26 #include "frame-unwind.h"
30 #include "gdb_string.h"
31 #include "gdb_assert.h"
34 #include "arch-utils.h"
38 #include "m68k-tdep.h"
41 #define P_LINKL_FP 0x480e
42 #define P_LINKW_FP 0x4e56
43 #define P_PEA_FP 0x4856
44 #define P_MOVEAL_SP_FP 0x2c4f
45 #define P_ADDAW_SP 0xdefc
46 #define P_ADDAL_SP 0xdffc
47 #define P_SUBQW_SP 0x514f
48 #define P_SUBQL_SP 0x518f
49 #define P_LEA_SP_SP 0x4fef
50 #define P_LEA_PC_A5 0x4bfb0170
51 #define P_FMOVEMX_SP 0xf227
52 #define P_MOVEL_SP 0x2f00
53 #define P_MOVEML_SP 0x48e7
56 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
57 #define REGISTER_BYTES_NOFP (16*4 + 8)
59 /* Offset from SP to first arg on stack at first instruction of a function */
60 #define SP_ARG0 (1 * 4)
62 #if !defined (BPT_VECTOR)
63 #define BPT_VECTOR 0xf
66 #if !defined (REMOTE_BPT_VECTOR)
67 #define REMOTE_BPT_VECTOR 1
71 /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
72 so m68k_remote_breakpoint_from_pc is currently not used. */
74 static const unsigned char *
75 m68k_remote_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
77 static unsigned char break_insn
[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR
)};
78 *lenptr
= sizeof (break_insn
);
82 static const unsigned char *
83 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
85 static unsigned char break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
86 *lenptr
= sizeof (break_insn
);
92 m68k_register_bytes_ok (long numbytes
)
94 return ((numbytes
== REGISTER_BYTES_FP
)
95 || (numbytes
== REGISTER_BYTES_NOFP
));
98 /* Return the GDB type object for the "standard" data type of data in
99 register N. This should be int for D0-D7, SR, FPCONTROL and
100 FPSTATUS, long double for FP0-FP7, and void pointer for all others
101 (A0-A7, PC, FPIADDR). Note, for registers which contain
102 addresses return pointer to void, not pointer to char, because we
103 don't want to attempt to print the string after printing the
107 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
109 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
110 return builtin_type_m68881_ext
;
112 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
113 return builtin_type_void_func_ptr
;
115 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
116 || regnum
== PS_REGNUM
)
117 return builtin_type_int32
;
119 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
120 return builtin_type_void_data_ptr
;
122 return builtin_type_int32
;
125 /* Function: m68k_register_name
126 Returns the name of the standard m68k register regnum. */
129 m68k_register_name (int regnum
)
131 static char *register_names
[] = {
132 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
133 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
135 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
136 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
140 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
141 internal_error (__FILE__
, __LINE__
,
142 "m68k_register_name: illegal register number %d", regnum
);
144 return register_names
[regnum
];
147 /* Index within `registers' of the first byte of the space for
151 m68k_register_byte (int regnum
)
153 if (regnum
>= M68K_FPC_REGNUM
)
154 return (((regnum
- M68K_FPC_REGNUM
) * 4) + 168);
155 else if (regnum
>= FP0_REGNUM
)
156 return (((regnum
- FP0_REGNUM
) * 12) + 72);
161 /* Extract from an array REGBUF containing the (raw) register state, a
162 function return value of TYPE, and copy that, in virtual format,
166 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
169 int len
= TYPE_LENGTH (type
);
170 char buf
[M68K_MAX_REGISTER_SIZE
];
172 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
173 && TYPE_NFIELDS (type
) == 1)
175 m68k_extract_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
181 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
182 memcpy (valbuf
, buf
+ (4 - len
), len
);
186 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
187 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
188 regcache_raw_read (regcache
, M68K_D1_REGNUM
,
189 (char *) valbuf
+ (len
- 4));
192 internal_error (__FILE__
, __LINE__
,
193 "Cannot extract return value of %d bytes long.", len
);
196 /* Write into the appropriate registers a function return value stored
197 in VALBUF of type TYPE, given in virtual format. */
200 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
203 int len
= TYPE_LENGTH (type
);
205 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
206 && TYPE_NFIELDS (type
) == 1)
208 m68k_store_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
213 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
216 regcache_raw_write_part (regcache
, M68K_D1_REGNUM
, 8 - len
,
218 regcache_raw_write (regcache
, M68K_D0_REGNUM
,
219 (char *) valbuf
+ (len
- 4));
222 internal_error (__FILE__
, __LINE__
,
223 "Cannot store return value of %d bytes long.", len
);
226 /* Extract from REGCACHE, which contains the (raw) register state, the
227 address in which a function should return its structure value, as a
231 m68k_extract_struct_value_address (struct regcache
*regcache
)
235 regcache_cooked_read (regcache
, M68K_D0_REGNUM
, buf
);
236 return extract_unsigned_integer (buf
, 4);
240 m68k_use_struct_convention (int gcc_p
, struct type
*type
)
242 enum struct_return struct_return
;
244 struct_return
= gdbarch_tdep (current_gdbarch
)->struct_return
;
245 return generic_use_struct_convention (struct_return
== reg_struct_return
,
249 /* A function that tells us whether the function invocation represented
250 by fi does not have a frame on the stack associated with it. If it
251 does not, FRAMELESS is set to 1, else 0. */
254 m68k_frameless_function_invocation (struct frame_info
*fi
)
256 if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
259 return frameless_look_for_prologue (fi
);
263 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
266 return strcmp (name
, "_sigcode") == 0;
272 delta68_frame_args_address (struct frame_info
*frame_info
)
274 /* we assume here that the only frameless functions are the system calls
275 or other functions who do not put anything on the stack. */
276 if (get_frame_type (frame_info
) == SIGTRAMP_FRAME
)
277 return get_frame_base (frame_info
) + 12;
278 else if (frameless_look_for_prologue (frame_info
))
280 /* Check for an interrupted system call */
281 if (get_next_frame (frame_info
) && (get_frame_type (get_next_frame (frame_info
)) == SIGTRAMP_FRAME
))
282 return get_frame_base (get_next_frame (frame_info
)) + 16;
284 return get_frame_base (frame_info
) + 4;
287 return get_frame_base (frame_info
);
291 delta68_frame_saved_pc (struct frame_info
*frame_info
)
293 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info
)
298 delta68_frame_num_args (struct frame_info
*fi
)
301 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
302 int insn
= read_memory_unsigned_integer (pc
, 2);
304 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
305 val
= read_memory_integer (pc
+ 2, 2);
306 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
307 || (insn
& 0170777) == 0050117) /* addqw */
309 val
= (insn
>> 9) & 7;
313 else if (insn
== 0157774) /* addal #WW, sp */
314 val
= read_memory_integer (pc
+ 2, 4);
320 m68k_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
321 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
322 struct value
**args
, CORE_ADDR sp
, int struct_return
,
323 CORE_ADDR struct_addr
)
328 /* Push arguments in reverse order. */
329 for (i
= nargs
- 1; i
>= 0; i
--)
331 struct type
*value_type
= VALUE_ENCLOSING_TYPE (args
[i
]);
332 int len
= TYPE_LENGTH (value_type
);
333 int container_len
= (len
+ 3) & ~3;
336 /* Non-scalars bigger than 4 bytes are left aligned, others are
338 if ((TYPE_CODE (value_type
) == TYPE_CODE_STRUCT
339 || TYPE_CODE (value_type
) == TYPE_CODE_UNION
340 || TYPE_CODE (value_type
) == TYPE_CODE_ARRAY
)
344 offset
= container_len
- len
;
346 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (args
[i
]), len
);
349 /* Store struct value address. */
352 store_unsigned_integer (buf
, 4, struct_addr
);
353 regcache_cooked_write (regcache
, M68K_A1_REGNUM
, buf
);
356 /* Store return address. */
358 store_unsigned_integer (buf
, 4, bp_addr
);
359 write_memory (sp
, buf
, 4);
361 /* Finally, update the stack pointer... */
362 store_unsigned_integer (buf
, 4, sp
);
363 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
365 /* ...and fake a frame pointer. */
366 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
368 /* DWARF2/GCC uses the stack address *before* the function call as a
373 struct m68k_frame_cache
380 /* Saved registers. */
381 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
384 /* Stack space reserved for local variables. */
388 /* Allocate and initialize a frame cache. */
390 static struct m68k_frame_cache
*
391 m68k_alloc_frame_cache (void)
393 struct m68k_frame_cache
*cache
;
396 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
400 cache
->sp_offset
= -4;
403 /* Saved registers. We initialize these to -1 since zero is a valid
404 offset (that's where %fp is supposed to be stored). */
405 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
406 cache
->saved_regs
[i
] = -1;
408 /* Frameless until proven otherwise. */
414 /* Check whether PC points at a code that sets up a new stack frame.
415 If so, it updates CACHE and returns the address of the first
416 instruction after the sequence that sets removes the "hidden"
417 argument from the stack or CURRENT_PC, whichever is smaller.
418 Otherwise, return PC. */
421 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
422 struct m68k_frame_cache
*cache
)
426 if (pc
>= current_pc
)
429 op
= read_memory_unsigned_integer (pc
, 2);
431 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
433 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
434 cache
->sp_offset
+= 4;
435 if (op
== P_LINKW_FP
)
437 /* link.w %fp, #-N */
438 /* link.w %fp, #0; adda.l #-N, %sp */
439 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
441 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
443 op
= read_memory_unsigned_integer (pc
+ 4, 2);
444 if (op
== P_ADDAL_SP
)
446 cache
->locals
= read_memory_integer (pc
+ 6, 4);
453 else if (op
== P_LINKL_FP
)
455 /* link.l %fp, #-N */
456 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
461 /* pea (%fp); movea.l %sp, %fp */
464 if (pc
+ 2 < current_pc
)
466 op
= read_memory_unsigned_integer (pc
+ 2, 2);
468 if (op
== P_MOVEAL_SP_FP
)
470 /* move.l %sp, %fp */
478 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
480 /* subq.[wl] #N,%sp */
481 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
482 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
483 if (pc
+ 2 < current_pc
)
485 op
= read_memory_unsigned_integer (pc
+ 2, 2);
486 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
488 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
494 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
497 /* lea (-N,%sp),%sp */
498 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
501 else if (op
== P_ADDAL_SP
)
504 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
511 /* Check whether PC points at code that saves registers on the stack.
512 If so, it updates CACHE and returns the address of the first
513 instruction after the register saves or CURRENT_PC, whichever is
514 smaller. Otherwise, return PC. */
517 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
518 struct m68k_frame_cache
*cache
)
520 if (cache
->locals
>= 0)
526 offset
= -4 - cache
->locals
;
527 while (pc
< current_pc
)
529 op
= read_memory_unsigned_integer (pc
, 2);
530 if (op
== P_FMOVEMX_SP
)
532 /* fmovem.x REGS,-(%sp) */
533 op
= read_memory_unsigned_integer (pc
+ 2, 2);
534 if ((op
& 0xff00) == 0xe000)
537 for (i
= 0; i
< 16; i
++, mask
>>= 1)
541 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
550 else if ((op
& 0170677) == P_MOVEL_SP
)
552 /* move.l %R,-(%sp) */
553 regno
= ((op
& 07000) >> 9) | ((op
& 0100) >> 3);
554 cache
->saved_regs
[regno
] = offset
;
558 else if (op
== P_MOVEML_SP
)
560 /* movem.l REGS,-(%sp) */
561 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
562 for (i
= 0; i
< 16; i
++, mask
>>= 1)
566 cache
->saved_regs
[15 - i
] = offset
;
581 /* Do a full analysis of the prologue at PC and update CACHE
582 accordingly. Bail out early if CURRENT_PC is reached. Return the
583 address where the analysis stopped.
585 We handle all cases that can be generated by gcc.
587 For allocating a stack frame:
591 pea (%fp); move.l %sp,%fp
592 link.w %a6,#0; add.l #-N,%sp
595 subq.w #8,%sp; subq.w #N-8,%sp
600 For saving registers:
604 move.l R1,-(%sp); move.l R2,-(%sp)
607 For setting up the PIC register:
614 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
615 struct m68k_frame_cache
*cache
)
619 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
620 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
621 if (pc
>= current_pc
)
624 /* Check for GOT setup. */
625 op
= read_memory_unsigned_integer (pc
, 4);
626 if (op
== P_LEA_PC_A5
)
628 /* lea (%pc,N),%a5 */
635 /* Return PC of first real instruction. */
638 m68k_skip_prologue (CORE_ADDR start_pc
)
640 struct m68k_frame_cache cache
;
645 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
646 if (cache
.locals
< 0)
652 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
656 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
657 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
662 static struct m68k_frame_cache
*
663 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
665 struct m68k_frame_cache
*cache
;
672 cache
= m68k_alloc_frame_cache ();
675 /* In principle, for normal frames, %fp holds the frame pointer,
676 which holds the base address for the current stack frame.
677 However, for functions that don't need it, the frame pointer is
678 optional. For these "frameless" functions the frame pointer is
679 actually the frame pointer of the calling frame. Signal
680 trampolines are just a special case of a "frameless" function.
681 They (usually) share their frame pointer with the frame that was
682 in progress when the signal occurred. */
684 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
685 cache
->base
= extract_unsigned_integer (buf
, 4);
686 if (cache
->base
== 0)
689 /* For normal frames, %pc is stored at 4(%fp). */
690 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
692 cache
->pc
= frame_func_unwind (next_frame
);
694 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
696 if (cache
->locals
< 0)
698 /* We didn't find a valid frame, which means that CACHE->base
699 currently holds the frame pointer for our calling frame. If
700 we're at the start of a function, or somewhere half-way its
701 prologue, the function's frame probably hasn't been fully
702 setup yet. Try to reconstruct the base address for the stack
703 frame by looking at the stack pointer. For truly "frameless"
704 functions this might work too. */
706 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
707 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
710 /* Now that we have the base address for the stack frame we can
711 calculate the value of %sp in the calling frame. */
712 cache
->saved_sp
= cache
->base
+ 8;
714 /* Adjust all the saved registers such that they contain addresses
715 instead of offsets. */
716 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
717 if (cache
->saved_regs
[i
] != -1)
718 cache
->saved_regs
[i
] += cache
->base
;
724 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
725 struct frame_id
*this_id
)
727 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
729 /* This marks the outermost frame. */
730 if (cache
->base
== 0)
733 /* See the end of m68k_push_dummy_call. */
734 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
738 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
739 int regnum
, int *optimizedp
,
740 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
741 int *realnump
, void *valuep
)
743 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
745 gdb_assert (regnum
>= 0);
747 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
755 /* Store the value. */
756 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
761 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
764 *lvalp
= lval_memory
;
765 *addrp
= cache
->saved_regs
[regnum
];
769 /* Read the value in from memory. */
770 read_memory (*addrp
, valuep
,
771 register_size (current_gdbarch
, regnum
));
776 frame_register_unwind (next_frame
, regnum
,
777 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
780 static const struct frame_unwind m68k_frame_unwind
=
784 m68k_frame_prev_register
787 static const struct frame_unwind
*
788 m68k_frame_sniffer (struct frame_info
*next_frame
)
790 return &m68k_frame_unwind
;
793 /* Signal trampolines. */
795 static struct m68k_frame_cache
*
796 m68k_sigtramp_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
798 struct m68k_frame_cache
*cache
;
799 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
800 struct m68k_sigtramp_info info
;
807 cache
= m68k_alloc_frame_cache ();
809 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
810 cache
->base
= extract_unsigned_integer (buf
, 4) - 4;
812 info
= tdep
->get_sigtramp_info (next_frame
);
814 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
815 if (info
.sc_reg_offset
[i
] != -1)
816 cache
->saved_regs
[i
] = info
.sigcontext_addr
+ info
.sc_reg_offset
[i
];
823 m68k_sigtramp_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
824 struct frame_id
*this_id
)
826 struct m68k_frame_cache
*cache
=
827 m68k_sigtramp_frame_cache (next_frame
, this_cache
);
829 /* See the end of m68k_push_dummy_call. */
830 *this_id
= frame_id_build (cache
->base
+ 8, frame_pc_unwind (next_frame
));
834 m68k_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
836 int regnum
, int *optimizedp
,
837 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
838 int *realnump
, void *valuep
)
840 /* Make sure we've initialized the cache. */
841 m68k_sigtramp_frame_cache (next_frame
, this_cache
);
843 m68k_frame_prev_register (next_frame
, this_cache
, regnum
,
844 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
847 static const struct frame_unwind m68k_sigtramp_frame_unwind
=
850 m68k_sigtramp_frame_this_id
,
851 m68k_sigtramp_frame_prev_register
854 static const struct frame_unwind
*
855 m68k_sigtramp_frame_sniffer (struct frame_info
*next_frame
)
857 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
860 /* We shouldn't even bother to try if the OSABI didn't register
861 a get_sigtramp_info handler. */
862 if (!gdbarch_tdep (current_gdbarch
)->get_sigtramp_info
)
865 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
866 if (PC_IN_SIGTRAMP (pc
, name
))
867 return &m68k_sigtramp_frame_unwind
;
873 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
875 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
880 static const struct frame_base m68k_frame_base
=
883 m68k_frame_base_address
,
884 m68k_frame_base_address
,
885 m68k_frame_base_address
888 static struct frame_id
889 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
894 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
895 fp
= extract_unsigned_integer (buf
, 4);
897 /* See the end of m68k_push_dummy_call. */
898 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
901 #ifdef USE_PROC_FS /* Target dependent support for /proc */
903 #include <sys/procfs.h>
905 /* Prototypes for supply_gregset etc. */
908 /* The /proc interface divides the target machine's register set up into
909 two different sets, the general register set (gregset) and the floating
910 point register set (fpregset). For each set, there is an ioctl to get
911 the current register set and another ioctl to set the current values.
913 The actual structure passed through the ioctl interface is, of course,
914 naturally machine dependent, and is different for each set of registers.
915 For the m68k for example, the general register set is typically defined
918 typedef int gregset_t[18];
924 and the floating point set by:
926 typedef struct fpregset {
930 int f_fpregs[8][3]; (8 regs, 96 bits each)
933 These routines provide the packing and unpacking of gregset_t and
934 fpregset_t formatted data.
938 /* Atari SVR4 has R_SR but not R_PS */
940 #if !defined (R_PS) && defined (R_SR)
944 /* Given a pointer to a general register set in /proc format (gregset_t *),
945 unpack the register contents and supply them as gdb's idea of the current
949 supply_gregset (gregset_t
*gregsetp
)
952 register greg_t
*regp
= (greg_t
*) gregsetp
;
954 for (regi
= 0; regi
< R_PC
; regi
++)
956 supply_register (regi
, (char *) (regp
+ regi
));
958 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
959 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
963 fill_gregset (gregset_t
*gregsetp
, int regno
)
966 register greg_t
*regp
= (greg_t
*) gregsetp
;
968 for (regi
= 0; regi
< R_PC
; regi
++)
970 if (regno
== -1 || regno
== regi
)
971 regcache_collect (regi
, regp
+ regi
);
973 if (regno
== -1 || regno
== PS_REGNUM
)
974 regcache_collect (PS_REGNUM
, regp
+ R_PS
);
975 if (regno
== -1 || regno
== PC_REGNUM
)
976 regcache_collect (PC_REGNUM
, regp
+ R_PC
);
979 #if defined (FP0_REGNUM)
981 /* Given a pointer to a floating point register set in /proc format
982 (fpregset_t *), unpack the register contents and supply them as gdb's
983 idea of the current floating point register values. */
986 supply_fpregset (fpregset_t
*fpregsetp
)
991 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
993 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
994 supply_register (regi
, from
);
996 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
997 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
998 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
1001 /* Given a pointer to a floating point register set in /proc format
1002 (fpregset_t *), update the register specified by REGNO from gdb's idea
1003 of the current floating point register set. If REGNO is -1, update
1007 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
1011 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
1013 if (regno
== -1 || regno
== regi
)
1014 regcache_collect (regi
, &fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
1016 if (regno
== -1 || regno
== M68K_FPC_REGNUM
)
1017 regcache_collect (M68K_FPC_REGNUM
, &fpregsetp
->f_pcr
);
1018 if (regno
== -1 || regno
== M68K_FPS_REGNUM
)
1019 regcache_collect (M68K_FPS_REGNUM
, &fpregsetp
->f_psr
);
1020 if (regno
== -1 || regno
== M68K_FPI_REGNUM
)
1021 regcache_collect (M68K_FPI_REGNUM
, &fpregsetp
->f_fpiaddr
);
1024 #endif /* defined (FP0_REGNUM) */
1026 #endif /* USE_PROC_FS */
1028 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1029 We expect the first arg to be a pointer to the jmp_buf structure from which
1030 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1031 This routine returns true on success. */
1034 m68k_get_longjmp_target (CORE_ADDR
*pc
)
1037 CORE_ADDR sp
, jb_addr
;
1038 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1040 if (tdep
->jb_pc
< 0)
1042 internal_error (__FILE__
, __LINE__
,
1043 "m68k_get_longjmp_target: not implemented");
1047 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1048 sp
= read_register (SP_REGNUM
);
1050 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1051 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1054 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1056 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1057 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1060 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1065 /* Immediately after a function call, return the saved pc before the frame
1066 is setup. For sun3's, we check for the common case of being inside of a
1067 system call, and if so, we know that Sun pushes the call # on the stack
1068 prior to doing the trap. */
1071 m68k_saved_pc_after_call (struct frame_info
*frame
)
1075 op
= read_memory_unsigned_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
1077 if (op
== SYSCALL_TRAP
)
1078 return read_memory_unsigned_integer (read_register (SP_REGNUM
) + 4, 4);
1080 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
1082 #endif /* SYSCALL_TRAP */
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_function_start_offset (gdbarch
, 0);
1107 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1109 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, m68k_saved_pc_after_call
);
1111 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1113 /* Stack grows down. */
1114 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1115 set_gdbarch_parm_boundary (gdbarch
, 32);
1117 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1118 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1120 set_gdbarch_extract_return_value (gdbarch
, m68k_extract_return_value
);
1121 set_gdbarch_store_return_value (gdbarch
, m68k_store_return_value
);
1122 set_gdbarch_extract_struct_value_address (gdbarch
,
1123 m68k_extract_struct_value_address
);
1124 set_gdbarch_use_struct_convention (gdbarch
, m68k_use_struct_convention
);
1126 set_gdbarch_frameless_function_invocation (gdbarch
,
1127 m68k_frameless_function_invocation
);
1128 set_gdbarch_frame_args_skip (gdbarch
, 8);
1130 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1131 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1132 set_gdbarch_num_regs (gdbarch
, 29);
1133 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1134 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1135 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1136 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1137 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1139 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1142 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1144 #if defined JB_PC && defined JB_ELEMENT_SIZE
1145 tdep
->jb_pc
= JB_PC
;
1146 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1150 tdep
->get_sigtramp_info
= NULL
;
1151 tdep
->struct_return
= pcc_struct_return
;
1153 /* Frame unwinder. */
1154 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1155 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1156 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1158 /* Hook in ABI-specific overrides, if they have been registered. */
1159 gdbarch_init_osabi (info
, gdbarch
);
1161 /* Now we have tuned the configuration, set a few final things,
1162 based on what the OS ABI has told us. */
1164 if (tdep
->jb_pc
>= 0)
1165 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1167 frame_unwind_append_sniffer (gdbarch
, m68k_sigtramp_frame_sniffer
);
1168 frame_unwind_append_sniffer (gdbarch
, m68k_frame_sniffer
);
1175 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1177 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1183 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1186 _initialize_m68k_tdep (void)
1188 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);