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"
37 #include "m68k-tdep.h"
40 #define P_LINKL_FP 0x480e
41 #define P_LINKW_FP 0x4e56
42 #define P_PEA_FP 0x4856
43 #define P_MOVEAL_SP_FP 0x2c4f
44 #define P_ADDAW_SP 0xdefc
45 #define P_ADDAL_SP 0xdffc
46 #define P_SUBQW_SP 0x514f
47 #define P_SUBQL_SP 0x518f
48 #define P_LEA_SP_SP 0x4fef
49 #define P_LEA_PC_A5 0x4bfb0170
50 #define P_FMOVEMX_SP 0xf227
51 #define P_MOVEL_SP 0x2f00
52 #define P_MOVEML_SP 0x48e7
55 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
56 #define REGISTER_BYTES_NOFP (16*4 + 8)
58 /* Offset from SP to first arg on stack at first instruction of a function */
59 #define SP_ARG0 (1 * 4)
61 #if !defined (BPT_VECTOR)
62 #define BPT_VECTOR 0xf
65 #if !defined (REMOTE_BPT_VECTOR)
66 #define REMOTE_BPT_VECTOR 1
70 /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
71 so m68k_remote_breakpoint_from_pc is currently not used. */
73 static const unsigned char *
74 m68k_remote_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
76 static unsigned char break_insn
[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR
)};
77 *lenptr
= sizeof (break_insn
);
81 static const unsigned char *
82 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
84 static unsigned char break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
85 *lenptr
= sizeof (break_insn
);
91 m68k_register_bytes_ok (long numbytes
)
93 return ((numbytes
== REGISTER_BYTES_FP
)
94 || (numbytes
== REGISTER_BYTES_NOFP
));
97 /* Return the GDB type object for the "standard" data type of data in
98 register N. This should be int for D0-D7, SR, FPCONTROL and
99 FPSTATUS, long double for FP0-FP7, and void pointer for all others
100 (A0-A7, PC, FPIADDR). Note, for registers which contain
101 addresses return pointer to void, not pointer to char, because we
102 don't want to attempt to print the string after printing the
106 m68k_register_type (struct gdbarch
*gdbarch
, int regnum
)
108 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
109 return builtin_type_m68881_ext
;
111 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
112 return builtin_type_void_func_ptr
;
114 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
115 || regnum
== PS_REGNUM
)
116 return builtin_type_int32
;
118 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
119 return builtin_type_void_data_ptr
;
121 return builtin_type_int32
;
124 /* Function: m68k_register_name
125 Returns the name of the standard m68k register regnum. */
128 m68k_register_name (int regnum
)
130 static char *register_names
[] = {
131 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
132 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
134 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
135 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
139 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
140 internal_error (__FILE__
, __LINE__
,
141 "m68k_register_name: illegal register number %d", regnum
);
143 return register_names
[regnum
];
146 /* Index within `registers' of the first byte of the space for
150 m68k_register_byte (int regnum
)
152 if (regnum
>= M68K_FPC_REGNUM
)
153 return (((regnum
- M68K_FPC_REGNUM
) * 4) + 168);
154 else if (regnum
>= FP0_REGNUM
)
155 return (((regnum
- FP0_REGNUM
) * 12) + 72);
160 /* Extract from an array REGBUF containing the (raw) register state, a
161 function return value of TYPE, and copy that, in virtual format,
165 m68k_extract_return_value (struct type
*type
, struct regcache
*regcache
,
168 int len
= TYPE_LENGTH (type
);
169 char buf
[M68K_MAX_REGISTER_SIZE
];
171 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
172 && TYPE_NFIELDS (type
) == 1)
174 m68k_extract_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
180 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
181 memcpy (valbuf
, buf
+ (4 - len
), len
);
185 regcache_raw_read (regcache
, M68K_D0_REGNUM
, buf
);
186 memcpy (valbuf
, buf
+ (8 - len
), len
- 4);
187 regcache_raw_read (regcache
, M68K_D1_REGNUM
,
188 (char *) valbuf
+ (len
- 4));
191 internal_error (__FILE__
, __LINE__
,
192 "Cannot extract return value of %d bytes long.", len
);
195 /* Write into the appropriate registers a function return value stored
196 in VALBUF of type TYPE, given in virtual format. */
199 m68k_store_return_value (struct type
*type
, struct regcache
*regcache
,
202 int len
= TYPE_LENGTH (type
);
204 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
205 && TYPE_NFIELDS (type
) == 1)
207 m68k_store_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
212 regcache_raw_write_part (regcache
, M68K_D0_REGNUM
, 4 - len
, len
, valbuf
);
215 regcache_raw_write_part (regcache
, M68K_D1_REGNUM
, 8 - len
,
217 regcache_raw_write (regcache
, M68K_D0_REGNUM
,
218 (char *) valbuf
+ (len
- 4));
221 internal_error (__FILE__
, __LINE__
,
222 "Cannot store return value of %d bytes long.", len
);
225 /* Extract from REGCACHE, which contains the (raw) register state, the
226 address in which a function should return its structure value, as a
230 m68k_extract_struct_value_address (struct regcache
*regcache
)
234 regcache_cooked_read (regcache
, M68K_D0_REGNUM
, buf
);
235 return extract_unsigned_integer (buf
, 4);
238 /* A function that tells us whether the function invocation represented
239 by fi does not have a frame on the stack associated with it. If it
240 does not, FRAMELESS is set to 1, else 0. */
243 m68k_frameless_function_invocation (struct frame_info
*fi
)
245 if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
248 return frameless_look_for_prologue (fi
);
252 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
255 return strcmp (name
, "_sigcode") == 0;
261 delta68_frame_args_address (struct frame_info
*frame_info
)
263 /* we assume here that the only frameless functions are the system calls
264 or other functions who do not put anything on the stack. */
265 if (get_frame_type (frame_info
) == SIGTRAMP_FRAME
)
266 return get_frame_base (frame_info
) + 12;
267 else if (frameless_look_for_prologue (frame_info
))
269 /* Check for an interrupted system call */
270 if (get_next_frame (frame_info
) && (get_frame_type (get_next_frame (frame_info
)) == SIGTRAMP_FRAME
))
271 return get_frame_base (get_next_frame (frame_info
)) + 16;
273 return get_frame_base (frame_info
) + 4;
276 return get_frame_base (frame_info
);
280 delta68_frame_saved_pc (struct frame_info
*frame_info
)
282 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info
)
287 delta68_frame_num_args (struct frame_info
*fi
)
290 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
291 int insn
= read_memory_unsigned_integer (pc
, 2);
293 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
294 val
= read_memory_integer (pc
+ 2, 2);
295 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
296 || (insn
& 0170777) == 0050117) /* addqw */
298 val
= (insn
>> 9) & 7;
302 else if (insn
== 0157774) /* addal #WW, sp */
303 val
= read_memory_integer (pc
+ 2, 4);
309 m68k_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
310 struct regcache
*regcache
, CORE_ADDR bp_addr
, int nargs
,
311 struct value
**args
, CORE_ADDR sp
, int struct_return
,
312 CORE_ADDR struct_addr
)
317 /* Push arguments in reverse order. */
318 for (i
= nargs
- 1; i
>= 0; i
--)
320 int len
= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args
[i
]));
321 int container_len
= (len
+ 3) & ~3;
322 int offset
= container_len
- len
;
325 write_memory (sp
+ offset
, VALUE_CONTENTS_ALL (args
[i
]), len
);
328 /* Push value address. */
332 store_unsigned_integer (buf
, 4, struct_addr
);
333 write_memory (sp
, buf
, 4);
336 /* Store return address. */
338 store_unsigned_integer (buf
, 4, bp_addr
);
339 write_memory (sp
, buf
, 4);
341 /* Finally, update the stack pointer... */
342 store_unsigned_integer (buf
, 4, sp
);
343 regcache_cooked_write (regcache
, M68K_SP_REGNUM
, buf
);
345 /* ...and fake a frame pointer. */
346 regcache_cooked_write (regcache
, M68K_FP_REGNUM
, buf
);
348 /* DWARF2/GCC uses the stack address *before* the function call as a
353 struct m68k_frame_cache
360 /* Saved registers. */
361 CORE_ADDR saved_regs
[M68K_NUM_REGS
];
364 /* Stack space reserved for local variables. */
368 /* Allocate and initialize a frame cache. */
370 static struct m68k_frame_cache
*
371 m68k_alloc_frame_cache (void)
373 struct m68k_frame_cache
*cache
;
376 cache
= FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache
);
380 cache
->sp_offset
= -4;
383 /* Saved registers. We initialize these to -1 since zero is a valid
384 offset (that's where %fp is supposed to be stored). */
385 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
386 cache
->saved_regs
[i
] = -1;
388 /* Frameless until proven otherwise. */
394 /* Check whether PC points at a code that sets up a new stack frame.
395 If so, it updates CACHE and returns the address of the first
396 instruction after the sequence that sets removes the "hidden"
397 argument from the stack or CURRENT_PC, whichever is smaller.
398 Otherwise, return PC. */
401 m68k_analyze_frame_setup (CORE_ADDR pc
, CORE_ADDR current_pc
,
402 struct m68k_frame_cache
*cache
)
406 if (pc
>= current_pc
)
409 op
= read_memory_unsigned_integer (pc
, 2);
411 if (op
== P_LINKW_FP
|| op
== P_LINKL_FP
|| op
== P_PEA_FP
)
413 cache
->saved_regs
[M68K_FP_REGNUM
] = 0;
414 cache
->sp_offset
+= 4;
415 if (op
== P_LINKW_FP
)
417 /* link.w %fp, #-N */
418 /* link.w %fp, #0; adda.l #-N, %sp */
419 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
421 if (pc
+ 4 < current_pc
&& cache
->locals
== 0)
423 op
= read_memory_unsigned_integer (pc
+ 4, 2);
424 if (op
== P_ADDAL_SP
)
426 cache
->locals
= read_memory_integer (pc
+ 6, 4);
433 else if (op
== P_LINKL_FP
)
435 /* link.l %fp, #-N */
436 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
441 /* pea (%fp); movea.l %sp, %fp */
444 if (pc
+ 2 < current_pc
)
446 op
= read_memory_unsigned_integer (pc
+ 2, 2);
448 if (op
== P_MOVEAL_SP_FP
)
450 /* move.l %sp, %fp */
458 else if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
460 /* subq.[wl] #N,%sp */
461 /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */
462 cache
->locals
= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
463 if (pc
+ 2 < current_pc
)
465 op
= read_memory_unsigned_integer (pc
+ 2, 2);
466 if ((op
& 0170777) == P_SUBQW_SP
|| (op
& 0170777) == P_SUBQL_SP
)
468 cache
->locals
+= (op
& 07000) == 0 ? 8 : (op
& 07000) >> 9;
474 else if (op
== P_ADDAW_SP
|| op
== P_LEA_SP_SP
)
477 /* lea (-N,%sp),%sp */
478 cache
->locals
= -read_memory_integer (pc
+ 2, 2);
481 else if (op
== P_ADDAL_SP
)
484 cache
->locals
= -read_memory_integer (pc
+ 2, 4);
491 /* Check whether PC points at code that saves registers on the stack.
492 If so, it updates CACHE and returns the address of the first
493 instruction after the register saves or CURRENT_PC, whichever is
494 smaller. Otherwise, return PC. */
497 m68k_analyze_register_saves (CORE_ADDR pc
, CORE_ADDR current_pc
,
498 struct m68k_frame_cache
*cache
)
500 if (cache
->locals
>= 0)
506 offset
= -4 - cache
->locals
;
507 while (pc
< current_pc
)
509 op
= read_memory_unsigned_integer (pc
, 2);
510 if (op
== P_FMOVEMX_SP
)
512 /* fmovem.x REGS,-(%sp) */
513 op
= read_memory_unsigned_integer (pc
+ 2, 2);
514 if ((op
& 0xff00) == 0xe000)
517 for (i
= 0; i
< 16; i
++, mask
>>= 1)
521 cache
->saved_regs
[i
+ M68K_FP0_REGNUM
] = offset
;
530 else if ((op
& 0170677) == P_MOVEL_SP
)
532 /* move.l %R,-(%sp) */
533 regno
= ((op
& 07000) >> 9) | ((op
& 0100) >> 3);
534 cache
->saved_regs
[regno
] = offset
;
538 else if (op
== P_MOVEML_SP
)
540 /* movem.l REGS,-(%sp) */
541 mask
= read_memory_unsigned_integer (pc
+ 2, 2);
542 for (i
= 0; i
< 16; i
++, mask
>>= 1)
546 cache
->saved_regs
[15 - i
] = offset
;
561 /* Do a full analysis of the prologue at PC and update CACHE
562 accordingly. Bail out early if CURRENT_PC is reached. Return the
563 address where the analysis stopped.
565 We handle all cases that can be generated by gcc.
567 For allocating a stack frame:
571 pea (%fp); move.l %sp,%fp
572 link.w %a6,#0; add.l #-N,%sp
575 subq.w #8,%sp; subq.w #N-8,%sp
580 For saving registers:
584 move.l R1,-(%sp); move.l R2,-(%sp)
587 For setting up the PIC register:
594 m68k_analyze_prologue (CORE_ADDR pc
, CORE_ADDR current_pc
,
595 struct m68k_frame_cache
*cache
)
599 pc
= m68k_analyze_frame_setup (pc
, current_pc
, cache
);
600 pc
= m68k_analyze_register_saves (pc
, current_pc
, cache
);
601 if (pc
>= current_pc
)
604 /* Check for GOT setup. */
605 op
= read_memory_unsigned_integer (pc
, 4);
606 if (op
== P_LEA_PC_A5
)
608 /* lea (%pc,N),%a5 */
615 /* Return PC of first real instruction. */
618 m68k_skip_prologue (CORE_ADDR start_pc
)
620 struct m68k_frame_cache cache
;
625 pc
= m68k_analyze_prologue (start_pc
, (CORE_ADDR
) -1, &cache
);
626 if (cache
.locals
< 0)
632 m68k_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
636 frame_unwind_register (next_frame
, PC_REGNUM
, buf
);
637 return extract_typed_address (buf
, builtin_type_void_func_ptr
);
642 static struct m68k_frame_cache
*
643 m68k_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
645 struct m68k_frame_cache
*cache
;
652 cache
= m68k_alloc_frame_cache ();
655 /* In principle, for normal frames, %fp holds the frame pointer,
656 which holds the base address for the current stack frame.
657 However, for functions that don't need it, the frame pointer is
658 optional. For these "frameless" functions the frame pointer is
659 actually the frame pointer of the calling frame. Signal
660 trampolines are just a special case of a "frameless" function.
661 They (usually) share their frame pointer with the frame that was
662 in progress when the signal occurred. */
664 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
665 cache
->base
= extract_unsigned_integer (buf
, 4);
666 if (cache
->base
== 0)
669 /* For normal frames, %pc is stored at 4(%fp). */
670 cache
->saved_regs
[M68K_PC_REGNUM
] = 4;
672 cache
->pc
= frame_func_unwind (next_frame
);
674 m68k_analyze_prologue (cache
->pc
, frame_pc_unwind (next_frame
), cache
);
676 if (cache
->locals
< 0)
678 /* We didn't find a valid frame, which means that CACHE->base
679 currently holds the frame pointer for our calling frame. If
680 we're at the start of a function, or somewhere half-way its
681 prologue, the function's frame probably hasn't been fully
682 setup yet. Try to reconstruct the base address for the stack
683 frame by looking at the stack pointer. For truly "frameless"
684 functions this might work too. */
686 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
687 cache
->base
= extract_unsigned_integer (buf
, 4) + cache
->sp_offset
;
690 /* Now that we have the base address for the stack frame we can
691 calculate the value of %sp in the calling frame. */
692 cache
->saved_sp
= cache
->base
+ 8;
694 /* Adjust all the saved registers such that they contain addresses
695 instead of offsets. */
696 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
697 if (cache
->saved_regs
[i
] != -1)
698 cache
->saved_regs
[i
] += cache
->base
;
704 m68k_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
705 struct frame_id
*this_id
)
707 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
709 /* This marks the outermost frame. */
710 if (cache
->base
== 0)
713 /* See the end of m68k_push_dummy_call. */
714 *this_id
= frame_id_build (cache
->base
+ 8, cache
->pc
);
718 m68k_frame_prev_register (struct frame_info
*next_frame
, void **this_cache
,
719 int regnum
, int *optimizedp
,
720 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
721 int *realnump
, void *valuep
)
723 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
725 gdb_assert (regnum
>= 0);
727 if (regnum
== M68K_SP_REGNUM
&& cache
->saved_sp
)
735 /* Store the value. */
736 store_unsigned_integer (valuep
, 4, cache
->saved_sp
);
741 if (regnum
< M68K_NUM_REGS
&& cache
->saved_regs
[regnum
] != -1)
744 *lvalp
= lval_memory
;
745 *addrp
= cache
->saved_regs
[regnum
];
749 /* Read the value in from memory. */
750 read_memory (*addrp
, valuep
,
751 register_size (current_gdbarch
, regnum
));
756 frame_register_unwind (next_frame
, regnum
,
757 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
760 static const struct frame_unwind m68k_frame_unwind
=
764 m68k_frame_prev_register
767 static const struct frame_unwind
*
768 m68k_frame_p (CORE_ADDR pc
)
770 return &m68k_frame_unwind
;
773 /* Signal trampolines. */
775 static struct m68k_frame_cache
*
776 m68k_sigtramp_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
778 struct m68k_frame_cache
*cache
;
779 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
780 struct m68k_sigtramp_info info
;
787 cache
= m68k_alloc_frame_cache ();
789 frame_unwind_register (next_frame
, M68K_SP_REGNUM
, buf
);
790 cache
->base
= extract_unsigned_integer (buf
, 4) - 4;
792 info
= tdep
->get_sigtramp_info (next_frame
);
794 for (i
= 0; i
< M68K_NUM_REGS
; i
++)
795 if (info
.sc_reg_offset
[i
] != -1)
796 cache
->saved_regs
[i
] = info
.sigcontext_addr
+ info
.sc_reg_offset
[i
];
803 m68k_sigtramp_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
804 struct frame_id
*this_id
)
806 struct m68k_frame_cache
*cache
=
807 m68k_sigtramp_frame_cache (next_frame
, this_cache
);
809 /* See the end of m68k_push_dummy_call. */
810 *this_id
= frame_id_build (cache
->base
+ 8, frame_pc_unwind (next_frame
));
814 m68k_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
816 int regnum
, int *optimizedp
,
817 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
818 int *realnump
, void *valuep
)
820 /* Make sure we've initialized the cache. */
821 m68k_sigtramp_frame_cache (next_frame
, this_cache
);
823 m68k_frame_prev_register (next_frame
, this_cache
, regnum
,
824 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
827 static const struct frame_unwind m68k_sigtramp_frame_unwind
=
830 m68k_sigtramp_frame_this_id
,
831 m68k_sigtramp_frame_prev_register
834 static const struct frame_unwind
*
835 m68k_sigtramp_frame_p (CORE_ADDR pc
)
839 /* We shouldn't even bother to try if the OSABI didn't register
840 a get_sigtramp_info handler. */
841 if (!gdbarch_tdep (current_gdbarch
)->get_sigtramp_info
)
844 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
845 if (PC_IN_SIGTRAMP (pc
, name
))
846 return &m68k_sigtramp_frame_unwind
;
852 m68k_frame_base_address (struct frame_info
*next_frame
, void **this_cache
)
854 struct m68k_frame_cache
*cache
= m68k_frame_cache (next_frame
, this_cache
);
859 static const struct frame_base m68k_frame_base
=
862 m68k_frame_base_address
,
863 m68k_frame_base_address
,
864 m68k_frame_base_address
867 static struct frame_id
868 m68k_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
873 frame_unwind_register (next_frame
, M68K_FP_REGNUM
, buf
);
874 fp
= extract_unsigned_integer (buf
, 4);
876 /* See the end of m68k_push_dummy_call. */
877 return frame_id_build (fp
+ 8, frame_pc_unwind (next_frame
));
880 #ifdef USE_PROC_FS /* Target dependent support for /proc */
882 #include <sys/procfs.h>
884 /* Prototypes for supply_gregset etc. */
887 /* The /proc interface divides the target machine's register set up into
888 two different sets, the general register set (gregset) and the floating
889 point register set (fpregset). For each set, there is an ioctl to get
890 the current register set and another ioctl to set the current values.
892 The actual structure passed through the ioctl interface is, of course,
893 naturally machine dependent, and is different for each set of registers.
894 For the m68k for example, the general register set is typically defined
897 typedef int gregset_t[18];
903 and the floating point set by:
905 typedef struct fpregset {
909 int f_fpregs[8][3]; (8 regs, 96 bits each)
912 These routines provide the packing and unpacking of gregset_t and
913 fpregset_t formatted data.
917 /* Atari SVR4 has R_SR but not R_PS */
919 #if !defined (R_PS) && defined (R_SR)
923 /* Given a pointer to a general register set in /proc format (gregset_t *),
924 unpack the register contents and supply them as gdb's idea of the current
928 supply_gregset (gregset_t
*gregsetp
)
931 register greg_t
*regp
= (greg_t
*) gregsetp
;
933 for (regi
= 0; regi
< R_PC
; regi
++)
935 supply_register (regi
, (char *) (regp
+ regi
));
937 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
938 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
942 fill_gregset (gregset_t
*gregsetp
, int regno
)
945 register greg_t
*regp
= (greg_t
*) gregsetp
;
947 for (regi
= 0; regi
< R_PC
; regi
++)
949 if (regno
== -1 || regno
== regi
)
950 regcache_collect (regi
, regp
+ regi
);
952 if (regno
== -1 || regno
== PS_REGNUM
)
953 regcache_collect (PS_REGNUM
, regp
+ R_PS
);
954 if (regno
== -1 || regno
== PC_REGNUM
)
955 regcache_collect (PC_REGNUM
, regp
+ R_PC
);
958 #if defined (FP0_REGNUM)
960 /* Given a pointer to a floating point register set in /proc format
961 (fpregset_t *), unpack the register contents and supply them as gdb's
962 idea of the current floating point register values. */
965 supply_fpregset (fpregset_t
*fpregsetp
)
970 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
972 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
973 supply_register (regi
, from
);
975 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
976 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
977 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
980 /* Given a pointer to a floating point register set in /proc format
981 (fpregset_t *), update the register specified by REGNO from gdb's idea
982 of the current floating point register set. If REGNO is -1, update
986 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
990 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
992 if (regno
== -1 || regno
== regi
)
993 regcache_collect (regi
, &fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
995 if (regno
== -1 || regno
== M68K_FPC_REGNUM
)
996 regcache_collect (M68K_FPC_REGNUM
, &fpregsetp
->f_pcr
);
997 if (regno
== -1 || regno
== M68K_FPS_REGNUM
)
998 regcache_collect (M68K_FPS_REGNUM
, &fpregsetp
->f_psr
);
999 if (regno
== -1 || regno
== M68K_FPI_REGNUM
)
1000 regcache_collect (M68K_FPI_REGNUM
, &fpregsetp
->f_fpiaddr
);
1003 #endif /* defined (FP0_REGNUM) */
1005 #endif /* USE_PROC_FS */
1007 /* Figure out where the longjmp will land. Slurp the args out of the stack.
1008 We expect the first arg to be a pointer to the jmp_buf structure from which
1009 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
1010 This routine returns true on success. */
1013 m68k_get_longjmp_target (CORE_ADDR
*pc
)
1016 CORE_ADDR sp
, jb_addr
;
1017 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1019 if (tdep
->jb_pc
< 0)
1021 internal_error (__FILE__
, __LINE__
,
1022 "m68k_get_longjmp_target: not implemented");
1026 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1027 sp
= read_register (SP_REGNUM
);
1029 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
1030 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1033 jb_addr
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1035 if (target_read_memory (jb_addr
+ tdep
->jb_pc
* tdep
->jb_elt_size
, buf
,
1036 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
1039 *pc
= extract_unsigned_integer (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1044 /* Immediately after a function call, return the saved pc before the frame
1045 is setup. For sun3's, we check for the common case of being inside of a
1046 system call, and if so, we know that Sun pushes the call # on the stack
1047 prior to doing the trap. */
1050 m68k_saved_pc_after_call (struct frame_info
*frame
)
1054 op
= read_memory_unsigned_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
1056 if (op
== SYSCALL_TRAP
)
1057 return read_memory_unsigned_integer (read_register (SP_REGNUM
) + 4, 4);
1059 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
1061 #endif /* SYSCALL_TRAP */
1063 /* Function: m68k_gdbarch_init
1064 Initializer function for the m68k gdbarch vector.
1065 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
1067 static struct gdbarch
*
1068 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1070 struct gdbarch_tdep
*tdep
= NULL
;
1071 struct gdbarch
*gdbarch
;
1073 /* find a candidate among the list of pre-declared architectures. */
1074 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1076 return (arches
->gdbarch
);
1078 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1079 gdbarch
= gdbarch_alloc (&info
, tdep
);
1081 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
1082 set_gdbarch_long_double_bit (gdbarch
, 96);
1084 set_gdbarch_function_start_offset (gdbarch
, 0);
1086 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
1088 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, m68k_saved_pc_after_call
);
1090 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1092 /* Stack grows down. */
1093 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1094 set_gdbarch_parm_boundary (gdbarch
, 32);
1096 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1097 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1099 set_gdbarch_extract_return_value (gdbarch
, m68k_extract_return_value
);
1100 set_gdbarch_store_return_value (gdbarch
, m68k_store_return_value
);
1101 set_gdbarch_extract_struct_value_address (gdbarch
,
1102 m68k_extract_struct_value_address
);
1104 set_gdbarch_frameless_function_invocation (gdbarch
,
1105 m68k_frameless_function_invocation
);
1106 set_gdbarch_frame_args_skip (gdbarch
, 8);
1108 set_gdbarch_register_type (gdbarch
, m68k_register_type
);
1109 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1110 set_gdbarch_num_regs (gdbarch
, 29);
1111 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1112 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1113 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1114 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1115 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1117 set_gdbarch_push_dummy_call (gdbarch
, m68k_push_dummy_call
);
1120 set_gdbarch_print_insn (gdbarch
, print_insn_m68k
);
1122 #if defined JB_PC && defined JB_ELEMENT_SIZE
1123 tdep
->jb_pc
= JB_PC
;
1124 tdep
->jb_elt_size
= JB_ELEMENT_SIZE
;
1128 tdep
->get_sigtramp_info
= NULL
;
1130 /* Frame unwinder. */
1131 set_gdbarch_unwind_dummy_id (gdbarch
, m68k_unwind_dummy_id
);
1132 set_gdbarch_unwind_pc (gdbarch
, m68k_unwind_pc
);
1133 frame_base_set_default (gdbarch
, &m68k_frame_base
);
1135 /* Hook in ABI-specific overrides, if they have been registered. */
1136 gdbarch_init_osabi (info
, gdbarch
);
1138 /* Now we have tuned the configuration, set a few final things,
1139 based on what the OS ABI has told us. */
1141 if (tdep
->jb_pc
>= 0)
1142 set_gdbarch_get_longjmp_target (gdbarch
, m68k_get_longjmp_target
);
1144 frame_unwind_append_predicate (gdbarch
, m68k_sigtramp_frame_p
);
1145 frame_unwind_append_predicate (gdbarch
, m68k_frame_p
);
1152 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1154 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1160 extern initialize_file_ftype _initialize_m68k_tdep
; /* -Wmissing-prototypes */
1163 _initialize_m68k_tdep (void)
1165 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);