1 /* Target dependent code for the Motorola 68000 series.
2 Copyright (C) 1990, 1992 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
29 /* The only reason this is here is the tm-altos.h reference below. It
30 was moved back here from tm-m68k.h. FIXME? */
33 altos_skip_prologue (pc
)
36 register int op
= read_memory_integer (pc
, 2);
38 pc
+= 4; /* Skip link #word */
39 else if (op
== 0044016)
40 pc
+= 6; /* Skip link #long */
41 /* Not sure why branches are here. */
42 /* From tm-isi.h, tm-altos.h */
43 else if (op
== 0060000)
44 pc
+= 4; /* Skip bra #word */
45 else if (op
== 00600377)
46 pc
+= 6; /* skip bra #long */
47 else if ((op
& 0177400) == 0060000)
48 pc
+= 2; /* skip bra #char */
52 /* The only reason this is here is the tm-isi.h reference below. It
53 was moved back here from tm-m68k.h. FIXME? */
56 isi_skip_prologue (pc
)
59 register int op
= read_memory_integer (pc
, 2);
61 pc
+= 4; /* Skip link #word */
62 else if (op
== 0044016)
63 pc
+= 6; /* Skip link #long */
64 /* Not sure why branches are here. */
65 /* From tm-isi.h, tm-altos.h */
66 else if (op
== 0060000)
67 pc
+= 4; /* Skip bra #word */
68 else if (op
== 00600377)
69 pc
+= 6; /* skip bra #long */
70 else if ((op
& 0177400) == 0060000)
71 pc
+= 2; /* skip bra #char */
76 /* Push an empty stack frame, to record the current PC, etc. */
79 m68k_push_dummy_frame ()
81 register CORE_ADDR sp
= read_register (SP_REGNUM
);
85 sp
= push_word (sp
, read_register (PC_REGNUM
));
86 sp
= push_word (sp
, read_register (FP_REGNUM
));
87 write_register (FP_REGNUM
, sp
);
89 /* Always save the floating-point registers, whether they exist on
90 this target or not. */
91 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
93 read_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
94 sp
= push_bytes (sp
, raw_buffer
, 12);
97 for (regnum
= FP_REGNUM
- 1; regnum
>= 0; regnum
--)
99 sp
= push_word (sp
, read_register (regnum
));
101 sp
= push_word (sp
, read_register (PS_REGNUM
));
102 write_register (SP_REGNUM
, sp
);
105 /* Discard from the stack the innermost frame,
106 restoring all saved registers. */
111 register struct frame_info
*frame
= get_current_frame ();
112 register CORE_ADDR fp
;
114 struct frame_saved_regs fsr
;
117 fp
= FRAME_FP (frame
);
118 get_frame_saved_regs (frame
, &fsr
);
119 for (regnum
= FP0_REGNUM
+ 7 ; regnum
>= FP0_REGNUM
; regnum
--)
121 if (fsr
.regs
[regnum
])
123 read_memory (fsr
.regs
[regnum
], raw_buffer
, 12);
124 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
127 for (regnum
= FP_REGNUM
- 1 ; regnum
>= 0 ; regnum
--)
129 if (fsr
.regs
[regnum
])
131 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
134 if (fsr
.regs
[PS_REGNUM
])
136 write_register (PS_REGNUM
, read_memory_integer (fsr
.regs
[PS_REGNUM
], 4));
138 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
139 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
140 write_register (SP_REGNUM
, fp
+ 8);
141 flush_cached_frames ();
145 /* Given an ip value corresponding to the start of a function,
146 return the ip of the first instruction after the function
147 prologue. This is the generic m68k support. Machines which
148 require something different can override the SKIP_PROLOGUE
149 macro to point elsewhere.
151 Some instructions which typically may appear in a function
154 A link instruction, word form:
156 link.w %a6,&0 4e56 XXXX
158 A link instruction, long form:
160 link.l %fp,&F%1 480e XXXX XXXX
162 A movm instruction to preserve integer regs:
164 movm.l &M%1,(4,%sp) 48ef XXXX XXXX
166 A fmovm instruction to preserve float regs:
168 fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX
170 Some profiling setup code (FIXME, not recognized yet):
172 lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX
173 bsr _mcount 61ff XXXX XXXX
177 #define P_LINK_L 0x480e
178 #define P_LINK_W 0x4e56
179 #define P_MOV_L 0x207c
182 #define P_LEA_L 0x43fb
183 #define P_MOVM_L 0x48ef
184 #define P_FMOVM 0xf237
185 #define P_TRAP 0x4e40
188 m68k_skip_prologue (ip
)
191 register CORE_ADDR limit
;
192 struct symtab_and_line sal
;
195 /* Find out if there is a known limit for the extent of the prologue.
196 If so, ensure we don't go past it. If not, assume "infinity". */
198 sal
= find_pc_line (ip
, 0);
199 limit
= (sal
.end
) ? sal
.end
: (CORE_ADDR
) ~0;
203 op
= read_memory_integer (ip
, 2);
208 ip
+= 4; /* Skip link.w */
210 else if (op
== 0x4856)
211 ip
+= 2; /* Skip pea %fp */
212 else if (op
== 0x2c4f)
213 ip
+= 2; /* Skip move.l %sp, %fp */
214 else if (op
== P_LINK_L
)
216 ip
+= 6; /* Skip link.l */
218 else if (op
== P_MOVM_L
)
220 ip
+= 6; /* Skip movm.l */
222 else if (op
== P_FMOVM
)
224 ip
+= 10; /* Skip fmovm */
228 break; /* Found unknown code, bail out. */
235 m68k_find_saved_regs (frame_info
, saved_regs
)
236 struct frame_info
*frame_info
;
237 struct frame_saved_regs
*saved_regs
;
240 register int regmask
;
241 register CORE_ADDR next_addr
;
242 register CORE_ADDR pc
;
244 /* First possible address for a pc in a call dummy for this frame. */
245 CORE_ADDR possible_call_dummy_start
=
246 (frame_info
)->frame
- CALL_DUMMY_LENGTH
- FP_REGNUM
*4 - 4 - 8*12;
249 memset (saved_regs
, 0, sizeof (*saved_regs
));
250 if ((frame_info
)->pc
>= possible_call_dummy_start
251 && (frame_info
)->pc
<= (frame_info
)->frame
)
254 /* It is a call dummy. We could just stop now, since we know
255 what the call dummy saves and where. But this code proceeds
256 to parse the "prologue" which is part of the call dummy.
257 This is needlessly complex and confusing. FIXME. */
259 next_addr
= (frame_info
)->frame
;
260 pc
= possible_call_dummy_start
;
264 pc
= get_pc_function_start ((frame_info
)->pc
);
266 if (0x4856 == read_memory_integer (pc
, 2)
267 && 0x2c4f == read_memory_integer (pc
+ 2, 2))
274 next_addr
= frame_info
->frame
;
276 else if (044016 == read_memory_integer (pc
, 2))
278 /* Find the address above the saved
279 regs using the amount of storage from the link instruction. */
280 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 2, 4), pc
+=4;
281 else if (047126 == read_memory_integer (pc
, 2))
283 /* Find the address above the saved
284 regs using the amount of storage from the link instruction. */
285 next_addr
= (frame_info
)->frame
+ read_memory_integer (pc
+= 2, 2), pc
+=2;
288 /* If have an addal #-n, sp next, adjust next_addr. */
289 if ((0177777 & read_memory_integer (pc
, 2)) == 0157774)
290 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
292 regmask
= read_memory_integer (pc
+ 2, 2);
294 /* Here can come an fmovem. Check for it. */
295 nextinsn
= 0xffff & read_memory_integer (pc
, 2);
296 if (0xf227 == nextinsn
297 && (regmask
& 0xff00) == 0xe000)
298 { pc
+= 4; /* Regmask's low bit is for register fp7, the first pushed */
299 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--, regmask
>>= 1)
301 saved_regs
->regs
[regnum
] = (next_addr
-= 12);
302 regmask
= read_memory_integer (pc
+ 2, 2); }
304 /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */
305 if (0044327 == read_memory_integer (pc
, 2))
306 { pc
+= 4; /* Regmask's low bit is for register 0, the first written */
307 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
309 saved_regs
->regs
[regnum
] = (next_addr
+= 4) - 4; }
310 else if (0044347 == read_memory_integer (pc
, 2))
312 pc
+= 4; /* Regmask's low bit is for register 15, the first pushed */
313 for (regnum
= 15; regnum
>= 0; regnum
--, regmask
>>= 1)
315 saved_regs
->regs
[regnum
] = (next_addr
-= 4);
317 else if (0x2f00 == (0xfff0 & read_memory_integer (pc
, 2)))
319 regnum
= 0xf & read_memory_integer (pc
, 2); pc
+= 2;
320 saved_regs
->regs
[regnum
] = (next_addr
-= 4);
321 /* gcc, at least, may use a pair of movel instructions when saving
322 exactly 2 registers. */
323 if (0x2f00 == (0xfff0 & read_memory_integer (pc
, 2)))
325 regnum
= 0xf & read_memory_integer (pc
, 2);
327 saved_regs
->regs
[regnum
] = (next_addr
-= 4);
331 /* fmovemx to index of sp may follow. */
332 regmask
= read_memory_integer (pc
+ 2, 2);
333 nextinsn
= 0xffff & read_memory_integer (pc
, 2);
334 if (0xf236 == nextinsn
335 && (regmask
& 0xff00) == 0xf000)
336 { pc
+= 10; /* Regmask's low bit is for register fp0, the first written */
337 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--, regmask
>>= 1)
339 saved_regs
->regs
[regnum
] = (next_addr
+= 12) - 12;
340 regmask
= read_memory_integer (pc
+ 2, 2); }
342 /* clrw -(sp); movw ccr,-(sp) may follow. */
343 if (0x426742e7 == read_memory_integer (pc
, 4))
344 saved_regs
->regs
[PS_REGNUM
] = (next_addr
-= 4);
346 saved_regs
->regs
[SP_REGNUM
] = (frame_info
)->frame
+ 8;
347 saved_regs
->regs
[FP_REGNUM
] = (frame_info
)->frame
;
348 saved_regs
->regs
[PC_REGNUM
] = (frame_info
)->frame
+ 4;
349 #ifdef SIG_SP_FP_OFFSET
350 /* Adjust saved SP_REGNUM for fake _sigtramp frames. */
351 if (frame_info
->signal_handler_caller
&& frame_info
->next
)
352 saved_regs
->regs
[SP_REGNUM
] = frame_info
->next
->frame
+ SIG_SP_FP_OFFSET
;
357 #ifdef USE_PROC_FS /* Target dependent support for /proc */
359 #include <sys/procfs.h>
361 /* The /proc interface divides the target machine's register set up into
362 two different sets, the general register set (gregset) and the floating
363 point register set (fpregset). For each set, there is an ioctl to get
364 the current register set and another ioctl to set the current values.
366 The actual structure passed through the ioctl interface is, of course,
367 naturally machine dependent, and is different for each set of registers.
368 For the m68k for example, the general register set is typically defined
371 typedef int gregset_t[18];
377 and the floating point set by:
379 typedef struct fpregset {
383 int f_fpregs[8][3]; (8 regs, 96 bits each)
386 These routines provide the packing and unpacking of gregset_t and
387 fpregset_t formatted data.
391 /* Atari SVR4 has R_SR but not R_PS */
393 #if !defined (R_PS) && defined (R_SR)
397 /* Given a pointer to a general register set in /proc format (gregset_t *),
398 unpack the register contents and supply them as gdb's idea of the current
402 supply_gregset (gregsetp
)
406 register greg_t
*regp
= (greg_t
*) gregsetp
;
408 for (regi
= 0 ; regi
< R_PC
; regi
++)
410 supply_register (regi
, (char *) (regp
+ regi
));
412 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
413 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
417 fill_gregset (gregsetp
, regno
)
422 register greg_t
*regp
= (greg_t
*) gregsetp
;
424 for (regi
= 0 ; regi
< R_PC
; regi
++)
426 if ((regno
== -1) || (regno
== regi
))
428 *(regp
+ regi
) = *(int *) ®isters
[REGISTER_BYTE (regi
)];
431 if ((regno
== -1) || (regno
== PS_REGNUM
))
433 *(regp
+ R_PS
) = *(int *) ®isters
[REGISTER_BYTE (PS_REGNUM
)];
435 if ((regno
== -1) || (regno
== PC_REGNUM
))
437 *(regp
+ R_PC
) = *(int *) ®isters
[REGISTER_BYTE (PC_REGNUM
)];
441 #if defined (FP0_REGNUM)
443 /* Given a pointer to a floating point register set in /proc format
444 (fpregset_t *), unpack the register contents and supply them as gdb's
445 idea of the current floating point register values. */
448 supply_fpregset (fpregsetp
)
449 fpregset_t
*fpregsetp
;
454 for (regi
= FP0_REGNUM
; regi
< FPC_REGNUM
; regi
++)
456 from
= (char *) &(fpregsetp
-> f_fpregs
[regi
-FP0_REGNUM
][0]);
457 supply_register (regi
, from
);
459 supply_register (FPC_REGNUM
, (char *) &(fpregsetp
-> f_pcr
));
460 supply_register (FPS_REGNUM
, (char *) &(fpregsetp
-> f_psr
));
461 supply_register (FPI_REGNUM
, (char *) &(fpregsetp
-> f_fpiaddr
));
464 /* Given a pointer to a floating point register set in /proc format
465 (fpregset_t *), update the register specified by REGNO from gdb's idea
466 of the current floating point register set. If REGNO is -1, update
470 fill_fpregset (fpregsetp
, regno
)
471 fpregset_t
*fpregsetp
;
478 for (regi
= FP0_REGNUM
; regi
< FPC_REGNUM
; regi
++)
480 if ((regno
== -1) || (regno
== regi
))
482 from
= (char *) ®isters
[REGISTER_BYTE (regi
)];
483 to
= (char *) &(fpregsetp
-> f_fpregs
[regi
-FP0_REGNUM
][0]);
484 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
487 if ((regno
== -1) || (regno
== FPC_REGNUM
))
489 fpregsetp
-> f_pcr
= *(int *) ®isters
[REGISTER_BYTE (FPC_REGNUM
)];
491 if ((regno
== -1) || (regno
== FPS_REGNUM
))
493 fpregsetp
-> f_psr
= *(int *) ®isters
[REGISTER_BYTE (FPS_REGNUM
)];
495 if ((regno
== -1) || (regno
== FPI_REGNUM
))
497 fpregsetp
-> f_fpiaddr
= *(int *) ®isters
[REGISTER_BYTE (FPI_REGNUM
)];
501 #endif /* defined (FP0_REGNUM) */
503 #endif /* USE_PROC_FS */
505 #ifdef GET_LONGJMP_TARGET
506 /* Figure out where the longjmp will land. Slurp the args out of the stack.
507 We expect the first arg to be a pointer to the jmp_buf structure from which
508 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
509 This routine returns true on success. */
512 get_longjmp_target(pc
)
515 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
516 CORE_ADDR sp
, jb_addr
;
518 sp
= read_register(SP_REGNUM
);
520 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
522 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
525 jb_addr
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
527 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
528 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
531 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
535 #endif /* GET_LONGJMP_TARGET */
537 /* Immediately after a function call, return the saved pc before the frame
538 is setup. For sun3's, we check for the common case of being inside of a
539 system call, and if so, we know that Sun pushes the call # on the stack
540 prior to doing the trap. */
543 m68k_saved_pc_after_call(frame
)
544 struct frame_info
*frame
;
549 op
= read_memory_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
551 if (op
== SYSCALL_TRAP
)
552 return read_memory_integer (read_register (SP_REGNUM
) + 4, 4);
554 #endif /* SYSCALL_TRAP */
555 return read_memory_integer (read_register (SP_REGNUM
), 4);
559 _initialize_m68k_tdep ()
561 tm_print_insn
= print_insn_m68k
;