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. */
28 #include "gdb_string.h"
31 #include "arch-utils.h"
34 #include "m68k-tdep.h"
37 #define P_LINKL_FP 0x480e
38 #define P_LINKW_FP 0x4e56
39 #define P_PEA_FP 0x4856
40 #define P_MOVL_SP_FP 0x2c4f
45 #define P_MOVML 0x48ef
46 #define P_FMOVM 0xf237
50 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
51 #define REGISTER_BYTES_NOFP (16*4 + 8)
53 #define NUM_FREGS (NUM_REGS-24)
55 /* Offset from SP to first arg on stack at first instruction of a function */
57 #define SP_ARG0 (1 * 4)
59 /* This was determined by experimentation on hp300 BSD 4.3. Perhaps
60 it corresponds to some offset in /usr/include/sys/user.h or
61 something like that. Using some system include file would
62 have the advantage of probably being more robust in the face
63 of OS upgrades, but the disadvantage of being wrong for
66 #define SIG_PC_FP_OFFSET 530
71 #if !defined (BPT_VECTOR)
72 #define BPT_VECTOR 0xf
75 #if !defined (REMOTE_BPT_VECTOR)
76 #define REMOTE_BPT_VECTOR 1
80 void m68k_frame_init_saved_regs (struct frame_info
*frame_info
);
83 /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
84 so m68k_remote_breakpoint_from_pc is currently not used. */
86 const static unsigned char *
87 m68k_remote_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
89 static unsigned char break_insn
[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR
)};
90 *lenptr
= sizeof (break_insn
);
94 const static unsigned char *
95 m68k_local_breakpoint_from_pc (CORE_ADDR
*pcptr
, int *lenptr
)
97 static unsigned char break_insn
[] = {0x4e, (0x40 | BPT_VECTOR
)};
98 *lenptr
= sizeof (break_insn
);
104 m68k_register_bytes_ok (long numbytes
)
106 return ((numbytes
== REGISTER_BYTES_FP
)
107 || (numbytes
== REGISTER_BYTES_NOFP
));
110 /* Number of bytes of storage in the actual machine representation
111 for register regnum. On the 68000, all regs are 4 bytes
112 except the floating point regs which are 12 bytes. */
113 /* Note that the unsigned cast here forces the result of the
114 subtraction to very high positive values if regnum < FP0_REGNUM */
117 m68k_register_raw_size (int regnum
)
119 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
122 /* Number of bytes of storage in the program's representation
123 for register regnum. On the 68000, all regs are 4 bytes
124 except the floating point regs which are 12-byte long doubles. */
127 m68k_register_virtual_size (int regnum
)
129 return (((unsigned) (regnum
) - FP0_REGNUM
) < 8 ? 12 : 4);
132 /* Return the GDB type object for the "standard" data type of data in
133 register N. This should be int for D0-D7, SR, FPCONTROL and
134 FPSTATUS, long double for FP0-FP7, and void pointer for all others
135 (A0-A7, PC, FPIADDR). Note, for registers which contain
136 addresses return pointer to void, not pointer to char, because we
137 don't want to attempt to print the string after printing the
141 m68k_register_virtual_type (int regnum
)
143 if (regnum
>= FP0_REGNUM
&& regnum
<= FP0_REGNUM
+ 7)
144 return builtin_type_m68881_ext
;
146 if (regnum
== M68K_FPI_REGNUM
|| regnum
== PC_REGNUM
)
147 return builtin_type_void_func_ptr
;
149 if (regnum
== M68K_FPC_REGNUM
|| regnum
== M68K_FPS_REGNUM
150 || regnum
== PS_REGNUM
)
151 return builtin_type_int32
;
153 if (regnum
>= M68K_A0_REGNUM
&& regnum
<= M68K_A0_REGNUM
+ 7)
154 return builtin_type_void_data_ptr
;
156 return builtin_type_int32
;
159 /* Function: m68k_register_name
160 Returns the name of the standard m68k register regnum. */
163 m68k_register_name (int regnum
)
165 static char *register_names
[] = {
166 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
167 "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",
169 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
170 "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags"
174 regnum
>= sizeof (register_names
) / sizeof (register_names
[0]))
175 internal_error (__FILE__
, __LINE__
,
176 "m68k_register_name: illegal register number %d", regnum
);
178 return register_names
[regnum
];
181 /* Stack must be kept short aligned when doing function calls. */
184 m68k_stack_align (CORE_ADDR addr
)
186 return ((addr
+ 1) & ~1);
189 /* Index within `registers' of the first byte of the space for
193 m68k_register_byte (int regnum
)
195 if (regnum
>= M68K_FPC_REGNUM
)
196 return (((regnum
- M68K_FPC_REGNUM
) * 4) + 168);
197 else if (regnum
>= FP0_REGNUM
)
198 return (((regnum
- FP0_REGNUM
) * 12) + 72);
203 /* Store the address of the place in which to copy the structure the
204 subroutine will return. This is called from call_function. */
207 m68k_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
209 write_register (M68K_A1_REGNUM
, addr
);
212 /* Extract from an array regbuf containing the (raw) register state
213 a function return value of type type, and copy that, in virtual format,
214 into valbuf. This is assuming that floating point values are returned
215 as doubles in d0/d1. */
218 m68k_deprecated_extract_return_value (struct type
*type
, char *regbuf
,
222 int typeLength
= TYPE_LENGTH (type
);
225 offset
= 4 - typeLength
;
227 memcpy (valbuf
, regbuf
+ offset
, typeLength
);
231 m68k_deprecated_extract_struct_value_address (char *regbuf
)
233 return (*(CORE_ADDR
*) (regbuf
));
236 /* Write into appropriate registers a function return value
237 of type TYPE, given in virtual format. Assumes floats are passed
241 m68k_store_return_value (struct type
*type
, char *valbuf
)
243 deprecated_write_register_bytes (0, valbuf
, TYPE_LENGTH (type
));
246 /* Describe the pointer in each stack frame to the previous stack frame
249 /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
250 the frame's chain-pointer. In the case of the 68000, the frame's
251 nominal address is the address of a 4-byte word containing the
252 calling frame's address. */
254 /* If we are chaining from sigtramp, then manufacture a sigtramp frame
255 (which isn't really on the stack. I'm not sure this is right for anything
256 but BSD4.3 on an hp300. */
259 m68k_frame_chain (struct frame_info
*thisframe
)
261 if (get_frame_type (thisframe
) == SIGTRAMP_FRAME
)
262 return get_frame_base (thisframe
);
263 else if (!inside_entry_file (get_frame_pc (thisframe
)))
264 return read_memory_unsigned_integer (get_frame_base (thisframe
), 4);
269 /* A function that tells us whether the function invocation represented
270 by fi does not have a frame on the stack associated with it. If it
271 does not, FRAMELESS is set to 1, else 0. */
274 m68k_frameless_function_invocation (struct frame_info
*fi
)
276 if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
279 return frameless_look_for_prologue (fi
);
283 m68k_frame_saved_pc (struct frame_info
*frame
)
285 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
287 if (get_next_frame (frame
))
288 return read_memory_unsigned_integer (get_frame_base (get_next_frame (frame
))
289 + SIG_PC_FP_OFFSET
, 4);
291 return read_memory_unsigned_integer (read_register (SP_REGNUM
)
292 + SIG_PC_FP_OFFSET
- 8, 4);
295 return read_memory_unsigned_integer (get_frame_base (frame
) + 4, 4);
299 /* The only reason this is here is the tm-altos.h reference below. It
300 was moved back here from tm-m68k.h. FIXME? */
303 altos_skip_prologue (CORE_ADDR pc
)
305 register int op
= read_memory_unsigned_integer (pc
, 2);
306 if (op
== P_LINKW_FP
)
307 pc
+= 4; /* Skip link #word */
308 else if (op
== P_LINKL_FP
)
309 pc
+= 6; /* Skip link #long */
310 /* Not sure why branches are here. */
311 /* From tm-altos.h */
312 else if (op
== 0060000)
313 pc
+= 4; /* Skip bra #word */
314 else if (op
== 00600377)
315 pc
+= 6; /* skip bra #long */
316 else if ((op
& 0177400) == 0060000)
317 pc
+= 2; /* skip bra #char */
322 delta68_in_sigtramp (CORE_ADDR pc
, char *name
)
325 return strcmp (name
, "_sigcode") == 0;
331 delta68_frame_args_address (struct frame_info
*frame_info
)
333 /* we assume here that the only frameless functions are the system calls
334 or other functions who do not put anything on the stack. */
335 if (get_frame_type (frame_info
) == SIGTRAMP_FRAME
)
336 return get_frame_base (frame_info
) + 12;
337 else if (frameless_look_for_prologue (frame_info
))
339 /* Check for an interrupted system call */
340 if (get_next_frame (frame_info
) && (get_frame_type (get_next_frame (frame_info
)) == SIGTRAMP_FRAME
))
341 return get_frame_base (get_next_frame (frame_info
)) + 16;
343 return get_frame_base (frame_info
) + 4;
346 return get_frame_base (frame_info
);
350 delta68_frame_saved_pc (struct frame_info
*frame_info
)
352 return read_memory_unsigned_integer (delta68_frame_args_address (frame_info
)
356 /* Return number of args passed to a frame.
357 Can return -1, meaning no way to tell. */
360 isi_frame_num_args (struct frame_info
*fi
)
363 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
364 int insn
= read_memory_unsigned_integer (pc
, 2);
366 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
367 val
= read_memory_integer (pc
+ 2, 2);
368 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
369 || (insn
& 0170777) == 0050117) /* addqw */
371 val
= (insn
>> 9) & 7;
375 else if (insn
== 0157774) /* addal #WW, sp */
376 val
= read_memory_integer (pc
+ 2, 4);
382 delta68_frame_num_args (struct frame_info
*fi
)
385 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
386 int insn
= read_memory_unsigned_integer (pc
, 2);
388 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
389 val
= read_memory_integer (pc
+ 2, 2);
390 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
391 || (insn
& 0170777) == 0050117) /* addqw */
393 val
= (insn
>> 9) & 7;
397 else if (insn
== 0157774) /* addal #WW, sp */
398 val
= read_memory_integer (pc
+ 2, 4);
404 news_frame_num_args (struct frame_info
*fi
)
407 CORE_ADDR pc
= DEPRECATED_FRAME_SAVED_PC (fi
);
408 int insn
= read_memory_unsigned_integer (pc
, 2);
410 if (insn
== 0047757 || insn
== 0157374) /* lea W(sp),sp or addaw #W,sp */
411 val
= read_memory_integer (pc
+ 2, 2);
412 else if ((insn
& 0170777) == 0050217 /* addql #N, sp */
413 || (insn
& 0170777) == 0050117) /* addqw */
415 val
= (insn
>> 9) & 7;
419 else if (insn
== 0157774) /* addal #WW, sp */
420 val
= read_memory_integer (pc
+ 2, 4);
425 /* Insert the specified number of args and function address
426 into a call sequence of the above form stored at DUMMYNAME.
427 We use the BFD routines to store a big-endian value of known size. */
430 m68k_fix_call_dummy (char *dummy
, CORE_ADDR pc
, CORE_ADDR fun
, int nargs
,
431 struct value
**args
, struct type
*type
, int gcc_p
)
433 bfd_putb32 (fun
, (unsigned char *) dummy
+ DEPRECATED_CALL_DUMMY_START_OFFSET
+ 2);
434 bfd_putb32 (nargs
* 4,
435 (unsigned char *) dummy
+ DEPRECATED_CALL_DUMMY_START_OFFSET
+ 8);
439 /* Push an empty stack frame, to record the current PC, etc. */
442 m68k_push_dummy_frame (void)
444 register CORE_ADDR sp
= read_register (SP_REGNUM
);
448 sp
= push_word (sp
, read_register (PC_REGNUM
));
449 sp
= push_word (sp
, read_register (DEPRECATED_FP_REGNUM
));
450 write_register (DEPRECATED_FP_REGNUM
, sp
);
452 /* Always save the floating-point registers, whether they exist on
453 this target or not. */
454 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
456 deprecated_read_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 12);
457 sp
= push_bytes (sp
, raw_buffer
, 12);
460 for (regnum
= DEPRECATED_FP_REGNUM
- 1; regnum
>= 0; regnum
--)
462 sp
= push_word (sp
, read_register (regnum
));
464 sp
= push_word (sp
, read_register (PS_REGNUM
));
465 write_register (SP_REGNUM
, sp
);
468 /* Discard from the stack the innermost frame,
469 restoring all saved registers. */
472 m68k_pop_frame (void)
474 register struct frame_info
*frame
= get_current_frame ();
475 register CORE_ADDR fp
;
479 fp
= get_frame_base (frame
);
480 m68k_frame_init_saved_regs (frame
);
481 for (regnum
= FP0_REGNUM
+ 7; regnum
>= FP0_REGNUM
; regnum
--)
483 if (get_frame_saved_regs (frame
)[regnum
])
485 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
, 12);
486 deprecated_write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
,
490 for (regnum
= DEPRECATED_FP_REGNUM
- 1; regnum
>= 0; regnum
--)
492 if (get_frame_saved_regs (frame
)[regnum
])
494 write_register (regnum
,
495 read_memory_integer (get_frame_saved_regs (frame
)[regnum
], 4));
498 if (get_frame_saved_regs (frame
)[PS_REGNUM
])
500 write_register (PS_REGNUM
,
501 read_memory_integer (get_frame_saved_regs (frame
)[PS_REGNUM
], 4));
503 write_register (DEPRECATED_FP_REGNUM
, read_memory_integer (fp
, 4));
504 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
505 write_register (SP_REGNUM
, fp
+ 8);
506 flush_cached_frames ();
510 /* Given an ip value corresponding to the start of a function,
511 return the ip of the first instruction after the function
512 prologue. This is the generic m68k support. Machines which
513 require something different can override the SKIP_PROLOGUE
514 macro to point elsewhere.
516 Some instructions which typically may appear in a function
519 A link instruction, word form:
521 link.w %a6,&0 4e56 XXXX
523 A link instruction, long form:
525 link.l %fp,&F%1 480e XXXX XXXX
527 A movm instruction to preserve integer regs:
529 movm.l &M%1,(4,%sp) 48ef XXXX XXXX
531 A fmovm instruction to preserve float regs:
533 fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX
535 Some profiling setup code (FIXME, not recognized yet):
537 lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX
538 bsr _mcount 61ff XXXX XXXX
543 m68k_skip_prologue (CORE_ADDR ip
)
545 register CORE_ADDR limit
;
546 struct symtab_and_line sal
;
549 /* Find out if there is a known limit for the extent of the prologue.
550 If so, ensure we don't go past it. If not, assume "infinity". */
552 sal
= find_pc_line (ip
, 0);
553 limit
= (sal
.end
) ? sal
.end
: (CORE_ADDR
) ~0;
557 op
= read_memory_unsigned_integer (ip
, 2);
559 if (op
== P_LINKW_FP
)
560 ip
+= 4; /* Skip link.w */
561 else if (op
== P_PEA_FP
)
562 ip
+= 2; /* Skip pea %fp */
563 else if (op
== P_MOVL_SP_FP
)
564 ip
+= 2; /* Skip move.l %sp, %fp */
565 else if (op
== P_LINKL_FP
)
566 ip
+= 6; /* Skip link.l */
567 else if (op
== P_MOVML
)
568 ip
+= 6; /* Skip movm.l */
569 else if (op
== P_FMOVM
)
570 ip
+= 10; /* Skip fmovm */
572 break; /* Found unknown code, bail out. */
577 /* Store the addresses of the saved registers of the frame described by
578 FRAME_INFO in its saved_regs field.
579 This includes special registers such as pc and fp saved in special
580 ways in the stack frame. sp is even more special:
581 the address we return for it IS the sp for the next frame. */
584 m68k_frame_init_saved_regs (struct frame_info
*frame_info
)
587 register int regmask
;
588 register CORE_ADDR next_addr
;
589 register CORE_ADDR pc
;
591 /* First possible address for a pc in a call dummy for this frame. */
592 CORE_ADDR possible_call_dummy_start
=
593 get_frame_base (frame_info
) - 28 - DEPRECATED_FP_REGNUM
* 4 - 4 - 8 * 12;
597 if (get_frame_saved_regs (frame_info
))
600 frame_saved_regs_zalloc (frame_info
);
602 memset (get_frame_saved_regs (frame_info
), 0, SIZEOF_FRAME_SAVED_REGS
);
604 if (get_frame_pc (frame_info
) >= possible_call_dummy_start
605 && get_frame_pc (frame_info
) <= get_frame_base (frame_info
))
608 /* It is a call dummy. We could just stop now, since we know
609 what the call dummy saves and where. But this code proceeds
610 to parse the "prologue" which is part of the call dummy.
611 This is needlessly complex and confusing. FIXME. */
613 next_addr
= get_frame_base (frame_info
);
614 pc
= possible_call_dummy_start
;
618 pc
= get_frame_func (frame_info
);
620 nextinsn
= read_memory_unsigned_integer (pc
, 2);
621 if (P_PEA_FP
== nextinsn
622 && P_MOVL_SP_FP
== read_memory_unsigned_integer (pc
+ 2, 2))
626 next_addr
= get_frame_base (frame_info
);
629 else if (P_LINKL_FP
== nextinsn
)
631 /* Find the address above the saved
632 regs using the amount of storage from the link instruction. */
634 next_addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 2, 4);
637 else if (P_LINKW_FP
== nextinsn
)
639 /* Find the address above the saved
640 regs using the amount of storage from the link instruction. */
642 next_addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 2, 2);
648 /* If have an addal #-n, sp next, adjust next_addr. */
649 if (read_memory_unsigned_integer (pc
, 2) == 0157774)
650 next_addr
+= read_memory_integer (pc
+= 2, 4), pc
+= 4;
655 nextinsn
= read_memory_unsigned_integer (pc
, 2);
656 regmask
= read_memory_unsigned_integer (pc
+ 2, 2);
657 /* fmovemx to -(sp) */
658 if (0xf227 == nextinsn
&& (regmask
& 0xff00) == 0xe000)
660 /* Regmask's low bit is for register fp7, the first pushed */
661 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
663 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 12);
666 /* fmovemx to (fp + displacement) */
667 else if (0171056 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
669 register CORE_ADDR addr
;
671 addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 4, 2);
672 /* Regmask's low bit is for register fp7, the first pushed */
673 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
676 get_frame_saved_regs (frame_info
)[regnum
] = addr
;
682 else if (0044327 == nextinsn
)
684 /* Regmask's low bit is for register 0, the first written */
685 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
688 get_frame_saved_regs (frame_info
)[regnum
] = next_addr
;
693 /* moveml to (fp + displacement) */
694 else if (0044356 == nextinsn
)
696 register CORE_ADDR addr
;
698 addr
= get_frame_base (frame_info
) + read_memory_integer (pc
+ 4, 2);
699 /* Regmask's low bit is for register 0, the first written */
700 for (regnum
= 0; regnum
< 16; regnum
++, regmask
>>= 1)
703 get_frame_saved_regs (frame_info
)[regnum
] = addr
;
708 /* moveml to -(sp) */
709 else if (0044347 == nextinsn
)
711 /* Regmask's low bit is for register 15, the first pushed */
712 for (regnum
= 16; --regnum
>= 0; regmask
>>= 1)
714 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 4);
718 else if (0x2f00 == (0xfff0 & nextinsn
))
720 regnum
= 0xf & nextinsn
;
721 get_frame_saved_regs (frame_info
)[regnum
] = (next_addr
-= 4);
724 /* fmovemx to index of sp */
725 else if (0xf236 == nextinsn
&& (regmask
& 0xff00) == 0xf000)
727 /* Regmask's low bit is for register fp0, the first written */
728 for (regnum
= FP0_REGNUM
+ 8; --regnum
>= FP0_REGNUM
; regmask
>>= 1)
731 get_frame_saved_regs (frame_info
)[regnum
] = next_addr
;
736 /* clrw -(sp); movw ccr,-(sp) */
737 else if (0x4267 == nextinsn
&& 0x42e7 == regmask
)
739 get_frame_saved_regs (frame_info
)[PS_REGNUM
] = (next_addr
-= 4);
746 get_frame_saved_regs (frame_info
)[SP_REGNUM
] = get_frame_base (frame_info
) + 8;
747 get_frame_saved_regs (frame_info
)[DEPRECATED_FP_REGNUM
] = get_frame_base (frame_info
);
748 get_frame_saved_regs (frame_info
)[PC_REGNUM
] = get_frame_base (frame_info
) + 4;
749 #ifdef SIG_SP_FP_OFFSET
750 /* Adjust saved SP_REGNUM for fake _sigtramp frames. */
751 if ((get_frame_type (frame_info
) == SIGTRAMP_FRAME
) && frame_info
->next
)
752 frame_info
->saved_regs
[SP_REGNUM
] =
753 frame_info
->next
->frame
+ SIG_SP_FP_OFFSET
;
758 #ifdef USE_PROC_FS /* Target dependent support for /proc */
760 #include <sys/procfs.h>
762 /* Prototypes for supply_gregset etc. */
765 /* The /proc interface divides the target machine's register set up into
766 two different sets, the general register set (gregset) and the floating
767 point register set (fpregset). For each set, there is an ioctl to get
768 the current register set and another ioctl to set the current values.
770 The actual structure passed through the ioctl interface is, of course,
771 naturally machine dependent, and is different for each set of registers.
772 For the m68k for example, the general register set is typically defined
775 typedef int gregset_t[18];
781 and the floating point set by:
783 typedef struct fpregset {
787 int f_fpregs[8][3]; (8 regs, 96 bits each)
790 These routines provide the packing and unpacking of gregset_t and
791 fpregset_t formatted data.
795 /* Atari SVR4 has R_SR but not R_PS */
797 #if !defined (R_PS) && defined (R_SR)
801 /* Given a pointer to a general register set in /proc format (gregset_t *),
802 unpack the register contents and supply them as gdb's idea of the current
806 supply_gregset (gregset_t
*gregsetp
)
809 register greg_t
*regp
= (greg_t
*) gregsetp
;
811 for (regi
= 0; regi
< R_PC
; regi
++)
813 supply_register (regi
, (char *) (regp
+ regi
));
815 supply_register (PS_REGNUM
, (char *) (regp
+ R_PS
));
816 supply_register (PC_REGNUM
, (char *) (regp
+ R_PC
));
820 fill_gregset (gregset_t
*gregsetp
, int regno
)
823 register greg_t
*regp
= (greg_t
*) gregsetp
;
825 for (regi
= 0; regi
< R_PC
; regi
++)
827 if ((regno
== -1) || (regno
== regi
))
829 *(regp
+ regi
) = *(int *) &deprecated_registers
[REGISTER_BYTE (regi
)];
832 if ((regno
== -1) || (regno
== PS_REGNUM
))
834 *(regp
+ R_PS
) = *(int *) &deprecated_registers
[REGISTER_BYTE (PS_REGNUM
)];
836 if ((regno
== -1) || (regno
== PC_REGNUM
))
838 *(regp
+ R_PC
) = *(int *) &deprecated_registers
[REGISTER_BYTE (PC_REGNUM
)];
842 #if defined (FP0_REGNUM)
844 /* Given a pointer to a floating point register set in /proc format
845 (fpregset_t *), unpack the register contents and supply them as gdb's
846 idea of the current floating point register values. */
849 supply_fpregset (fpregset_t
*fpregsetp
)
854 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
856 from
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
857 supply_register (regi
, from
);
859 supply_register (M68K_FPC_REGNUM
, (char *) &(fpregsetp
->f_pcr
));
860 supply_register (M68K_FPS_REGNUM
, (char *) &(fpregsetp
->f_psr
));
861 supply_register (M68K_FPI_REGNUM
, (char *) &(fpregsetp
->f_fpiaddr
));
864 /* Given a pointer to a floating point register set in /proc format
865 (fpregset_t *), update the register specified by REGNO from gdb's idea
866 of the current floating point register set. If REGNO is -1, update
870 fill_fpregset (fpregset_t
*fpregsetp
, int regno
)
876 for (regi
= FP0_REGNUM
; regi
< M68K_FPC_REGNUM
; regi
++)
878 if ((regno
== -1) || (regno
== regi
))
880 from
= (char *) &deprecated_registers
[REGISTER_BYTE (regi
)];
881 to
= (char *) &(fpregsetp
->f_fpregs
[regi
- FP0_REGNUM
][0]);
882 memcpy (to
, from
, REGISTER_RAW_SIZE (regi
));
885 if ((regno
== -1) || (regno
== M68K_FPC_REGNUM
))
887 fpregsetp
->f_pcr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPC_REGNUM
)];
889 if ((regno
== -1) || (regno
== M68K_FPS_REGNUM
))
891 fpregsetp
->f_psr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPS_REGNUM
)];
893 if ((regno
== -1) || (regno
== M68K_FPI_REGNUM
))
895 fpregsetp
->f_fpiaddr
= *(int *) &deprecated_registers
[REGISTER_BYTE (M68K_FPI_REGNUM
)];
899 #endif /* defined (FP0_REGNUM) */
901 #endif /* USE_PROC_FS */
903 /* Figure out where the longjmp will land. Slurp the args out of the stack.
904 We expect the first arg to be a pointer to the jmp_buf structure from which
905 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
906 This routine returns true on success. */
908 /* NOTE: cagney/2000-11-08: For this function to be fully multi-arched
909 the macro's JB_PC and JB_ELEMENT_SIZE would need to be moved into
910 the ``struct gdbarch_tdep'' object and then set on a target ISA/ABI
914 m68k_get_longjmp_target (CORE_ADDR
*pc
)
916 #if defined (JB_PC) && defined (JB_ELEMENT_SIZE)
918 CORE_ADDR sp
, jb_addr
;
920 buf
= alloca (TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
921 sp
= read_register (SP_REGNUM
);
923 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
924 buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
927 jb_addr
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
929 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
930 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
933 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
937 internal_error (__FILE__
, __LINE__
,
938 "m68k_get_longjmp_target: not implemented");
943 /* Immediately after a function call, return the saved pc before the frame
944 is setup. For sun3's, we check for the common case of being inside of a
945 system call, and if so, we know that Sun pushes the call # on the stack
946 prior to doing the trap. */
949 m68k_saved_pc_after_call (struct frame_info
*frame
)
954 op
= read_memory_unsigned_integer (frame
->pc
- SYSCALL_TRAP_OFFSET
, 2);
956 if (op
== SYSCALL_TRAP
)
957 return read_memory_unsigned_integer (read_register (SP_REGNUM
) + 4, 4);
959 #endif /* SYSCALL_TRAP */
960 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
963 /* Function: m68k_gdbarch_init
964 Initializer function for the m68k gdbarch vector.
965 Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
967 static struct gdbarch
*
968 m68k_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
970 static LONGEST call_dummy_words
[7] = { 0xf227e0ff, 0x48e7fffc, 0x426742e7,
971 0x4eb93232, 0x3232dffc, 0x69696969,
972 (0x4e404e71 | (BPT_VECTOR
<< 16))
974 struct gdbarch_tdep
*tdep
= NULL
;
975 struct gdbarch
*gdbarch
;
977 /* find a candidate among the list of pre-declared architectures. */
978 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
980 return (arches
->gdbarch
);
983 tdep
= (struct gdbarch_tdep
*) xmalloc (sizeof (struct gdbarch_tdep
));
986 gdbarch
= gdbarch_alloc (&info
, 0);
988 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
989 ready to unwind the PC first (see frame.c:get_prev_frame()). */
990 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
992 set_gdbarch_long_double_format (gdbarch
, &floatformat_m68881_ext
);
993 set_gdbarch_long_double_bit (gdbarch
, 96);
995 set_gdbarch_function_start_offset (gdbarch
, 0);
997 set_gdbarch_skip_prologue (gdbarch
, m68k_skip_prologue
);
998 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, m68k_saved_pc_after_call
);
999 set_gdbarch_breakpoint_from_pc (gdbarch
, m68k_local_breakpoint_from_pc
);
1001 /* Stack grows down. */
1002 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1003 set_gdbarch_stack_align (gdbarch
, m68k_stack_align
);
1004 set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch
, 1);
1006 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
1007 set_gdbarch_decr_pc_after_break (gdbarch
, 2);
1009 set_gdbarch_deprecated_store_struct_return (gdbarch
, m68k_store_struct_return
);
1010 set_gdbarch_deprecated_extract_return_value (gdbarch
,
1011 m68k_deprecated_extract_return_value
);
1012 set_gdbarch_deprecated_store_return_value (gdbarch
, m68k_store_return_value
);
1014 set_gdbarch_deprecated_frame_chain (gdbarch
, m68k_frame_chain
);
1015 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, m68k_frame_saved_pc
);
1016 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, m68k_frame_init_saved_regs
);
1017 set_gdbarch_frameless_function_invocation (gdbarch
,
1018 m68k_frameless_function_invocation
);
1019 /* OK to default this value to 'unknown'. */
1020 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1021 set_gdbarch_frame_args_skip (gdbarch
, 8);
1023 set_gdbarch_register_raw_size (gdbarch
, m68k_register_raw_size
);
1024 set_gdbarch_register_virtual_size (gdbarch
, m68k_register_virtual_size
);
1025 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 12);
1026 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 12);
1027 set_gdbarch_register_virtual_type (gdbarch
, m68k_register_virtual_type
);
1028 set_gdbarch_register_name (gdbarch
, m68k_register_name
);
1029 set_gdbarch_deprecated_register_size (gdbarch
, 4);
1030 set_gdbarch_register_byte (gdbarch
, m68k_register_byte
);
1031 set_gdbarch_num_regs (gdbarch
, 29);
1032 set_gdbarch_register_bytes_ok (gdbarch
, m68k_register_bytes_ok
);
1033 set_gdbarch_deprecated_register_bytes (gdbarch
, (16 * 4 + 8 + 8 * 12 + 3 * 4));
1034 set_gdbarch_sp_regnum (gdbarch
, M68K_SP_REGNUM
);
1035 set_gdbarch_deprecated_fp_regnum (gdbarch
, M68K_FP_REGNUM
);
1036 set_gdbarch_pc_regnum (gdbarch
, M68K_PC_REGNUM
);
1037 set_gdbarch_ps_regnum (gdbarch
, M68K_PS_REGNUM
);
1038 set_gdbarch_fp0_regnum (gdbarch
, M68K_FP0_REGNUM
);
1040 set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch
, 0);
1041 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1042 set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch
, 24);
1043 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_on_stack
);
1044 set_gdbarch_deprecated_call_dummy_length (gdbarch
, 28);
1045 set_gdbarch_deprecated_call_dummy_start_offset (gdbarch
, 12);
1047 set_gdbarch_deprecated_call_dummy_words (gdbarch
, call_dummy_words
);
1048 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (call_dummy_words
));
1049 set_gdbarch_deprecated_fix_call_dummy (gdbarch
, m68k_fix_call_dummy
);
1050 set_gdbarch_deprecated_push_dummy_frame (gdbarch
, m68k_push_dummy_frame
);
1051 set_gdbarch_deprecated_pop_frame (gdbarch
, m68k_pop_frame
);
1053 /* Should be using push_dummy_call. */
1054 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
1056 /* Hook in ABI-specific overrides, if they have been registered. */
1057 gdbarch_init_osabi (info
, gdbarch
);
1064 m68k_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1070 _initialize_m68k_tdep (void)
1072 gdbarch_register (bfd_arch_m68k
, m68k_gdbarch_init
, m68k_dump_tdep
);
1073 deprecated_tm_print_insn
= print_insn_m68k
;